configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS TOPLEVEL_CONFIGURE_ARGUMENTS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc ppllibs pplinc clooglibs clooginc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR GCC_SHLIB_SUBDIR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --disable-ppl-version-check    disable check for PPL version
 939   --disable-cloog-version-check  disable check for CLooG version
 940   --enable-stage1-languages[=all]   choose additional languages to build during
 941                           stage1.  Mostly useful for compiler development.
 942   --enable-objc-gc        enable use of Boehm's garbage collector with the
 943                           GNU Objective-C runtime
 944   --enable-bootstrap      enable bootstrapping [yes if native build]
 945   --enable-serial-[{host,target,build}-]configure
 946                           force sequential configuration of
 947                           sub-packages for the host, target or build
 948                           machine, or all sub-packages
 949   --enable-maintainer-mode enable make rules and dependencies not useful
 950                           (and sometimes confusing) to the casual installer
 951   --enable-stage1-checking[=all]   choose additional checking for stage1
 952                           of the compiler
 953   --enable-werror         enable -Werror in bootstrap stage2 and later
 954
 955 Optional Packages:
 956   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 957   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 958   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 959   --with-mpfr-dir=PATH    this option has been REMOVED
 960   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 961                           Equivalent to --with-mpfr-include=PATH/include
 962                           plus --with-mpfr-lib=PATH/lib
 963   --with-mpfr-include=PATH
 964                           specify directory for installed MPFR include files
 965   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 966   --with-gmp-dir=PATH     this option has been REMOVED
 967   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 968                           Equivalent to --with-gmp-include=PATH/include
 969                           plus --with-gmp-lib=PATH/lib
 970   --with-gmp-include=PATH specify directory for installed GMP include files
 971   --with-gmp-lib=PATH     specify directory for the installed GMP library
 972   --with-ppl=PATH         Specify prefix directory for the installed PPL package
 973                           Equivalent to --with-ppl-include=PATH/include
 974                           plus --with-ppl-lib=PATH/lib
 975   --with-ppl-include=PATH Specify directory for installed PPL include files
 976   --with-ppl-lib=PATH     Specify the directory for the installed PPL library
 977   --with-cloog=PATH       Specify prefix directory for the installed CLooG-PPL package
 978                           Equivalent to --with-cloog-include=PATH/include
 979                           plus --with-cloog-lib=PATH/lib
 980   --with-cloog-include=PATH Specify directory for installed CLooG include files
 981   --with-cloog-lib=PATH   Specify the directory for the installed CLooG library
 982   --with-build-sysroot=SYSROOT
 983                           use sysroot as the system root during the build
 984   --with-debug-prefix-map='A=B C=D ...'
 985                              map A to B, C to D ... in debug information
 986   --with-build-time-tools=PATH
 987                           use given path to find target tools during the build
 988   --with-datarootdir      use datarootdir as the data root directory.
 989   --with-docdir           install documentation in this directory.
 990   --with-pdfdir           install pdf in this directory.
 991   --with-htmldir          install html in this directory.
 992
 993 Some influential environment variables:
 994   CC          C compiler command
 995   CFLAGS      C compiler flags
 996   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 997               nonstandard directory <lib dir>
 998   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 999               headers in a nonstandard directory <include dir>
1000   CXX         C++ compiler command
1001   CXXFLAGS    C++ compiler flags
1002   AR          AR for the host
1003   AS          AS for the host
1004   DLLTOOL     DLLTOOL for the host
1005   LD          LD for the host
1006   LIPO        LIPO for the host
1007   NM          NM for the host
1008   RANLIB      RANLIB for the host
1009   STRIP       STRIP for the host
1010   WINDRES     WINDRES for the host
1011   WINDMC      WINDMC for the host
1012   OBJCOPY     OBJCOPY for the host
1013   OBJDUMP     OBJDUMP for the host
1014   CC_FOR_TARGET
1015               CC for the target
1016   CXX_FOR_TARGET
1017               CXX for the target
1018   GCC_FOR_TARGET
1019               GCC for the target
1020   GCJ_FOR_TARGET
1021               GCJ for the target
1022   GFORTRAN_FOR_TARGET
1023               GFORTRAN for the target
1024   AR_FOR_TARGET
1025               AR for the target
1026   AS_FOR_TARGET
1027               AS for the target
1028   DLLTOOL_FOR_TARGET
1029               DLLTOOL for the target
1030   LD_FOR_TARGET
1031               LD for the target
1032   LIPO_FOR_TARGET
1033               LIPO for the target
1034   NM_FOR_TARGET
1035               NM for the target
1036   OBJDUMP_FOR_TARGET
1037               OBJDUMP for the target
1038   RANLIB_FOR_TARGET
1039               RANLIB for the target
1040   STRIP_FOR_TARGET
1041               STRIP for the target
1042   WINDRES_FOR_TARGET
1043               WINDRES for the target
1044   WINDMC_FOR_TARGET
1045               WINDMC for the target
1046
1047 Use these variables to override the choices made by `configure' or to help
1048 it to find libraries and programs with nonstandard names/locations.
1049
1050 _ACEOF
1051 fi
1052
1053 if test "$ac_init_help" = "recursive"; then
1054   # If there are subdirs, report their specific --help.
1055   ac_popdir=`pwd`
1056   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1057     test -d $ac_dir || continue
1058     ac_builddir=.
1059
1060 if test "$ac_dir" != .; then
1061   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1062   # A "../" for each directory in $ac_dir_suffix.
1063   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1064 else
1065   ac_dir_suffix= ac_top_builddir=
1066 fi
1067
1068 case $srcdir in
1069   .)  # No --srcdir option.  We are building in place.
1070     ac_srcdir=.
1071     if test -z "$ac_top_builddir"; then
1072        ac_top_srcdir=.
1073     else
1074        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1075     fi ;;
1076   [\\/]* | ?:[\\/]* )  # Absolute path.
1077     ac_srcdir=$srcdir$ac_dir_suffix;
1078     ac_top_srcdir=$srcdir ;;
1079   *) # Relative path.
1080     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1081     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1082 esac
1083
1084 # Do not use `cd foo && pwd` to compute absolute paths, because
1085 # the directories may not exist.
1086 case `pwd` in
1087 .) ac_abs_builddir="$ac_dir";;
1088 *)
1089   case "$ac_dir" in
1090   .) ac_abs_builddir=`pwd`;;
1091   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1092   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1093   esac;;
1094 esac
1095 case $ac_abs_builddir in
1096 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1097 *)
1098   case ${ac_top_builddir}. in
1099   .) ac_abs_top_builddir=$ac_abs_builddir;;
1100   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1101   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1102   esac;;
1103 esac
1104 case $ac_abs_builddir in
1105 .) ac_abs_srcdir=$ac_srcdir;;
1106 *)
1107   case $ac_srcdir in
1108   .) ac_abs_srcdir=$ac_abs_builddir;;
1109   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1110   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1111   esac;;
1112 esac
1113 case $ac_abs_builddir in
1114 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1115 *)
1116   case $ac_top_srcdir in
1117   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1118   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1119   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1120   esac;;
1121 esac
1122
1123     cd $ac_dir
1124     # Check for guested configure; otherwise get Cygnus style configure.
1125     if test -f $ac_srcdir/configure.gnu; then
1126       echo
1127       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1128     elif test -f $ac_srcdir/configure; then
1129       echo
1130       $SHELL $ac_srcdir/configure  --help=recursive
1131     elif test -f $ac_srcdir/configure.ac ||
1132            test -f $ac_srcdir/configure.in; then
1133       echo
1134       $ac_configure --help
1135     else
1136       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1137     fi
1138     cd $ac_popdir
1139   done
1140 fi
1141
1142 test -n "$ac_init_help" && exit 0
1143 if $ac_init_version; then
1144   cat <<\_ACEOF
1145
1146 Copyright (C) 2003 Free Software Foundation, Inc.
1147 This configure script is free software; the Free Software Foundation
1148 gives unlimited permission to copy, distribute and modify it.
1149 _ACEOF
1150   exit 0
1151 fi
1152 exec 5>config.log
1153 cat >&5 <<_ACEOF
1154 This file contains any messages produced by compilers while
1155 running configure, to aid debugging if configure makes a mistake.
1156
1157 It was created by $as_me, which was
1158 generated by GNU Autoconf 2.59.  Invocation command line was
1159
1160   $ $0 $@
1161
1162 _ACEOF
1163 {
1164 cat <<_ASUNAME
1165 ## --------- ##
1166 ## Platform. ##
1167 ## --------- ##
1168
1169 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1170 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1171 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1172 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1173 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1174
1175 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1176 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1177
1178 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1179 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1180 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1181 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1182 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1183 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1184 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1185
1186 _ASUNAME
1187
1188 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1189 for as_dir in $PATH
1190 do
1191   IFS=$as_save_IFS
1192   test -z "$as_dir" && as_dir=.
1193   echo "PATH: $as_dir"
1194 done
1195
1196 } >&5
1197
1198 cat >&5 <<_ACEOF
1199
1200
1201 ## ----------- ##
1202 ## Core tests. ##
1203 ## ----------- ##
1204
1205 _ACEOF
1206
1207
1208 # Keep a trace of the command line.
1209 # Strip out --no-create and --no-recursion so they do not pile up.
1210 # Strip out --silent because we don't want to record it for future runs.
1211 # Also quote any args containing shell meta-characters.
1212 # Make two passes to allow for proper duplicate-argument suppression.
1213 ac_configure_args=
1214 ac_configure_args0=
1215 ac_configure_args1=
1216 ac_sep=
1217 ac_must_keep_next=false
1218 for ac_pass in 1 2
1219 do
1220   for ac_arg
1221   do
1222     case $ac_arg in
1223     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1224     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1225     | -silent | --silent | --silen | --sile | --sil)
1226       continue ;;
1227     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1228       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1229     esac
1230     case $ac_pass in
1231     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1232     2)
1233       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1234       if test $ac_must_keep_next = true; then
1235         ac_must_keep_next=false # Got value, back to normal.
1236       else
1237         case $ac_arg in
1238           *=* | --config-cache | -C | -disable-* | --disable-* \
1239           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1240           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1241           | -with-* | --with-* | -without-* | --without-* | --x)
1242             case "$ac_configure_args0 " in
1243               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1244             esac
1245             ;;
1246           -* ) ac_must_keep_next=true ;;
1247         esac
1248       fi
1249       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1250       # Get rid of the leading space.
1251       ac_sep=" "
1252       ;;
1253     esac
1254   done
1255 done
1256 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1257 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1258
1259 # When interrupted or exit'd, cleanup temporary files, and complete
1260 # config.log.  We remove comments because anyway the quotes in there
1261 # would cause problems or look ugly.
1262 # WARNING: Be sure not to use single quotes in there, as some shells,
1263 # such as our DU 5.0 friend, will then `close' the trap.
1264 trap 'exit_status=$?
1265   # Save into config.log some information that might help in debugging.
1266   {
1267     echo
1268
1269     cat <<\_ASBOX
1270 ## ---------------- ##
1271 ## Cache variables. ##
1272 ## ---------------- ##
1273 _ASBOX
1274     echo
1275     # The following way of writing the cache mishandles newlines in values,
1276 {
1277   (set) 2>&1 |
1278     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1279     *ac_space=\ *)
1280       sed -n \
1281         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1282           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1283       ;;
1284     *)
1285       sed -n \
1286         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1287       ;;
1288     esac;
1289 }
1290     echo
1291
1292     cat <<\_ASBOX
1293 ## ----------------- ##
1294 ## Output variables. ##
1295 ## ----------------- ##
1296 _ASBOX
1297     echo
1298     for ac_var in $ac_subst_vars
1299     do
1300       eval ac_val=$`echo $ac_var`
1301       echo "$ac_var='"'"'$ac_val'"'"'"
1302     done | sort
1303     echo
1304
1305     if test -n "$ac_subst_files"; then
1306       cat <<\_ASBOX
1307 ## ------------- ##
1308 ## Output files. ##
1309 ## ------------- ##
1310 _ASBOX
1311       echo
1312       for ac_var in $ac_subst_files
1313       do
1314         eval ac_val=$`echo $ac_var`
1315         echo "$ac_var='"'"'$ac_val'"'"'"
1316       done | sort
1317       echo
1318     fi
1319
1320     if test -s confdefs.h; then
1321       cat <<\_ASBOX
1322 ## ----------- ##
1323 ## confdefs.h. ##
1324 ## ----------- ##
1325 _ASBOX
1326       echo
1327       sed "/^$/d" confdefs.h | sort
1328       echo
1329     fi
1330     test "$ac_signal" != 0 &&
1331       echo "$as_me: caught signal $ac_signal"
1332     echo "$as_me: exit $exit_status"
1333   } >&5
1334   rm -f core *.core &&
1335   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1336     exit $exit_status
1337      ' 0
1338 for ac_signal in 1 2 13 15; do
1339   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1340 done
1341 ac_signal=0
1342
1343 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1344 rm -rf conftest* confdefs.h
1345 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1346 echo >confdefs.h
1347
1348 # Predefined preprocessor variables.
1349
1350 cat >>confdefs.h <<_ACEOF
1351 #define PACKAGE_NAME "$PACKAGE_NAME"
1352 _ACEOF
1353
1354
1355 cat >>confdefs.h <<_ACEOF
1356 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1357 _ACEOF
1358
1359
1360 cat >>confdefs.h <<_ACEOF
1361 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1362 _ACEOF
1363
1364
1365 cat >>confdefs.h <<_ACEOF
1366 #define PACKAGE_STRING "$PACKAGE_STRING"
1367 _ACEOF
1368
1369
1370 cat >>confdefs.h <<_ACEOF
1371 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1372 _ACEOF
1373
1374
1375 # Let the site file select an alternate cache file if it wants to.
1376 # Prefer explicitly selected file to automatically selected ones.
1377 if test -z "$CONFIG_SITE"; then
1378   if test "x$prefix" != xNONE; then
1379     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1380   else
1381     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1382   fi
1383 fi
1384 for ac_site_file in $CONFIG_SITE; do
1385   if test -r "$ac_site_file"; then
1386     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1387 echo "$as_me: loading site script $ac_site_file" >&6;}
1388     sed 's/^/| /' "$ac_site_file" >&5
1389     . "$ac_site_file"
1390   fi
1391 done
1392
1393 if test -r "$cache_file"; then
1394   # Some versions of bash will fail to source /dev/null (special
1395   # files actually), so we avoid doing that.
1396   if test -f "$cache_file"; then
1397     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1398 echo "$as_me: loading cache $cache_file" >&6;}
1399     case $cache_file in
1400       [\\/]* | ?:[\\/]* ) . $cache_file;;
1401       *)                      . ./$cache_file;;
1402     esac
1403   fi
1404 else
1405   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1406 echo "$as_me: creating cache $cache_file" >&6;}
1407   >$cache_file
1408 fi
1409
1410 # Check that the precious variables saved in the cache have kept the same
1411 # value.
1412 ac_cache_corrupted=false
1413 for ac_var in `(set) 2>&1 |
1414                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1415   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1416   eval ac_new_set=\$ac_env_${ac_var}_set
1417   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1418   eval ac_new_val="\$ac_env_${ac_var}_value"
1419   case $ac_old_set,$ac_new_set in
1420     set,)
1421       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1422 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1423       ac_cache_corrupted=: ;;
1424     ,set)
1425       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1426 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1427       ac_cache_corrupted=: ;;
1428     ,);;
1429     *)
1430       if test "x$ac_old_val" != "x$ac_new_val"; then
1431         # differences in whitespace do not lead to failure.
1432         ac_old_val_w=`echo x $ac_old_val`
1433         ac_new_val_w=`echo x $ac_new_val`
1434         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1435           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1436 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1437           ac_cache_corrupted=:
1438         else
1439           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1440 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1441           eval $ac_var=\$ac_old_val
1442         fi
1443         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1444 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1445         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1446 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1447       fi;;
1448   esac
1449   # Pass precious variables to config.status.
1450   if test "$ac_new_set" = set; then
1451     case $ac_new_val in
1452     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1453       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1454     *) ac_arg=$ac_var=$ac_new_val ;;
1455     esac
1456     case " $ac_configure_args " in
1457       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1458       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1459     esac
1460   fi
1461 done
1462 if $ac_cache_corrupted; then
1463   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1464 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1465   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1466 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1467   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1468 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1469    { (exit 1); exit 1; }; }
1470 fi
1471
1472 ac_ext=c
1473 ac_cpp='$CPP $CPPFLAGS'
1474 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1475 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1476 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501 progname=$0
1502 # if PWD already has a value, it is probably wrong.
1503 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1504
1505 # Export original configure arguments for use by sub-configures.
1506 # Quote arguments with shell meta charatcers.
1507 TOPLEVEL_CONFIGURE_ARGUMENTS=
1508 set -- "$progname" "$@"
1509 for ac_arg
1510 do
1511   case "$ac_arg" in
1512   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1513     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1514     # if the argument is of the form -foo=baz, quote the baz part only
1515     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1516   *) ;;
1517   esac
1518   # Add the quoted argument to the list.
1519   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1520 done
1521 if test "$silent" = yes; then
1522   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1523 fi
1524 # Remove the initial space we just introduced and, as these will be
1525 # expanded by make, quote '$'.
1526 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1527
1528
1529 # Find the build, host, and target systems.
1530 ac_aux_dir=
1531 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1532   if test -f $ac_dir/install-sh; then
1533     ac_aux_dir=$ac_dir
1534     ac_install_sh="$ac_aux_dir/install-sh -c"
1535     break
1536   elif test -f $ac_dir/install.sh; then
1537     ac_aux_dir=$ac_dir
1538     ac_install_sh="$ac_aux_dir/install.sh -c"
1539     break
1540   elif test -f $ac_dir/shtool; then
1541     ac_aux_dir=$ac_dir
1542     ac_install_sh="$ac_aux_dir/shtool install -c"
1543     break
1544   fi
1545 done
1546 if test -z "$ac_aux_dir"; then
1547   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1548 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1549    { (exit 1); exit 1; }; }
1550 fi
1551 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1552 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1553 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1554
1555 # Make sure we can run config.sub.
1556 $ac_config_sub sun4 >/dev/null 2>&1 ||
1557   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1558 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1559    { (exit 1); exit 1; }; }
1560
1561 echo "$as_me:$LINENO: checking build system type" >&5
1562 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1563 if test "${ac_cv_build+set}" = set; then
1564   echo $ECHO_N "(cached) $ECHO_C" >&6
1565 else
1566   ac_cv_build_alias=$build_alias
1567 test -z "$ac_cv_build_alias" &&
1568   ac_cv_build_alias=`$ac_config_guess`
1569 test -z "$ac_cv_build_alias" &&
1570   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1571 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1572    { (exit 1); exit 1; }; }
1573 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1574   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1575 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1576    { (exit 1); exit 1; }; }
1577
1578 fi
1579 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1580 echo "${ECHO_T}$ac_cv_build" >&6
1581 build=$ac_cv_build
1582 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1583 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1584 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1585
1586
1587  case ${build_alias} in
1588   "") build_noncanonical=${build} ;;
1589   *) build_noncanonical=${build_alias} ;;
1590 esac
1591
1592
1593
1594  case ${host_alias} in
1595   "") host_noncanonical=${build_noncanonical} ;;
1596   *) host_noncanonical=${host_alias} ;;
1597 esac
1598
1599
1600
1601  case ${target_alias} in
1602   "") target_noncanonical=${host_noncanonical} ;;
1603   *) target_noncanonical=${target_alias} ;;
1604 esac
1605
1606
1607
1608
1609 test "$host_noncanonical" = "$target_noncanonical" &&
1610   test "$program_prefix$program_suffix$program_transform_name" = \
1611     NONENONEs,x,x, &&
1612   program_transform_name=s,y,y,
1613
1614 echo "$as_me:$LINENO: checking host system type" >&5
1615 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1616 if test "${ac_cv_host+set}" = set; then
1617   echo $ECHO_N "(cached) $ECHO_C" >&6
1618 else
1619   ac_cv_host_alias=$host_alias
1620 test -z "$ac_cv_host_alias" &&
1621   ac_cv_host_alias=$ac_cv_build_alias
1622 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1623   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1624 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1625    { (exit 1); exit 1; }; }
1626
1627 fi
1628 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1629 echo "${ECHO_T}$ac_cv_host" >&6
1630 host=$ac_cv_host
1631 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1632 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1633 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1634
1635
1636 echo "$as_me:$LINENO: checking target system type" >&5
1637 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1638 if test "${ac_cv_target+set}" = set; then
1639   echo $ECHO_N "(cached) $ECHO_C" >&6
1640 else
1641   ac_cv_target_alias=$target_alias
1642 test "x$ac_cv_target_alias" = "x" &&
1643   ac_cv_target_alias=$ac_cv_host_alias
1644 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1645   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1646 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1647    { (exit 1); exit 1; }; }
1648
1649 fi
1650 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1651 echo "${ECHO_T}$ac_cv_target" >&6
1652 target=$ac_cv_target
1653 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1654 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1655 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1656
1657
1658 # The aliases save the names the user supplied, while $host etc.
1659 # will get canonicalized.
1660 test -n "$target_alias" &&
1661   test "$program_prefix$program_suffix$program_transform_name" = \
1662     NONENONEs,x,x, &&
1663   program_prefix=${target_alias}-
1664 test "$program_prefix" != NONE &&
1665   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1666 # Use a double $ so make ignores it.
1667 test "$program_suffix" != NONE &&
1668   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1669 # Double any \ or $.  echo might interpret backslashes.
1670 # By default was `s,x,x', remove it if useless.
1671 cat <<\_ACEOF >conftest.sed
1672 s/[\\$]/&&/g;s/;s,x,x,$//
1673 _ACEOF
1674 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1675 rm conftest.sed
1676
1677
1678
1679 # Get 'install' or 'install-sh' and its variants.
1680 # Find a good install program.  We prefer a C program (faster),
1681 # so one script is as good as another.  But avoid the broken or
1682 # incompatible versions:
1683 # SysV /etc/install, /usr/sbin/install
1684 # SunOS /usr/etc/install
1685 # IRIX /sbin/install
1686 # AIX /bin/install
1687 # AmigaOS /C/install, which installs bootblocks on floppy discs
1688 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1689 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1690 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1691 # OS/2's system install, which has a completely different semantic
1692 # ./install, which can be erroneously created by make from ./install.sh.
1693 # Reject install programs that cannot install multiple files.
1694 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1695 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1696 if test -z "$INSTALL"; then
1697 if test "${ac_cv_path_install+set}" = set; then
1698   echo $ECHO_N "(cached) $ECHO_C" >&6
1699 else
1700   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1701 for as_dir in $PATH
1702 do
1703   IFS=$as_save_IFS
1704   test -z "$as_dir" && as_dir=.
1705   # Account for people who put trailing slashes in PATH elements.
1706 case $as_dir/ in
1707   ./ | .// | /cC/* | \
1708   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1709   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1710   /usr/ucb/* ) ;;
1711   *)
1712     # OSF1 and SCO ODT 3.0 have their own names for install.
1713     # Don't use installbsd from OSF since it installs stuff as root
1714     # by default.
1715     for ac_prog in ginstall scoinst install; do
1716       for ac_exec_ext in '' $ac_executable_extensions; do
1717         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1718           if test $ac_prog = install &&
1719             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1720             # AIX install.  It has an incompatible calling convention.
1721             :
1722           elif test $ac_prog = install &&
1723             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1724             # program-specific install script used by HP pwplus--don't use.
1725             :
1726           else
1727             rm -rf conftest.one conftest.two conftest.dir
1728             echo one > conftest.one
1729             echo two > conftest.two
1730             mkdir conftest.dir
1731             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1732               test -s conftest.one && test -s conftest.two &&
1733               test -s conftest.dir/conftest.one &&
1734               test -s conftest.dir/conftest.two
1735             then
1736               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1737               break 3
1738             fi
1739           fi
1740         fi
1741       done
1742     done
1743     ;;
1744 esac
1745 done
1746
1747 rm -rf conftest.one conftest.two conftest.dir
1748
1749 fi
1750   if test "${ac_cv_path_install+set}" = set; then
1751     INSTALL=$ac_cv_path_install
1752   else
1753     # As a last resort, use the slow shell script.  Don't cache a
1754     # value for INSTALL within a source directory, because that will
1755     # break other packages using the cache if that directory is
1756     # removed, or if the value is a relative name.
1757     INSTALL=$ac_install_sh
1758   fi
1759 fi
1760 echo "$as_me:$LINENO: result: $INSTALL" >&5
1761 echo "${ECHO_T}$INSTALL" >&6
1762
1763 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1764 # It thinks the first close brace ends the variable substitution.
1765 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1766
1767 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1768
1769 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1770
1771 echo "$as_me:$LINENO: checking whether ln works" >&5
1772 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1773 if test "${acx_cv_prog_LN+set}" = set; then
1774   echo $ECHO_N "(cached) $ECHO_C" >&6
1775 else
1776   rm -f conftestdata_t
1777 echo >conftestdata_f
1778 if ln conftestdata_f conftestdata_t 2>/dev/null
1779 then
1780   acx_cv_prog_LN=ln
1781 else
1782   acx_cv_prog_LN=no
1783 fi
1784 rm -f conftestdata_f conftestdata_t
1785
1786 fi
1787 if test $acx_cv_prog_LN = no; then
1788   LN="cp"
1789   echo "$as_me:$LINENO: result: no, using $LN" >&5
1790 echo "${ECHO_T}no, using $LN" >&6
1791 else
1792   LN="$acx_cv_prog_LN"
1793   echo "$as_me:$LINENO: result: yes" >&5
1794 echo "${ECHO_T}yes" >&6
1795 fi
1796
1797 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1798 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1799 LN_S=$as_ln_s
1800 if test "$LN_S" = "ln -s"; then
1801   echo "$as_me:$LINENO: result: yes" >&5
1802 echo "${ECHO_T}yes" >&6
1803 else
1804   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1805 echo "${ECHO_T}no, using $LN_S" >&6
1806 fi
1807
1808
1809 ### we might need to use some other shell than /bin/sh for running subshells
1810 ### If we are on Windows, search for the shell.  This will permit people
1811 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1812 ### without also having to set CONFIG_SHELL.  This code will work when
1813 ### using bash, which sets OSTYPE.
1814 case "${OSTYPE}" in
1815 *win32*)
1816   if test x${CONFIG_SHELL} = x ; then
1817     if test ! -f /bin/sh ; then
1818       if test x${SHELL} != x && test -f ${SHELL} ; then
1819         CONFIG_SHELL=${SHELL}
1820         export CONFIG_SHELL
1821       else
1822         for prog in sh sh.exe bash bash.exe; do
1823           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1824           for dir in $PATH; do
1825             test -z "$dir" && dir=.
1826             if test -f $dir/$prog; then
1827               CONFIG_SHELL=$dir/$prog
1828               export CONFIG_SHELL
1829               break
1830             fi
1831           done
1832           IFS="$save_ifs"
1833           test -n "${CONFIG_SHELL}" && break
1834         done
1835       fi
1836     fi
1837   fi
1838   ;;
1839 esac
1840
1841 config_shell=${CONFIG_SHELL-/bin/sh}
1842
1843 moveifchange=${srcdir}/move-if-change
1844
1845 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1846
1847 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1848 # a relative path.
1849 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1850   INSTALL="${srcpwd}/install-sh -c"
1851 fi
1852
1853 # Set srcdir to "." if that's what it is.
1854 # This is important for multilib support.
1855 pwd=`${PWDCMD-pwd}`
1856 if test "${pwd}" = "${srcpwd}" ; then
1857   srcdir=.
1858 fi
1859
1860 topsrcdir=$srcpwd
1861
1862 extra_host_args=
1863
1864 ### To add a new directory to the tree, first choose whether it is a target
1865 ### or a host dependent tool.  Then put it into the appropriate list
1866 ### (library or tools, host or target), doing a dependency sort.
1867
1868 # Subdirs will be configured in the order listed in build_configdirs,
1869 # configdirs, or target_configdirs; see the serialization section below.
1870
1871 # Dependency sorting is only needed when *configuration* must be done in
1872 # a particular order.  In all cases a dependency should be specified in
1873 # the Makefile, whether or not it's implicitly specified here.
1874
1875 # Double entries in build_configdirs, configdirs, or target_configdirs may
1876 # cause circular dependencies and break everything horribly.
1877
1878 # these library is used by various programs built for the build
1879 # environment
1880 #
1881 build_libs="build-libiberty"
1882
1883 # these tools are built for the build environment
1884 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1885
1886 # these libraries are used by various programs built for the host environment
1887 #
1888 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr ppl cloog"
1889
1890 # these tools are built for the host environment
1891 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1892 # know that we are building the simulator.
1893 # binutils, gas and ld appear in that order because it makes sense to run
1894 # "make check" in that particular order.
1895 # If --enable-gold is used, "gold" will replace "ld".
1896 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"
1897
1898 # libgcj represents the runtime libraries only used by gcj.
1899 libgcj="target-libffi \
1900         target-zlib \
1901         target-qthreads \
1902         target-libjava"
1903
1904 # these libraries are built for the target environment, and are built after
1905 # the host libraries and the host tools (which may be a cross compiler)
1906 #
1907 target_libraries="target-libgcc \
1908                 target-libiberty \
1909                 target-libgloss \
1910                 target-newlib \
1911                 target-libgomp \
1912                 target-libstdc++-v3 \
1913                 target-libmudflap \
1914                 target-libssp \
1915                 target-libgfortran \
1916                 target-boehm-gc \
1917                 ${libgcj} \
1918                 target-libobjc \
1919                 target-libada"
1920
1921 # these tools are built using the target libraries, and are intended to
1922 # run only in the target environment
1923 #
1924 # note: any program that *uses* libraries that are in the "target_libraries"
1925 # list belongs in this list.  those programs are also very likely
1926 # candidates for the "native_only" list which follows
1927 #
1928 target_tools="target-examples target-groff target-gperf target-rda"
1929
1930 ################################################################################
1931
1932 ## All tools belong in one of the four categories, and are assigned above
1933 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1934 ## is important because configure will choke if they ever get through.
1935 ## ${configdirs} is directories we build using the host tools.
1936 ## ${target_configdirs} is directories we build using the target tools.
1937 configdirs=`echo ${host_libs} ${host_tools}`
1938 target_configdirs=`echo ${target_libraries} ${target_tools}`
1939 build_configdirs=`echo ${build_libs} ${build_tools}`
1940
1941
1942
1943 ################################################################################
1944
1945 srcname="gnu development package"
1946
1947 # This gets set non-empty for some net releases of packages.
1948 appdirs=""
1949
1950 # Define is_cross_compiler to save on calls to 'test'.
1951 is_cross_compiler=
1952 if test x"${host}" = x"${target}" ; then
1953   is_cross_compiler=no
1954 else
1955   is_cross_compiler=yes
1956 fi
1957
1958 # Find the build and target subdir names.
1959
1960 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1961 # have matching libraries, they should use host libraries: Makefile.tpl
1962 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1963 # However, they still use the build modules, because the corresponding
1964 # host modules (e.g. bison) are only built for the host when bootstrap
1965 # finishes. So:
1966 # - build_subdir is where we find build modules, and never changes.
1967 # - build_libsubdir is where we find build libraries, and can be overridden.
1968
1969 # Prefix 'build-' so this never conflicts with target_subdir.
1970 build_subdir="build-${build_noncanonical}"
1971
1972 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1973 if test "${with_build_libsubdir+set}" = set; then
1974   withval="$with_build_libsubdir"
1975   build_libsubdir="$withval"
1976 else
1977   build_libsubdir="$build_subdir"
1978 fi;
1979 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1980 if ( test $srcdir = . && test -d gcc ) \
1981    || test -d $srcdir/../host-${host_noncanonical}; then
1982   host_subdir="host-${host_noncanonical}"
1983 else
1984   host_subdir=.
1985 fi
1986 # No prefix.
1987 target_subdir=${target_noncanonical}
1988
1989
1990 # Skipdirs are removed silently.
1991 skipdirs=
1992 # Noconfigdirs are removed loudly.
1993 noconfigdirs=""
1994
1995 use_gnu_ld=
1996 # Make sure we don't let GNU ld be added if we didn't want it.
1997 if test x$with_gnu_ld = xno ; then
1998   use_gnu_ld=no
1999   noconfigdirs="$noconfigdirs ld gold"
2000 fi
2001
2002 use_gnu_as=
2003 # Make sure we don't let GNU as be added if we didn't want it.
2004 if test x$with_gnu_as = xno ; then
2005   use_gnu_as=no
2006   noconfigdirs="$noconfigdirs gas"
2007 fi
2008
2009 # some tools are so dependent upon X11 that if we're not building with X,
2010 # it's not even worth trying to configure, much less build, that tool.
2011
2012 case ${with_x} in
2013   yes | "") ;; # the default value for this tree is that X11 is available
2014   no)
2015     skipdirs="${skipdirs} tk itcl libgui"
2016     # We won't be able to build gdbtk without X.
2017     enable_gdbtk=no
2018     ;;
2019   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2020 esac
2021
2022 # Some tools are only suitable for building in a "native" situation.
2023 # Remove these if host!=target.
2024 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"
2025
2026 # Similarly, some are only suitable for cross toolchains.
2027 # Remove these if host=target.
2028 cross_only="target-libgloss target-newlib target-opcodes"
2029
2030 case $is_cross_compiler in
2031   no) skipdirs="${skipdirs} ${cross_only}" ;;
2032   yes) skipdirs="${skipdirs} ${native_only}" ;;
2033 esac
2034
2035 # If both --with-headers and --with-libs are specified, default to
2036 # --without-newlib.
2037 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2038    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2039   if test x"${with_newlib}" = x ; then
2040     with_newlib=no
2041   fi
2042 fi
2043
2044 # Recognize --with-newlib/--without-newlib.
2045 case ${with_newlib} in
2046   no) skipdirs="${skipdirs} target-newlib" ;;
2047   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2048 esac
2049
2050 # Handle --enable-gold.
2051
2052 # Check whether --enable-gold or --disable-gold was given.
2053 if test "${enable_gold+set}" = set; then
2054   enableval="$enable_gold"
2055   ENABLE_GOLD=$enableval
2056 else
2057   ENABLE_GOLD=no
2058 fi;
2059 if test "${ENABLE_GOLD}" = "yes"; then
2060   # Check for ELF target.
2061   is_elf=no
2062   case "${target}" in
2063     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2064     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2065     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2066       case "${target}" in
2067         *-*-linux*aout* | *-*-linux*oldld*)
2068           ;;
2069         *)
2070           is_elf=yes
2071           ;;
2072       esac
2073   esac
2074
2075   if test "$is_elf" = "yes"; then
2076     # Check for target supported by gold.
2077     case "${target}" in
2078       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-*)
2079         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2080         ;;
2081     esac
2082   fi
2083 fi
2084
2085 # Configure extra directories which are host specific
2086
2087 case "${host}" in
2088   *-cygwin*)
2089     configdirs="$configdirs libtermcap" ;;
2090 esac
2091
2092 # A target can indicate whether a language isn't supported for some reason.
2093 # Only spaces may be used in this macro; not newlines or tabs.
2094 unsupported_languages=
2095
2096 # Remove more programs from consideration, based on the host or
2097 # target this usually means that a port of the program doesn't
2098 # exist yet.
2099
2100 case "${host}" in
2101   hppa*64*-*-*)
2102     noconfigdirs="$noconfigdirs byacc"
2103     ;;
2104   i[3456789]86-*-vsta)
2105     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2106     ;;
2107   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2108     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2109     ;;
2110   x86_64-*-mingw*)
2111     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2112     ;;
2113   i[3456789]86-*-mingw32*)
2114     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2115     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2116     ;;
2117   i[3456789]86-*-beos*)
2118     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2119     ;;
2120   *-*-cygwin*)
2121     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2122     ;;
2123   *-*-netbsd*)
2124     noconfigdirs="$noconfigdirs rcs"
2125     ;;
2126   ppc*-*-pe)
2127     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2128     ;;
2129   powerpc-*-beos*)
2130     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2131     ;;
2132 esac
2133
2134
2135 # Check whether --enable-libada or --disable-libada was given.
2136 if test "${enable_libada+set}" = set; then
2137   enableval="$enable_libada"
2138   ENABLE_LIBADA=$enableval
2139 else
2140   ENABLE_LIBADA=yes
2141 fi;
2142 if test "${ENABLE_LIBADA}" != "yes" ; then
2143   noconfigdirs="$noconfigdirs gnattools"
2144 fi
2145
2146 # Check whether --enable-libssp or --disable-libssp was given.
2147 if test "${enable_libssp+set}" = set; then
2148   enableval="$enable_libssp"
2149   ENABLE_LIBSSP=$enableval
2150 else
2151   ENABLE_LIBSSP=yes
2152 fi;
2153
2154 # Save it here so that, even in case of --enable-libgcj, if the Java
2155 # front-end isn't enabled, we still get libgcj disabled.
2156 libgcj_saved=$libgcj
2157 case $enable_libgcj in
2158 yes)
2159   # If we reset it here, it won't get added to noconfigdirs in the
2160   # target-specific build rules, so it will be forcibly enabled
2161   # (unless the Java language itself isn't enabled).
2162   libgcj=
2163   ;;
2164 no)
2165   # Make sure we get it printed in the list of not supported target libs.
2166   noconfigdirs="$noconfigdirs ${libgcj}"
2167   ;;
2168 esac
2169
2170
2171 # Disable libmudflap on some systems.
2172 if test x$enable_libmudflap = x ; then
2173     case "${target}" in
2174     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux* | *-*-kopensolaris*-gnu)
2175         # Enable libmudflap by default in GNU and friends.
2176         ;;
2177     *-*-freebsd*)
2178         # Enable libmudflap by default in FreeBSD.
2179         ;;
2180     *)
2181         # Disable it by default everywhere else.
2182         noconfigdirs="$noconfigdirs target-libmudflap"
2183         ;;
2184     esac
2185 fi
2186
2187 # Disable libgomp on non POSIX hosted systems.
2188 if test x$enable_libgomp = x ; then
2189     # Enable libgomp by default on hosted POSIX systems.
2190     case "${target}" in
2191     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2192         ;;
2193     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2194         ;;
2195     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2196         ;;
2197     *-*-darwin* | *-*-aix*)
2198         ;;
2199     *)
2200         noconfigdirs="$noconfigdirs target-libgomp"
2201         ;;
2202     esac
2203 fi
2204
2205 # Default libgloss CPU subdirectory.
2206 libgloss_dir="$target_cpu"
2207
2208 case "${target}" in
2209   *-*-chorusos)
2210     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2211     ;;
2212   powerpc-*-darwin* | x86_64-*-darwin[912]*)
2213     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2214     noconfigdirs="$noconfigdirs sim target-rda"
2215     ;;
2216   i[3456789]86-*-darwin*)
2217     noconfigdirs="$noconfigdirs ld gas gprof"
2218     noconfigdirs="$noconfigdirs sim target-rda"
2219     ;;
2220   *-*-darwin*)
2221     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2222     noconfigdirs="$noconfigdirs sim target-rda"
2223     noconfigdirs="$noconfigdirs ${libgcj}"
2224     ;;
2225   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2226     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2227     ;;
2228   *-*-freebsd*)
2229     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2230     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2231         && test -f /usr/local/include/gmp.h; then
2232       with_gmp=/usr/local
2233     fi
2234
2235     # Skip some stuff that's unsupported on some FreeBSD configurations.
2236     case "${target}" in
2237       i*86-*-*) ;;
2238       alpha*-*-*) ;;
2239       *)
2240         noconfigdirs="$noconfigdirs ${libgcj}"
2241         ;;
2242     esac
2243     ;;
2244   *-*-kaos*)
2245     # Remove unsupported stuff on all kaOS configurations.
2246     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2247     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2248     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2249     noconfigdirs="$noconfigdirs target-libgloss"
2250     ;;
2251   *-*-netbsd*)
2252     # Skip some stuff on all NetBSD configurations.
2253     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2254
2255     # Skip some stuff that's unsupported on some NetBSD configurations.
2256     case "${target}" in
2257       i*86-*-netbsdelf*) ;;
2258       arm*-*-netbsdelf*) ;;
2259       *)
2260         noconfigdirs="$noconfigdirs ${libgcj}"
2261         ;;
2262     esac
2263     ;;
2264   *-*-netware*)
2265     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2266     ;;
2267   *-*-rtems*)
2268     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2269     ;;
2270     # The tpf target doesn't support gdb yet.
2271   *-*-tpf*)
2272     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2273     ;;
2274   *-*-uclinux*)
2275     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2276     ;;
2277   *-*-vxworks*)
2278     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2279     ;;
2280   alpha*-dec-osf*)
2281     # ld works, but does not support shared libraries.
2282     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2283     # gas doesn't generate exception information.
2284     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2285     ;;
2286   alpha*-*-*vms*)
2287     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2288     ;;
2289   alpha*-*-linux*)
2290     # newlib is not 64 bit ready
2291     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2292     ;;
2293   alpha*-*-*)
2294     # newlib is not 64 bit ready
2295     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2296     ;;
2297   am33_2.0-*-linux*)
2298     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2299     ;;
2300   sh-*-linux*)
2301     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2302     ;;
2303   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2304     noconfigdirs="$noconfigdirs ${libgcj}"
2305     noconfigdirs="$noconfigdirs target-examples"
2306     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2307     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2308     noconfigdirs="$noconfigdirs expect dejagnu"
2309     # the C++ libraries don't build on top of CE's C libraries
2310     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2311     noconfigdirs="$noconfigdirs target-newlib"
2312     case "${host}" in
2313       *-*-cygwin*) ;; # keep gdb and readline
2314       *) noconfigdirs="$noconfigdirs gdb readline"
2315          ;;
2316     esac
2317     libgloss_dir=wince
2318     ;;
2319   arc-*-*)
2320     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2321     ;;
2322   arm-semi-aof )
2323     ;;
2324   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2325     noconfigdirs="$noconfigdirs ${libgcj}"
2326     libgloss_dir=arm
2327     ;;
2328   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2329     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2330     libgloss_dir=arm
2331     ;;
2332   arm*-*-linux-gnueabi)
2333     noconfigdirs="$noconfigdirs target-qthreads"
2334     case ${with_newlib} in
2335       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2336     esac
2337     libgloss_dir=arm
2338     ;;
2339   arm*-*-symbianelf*)
2340     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2341     libgloss_dir=arm
2342     ;;
2343   arm-*-pe*)
2344     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2345     ;;
2346   thumb-*-coff)
2347     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2348     ;;
2349   thumb-*-elf)
2350     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2351     ;;
2352   thumb-*-pe)
2353     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2354     ;;
2355   arm-*-riscix*)
2356     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2357     ;;
2358   avr-*-*)
2359     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2360     ;;
2361   bfin-*-*)
2362     noconfigdirs="$noconfigdirs gdb"
2363     if test x${is_cross_compiler} != xno ; then
2364       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2365     fi
2366     ;;
2367   c4x-*-* | tic4x-*-*)
2368     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2369     ;;
2370   c54x*-*-* | tic54x-*-*)
2371     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2372     ;;
2373   cr16-*-*)
2374     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2375     ;;
2376   cris-*-* | crisv32-*-*)
2377     unsupported_languages="$unsupported_languages java"
2378     case "${target}" in
2379       *-*-aout)
2380         unsupported_languages="$unsupported_languages fortran"
2381         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2382       *-*-elf)
2383         noconfigdirs="$noconfigdirs target-boehm-gc";;
2384       *-*-linux*)
2385         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2386       *)
2387         unsupported_languages="$unsupported_languages fortran"
2388         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2389     esac
2390     libgloss_dir=cris
2391     ;;
2392   crx-*-*)
2393     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2394     ;;
2395   d10v-*-*)
2396     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2397     ;;
2398   d30v-*-*)
2399     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2400     ;;
2401   ep9312-*-elf | ep9312-*-coff)
2402     libgloss_dir=arm
2403     ;;
2404   fr30-*-elf*)
2405     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2406     ;;
2407   frv-*-*)
2408     noconfigdirs="$noconfigdirs ${libgcj}"
2409     ;;
2410   h8300*-*-*)
2411     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2412     ;;
2413   h8500-*-*)
2414     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2415     ;;
2416   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2417     ;;
2418   hppa*64*-*-linux* | parisc*64*-*-linux*)
2419     # In this case, it's because the hppa64-linux target is for
2420     # the kernel only at this point and has no libc, and thus no
2421     # headers, crt*.o, etc., all of which are needed by these.
2422     noconfigdirs="$noconfigdirs target-zlib"
2423     ;;
2424   parisc*-*-linux* | hppa*-*-linux*)
2425     ;;
2426   hppa*-*-*elf* | \
2427   hppa*-*-lites* | \
2428   hppa*-*-openbsd* | \
2429   hppa*64*-*-*)
2430     noconfigdirs="$noconfigdirs ${libgcj}"
2431     ;;
2432   hppa*-hp-hpux11*)
2433     noconfigdirs="$noconfigdirs ld shellutils"
2434     ;;
2435   hppa*-*-pro*)
2436     libgloss_dir=pa
2437     ;;
2438   hppa*-*-*)
2439     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2440     # build on HP-UX 10.20.
2441     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2442     ;;
2443   i960-*-*)
2444     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2445     ;;
2446   ia64*-*-elf*)
2447     # No gdb support yet.
2448     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2449     ;;
2450   ia64*-**-hpux*)
2451     # No gdb or ld support yet.
2452     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2453     ;;
2454   ia64*-*-*vms*)
2455     # No gdb or ld support yet.
2456     noconfigdirs="$noconfigdirs ${libgcj} tix readline mmalloc libgui itcl gdb ld"
2457     ;;
2458   i370-*-opened*)
2459     ;;
2460   i[3456789]86-*-coff | i[3456789]86-*-elf)
2461     noconfigdirs="$noconfigdirs ${libgcj}"
2462     libgloss_dir=i386
2463     ;;
2464   i[3456789]86-*-linux*)
2465     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2466     # not build java stuff by default.
2467     case "${target}" in
2468       *-*-*libc1*)
2469         noconfigdirs="$noconfigdirs ${libgcj}";;
2470     esac
2471
2472     # This section makes it possible to build newlib natively on linux.
2473     # If we are using a cross compiler then don't configure newlib.
2474     if test x${is_cross_compiler} != xno ; then
2475       noconfigdirs="$noconfigdirs target-newlib"
2476     fi
2477     noconfigdirs="$noconfigdirs target-libgloss"
2478     # If we are not using a cross compiler, do configure newlib.
2479     # Note however, that newlib will only be configured in this situation
2480     # if the --with-newlib option has been given, because otherwise
2481     # 'target-newlib' will appear in skipdirs.
2482     ;;
2483   i[3456789]86-*-mingw32*)
2484     target_configdirs="$target_configdirs target-winsup"
2485     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2486     ;;
2487   x86_64-*-mingw*)
2488     target_configdirs="$target_configdirs target-winsup"
2489     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2490     ;;
2491   *-*-cygwin*)
2492     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2493     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2494     # always build newlib if winsup directory is present.
2495     if test -d "$srcdir/winsup/cygwin"; then
2496       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2497     elif test -d "$srcdir/newlib"; then
2498       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2499     fi
2500     ;;
2501   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2502   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2503     ;;
2504   i[3456789]86-*-pe)
2505     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2506     ;;
2507   i[3456789]86-*-sco3.2v5*)
2508     # The linker does not yet know about weak symbols in COFF,
2509     # and is not configured to handle mixed ELF and COFF.
2510     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2511     ;;
2512   i[3456789]86-*-sco*)
2513     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2514     ;;
2515   i[3456789]86-*-solaris2*)
2516     noconfigdirs="$noconfigdirs target-libgloss"
2517     ;;
2518   i[3456789]86-*-sysv4*)
2519     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2520     ;;
2521   i[3456789]86-*-beos*)
2522     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2523     ;;
2524   i[3456789]86-*-rdos*)
2525     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2526     ;;
2527   m32r-*-*)
2528     noconfigdirs="$noconfigdirs ${libgcj}"
2529     ;;
2530   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2531     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2532     libgloss_dir=m68hc11
2533     ;;
2534   m68k-*-elf*)
2535     noconfigdirs="$noconfigdirs ${libgcj}"
2536     ;;
2537   m68k-*-coff*)
2538     noconfigdirs="$noconfigdirs ${libgcj}"
2539     ;;
2540   m68*-*-* | fido-*-*)
2541     libgloss_dir=m68k
2542     ;;
2543   mcore-*-pe*)
2544   # The EPOC C++ environment does not support exceptions or rtti,
2545   # and so building libstdc++-v3 tends not to always work.
2546     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2547     ;;
2548   mmix-*-*)
2549     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2550     unsupported_languages="$unsupported_languages fortran java"
2551     ;;
2552   mn10200-*-*)
2553     noconfigdirs="$noconfigdirs ${libgcj}"
2554     ;;
2555   mn10300-*-*)
2556     noconfigdirs="$noconfigdirs ${libgcj}"
2557     ;;
2558   mt-*-*)
2559     noconfigdirs="$noconfigdirs sim"
2560     ;;
2561   powerpc-*-aix*)
2562     # copied from rs6000-*-* entry
2563     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2564     ;;
2565   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2566     target_configdirs="$target_configdirs target-winsup"
2567     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2568     # always build newlib.
2569     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2570     ;;
2571     # This is temporary until we can link against shared libraries
2572   powerpcle-*-solaris*)
2573     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2574     libgloss_dir=rs6000
2575     ;;
2576   powerpc-*-beos*)
2577     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2578     ;;
2579   powerpc-*-eabi)
2580     noconfigdirs="$noconfigdirs ${libgcj}"
2581     libgloss_dir=rs6000
2582     ;;
2583   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2584     libgloss_dir=rs6000
2585     ;;
2586   rs6000-*-lynxos*)
2587     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2588     ;;
2589   rs6000-*-aix*)
2590     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2591     ;;
2592   rs6000-*-*)
2593     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2594     ;;
2595   m68k-apollo-*)
2596     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2597     ;;
2598   mips*-sde-elf*)
2599     skipdirs="$skipdirs target-libiberty"
2600     noconfigdirs="$noconfigdirs ${libgcj}"
2601     if test x$with_newlib = xyes; then
2602       noconfigdirs="$noconfigdirs gprof"
2603     fi
2604     libgloss_dir=mips
2605     ;;
2606   mips*-*-irix5*)
2607     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2608     ;;
2609   mips*-*-irix6*)
2610     # Linking libjava exceeds command-line length limits on at least
2611     # IRIX 6.2, but not on IRIX 6.5.
2612     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2613     # <oldham@codesourcery.com>
2614     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2615     ;;
2616   mips*-*-bsd*)
2617     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2618     ;;
2619   mips*-*-linux*)
2620     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2621     ;;
2622   mips*-*-*)
2623     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2624     libgloss_dir=mips
2625     ;;
2626   romp-*-*)
2627     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2628     ;;
2629   sh-*-* | sh64-*-*)
2630     case "${host}" in
2631       i[3456789]86-*-vsta) ;; # don't add gprof back in
2632       i[3456789]86-*-go32*) ;; # don't add gprof back in
2633       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2634       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2635     esac
2636     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2637     ;;
2638   sparclet-*-aout* | sparc86x-*-*)
2639     libgloss_dir=sparc
2640     ;;
2641   sparc-*-elf*)
2642     noconfigdirs="$noconfigdirs ${libgcj}"
2643     ;;
2644   sparc64-*-elf*)
2645     noconfigdirs="$noconfigdirs ${libgcj}"
2646     libgloss_dir=sparc
2647     ;;
2648   sparclite-*-*)
2649     noconfigdirs="$noconfigdirs ${libgcj}"
2650     libgloss_dir=sparc
2651     ;;
2652   sparc-*-sunos4*)
2653     noconfigdirs="$noconfigdirs ${libgcj}"
2654     if test x${is_cross_compiler} != xno ; then
2655            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2656     else
2657            use_gnu_ld=no
2658     fi
2659     ;;
2660   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2661     noconfigdirs="$noconfigdirs ${libgcj}"
2662     ;;
2663   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2664     ;;
2665   v810-*-*)
2666     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2667     ;;
2668   v850-*-*)
2669     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2670     ;;
2671   v850e-*-*)
2672     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2673     ;;
2674   v850ea-*-*)
2675     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2676     ;;
2677   vax-*-vms)
2678     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2679     ;;
2680   vax-*-*)
2681     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2682     ;;
2683   xtensa*-*-*)
2684     noconfigdirs="$noconfigdirs ${libgcj}"
2685     ;;
2686   ip2k-*-*)
2687     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2688     ;;
2689   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
2690     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2691     ;;
2692   *-*-lynxos*)
2693     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2694     ;;
2695   *-*-*)
2696     noconfigdirs="$noconfigdirs ${libgcj}"
2697     ;;
2698 esac
2699
2700 # If we aren't building newlib, then don't build libgloss, since libgloss
2701 # depends upon some newlib header files.
2702 case "${noconfigdirs}" in
2703   *target-libgloss*) ;;
2704   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2705 esac
2706
2707 # Work in distributions that contain no compiler tools, like Autoconf.
2708 tentative_cc=""
2709 host_makefile_frag=/dev/null
2710 if test -d ${srcdir}/config ; then
2711 case "${host}" in
2712   m68k-hp-hpux*)
2713     # Avoid "too much defining" errors from HPUX compiler.
2714     tentative_cc="cc -Wp,-H256000"
2715     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2716     # If it's HP/UX ar, this should be harmless.
2717     RANLIB="ar ts"
2718     ;;
2719   m68k-apollo-sysv*)
2720     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2721     ;;
2722   m68k-apollo-bsd*)
2723     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2724     # chokes on bfd, the compiler won't let you assign integers to enums, and
2725     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2726     # the apollo compiler" (the preferred version of GCC could be called cc,
2727     # or whatever), but I'm not sure leaving CC as cc is any better...
2728     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2729     # Used to have BISON=yacc.
2730     tentative_cc=gcc
2731     ;;
2732   m88k-dg-dgux*)
2733     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2734     ;;
2735   m88k-harris-cxux*)
2736     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2737     tentative_cc="cc -Xa"
2738     host_makefile_frag="config/mh-cxux"
2739     ;;
2740   m88k-motorola-sysv*)
2741     ;;
2742   mips*-dec-ultrix*)
2743     tentative_cc="cc -Wf,-XNg1000"
2744     host_makefile_frag="config/mh-decstation"
2745     ;;
2746   mips*-nec-sysv4*)
2747     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2748     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2749     host_makefile_frag="config/mh-necv4"
2750     ;;
2751   mips*-sgi-irix4*)
2752     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2753     # environment.  Also bump switch table size so that cp-parse will
2754     # compile.  Bump string length limit so linker builds.
2755     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2756     ;;
2757   mips*-*-sysv4*)
2758     host_makefile_frag="config/mh-sysv4"
2759     ;;
2760   mips*-*-sysv*)
2761     # This is for a MIPS running RISC/os 4.52C.
2762
2763     # This is needed for GDB, but needs to be in the top-level make because
2764     # if a library is compiled with the bsd headers and gets linked with the
2765     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2766     # a different size).
2767     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2768     # known except to select the sysv environment.  Could we use /proc instead?
2769     # These "sysv environments" and "bsd environments" often end up being a pain.
2770     #
2771     # This is not part of CFLAGS because perhaps not all C compilers have this
2772     # option.
2773     tentative_cc="cc -systype sysv"
2774     ;;
2775   i370-ibm-opened*)
2776     tentative_cc="c89"
2777     ;;
2778   i[3456789]86-*-sysv5*)
2779     host_makefile_frag="config/mh-sysv5"
2780     ;;
2781   i[3456789]86-*-dgux*)
2782     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2783     host_makefile_frag="config/mh-dgux386"
2784     ;;
2785   i[3456789]86-ncr-sysv4.3*)
2786     # The MetaWare compiler will generate a copyright message unless you
2787     # turn it off by adding the -Hnocopyr flag.
2788     tentative_cc="cc -Hnocopyr"
2789     ;;
2790   i[3456789]86-ncr-sysv4*)
2791     # for an NCR 3000 (i486/SVR4) system.
2792     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2793     # This compiler not only emits obnoxious copyright messages every time
2794     # you run it, but it chokes and dies on a whole bunch of GNU source
2795     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2796     tentative_cc="/usr/ccs/ATT/cc"
2797     host_makefile_frag="config/mh-ncr3000"
2798     ;;
2799   i[3456789]86-*-sco3.2v5*)
2800     ;;
2801   i[3456789]86-*-sco*)
2802     # The native C compiler botches some simple uses of const.  Unfortunately,
2803     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2804     tentative_cc="cc -Dconst="
2805     host_makefile_frag="config/mh-sco"
2806     ;;
2807   i[3456789]86-*-udk*)
2808     host_makefile_frag="config/mh-sysv5"
2809     ;;
2810   i[3456789]86-*-solaris2*)
2811     host_makefile_frag="config/mh-sysv4"
2812     ;;
2813   i[3456789]86-*-msdosdjgpp*)
2814     host_makefile_frag="config/mh-djgpp"
2815     ;;
2816   *-cygwin*)
2817
2818 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2819 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2820 echo a >cygwin-cat-check
2821 if test `cat cygwin-cat-check` == a ; then
2822   rm cygwin-cat-check
2823   echo "$as_me:$LINENO: result: yes" >&5
2824 echo "${ECHO_T}yes" >&6
2825 else
2826   rm cygwin-cat-check
2827   echo "$as_me:$LINENO: result: no" >&5
2828 echo "${ECHO_T}no" >&6
2829   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2830   Please either mount the build directory in binary mode or run the following
2831   commands before running any configure script:
2832 set -o igncr
2833 export SHELLOPTS
2834   " >&5
2835 echo "$as_me: 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   " >&2;}
2841    { (exit 1); exit 1; }; }
2842 fi
2843
2844     host_makefile_frag="config/mh-cygwin"
2845     ;;
2846   *-mingw*)
2847     host_makefile_frag="config/mh-mingw"
2848     ;;
2849   *-interix*)
2850     host_makefile_frag="config/mh-interix"
2851     ;;
2852   vax-*-ultrix2*)
2853     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2854     tentative_cc=gcc
2855     ;;
2856   *-*-solaris2*)
2857     host_makefile_frag="config/mh-solaris"
2858     ;;
2859   m68k-sun-sunos*)
2860     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2861     # without overflowing the jump tables (-J says to use a 32 bit table)
2862     tentative_cc="cc -J"
2863     ;;
2864   hppa*-hp-hpux10*)
2865     tentative_cc="cc -Wp,-H256000"
2866     host_makefile_frag="config/mh-pa-hpux10"
2867     ;;
2868   hppa*-hp-hpux* | hppa*-*-hiux*)
2869     tentative_cc="cc -Wp,-H256000"
2870     host_makefile_frag="config/mh-pa"
2871     ;;
2872   hppa*-*)
2873     host_makefile_frag="config/mh-pa"
2874     ;;
2875   *-hp-hpux* | *-*-hiux*)
2876     tentative_cc="cc -Wp,-H256000"
2877     ;;
2878   rs6000-*-lynxos*)
2879     # /bin/cc is less than useful for our purposes.  Always use GCC
2880     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2881     host_makefile_frag="config/mh-lynxrs6k"
2882     ;;
2883   powerpc-*-darwin*)
2884     host_makefile_frag="config/mh-ppc-darwin"
2885     ;;
2886   powerpc-*-aix*)
2887     host_makefile_frag="config/mh-ppc-aix"
2888     ;;
2889   rs6000-*-aix*)
2890     host_makefile_frag="config/mh-ppc-aix"
2891     ;;
2892   *-*-lynxos*)
2893     # /bin/cc is less than useful for our purposes.  Always use GCC
2894     tentative_cc="/bin/gcc"
2895     ;;
2896   *-*-sysv4*)
2897     host_makefile_frag="config/mh-sysv4"
2898     ;;
2899   # This is placed last to prevent interfering with the cases above.
2900   i[3456789]86-*-*)
2901     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2902     host_makefile_frag="config/mh-x86omitfp"
2903     ;;
2904 esac
2905 fi
2906
2907 # If we aren't going to be using gcc, see if we can extract a definition
2908 # of CC from the fragment.
2909 # Actually, use the 'pre-extracted' version above.
2910 if test -z "${CC}" && test "${build}" = "${host}" ; then
2911   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2912   found=
2913   for dir in $PATH; do
2914     test -z "$dir" && dir=.
2915     if test -f $dir/gcc; then
2916       found=yes
2917       break
2918     fi
2919   done
2920   IFS="$save_ifs"
2921   if test -z "${found}" && test -n "${tentative_cc}" ; then
2922     CC=$tentative_cc
2923   fi
2924 fi
2925
2926 if test "${build}" != "${host}" ; then
2927   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2928   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2929   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2930   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2931   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2932   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2933   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2934   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2935   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2936   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2937   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2938   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2939 else
2940   AR_FOR_BUILD="\$(AR)"
2941   AS_FOR_BUILD="\$(AS)"
2942   CC_FOR_BUILD="\$(CC)"
2943   CXX_FOR_BUILD="\$(CXX)"
2944   GCJ_FOR_BUILD="\$(GCJ)"
2945   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2946   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2947   LD_FOR_BUILD="\$(LD)"
2948   NM_FOR_BUILD="\$(NM)"
2949   RANLIB_FOR_BUILD="\$(RANLIB)"
2950   WINDRES_FOR_BUILD="\$(WINDRES)"
2951   WINDMC_FOR_BUILD="\$(WINDMC)"
2952 fi
2953
2954 ac_ext=c
2955 ac_cpp='$CPP $CPPFLAGS'
2956 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2957 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2958 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2959 if test -n "$ac_tool_prefix"; then
2960   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2961 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2962 echo "$as_me:$LINENO: checking for $ac_word" >&5
2963 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2964 if test "${ac_cv_prog_CC+set}" = set; then
2965   echo $ECHO_N "(cached) $ECHO_C" >&6
2966 else
2967   if test -n "$CC"; then
2968   ac_cv_prog_CC="$CC" # Let the user override the test.
2969 else
2970 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2971 for as_dir in $PATH
2972 do
2973   IFS=$as_save_IFS
2974   test -z "$as_dir" && as_dir=.
2975   for ac_exec_ext in '' $ac_executable_extensions; do
2976   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2977     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2978     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2979     break 2
2980   fi
2981 done
2982 done
2983
2984 fi
2985 fi
2986 CC=$ac_cv_prog_CC
2987 if test -n "$CC"; then
2988   echo "$as_me:$LINENO: result: $CC" >&5
2989 echo "${ECHO_T}$CC" >&6
2990 else
2991   echo "$as_me:$LINENO: result: no" >&5
2992 echo "${ECHO_T}no" >&6
2993 fi
2994
2995 fi
2996 if test -z "$ac_cv_prog_CC"; then
2997   ac_ct_CC=$CC
2998   # Extract the first word of "gcc", so it can be a program name with args.
2999 set dummy gcc; ac_word=$2
3000 echo "$as_me:$LINENO: checking for $ac_word" >&5
3001 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3002 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3003   echo $ECHO_N "(cached) $ECHO_C" >&6
3004 else
3005   if test -n "$ac_ct_CC"; then
3006   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3007 else
3008 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3009 for as_dir in $PATH
3010 do
3011   IFS=$as_save_IFS
3012   test -z "$as_dir" && as_dir=.
3013   for ac_exec_ext in '' $ac_executable_extensions; do
3014   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3015     ac_cv_prog_ac_ct_CC="gcc"
3016     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3017     break 2
3018   fi
3019 done
3020 done
3021
3022 fi
3023 fi
3024 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3025 if test -n "$ac_ct_CC"; then
3026   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3027 echo "${ECHO_T}$ac_ct_CC" >&6
3028 else
3029   echo "$as_me:$LINENO: result: no" >&5
3030 echo "${ECHO_T}no" >&6
3031 fi
3032
3033   CC=$ac_ct_CC
3034 else
3035   CC="$ac_cv_prog_CC"
3036 fi
3037
3038 if test -z "$CC"; then
3039   if test -n "$ac_tool_prefix"; then
3040   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3041 set dummy ${ac_tool_prefix}cc; ac_word=$2
3042 echo "$as_me:$LINENO: checking for $ac_word" >&5
3043 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3044 if test "${ac_cv_prog_CC+set}" = set; then
3045   echo $ECHO_N "(cached) $ECHO_C" >&6
3046 else
3047   if test -n "$CC"; then
3048   ac_cv_prog_CC="$CC" # Let the user override the test.
3049 else
3050 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3051 for as_dir in $PATH
3052 do
3053   IFS=$as_save_IFS
3054   test -z "$as_dir" && as_dir=.
3055   for ac_exec_ext in '' $ac_executable_extensions; do
3056   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3057     ac_cv_prog_CC="${ac_tool_prefix}cc"
3058     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3059     break 2
3060   fi
3061 done
3062 done
3063
3064 fi
3065 fi
3066 CC=$ac_cv_prog_CC
3067 if test -n "$CC"; then
3068   echo "$as_me:$LINENO: result: $CC" >&5
3069 echo "${ECHO_T}$CC" >&6
3070 else
3071   echo "$as_me:$LINENO: result: no" >&5
3072 echo "${ECHO_T}no" >&6
3073 fi
3074
3075 fi
3076 if test -z "$ac_cv_prog_CC"; then
3077   ac_ct_CC=$CC
3078   # Extract the first word of "cc", so it can be a program name with args.
3079 set dummy cc; ac_word=$2
3080 echo "$as_me:$LINENO: checking for $ac_word" >&5
3081 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3082 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3083   echo $ECHO_N "(cached) $ECHO_C" >&6
3084 else
3085   if test -n "$ac_ct_CC"; then
3086   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3087 else
3088 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3089 for as_dir in $PATH
3090 do
3091   IFS=$as_save_IFS
3092   test -z "$as_dir" && as_dir=.
3093   for ac_exec_ext in '' $ac_executable_extensions; do
3094   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3095     ac_cv_prog_ac_ct_CC="cc"
3096     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3097     break 2
3098   fi
3099 done
3100 done
3101
3102 fi
3103 fi
3104 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3105 if test -n "$ac_ct_CC"; then
3106   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3107 echo "${ECHO_T}$ac_ct_CC" >&6
3108 else
3109   echo "$as_me:$LINENO: result: no" >&5
3110 echo "${ECHO_T}no" >&6
3111 fi
3112
3113   CC=$ac_ct_CC
3114 else
3115   CC="$ac_cv_prog_CC"
3116 fi
3117
3118 fi
3119 if test -z "$CC"; then
3120   # Extract the first word of "cc", so it can be a program name with args.
3121 set dummy cc; ac_word=$2
3122 echo "$as_me:$LINENO: checking for $ac_word" >&5
3123 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3124 if test "${ac_cv_prog_CC+set}" = set; then
3125   echo $ECHO_N "(cached) $ECHO_C" >&6
3126 else
3127   if test -n "$CC"; then
3128   ac_cv_prog_CC="$CC" # Let the user override the test.
3129 else
3130   ac_prog_rejected=no
3131 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3132 for as_dir in $PATH
3133 do
3134   IFS=$as_save_IFS
3135   test -z "$as_dir" && as_dir=.
3136   for ac_exec_ext in '' $ac_executable_extensions; do
3137   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3138     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3139        ac_prog_rejected=yes
3140        continue
3141      fi
3142     ac_cv_prog_CC="cc"
3143     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3144     break 2
3145   fi
3146 done
3147 done
3148
3149 if test $ac_prog_rejected = yes; then
3150   # We found a bogon in the path, so make sure we never use it.
3151   set dummy $ac_cv_prog_CC
3152   shift
3153   if test $# != 0; then
3154     # We chose a different compiler from the bogus one.
3155     # However, it has the same basename, so the bogon will be chosen
3156     # first if we set CC to just the basename; use the full file name.
3157     shift
3158     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3159   fi
3160 fi
3161 fi
3162 fi
3163 CC=$ac_cv_prog_CC
3164 if test -n "$CC"; then
3165   echo "$as_me:$LINENO: result: $CC" >&5
3166 echo "${ECHO_T}$CC" >&6
3167 else
3168   echo "$as_me:$LINENO: result: no" >&5
3169 echo "${ECHO_T}no" >&6
3170 fi
3171
3172 fi
3173 if test -z "$CC"; then
3174   if test -n "$ac_tool_prefix"; then
3175   for ac_prog in cl
3176   do
3177     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3178 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3179 echo "$as_me:$LINENO: checking for $ac_word" >&5
3180 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3181 if test "${ac_cv_prog_CC+set}" = set; then
3182   echo $ECHO_N "(cached) $ECHO_C" >&6
3183 else
3184   if test -n "$CC"; then
3185   ac_cv_prog_CC="$CC" # Let the user override the test.
3186 else
3187 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3188 for as_dir in $PATH
3189 do
3190   IFS=$as_save_IFS
3191   test -z "$as_dir" && as_dir=.
3192   for ac_exec_ext in '' $ac_executable_extensions; do
3193   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3194     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3195     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3196     break 2
3197   fi
3198 done
3199 done
3200
3201 fi
3202 fi
3203 CC=$ac_cv_prog_CC
3204 if test -n "$CC"; then
3205   echo "$as_me:$LINENO: result: $CC" >&5
3206 echo "${ECHO_T}$CC" >&6
3207 else
3208   echo "$as_me:$LINENO: result: no" >&5
3209 echo "${ECHO_T}no" >&6
3210 fi
3211
3212     test -n "$CC" && break
3213   done
3214 fi
3215 if test -z "$CC"; then
3216   ac_ct_CC=$CC
3217   for ac_prog in cl
3218 do
3219   # Extract the first word of "$ac_prog", so it can be a program name with args.
3220 set dummy $ac_prog; ac_word=$2
3221 echo "$as_me:$LINENO: checking for $ac_word" >&5
3222 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3223 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3224   echo $ECHO_N "(cached) $ECHO_C" >&6
3225 else
3226   if test -n "$ac_ct_CC"; then
3227   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3228 else
3229 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3230 for as_dir in $PATH
3231 do
3232   IFS=$as_save_IFS
3233   test -z "$as_dir" && as_dir=.
3234   for ac_exec_ext in '' $ac_executable_extensions; do
3235   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3236     ac_cv_prog_ac_ct_CC="$ac_prog"
3237     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3238     break 2
3239   fi
3240 done
3241 done
3242
3243 fi
3244 fi
3245 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3246 if test -n "$ac_ct_CC"; then
3247   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3248 echo "${ECHO_T}$ac_ct_CC" >&6
3249 else
3250   echo "$as_me:$LINENO: result: no" >&5
3251 echo "${ECHO_T}no" >&6
3252 fi
3253
3254   test -n "$ac_ct_CC" && break
3255 done
3256
3257   CC=$ac_ct_CC
3258 fi
3259
3260 fi
3261
3262
3263 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3264 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3265 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3266 See \`config.log' for more details." >&5
3267 echo "$as_me: error: no acceptable C compiler found in \$PATH
3268 See \`config.log' for more details." >&2;}
3269    { (exit 1); exit 1; }; }; }
3270
3271 # Provide some information about the compiler.
3272 echo "$as_me:$LINENO:" \
3273      "checking for C compiler version" >&5
3274 ac_compiler=`set X $ac_compile; echo $2`
3275 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3276   (eval $ac_compiler --version </dev/null >&5) 2>&5
3277   ac_status=$?
3278   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3279   (exit $ac_status); }
3280 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3281   (eval $ac_compiler -v </dev/null >&5) 2>&5
3282   ac_status=$?
3283   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3284   (exit $ac_status); }
3285 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3286   (eval $ac_compiler -V </dev/null >&5) 2>&5
3287   ac_status=$?
3288   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3289   (exit $ac_status); }
3290
3291 cat >conftest.$ac_ext <<_ACEOF
3292 /* confdefs.h.  */
3293 _ACEOF
3294 cat confdefs.h >>conftest.$ac_ext
3295 cat >>conftest.$ac_ext <<_ACEOF
3296 /* end confdefs.h.  */
3297
3298 int
3299 main ()
3300 {
3301
3302   ;
3303   return 0;
3304 }
3305 _ACEOF
3306 ac_clean_files_save=$ac_clean_files
3307 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3308 # Try to create an executable without -o first, disregard a.out.
3309 # It will help us diagnose broken compilers, and finding out an intuition
3310 # of exeext.
3311 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3312 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3313 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3314 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3315   (eval $ac_link_default) 2>&5
3316   ac_status=$?
3317   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3318   (exit $ac_status); }; then
3319   # Find the output, starting from the most likely.  This scheme is
3320 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3321 # resort.
3322
3323 # Be careful to initialize this variable, since it used to be cached.
3324 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3325 ac_cv_exeext=
3326 # b.out is created by i960 compilers.
3327 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3328 do
3329   test -f "$ac_file" || continue
3330   case $ac_file in
3331     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3332         ;;
3333     conftest.$ac_ext )
3334         # This is the source file.
3335         ;;
3336     [ab].out )
3337         # We found the default executable, but exeext='' is most
3338         # certainly right.
3339         break;;
3340     *.* )
3341         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3342         # FIXME: I believe we export ac_cv_exeext for Libtool,
3343         # but it would be cool to find out if it's true.  Does anybody
3344         # maintain Libtool? --akim.
3345         export ac_cv_exeext
3346         break;;
3347     * )
3348         break;;
3349   esac
3350 done
3351 else
3352   echo "$as_me: failed program was:" >&5
3353 sed 's/^/| /' conftest.$ac_ext >&5
3354
3355 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3356 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3357 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3358 See \`config.log' for more details." >&5
3359 echo "$as_me: error: C compiler cannot create executables
3360 See \`config.log' for more details." >&2;}
3361    { (exit 77); exit 77; }; }; }
3362 fi
3363
3364 ac_exeext=$ac_cv_exeext
3365 echo "$as_me:$LINENO: result: $ac_file" >&5
3366 echo "${ECHO_T}$ac_file" >&6
3367
3368 # Check the compiler produces executables we can run.  If not, either
3369 # the compiler is broken, or we cross compile.
3370 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3371 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3372 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3373 # If not cross compiling, check that we can run a simple program.
3374 if test "$cross_compiling" != yes; then
3375   if { ac_try='./$ac_file'
3376   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3377   (eval $ac_try) 2>&5
3378   ac_status=$?
3379   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3380   (exit $ac_status); }; }; then
3381     cross_compiling=no
3382   else
3383     if test "$cross_compiling" = maybe; then
3384         cross_compiling=yes
3385     else
3386         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3387 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3388 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3389 If you meant to cross compile, use \`--host'.
3390 See \`config.log' for more details." >&5
3391 echo "$as_me: error: cannot run C compiled programs.
3392 If you meant to cross compile, use \`--host'.
3393 See \`config.log' for more details." >&2;}
3394    { (exit 1); exit 1; }; }; }
3395     fi
3396   fi
3397 fi
3398 echo "$as_me:$LINENO: result: yes" >&5
3399 echo "${ECHO_T}yes" >&6
3400
3401 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3402 ac_clean_files=$ac_clean_files_save
3403 # Check the compiler produces executables we can run.  If not, either
3404 # the compiler is broken, or we cross compile.
3405 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3406 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3407 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3408 echo "${ECHO_T}$cross_compiling" >&6
3409
3410 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3411 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3412 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3413   (eval $ac_link) 2>&5
3414   ac_status=$?
3415   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3416   (exit $ac_status); }; then
3417   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3418 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3419 # work properly (i.e., refer to `conftest.exe'), while it won't with
3420 # `rm'.
3421 for ac_file in conftest.exe conftest conftest.*; do
3422   test -f "$ac_file" || continue
3423   case $ac_file in
3424     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3425     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3426           export ac_cv_exeext
3427           break;;
3428     * ) break;;
3429   esac
3430 done
3431 else
3432   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3433 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3434 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3435 See \`config.log' for more details." >&5
3436 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3437 See \`config.log' for more details." >&2;}
3438    { (exit 1); exit 1; }; }; }
3439 fi
3440
3441 rm -f conftest$ac_cv_exeext
3442 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3443 echo "${ECHO_T}$ac_cv_exeext" >&6
3444
3445 rm -f conftest.$ac_ext
3446 EXEEXT=$ac_cv_exeext
3447 ac_exeext=$EXEEXT
3448 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3449 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3450 if test "${ac_cv_objext+set}" = set; then
3451   echo $ECHO_N "(cached) $ECHO_C" >&6
3452 else
3453   cat >conftest.$ac_ext <<_ACEOF
3454 /* confdefs.h.  */
3455 _ACEOF
3456 cat confdefs.h >>conftest.$ac_ext
3457 cat >>conftest.$ac_ext <<_ACEOF
3458 /* end confdefs.h.  */
3459
3460 int
3461 main ()
3462 {
3463
3464   ;
3465   return 0;
3466 }
3467 _ACEOF
3468 rm -f conftest.o conftest.obj
3469 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3470   (eval $ac_compile) 2>&5
3471   ac_status=$?
3472   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3473   (exit $ac_status); }; then
3474   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3475   case $ac_file in
3476     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3477     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3478        break;;
3479   esac
3480 done
3481 else
3482   echo "$as_me: failed program was:" >&5
3483 sed 's/^/| /' conftest.$ac_ext >&5
3484
3485 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3486 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3487 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3488 See \`config.log' for more details." >&5
3489 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3490 See \`config.log' for more details." >&2;}
3491    { (exit 1); exit 1; }; }; }
3492 fi
3493
3494 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3495 fi
3496 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3497 echo "${ECHO_T}$ac_cv_objext" >&6
3498 OBJEXT=$ac_cv_objext
3499 ac_objext=$OBJEXT
3500 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3501 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3502 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3503   echo $ECHO_N "(cached) $ECHO_C" >&6
3504 else
3505   cat >conftest.$ac_ext <<_ACEOF
3506 /* confdefs.h.  */
3507 _ACEOF
3508 cat confdefs.h >>conftest.$ac_ext
3509 cat >>conftest.$ac_ext <<_ACEOF
3510 /* end confdefs.h.  */
3511
3512 int
3513 main ()
3514 {
3515 #ifndef __GNUC__
3516        choke me
3517 #endif
3518
3519   ;
3520   return 0;
3521 }
3522 _ACEOF
3523 rm -f conftest.$ac_objext
3524 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3525   (eval $ac_compile) 2>conftest.er1
3526   ac_status=$?
3527   grep -v '^ *+' conftest.er1 >conftest.err
3528   rm -f conftest.er1
3529   cat conftest.err >&5
3530   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3531   (exit $ac_status); } &&
3532          { ac_try='test -z "$ac_c_werror_flag"
3533                          || test ! -s conftest.err'
3534   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3535   (eval $ac_try) 2>&5
3536   ac_status=$?
3537   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3538   (exit $ac_status); }; } &&
3539          { ac_try='test -s conftest.$ac_objext'
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); }; }; then
3545   ac_compiler_gnu=yes
3546 else
3547   echo "$as_me: failed program was:" >&5
3548 sed 's/^/| /' conftest.$ac_ext >&5
3549
3550 ac_compiler_gnu=no
3551 fi
3552 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3553 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3554
3555 fi
3556 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3557 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3558 GCC=`test $ac_compiler_gnu = yes && echo yes`
3559 ac_test_CFLAGS=${CFLAGS+set}
3560 ac_save_CFLAGS=$CFLAGS
3561 CFLAGS="-g"
3562 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3563 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3564 if test "${ac_cv_prog_cc_g+set}" = set; then
3565   echo $ECHO_N "(cached) $ECHO_C" >&6
3566 else
3567   cat >conftest.$ac_ext <<_ACEOF
3568 /* confdefs.h.  */
3569 _ACEOF
3570 cat confdefs.h >>conftest.$ac_ext
3571 cat >>conftest.$ac_ext <<_ACEOF
3572 /* end confdefs.h.  */
3573
3574 int
3575 main ()
3576 {
3577
3578   ;
3579   return 0;
3580 }
3581 _ACEOF
3582 rm -f conftest.$ac_objext
3583 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3584   (eval $ac_compile) 2>conftest.er1
3585   ac_status=$?
3586   grep -v '^ *+' conftest.er1 >conftest.err
3587   rm -f conftest.er1
3588   cat conftest.err >&5
3589   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3590   (exit $ac_status); } &&
3591          { ac_try='test -z "$ac_c_werror_flag"
3592                          || test ! -s conftest.err'
3593   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3594   (eval $ac_try) 2>&5
3595   ac_status=$?
3596   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3597   (exit $ac_status); }; } &&
3598          { ac_try='test -s conftest.$ac_objext'
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); }; }; then
3604   ac_cv_prog_cc_g=yes
3605 else
3606   echo "$as_me: failed program was:" >&5
3607 sed 's/^/| /' conftest.$ac_ext >&5
3608
3609 ac_cv_prog_cc_g=no
3610 fi
3611 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3612 fi
3613 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3614 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3615 if test "$ac_test_CFLAGS" = set; then
3616   CFLAGS=$ac_save_CFLAGS
3617 elif test $ac_cv_prog_cc_g = yes; then
3618   if test "$GCC" = yes; then
3619     CFLAGS="-g -O2"
3620   else
3621     CFLAGS="-g"
3622   fi
3623 else
3624   if test "$GCC" = yes; then
3625     CFLAGS="-O2"
3626   else
3627     CFLAGS=
3628   fi
3629 fi
3630 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3631 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3632 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3633   echo $ECHO_N "(cached) $ECHO_C" >&6
3634 else
3635   ac_cv_prog_cc_stdc=no
3636 ac_save_CC=$CC
3637 cat >conftest.$ac_ext <<_ACEOF
3638 /* confdefs.h.  */
3639 _ACEOF
3640 cat confdefs.h >>conftest.$ac_ext
3641 cat >>conftest.$ac_ext <<_ACEOF
3642 /* end confdefs.h.  */
3643 #include <stdarg.h>
3644 #include <stdio.h>
3645 #include <sys/types.h>
3646 #include <sys/stat.h>
3647 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3648 struct buf { int x; };
3649 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3650 static char *e (p, i)
3651      char **p;
3652      int i;
3653 {
3654   return p[i];
3655 }
3656 static char *f (char * (*g) (char **, int), char **p, ...)
3657 {
3658   char *s;
3659   va_list v;
3660   va_start (v,p);
3661   s = g (p, va_arg (v,int));
3662   va_end (v);
3663   return s;
3664 }
3665
3666 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3667    function prototypes and stuff, but not '\xHH' hex character constants.
3668    These don't provoke an error unfortunately, instead are silently treated
3669    as 'x'.  The following induces an error, until -std1 is added to get
3670    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3671    array size at least.  It's necessary to write '\x00'==0 to get something
3672    that's true only with -std1.  */
3673 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3674
3675 int test (int i, double x);
3676 struct s1 {int (*f) (int a);};
3677 struct s2 {int (*f) (double a);};
3678 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3679 int argc;
3680 char **argv;
3681 int
3682 main ()
3683 {
3684 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3685   ;
3686   return 0;
3687 }
3688 _ACEOF
3689 # Don't try gcc -ansi; that turns off useful extensions and
3690 # breaks some systems' header files.
3691 # AIX                   -qlanglvl=ansi
3692 # Ultrix and OSF/1      -std1
3693 # HP-UX 10.20 and later -Ae
3694 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3695 # SVR4                  -Xc -D__EXTENSIONS__
3696 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3697 do
3698   CC="$ac_save_CC $ac_arg"
3699   rm -f conftest.$ac_objext
3700 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3701   (eval $ac_compile) 2>conftest.er1
3702   ac_status=$?
3703   grep -v '^ *+' conftest.er1 >conftest.err
3704   rm -f conftest.er1
3705   cat conftest.err >&5
3706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3707   (exit $ac_status); } &&
3708          { ac_try='test -z "$ac_c_werror_flag"
3709                          || test ! -s conftest.err'
3710   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3711   (eval $ac_try) 2>&5
3712   ac_status=$?
3713   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3714   (exit $ac_status); }; } &&
3715          { ac_try='test -s conftest.$ac_objext'
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); }; }; then
3721   ac_cv_prog_cc_stdc=$ac_arg
3722 break
3723 else
3724   echo "$as_me: failed program was:" >&5
3725 sed 's/^/| /' conftest.$ac_ext >&5
3726
3727 fi
3728 rm -f conftest.err conftest.$ac_objext
3729 done
3730 rm -f conftest.$ac_ext conftest.$ac_objext
3731 CC=$ac_save_CC
3732
3733 fi
3734
3735 case "x$ac_cv_prog_cc_stdc" in
3736   x|xno)
3737     echo "$as_me:$LINENO: result: none needed" >&5
3738 echo "${ECHO_T}none needed" >&6 ;;
3739   *)
3740     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3741 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3742     CC="$CC $ac_cv_prog_cc_stdc" ;;
3743 esac
3744
3745 # Some people use a C++ compiler to compile C.  Since we use `exit',
3746 # in C++ we need to declare it.  In case someone uses the same compiler
3747 # for both compiling C and C++ we need to have the C++ compiler decide
3748 # the declaration of exit, since it's the most demanding environment.
3749 cat >conftest.$ac_ext <<_ACEOF
3750 #ifndef __cplusplus
3751   choke me
3752 #endif
3753 _ACEOF
3754 rm -f conftest.$ac_objext
3755 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3756   (eval $ac_compile) 2>conftest.er1
3757   ac_status=$?
3758   grep -v '^ *+' conftest.er1 >conftest.err
3759   rm -f conftest.er1
3760   cat conftest.err >&5
3761   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3762   (exit $ac_status); } &&
3763          { ac_try='test -z "$ac_c_werror_flag"
3764                          || test ! -s conftest.err'
3765   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3766   (eval $ac_try) 2>&5
3767   ac_status=$?
3768   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3769   (exit $ac_status); }; } &&
3770          { ac_try='test -s conftest.$ac_objext'
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); }; }; then
3776   for ac_declaration in \
3777    '' \
3778    'extern "C" void std::exit (int) throw (); using std::exit;' \
3779    'extern "C" void std::exit (int); using std::exit;' \
3780    'extern "C" void exit (int) throw ();' \
3781    'extern "C" void exit (int);' \
3782    'void exit (int);'
3783 do
3784   cat >conftest.$ac_ext <<_ACEOF
3785 /* confdefs.h.  */
3786 _ACEOF
3787 cat confdefs.h >>conftest.$ac_ext
3788 cat >>conftest.$ac_ext <<_ACEOF
3789 /* end confdefs.h.  */
3790 $ac_declaration
3791 #include <stdlib.h>
3792 int
3793 main ()
3794 {
3795 exit (42);
3796   ;
3797   return 0;
3798 }
3799 _ACEOF
3800 rm -f conftest.$ac_objext
3801 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3802   (eval $ac_compile) 2>conftest.er1
3803   ac_status=$?
3804   grep -v '^ *+' conftest.er1 >conftest.err
3805   rm -f conftest.er1
3806   cat conftest.err >&5
3807   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3808   (exit $ac_status); } &&
3809          { ac_try='test -z "$ac_c_werror_flag"
3810                          || test ! -s conftest.err'
3811   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3812   (eval $ac_try) 2>&5
3813   ac_status=$?
3814   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3815   (exit $ac_status); }; } &&
3816          { ac_try='test -s conftest.$ac_objext'
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); }; }; then
3822   :
3823 else
3824   echo "$as_me: failed program was:" >&5
3825 sed 's/^/| /' conftest.$ac_ext >&5
3826
3827 continue
3828 fi
3829 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3830   cat >conftest.$ac_ext <<_ACEOF
3831 /* confdefs.h.  */
3832 _ACEOF
3833 cat confdefs.h >>conftest.$ac_ext
3834 cat >>conftest.$ac_ext <<_ACEOF
3835 /* end confdefs.h.  */
3836 $ac_declaration
3837 int
3838 main ()
3839 {
3840 exit (42);
3841   ;
3842   return 0;
3843 }
3844 _ACEOF
3845 rm -f conftest.$ac_objext
3846 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3847   (eval $ac_compile) 2>conftest.er1
3848   ac_status=$?
3849   grep -v '^ *+' conftest.er1 >conftest.err
3850   rm -f conftest.er1
3851   cat conftest.err >&5
3852   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3853   (exit $ac_status); } &&
3854          { ac_try='test -z "$ac_c_werror_flag"
3855                          || test ! -s conftest.err'
3856   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3857   (eval $ac_try) 2>&5
3858   ac_status=$?
3859   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3860   (exit $ac_status); }; } &&
3861          { ac_try='test -s conftest.$ac_objext'
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); }; }; then
3867   break
3868 else
3869   echo "$as_me: failed program was:" >&5
3870 sed 's/^/| /' conftest.$ac_ext >&5
3871
3872 fi
3873 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3874 done
3875 rm -f conftest*
3876 if test -n "$ac_declaration"; then
3877   echo '#ifdef __cplusplus' >>confdefs.h
3878   echo $ac_declaration      >>confdefs.h
3879   echo '#endif'             >>confdefs.h
3880 fi
3881
3882 else
3883   echo "$as_me: failed program was:" >&5
3884 sed 's/^/| /' conftest.$ac_ext >&5
3885
3886 fi
3887 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3888 ac_ext=c
3889 ac_cpp='$CPP $CPPFLAGS'
3890 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3891 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3892 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3893
3894 ac_ext=cc
3895 ac_cpp='$CXXCPP $CPPFLAGS'
3896 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3897 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3898 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3899 if test -n "$ac_tool_prefix"; then
3900   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3901   do
3902     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3903 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3904 echo "$as_me:$LINENO: checking for $ac_word" >&5
3905 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3906 if test "${ac_cv_prog_CXX+set}" = set; then
3907   echo $ECHO_N "(cached) $ECHO_C" >&6
3908 else
3909   if test -n "$CXX"; then
3910   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3911 else
3912 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3913 for as_dir in $PATH
3914 do
3915   IFS=$as_save_IFS
3916   test -z "$as_dir" && as_dir=.
3917   for ac_exec_ext in '' $ac_executable_extensions; do
3918   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3919     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3920     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3921     break 2
3922   fi
3923 done
3924 done
3925
3926 fi
3927 fi
3928 CXX=$ac_cv_prog_CXX
3929 if test -n "$CXX"; then
3930   echo "$as_me:$LINENO: result: $CXX" >&5
3931 echo "${ECHO_T}$CXX" >&6
3932 else
3933   echo "$as_me:$LINENO: result: no" >&5
3934 echo "${ECHO_T}no" >&6
3935 fi
3936
3937     test -n "$CXX" && break
3938   done
3939 fi
3940 if test -z "$CXX"; then
3941   ac_ct_CXX=$CXX
3942   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3943 do
3944   # Extract the first word of "$ac_prog", so it can be a program name with args.
3945 set dummy $ac_prog; ac_word=$2
3946 echo "$as_me:$LINENO: checking for $ac_word" >&5
3947 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3948 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3949   echo $ECHO_N "(cached) $ECHO_C" >&6
3950 else
3951   if test -n "$ac_ct_CXX"; then
3952   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3953 else
3954 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3955 for as_dir in $PATH
3956 do
3957   IFS=$as_save_IFS
3958   test -z "$as_dir" && as_dir=.
3959   for ac_exec_ext in '' $ac_executable_extensions; do
3960   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3961     ac_cv_prog_ac_ct_CXX="$ac_prog"
3962     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3963     break 2
3964   fi
3965 done
3966 done
3967
3968 fi
3969 fi
3970 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3971 if test -n "$ac_ct_CXX"; then
3972   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3973 echo "${ECHO_T}$ac_ct_CXX" >&6
3974 else
3975   echo "$as_me:$LINENO: result: no" >&5
3976 echo "${ECHO_T}no" >&6
3977 fi
3978
3979   test -n "$ac_ct_CXX" && break
3980 done
3981 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3982
3983   CXX=$ac_ct_CXX
3984 fi
3985
3986
3987 # Provide some information about the compiler.
3988 echo "$as_me:$LINENO:" \
3989      "checking for C++ compiler version" >&5
3990 ac_compiler=`set X $ac_compile; echo $2`
3991 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3992   (eval $ac_compiler --version </dev/null >&5) 2>&5
3993   ac_status=$?
3994   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3995   (exit $ac_status); }
3996 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3997   (eval $ac_compiler -v </dev/null >&5) 2>&5
3998   ac_status=$?
3999   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4000   (exit $ac_status); }
4001 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4002   (eval $ac_compiler -V </dev/null >&5) 2>&5
4003   ac_status=$?
4004   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4005   (exit $ac_status); }
4006
4007 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4008 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4009 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4010   echo $ECHO_N "(cached) $ECHO_C" >&6
4011 else
4012   cat >conftest.$ac_ext <<_ACEOF
4013 /* confdefs.h.  */
4014 _ACEOF
4015 cat confdefs.h >>conftest.$ac_ext
4016 cat >>conftest.$ac_ext <<_ACEOF
4017 /* end confdefs.h.  */
4018
4019 int
4020 main ()
4021 {
4022 #ifndef __GNUC__
4023        choke me
4024 #endif
4025
4026   ;
4027   return 0;
4028 }
4029 _ACEOF
4030 rm -f conftest.$ac_objext
4031 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4032   (eval $ac_compile) 2>conftest.er1
4033   ac_status=$?
4034   grep -v '^ *+' conftest.er1 >conftest.err
4035   rm -f conftest.er1
4036   cat conftest.err >&5
4037   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4038   (exit $ac_status); } &&
4039          { ac_try='test -z "$ac_cxx_werror_flag"
4040                          || test ! -s conftest.err'
4041   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4042   (eval $ac_try) 2>&5
4043   ac_status=$?
4044   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4045   (exit $ac_status); }; } &&
4046          { ac_try='test -s conftest.$ac_objext'
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); }; }; then
4052   ac_compiler_gnu=yes
4053 else
4054   echo "$as_me: failed program was:" >&5
4055 sed 's/^/| /' conftest.$ac_ext >&5
4056
4057 ac_compiler_gnu=no
4058 fi
4059 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4060 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4061
4062 fi
4063 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4064 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4065 GXX=`test $ac_compiler_gnu = yes && echo yes`
4066 ac_test_CXXFLAGS=${CXXFLAGS+set}
4067 ac_save_CXXFLAGS=$CXXFLAGS
4068 CXXFLAGS="-g"
4069 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4070 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4071 if test "${ac_cv_prog_cxx_g+set}" = set; then
4072   echo $ECHO_N "(cached) $ECHO_C" >&6
4073 else
4074   cat >conftest.$ac_ext <<_ACEOF
4075 /* confdefs.h.  */
4076 _ACEOF
4077 cat confdefs.h >>conftest.$ac_ext
4078 cat >>conftest.$ac_ext <<_ACEOF
4079 /* end confdefs.h.  */
4080
4081 int
4082 main ()
4083 {
4084
4085   ;
4086   return 0;
4087 }
4088 _ACEOF
4089 rm -f conftest.$ac_objext
4090 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4091   (eval $ac_compile) 2>conftest.er1
4092   ac_status=$?
4093   grep -v '^ *+' conftest.er1 >conftest.err
4094   rm -f conftest.er1
4095   cat conftest.err >&5
4096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4097   (exit $ac_status); } &&
4098          { ac_try='test -z "$ac_cxx_werror_flag"
4099                          || test ! -s conftest.err'
4100   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4101   (eval $ac_try) 2>&5
4102   ac_status=$?
4103   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4104   (exit $ac_status); }; } &&
4105          { ac_try='test -s conftest.$ac_objext'
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); }; }; then
4111   ac_cv_prog_cxx_g=yes
4112 else
4113   echo "$as_me: failed program was:" >&5
4114 sed 's/^/| /' conftest.$ac_ext >&5
4115
4116 ac_cv_prog_cxx_g=no
4117 fi
4118 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4119 fi
4120 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4121 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4122 if test "$ac_test_CXXFLAGS" = set; then
4123   CXXFLAGS=$ac_save_CXXFLAGS
4124 elif test $ac_cv_prog_cxx_g = yes; then
4125   if test "$GXX" = yes; then
4126     CXXFLAGS="-g -O2"
4127   else
4128     CXXFLAGS="-g"
4129   fi
4130 else
4131   if test "$GXX" = yes; then
4132     CXXFLAGS="-O2"
4133   else
4134     CXXFLAGS=
4135   fi
4136 fi
4137 for ac_declaration in \
4138    '' \
4139    'extern "C" void std::exit (int) throw (); using std::exit;' \
4140    'extern "C" void std::exit (int); using std::exit;' \
4141    'extern "C" void exit (int) throw ();' \
4142    'extern "C" void exit (int);' \
4143    'void exit (int);'
4144 do
4145   cat >conftest.$ac_ext <<_ACEOF
4146 /* confdefs.h.  */
4147 _ACEOF
4148 cat confdefs.h >>conftest.$ac_ext
4149 cat >>conftest.$ac_ext <<_ACEOF
4150 /* end confdefs.h.  */
4151 $ac_declaration
4152 #include <stdlib.h>
4153 int
4154 main ()
4155 {
4156 exit (42);
4157   ;
4158   return 0;
4159 }
4160 _ACEOF
4161 rm -f conftest.$ac_objext
4162 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4163   (eval $ac_compile) 2>conftest.er1
4164   ac_status=$?
4165   grep -v '^ *+' conftest.er1 >conftest.err
4166   rm -f conftest.er1
4167   cat conftest.err >&5
4168   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4169   (exit $ac_status); } &&
4170          { ac_try='test -z "$ac_cxx_werror_flag"
4171                          || test ! -s conftest.err'
4172   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4173   (eval $ac_try) 2>&5
4174   ac_status=$?
4175   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4176   (exit $ac_status); }; } &&
4177          { ac_try='test -s conftest.$ac_objext'
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); }; }; then
4183   :
4184 else
4185   echo "$as_me: failed program was:" >&5
4186 sed 's/^/| /' conftest.$ac_ext >&5
4187
4188 continue
4189 fi
4190 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4191   cat >conftest.$ac_ext <<_ACEOF
4192 /* confdefs.h.  */
4193 _ACEOF
4194 cat confdefs.h >>conftest.$ac_ext
4195 cat >>conftest.$ac_ext <<_ACEOF
4196 /* end confdefs.h.  */
4197 $ac_declaration
4198 int
4199 main ()
4200 {
4201 exit (42);
4202   ;
4203   return 0;
4204 }
4205 _ACEOF
4206 rm -f conftest.$ac_objext
4207 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4208   (eval $ac_compile) 2>conftest.er1
4209   ac_status=$?
4210   grep -v '^ *+' conftest.er1 >conftest.err
4211   rm -f conftest.er1
4212   cat conftest.err >&5
4213   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4214   (exit $ac_status); } &&
4215          { ac_try='test -z "$ac_cxx_werror_flag"
4216                          || test ! -s conftest.err'
4217   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4218   (eval $ac_try) 2>&5
4219   ac_status=$?
4220   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4221   (exit $ac_status); }; } &&
4222          { ac_try='test -s conftest.$ac_objext'
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); }; }; then
4228   break
4229 else
4230   echo "$as_me: failed program was:" >&5
4231 sed 's/^/| /' conftest.$ac_ext >&5
4232
4233 fi
4234 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4235 done
4236 rm -f conftest*
4237 if test -n "$ac_declaration"; then
4238   echo '#ifdef __cplusplus' >>confdefs.h
4239   echo $ac_declaration      >>confdefs.h
4240   echo '#endif'             >>confdefs.h
4241 fi
4242
4243 ac_ext=c
4244 ac_cpp='$CPP $CPPFLAGS'
4245 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4246 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4247 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4248
4249
4250 # We must set the default linker to the linker used by gcc for the correct
4251 # operation of libtool.  If LD is not defined and we are using gcc, try to
4252 # set the LD default to the ld used by gcc.
4253 if test -z "$LD"; then
4254   if test "$GCC" = yes; then
4255     case $build in
4256     *-*-mingw*)
4257       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4258     *)
4259       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4260     esac
4261     case $gcc_prog_ld in
4262     # Accept absolute paths.
4263     [\\/]* | [A-Za-z]:[\\/]*)
4264       LD="$gcc_prog_ld" ;;
4265     esac
4266   fi
4267 fi
4268
4269
4270
4271
4272 if test -n "$ac_tool_prefix"; then
4273   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4274 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4275 echo "$as_me:$LINENO: checking for $ac_word" >&5
4276 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4277 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4278   echo $ECHO_N "(cached) $ECHO_C" >&6
4279 else
4280   if test -n "$GNATBIND"; then
4281   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4282 else
4283 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4284 for as_dir in $PATH
4285 do
4286   IFS=$as_save_IFS
4287   test -z "$as_dir" && as_dir=.
4288   for ac_exec_ext in '' $ac_executable_extensions; do
4289   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4290     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4291     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4292     break 2
4293   fi
4294 done
4295 done
4296
4297 fi
4298 fi
4299 GNATBIND=$ac_cv_prog_GNATBIND
4300 if test -n "$GNATBIND"; then
4301   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4302 echo "${ECHO_T}$GNATBIND" >&6
4303 else
4304   echo "$as_me:$LINENO: result: no" >&5
4305 echo "${ECHO_T}no" >&6
4306 fi
4307
4308 fi
4309 if test -z "$ac_cv_prog_GNATBIND"; then
4310   ac_ct_GNATBIND=$GNATBIND
4311   # Extract the first word of "gnatbind", so it can be a program name with args.
4312 set dummy gnatbind; ac_word=$2
4313 echo "$as_me:$LINENO: checking for $ac_word" >&5
4314 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4315 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4316   echo $ECHO_N "(cached) $ECHO_C" >&6
4317 else
4318   if test -n "$ac_ct_GNATBIND"; then
4319   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4320 else
4321 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4322 for as_dir in $PATH
4323 do
4324   IFS=$as_save_IFS
4325   test -z "$as_dir" && as_dir=.
4326   for ac_exec_ext in '' $ac_executable_extensions; do
4327   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4328     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4329     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4330     break 2
4331   fi
4332 done
4333 done
4334
4335   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4336 fi
4337 fi
4338 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4339 if test -n "$ac_ct_GNATBIND"; then
4340   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4341 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4342 else
4343   echo "$as_me:$LINENO: result: no" >&5
4344 echo "${ECHO_T}no" >&6
4345 fi
4346
4347   GNATBIND=$ac_ct_GNATBIND
4348 else
4349   GNATBIND="$ac_cv_prog_GNATBIND"
4350 fi
4351
4352 if test -n "$ac_tool_prefix"; then
4353   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4354 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4355 echo "$as_me:$LINENO: checking for $ac_word" >&5
4356 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4357 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4358   echo $ECHO_N "(cached) $ECHO_C" >&6
4359 else
4360   if test -n "$GNATMAKE"; then
4361   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4362 else
4363 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4364 for as_dir in $PATH
4365 do
4366   IFS=$as_save_IFS
4367   test -z "$as_dir" && as_dir=.
4368   for ac_exec_ext in '' $ac_executable_extensions; do
4369   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4370     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4371     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4372     break 2
4373   fi
4374 done
4375 done
4376
4377 fi
4378 fi
4379 GNATMAKE=$ac_cv_prog_GNATMAKE
4380 if test -n "$GNATMAKE"; then
4381   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4382 echo "${ECHO_T}$GNATMAKE" >&6
4383 else
4384   echo "$as_me:$LINENO: result: no" >&5
4385 echo "${ECHO_T}no" >&6
4386 fi
4387
4388 fi
4389 if test -z "$ac_cv_prog_GNATMAKE"; then
4390   ac_ct_GNATMAKE=$GNATMAKE
4391   # Extract the first word of "gnatmake", so it can be a program name with args.
4392 set dummy gnatmake; ac_word=$2
4393 echo "$as_me:$LINENO: checking for $ac_word" >&5
4394 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4395 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4396   echo $ECHO_N "(cached) $ECHO_C" >&6
4397 else
4398   if test -n "$ac_ct_GNATMAKE"; then
4399   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4400 else
4401 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4402 for as_dir in $PATH
4403 do
4404   IFS=$as_save_IFS
4405   test -z "$as_dir" && as_dir=.
4406   for ac_exec_ext in '' $ac_executable_extensions; do
4407   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4408     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4409     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4410     break 2
4411   fi
4412 done
4413 done
4414
4415   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4416 fi
4417 fi
4418 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4419 if test -n "$ac_ct_GNATMAKE"; then
4420   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4421 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4422 else
4423   echo "$as_me:$LINENO: result: no" >&5
4424 echo "${ECHO_T}no" >&6
4425 fi
4426
4427   GNATMAKE=$ac_ct_GNATMAKE
4428 else
4429   GNATMAKE="$ac_cv_prog_GNATMAKE"
4430 fi
4431
4432 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4433 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4434 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4435   echo $ECHO_N "(cached) $ECHO_C" >&6
4436 else
4437   cat >conftest.adb <<EOF
4438 procedure conftest is begin null; end conftest;
4439 EOF
4440 acx_cv_cc_gcc_supports_ada=no
4441 # There is a bug in old released versions of GCC which causes the
4442 # driver to exit successfully when the appropriate language module
4443 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4444 # Therefore we must check for the error message as well as an
4445 # unsuccessful exit.
4446 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4447 # given a .adb file, but produce no object file.  So we must check
4448 # if an object file was really produced to guard against this.
4449 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4450 if test x"$errors" = x && test -f conftest.$ac_objext; then
4451   acx_cv_cc_gcc_supports_ada=yes
4452 fi
4453 rm -f conftest.*
4454 fi
4455 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4456 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4457
4458 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4459   have_gnat=yes
4460 else
4461   have_gnat=no
4462 fi
4463
4464 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4465 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4466 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4467   echo $ECHO_N "(cached) $ECHO_C" >&6
4468 else
4469    echo abfoo >t1
4470   echo cdfoo >t2
4471   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4472   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4473     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4474       :
4475     else
4476       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4477     fi
4478   fi
4479   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4480     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4481       :
4482     else
4483       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4484     fi
4485   fi
4486   rm t1 t2
4487
4488 fi
4489 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4490 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4491 do_compare="$gcc_cv_prog_cmp_skip"
4492
4493
4494
4495 # Check for GMP and MPFR
4496 gmplibs="-lmpfr -lgmp"
4497 gmpinc=
4498 have_gmp=no
4499
4500 # Specify a location for mpfr
4501 # check for this first so it ends up on the link line before gmp.
4502
4503 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4504 if test "${with_mpfr_dir+set}" = set; then
4505   withval="$with_mpfr_dir"
4506   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4507 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4508 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4509 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4510    { (exit 1); exit 1; }; }
4511 fi;
4512
4513
4514 # Check whether --with-mpfr or --without-mpfr was given.
4515 if test "${with_mpfr+set}" = set; then
4516   withval="$with_mpfr"
4517
4518 fi;
4519
4520 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4521 if test "${with_mpfr_include+set}" = set; then
4522   withval="$with_mpfr_include"
4523
4524 fi;
4525
4526 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4527 if test "${with_mpfr_lib+set}" = set; then
4528   withval="$with_mpfr_lib"
4529
4530 fi;
4531
4532 if test "x$with_mpfr" != x; then
4533   gmplibs="-L$with_mpfr/lib $gmplibs"
4534   gmpinc="-I$with_mpfr/include"
4535 fi
4536 if test "x$with_mpfr_include" != x; then
4537   gmpinc="-I$with_mpfr_include"
4538 fi
4539 if test "x$with_mpfr_lib" != x; then
4540   gmplibs="-L$with_mpfr_lib $gmplibs"
4541 fi
4542 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4543   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4544   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4545   # Do not test the mpfr version.  Assume that it is sufficient, since
4546   # it is in the source tree, and the library has not been built yet
4547   # but it would be included on the link line in the version check below
4548   # hence making the test fail.
4549   have_gmp=yes
4550 fi
4551
4552 # Specify a location for gmp
4553
4554 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4555 if test "${with_gmp_dir+set}" = set; then
4556   withval="$with_gmp_dir"
4557   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4558 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4559 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4560 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4561    { (exit 1); exit 1; }; }
4562 fi;
4563
4564
4565 # Check whether --with-gmp or --without-gmp was given.
4566 if test "${with_gmp+set}" = set; then
4567   withval="$with_gmp"
4568
4569 fi;
4570
4571 # Check whether --with-gmp_include or --without-gmp_include was given.
4572 if test "${with_gmp_include+set}" = set; then
4573   withval="$with_gmp_include"
4574
4575 fi;
4576
4577 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4578 if test "${with_gmp_lib+set}" = set; then
4579   withval="$with_gmp_lib"
4580
4581 fi;
4582
4583
4584 if test "x$with_gmp" != x; then
4585   gmplibs="-L$with_gmp/lib $gmplibs"
4586   gmpinc="-I$with_gmp/include $gmpinc"
4587 fi
4588 if test "x$with_gmp_include" != x; then
4589   gmpinc="-I$with_gmp_include $gmpinc"
4590 fi
4591 if test "x$with_gmp_lib" != x; then
4592   gmplibs="-L$with_gmp_lib $gmplibs"
4593 fi
4594 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4595   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4596   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4597   # Do not test the gmp version.  Assume that it is sufficient, since
4598   # it is in the source tree, and the library has not been built yet
4599   # but it would be included on the link line in the version check below
4600   # hence making the test fail.
4601   have_gmp=yes
4602 fi
4603
4604 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4605   have_gmp=yes
4606   saved_CFLAGS="$CFLAGS"
4607   CFLAGS="$CFLAGS $gmpinc"
4608   # Check GMP actually works
4609   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4610 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4611
4612 cat >conftest.$ac_ext <<_ACEOF
4613 /* confdefs.h.  */
4614 _ACEOF
4615 cat confdefs.h >>conftest.$ac_ext
4616 cat >>conftest.$ac_ext <<_ACEOF
4617 /* end confdefs.h.  */
4618 #include "gmp.h"
4619 int
4620 main ()
4621 {
4622
4623   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4624   choke me
4625   #endif
4626
4627   ;
4628   return 0;
4629 }
4630 _ACEOF
4631 rm -f conftest.$ac_objext
4632 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4633   (eval $ac_compile) 2>conftest.er1
4634   ac_status=$?
4635   grep -v '^ *+' conftest.er1 >conftest.err
4636   rm -f conftest.er1
4637   cat conftest.err >&5
4638   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4639   (exit $ac_status); } &&
4640          { ac_try='test -z "$ac_c_werror_flag"
4641                          || test ! -s conftest.err'
4642   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4643   (eval $ac_try) 2>&5
4644   ac_status=$?
4645   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4646   (exit $ac_status); }; } &&
4647          { ac_try='test -s conftest.$ac_objext'
4648   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4649   (eval $ac_try) 2>&5
4650   ac_status=$?
4651   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4652   (exit $ac_status); }; }; then
4653   echo "$as_me:$LINENO: result: yes" >&5
4654 echo "${ECHO_T}yes" >&6
4655 else
4656   echo "$as_me: failed program was:" >&5
4657 sed 's/^/| /' conftest.$ac_ext >&5
4658
4659 echo "$as_me:$LINENO: result: no" >&5
4660 echo "${ECHO_T}no" >&6; have_gmp=no
4661 fi
4662 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4663
4664   if test x"$have_gmp" = xyes; then
4665     saved_LIBS="$LIBS"
4666     LIBS="$LIBS $gmplibs"
4667         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4668 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4669     cat >conftest.$ac_ext <<_ACEOF
4670 /* confdefs.h.  */
4671 _ACEOF
4672 cat confdefs.h >>conftest.$ac_ext
4673 cat >>conftest.$ac_ext <<_ACEOF
4674 /* end confdefs.h.  */
4675 #include <gmp.h>
4676     #include <mpfr.h>
4677 int
4678 main ()
4679 {
4680
4681     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4682     choke me
4683     #endif
4684     mpfr_t n;
4685     mpfr_t x;
4686     int t;
4687     mpfr_init (n);
4688     mpfr_init (x);
4689     mpfr_atan2 (n, n, x, GMP_RNDN);
4690     mpfr_erfc (n, x, GMP_RNDN);
4691     mpfr_subnormalize (x, t, GMP_RNDN);
4692
4693   ;
4694   return 0;
4695 }
4696 _ACEOF
4697 rm -f conftest.$ac_objext conftest$ac_exeext
4698 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4699   (eval $ac_link) 2>conftest.er1
4700   ac_status=$?
4701   grep -v '^ *+' conftest.er1 >conftest.err
4702   rm -f conftest.er1
4703   cat conftest.err >&5
4704   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4705   (exit $ac_status); } &&
4706          { ac_try='test -z "$ac_c_werror_flag"
4707                          || test ! -s conftest.err'
4708   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4709   (eval $ac_try) 2>&5
4710   ac_status=$?
4711   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4712   (exit $ac_status); }; } &&
4713          { ac_try='test -s conftest$ac_exeext'
4714   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4715   (eval $ac_try) 2>&5
4716   ac_status=$?
4717   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4718   (exit $ac_status); }; }; then
4719   cat >conftest.$ac_ext <<_ACEOF
4720 /* confdefs.h.  */
4721 _ACEOF
4722 cat confdefs.h >>conftest.$ac_ext
4723 cat >>conftest.$ac_ext <<_ACEOF
4724 /* end confdefs.h.  */
4725 #include <gmp.h>
4726     #include <mpfr.h>
4727 int
4728 main ()
4729 {
4730
4731     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4732     choke me
4733     #endif
4734     mpfr_t n; mpfr_init(n);
4735
4736   ;
4737   return 0;
4738 }
4739 _ACEOF
4740 rm -f conftest.$ac_objext conftest$ac_exeext
4741 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4742   (eval $ac_link) 2>conftest.er1
4743   ac_status=$?
4744   grep -v '^ *+' conftest.er1 >conftest.err
4745   rm -f conftest.er1
4746   cat conftest.err >&5
4747   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4748   (exit $ac_status); } &&
4749          { ac_try='test -z "$ac_c_werror_flag"
4750                          || test ! -s conftest.err'
4751   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4752   (eval $ac_try) 2>&5
4753   ac_status=$?
4754   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4755   (exit $ac_status); }; } &&
4756          { ac_try='test -s conftest$ac_exeext'
4757   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4758   (eval $ac_try) 2>&5
4759   ac_status=$?
4760   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4761   (exit $ac_status); }; }; then
4762   echo "$as_me:$LINENO: result: yes" >&5
4763 echo "${ECHO_T}yes" >&6
4764 else
4765   echo "$as_me: failed program was:" >&5
4766 sed 's/^/| /' conftest.$ac_ext >&5
4767
4768 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4769 echo "${ECHO_T}buggy but acceptable" >&6
4770 fi
4771 rm -f conftest.err conftest.$ac_objext \
4772       conftest$ac_exeext conftest.$ac_ext
4773 else
4774   echo "$as_me: failed program was:" >&5
4775 sed 's/^/| /' conftest.$ac_ext >&5
4776
4777 echo "$as_me:$LINENO: result: no" >&5
4778 echo "${ECHO_T}no" >&6; have_gmp=no
4779 fi
4780 rm -f conftest.err conftest.$ac_objext \
4781       conftest$ac_exeext conftest.$ac_ext
4782       LIBS="$saved_LIBS"
4783   fi
4784   CFLAGS="$saved_CFLAGS"
4785
4786   if test x$have_gmp != xyes; then
4787     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.2+.
4788 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4789 Copies of these libraries' source code can be found at their respective
4790 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4791 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4792 If you obtained GMP and/or MPFR from a vendor distribution package, make
4793 sure that you have installed both the libraries and the header files.
4794 They may be located in separate packages." >&5
4795 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.2+.
4796 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4797 Copies of these libraries' source code can be found at their respective
4798 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4799 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4800 If you obtained GMP and/or MPFR from a vendor distribution package, make
4801 sure that you have installed both the libraries and the header files.
4802 They may be located in separate packages." >&2;}
4803    { (exit 1); exit 1; }; }
4804   fi
4805 fi
4806
4807 # Flags needed for both GMP and/or MPFR
4808
4809
4810
4811
4812 # Check for PPL
4813 ppl_major_version=0
4814 ppl_minor_version=10
4815 ppllibs=" -lppl_c -lppl -lgmpxx "
4816 pplinc=
4817
4818
4819 # Check whether --with-ppl or --without-ppl was given.
4820 if test "${with_ppl+set}" = set; then
4821   withval="$with_ppl"
4822
4823 fi;
4824
4825 # Check whether --with-ppl_include or --without-ppl_include was given.
4826 if test "${with_ppl_include+set}" = set; then
4827   withval="$with_ppl_include"
4828
4829 fi;
4830
4831 # Check whether --with-ppl_lib or --without-ppl_lib was given.
4832 if test "${with_ppl_lib+set}" = set; then
4833   withval="$with_ppl_lib"
4834
4835 fi;
4836
4837 case $with_ppl in
4838   no)
4839     ppllibs=
4840     ;;
4841   *)
4842     ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx"
4843     pplinc="-I$with_ppl/include $pplinc"
4844     LIBS="$ppllibs $LIBS"
4845     ;;
4846 esac
4847 if test "x$with_ppl_include" != x; then
4848   pplinc="-I$with_ppl_include $pplinc"
4849 fi
4850 if test "x$with_ppl_lib" != x; then
4851   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx"
4852   LIBS="$ppllibs $LIBS"
4853 fi
4854 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
4855   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '
4856   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
4857   LIBS="$ppllibs $LIBS"
4858 fi
4859
4860 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
4861 if test "${enable_ppl_version_check+set}" = set; then
4862   enableval="$enable_ppl_version_check"
4863   ENABLE_PPL_CHECK=$enableval
4864 else
4865   ENABLE_PPL_CHECK=yes
4866 fi;
4867
4868 if test "${ENABLE_PPL_CHECK}" = "yes"; then
4869   saved_CFLAGS="$CFLAGS"
4870   CFLAGS="$CFLAGS $pplinc $gmpinc"
4871   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
4872 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
4873   cat >conftest.$ac_ext <<_ACEOF
4874 /* confdefs.h.  */
4875 _ACEOF
4876 cat confdefs.h >>conftest.$ac_ext
4877 cat >>conftest.$ac_ext <<_ACEOF
4878 /* end confdefs.h.  */
4879 #include "ppl_c.h"
4880 int
4881 main ()
4882 {
4883
4884   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
4885   choke me
4886   #endif
4887
4888   ;
4889   return 0;
4890 }
4891 _ACEOF
4892 rm -f conftest.$ac_objext
4893 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4894   (eval $ac_compile) 2>conftest.er1
4895   ac_status=$?
4896   grep -v '^ *+' conftest.er1 >conftest.err
4897   rm -f conftest.er1
4898   cat conftest.err >&5
4899   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4900   (exit $ac_status); } &&
4901          { ac_try='test -z "$ac_c_werror_flag"
4902                          || test ! -s conftest.err'
4903   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4904   (eval $ac_try) 2>&5
4905   ac_status=$?
4906   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4907   (exit $ac_status); }; } &&
4908          { ac_try='test -s conftest.$ac_objext'
4909   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4910   (eval $ac_try) 2>&5
4911   ac_status=$?
4912   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4913   (exit $ac_status); }; }; then
4914   echo "$as_me:$LINENO: result: yes" >&5
4915 echo "${ECHO_T}yes" >&6
4916 else
4917   echo "$as_me: failed program was:" >&5
4918 sed 's/^/| /' conftest.$ac_ext >&5
4919
4920 echo "$as_me:$LINENO: result: no" >&5
4921 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
4922 fi
4923 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4924   CFLAGS="$saved_CFLAGS"
4925 fi
4926
4927 # Flags needed for PPL
4928
4929
4930
4931
4932 # Check for CLOOG
4933 clooglibs=" -lcloog "
4934 clooginc=" -DCLOOG_PPL_BACKEND "
4935
4936
4937 # Check whether --with-cloog or --without-cloog was given.
4938 if test "${with_cloog+set}" = set; then
4939   withval="$with_cloog"
4940
4941 fi;
4942
4943 # Check whether --with-cloog_include or --without-cloog_include was given.
4944 if test "${with_cloog_include+set}" = set; then
4945   withval="$with_cloog_include"
4946
4947 fi;
4948
4949 # Check whether --with-cloog_lib or --without-cloog_lib was given.
4950 if test "${with_cloog_lib+set}" = set; then
4951   withval="$with_cloog_lib"
4952
4953 fi;
4954
4955 case $with_cloog in
4956   no)
4957     clooglibs=
4958     clooginc=
4959     ;;
4960   *)
4961     clooglibs="-L$with_cloog/lib -lcloog"
4962     clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
4963     LIBS="$clooglibs $LIBS"
4964     ;;
4965 esac
4966 if test "x$with_cloog_include" != x; then
4967   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
4968 fi
4969 if test "x$with_cloog_lib" != x; then
4970   clooglibs="-L$with_cloog_lib -lcloog"
4971   LIBS="$clooglibs $LIBS"
4972 fi
4973 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
4974   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
4975   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
4976   LIBS="$clooglibs $LIBS"
4977 fi
4978
4979 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
4980 if test "${enable_cloog_version_check+set}" = set; then
4981   enableval="$enable_cloog_version_check"
4982   ENABLE_CLOOG_CHECK=$enableval
4983 else
4984   ENABLE_CLOOG_CHECK=yes
4985 fi;
4986
4987 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
4988   saved_CFLAGS="$CFLAGS"
4989   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
4990   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
4991 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
4992   cat >conftest.$ac_ext <<_ACEOF
4993 /* confdefs.h.  */
4994 _ACEOF
4995 cat confdefs.h >>conftest.$ac_ext
4996 cat >>conftest.$ac_ext <<_ACEOF
4997 /* end confdefs.h.  */
4998 #include "cloog/cloog.h"
4999 int
5000 main ()
5001 {
5002
5003   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5004   choke me
5005   #endif
5006
5007   ;
5008   return 0;
5009 }
5010 _ACEOF
5011 rm -f conftest.$ac_objext
5012 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5013   (eval $ac_compile) 2>conftest.er1
5014   ac_status=$?
5015   grep -v '^ *+' conftest.er1 >conftest.err
5016   rm -f conftest.er1
5017   cat conftest.err >&5
5018   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5019   (exit $ac_status); } &&
5020          { ac_try='test -z "$ac_c_werror_flag"
5021                          || test ! -s conftest.err'
5022   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5023   (eval $ac_try) 2>&5
5024   ac_status=$?
5025   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5026   (exit $ac_status); }; } &&
5027          { ac_try='test -s conftest.$ac_objext'
5028   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5029   (eval $ac_try) 2>&5
5030   ac_status=$?
5031   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5032   (exit $ac_status); }; }; then
5033   echo "$as_me:$LINENO: result: yes" >&5
5034 echo "${ECHO_T}yes" >&6
5035 else
5036   echo "$as_me: failed program was:" >&5
5037 sed 's/^/| /' conftest.$ac_ext >&5
5038
5039 echo "$as_me:$LINENO: result: no" >&5
5040 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5041 fi
5042 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5043   CFLAGS="$saved_CFLAGS"
5044 fi
5045
5046 # Flags needed for CLOOG
5047
5048
5049
5050
5051 # By default, C is the only stage 1 language.
5052 stage1_languages=,c,
5053
5054 # Figure out what language subdirectories are present.
5055 # Look if the user specified --enable-languages="..."; if not, use
5056 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5057 # go away some day.
5058 # NB:  embedded tabs in this IF block -- do not untabify
5059 if test -d ${srcdir}/gcc; then
5060   if test x"${enable_languages+set}" != xset; then
5061     if test x"${LANGUAGES+set}" = xset; then
5062       enable_languages="${LANGUAGES}"
5063         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5064     else
5065       enable_languages=all
5066     fi
5067   else
5068     if test x"${enable_languages}" = x ||
5069        test x"${enable_languages}" = xyes;
5070        then
5071       echo configure.in: --enable-languages needs at least one language argument 1>&2
5072       exit 1
5073     fi
5074   fi
5075   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5076
5077   # 'f95' is the old name for the 'fortran' language. We issue a warning
5078   # and make the substitution.
5079   case ,${enable_languages}, in
5080     *,f95,*)
5081       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5082       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5083       ;;
5084   esac
5085
5086   # First scan to see if an enabled language requires some other language.
5087   # We assume that a given config-lang.in will list all the language
5088   # front ends it requires, even if some are required indirectly.
5089   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5090     case ${lang_frag} in
5091       ..) ;;
5092       # The odd quoting in the next line works around
5093       # an apparent bug in bash 1.12 on linux.
5094       ${srcdir}/gcc/[*]/config-lang.in) ;;
5095       *)
5096         # From the config-lang.in, get $language, $lang_requires
5097         language=
5098         lang_requires=
5099         . ${lang_frag}
5100         for other in ${lang_requires} ; do
5101           case ,${enable_languages}, in
5102             *,$other,*) ;;
5103             *,all,*) ;;
5104             *,$language,*)
5105               echo " \`$other' language required by \`$language'; enabling" 1>&2
5106               enable_languages="${enable_languages},${other}"
5107               ;;
5108           esac
5109         done
5110         ;;
5111     esac
5112   done
5113
5114   new_enable_languages=,c,
5115   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5116   potential_languages=,c,
5117
5118   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5119     case ${lang_frag} in
5120       ..) ;;
5121       # The odd quoting in the next line works around
5122       # an apparent bug in bash 1.12 on linux.
5123       ${srcdir}/gcc/[*]/config-lang.in) ;;
5124       *)
5125         # From the config-lang.in, get $language, $target_libs,
5126         # $lang_dirs, $boot_language, and $build_by_default
5127         language=
5128         target_libs=
5129         lang_dirs=
5130         subdir_requires=
5131         boot_language=no
5132         build_by_default=yes
5133         . ${lang_frag}
5134         if test x${language} = x; then
5135           echo "${lang_frag} doesn't set \$language." 1>&2
5136           exit 1
5137         fi
5138
5139         case ,${enable_languages}, in
5140           *,${language},*)
5141             # Language was explicitly selected; include it.
5142             add_this_lang=yes
5143             ;;
5144           *,all,*)
5145             # 'all' was selected, select it if it is a default language
5146             add_this_lang=${build_by_default}
5147             ;;
5148           *)
5149             add_this_lang=no
5150             ;;
5151         esac
5152
5153         # Disable languages that need other directories if these aren't available.
5154         for i in $subdir_requires; do
5155           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5156           case ,${enable_languages}, in
5157             *,${language},*)
5158               # Specifically requested language; tell them.
5159               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5160 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5161    { (exit 1); exit 1; }; }
5162               ;;
5163             *)
5164               # Silently disable.
5165               add_this_lang=unsupported
5166               ;;
5167           esac
5168         done
5169
5170         # Disable Ada if no preexisting GNAT is available.
5171         case ,${enable_languages},:${language}:${have_gnat} in
5172           *,${language},*:ada:no)
5173             # Specifically requested language; tell them.
5174             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5175 echo "$as_me: error: GNAT is required to build $language" >&2;}
5176    { (exit 1); exit 1; }; }
5177             ;;
5178           *:ada:no)
5179             # Silently disable.
5180             add_this_lang=unsupported
5181             ;;
5182         esac
5183
5184         # Disable a language that is unsupported by the target.
5185         case " $unsupported_languages " in
5186           *" $language "*)
5187             add_this_lang=unsupported
5188             ;;
5189         esac
5190
5191         case $add_this_lang in
5192           unsupported)
5193             # Remove language-dependent dirs.
5194             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5195             ;;
5196           no)
5197             # Remove language-dependent dirs; still show language as supported.
5198             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5199             potential_languages="${potential_languages}${language},"
5200             ;;
5201           yes)
5202             new_enable_languages="${new_enable_languages}${language},"
5203             potential_languages="${potential_languages}${language},"
5204             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5205             case ${boot_language} in
5206               yes)
5207                 # Add to (comma-separated) list of stage 1 languages.
5208                 stage1_languages="${stage1_languages}${language},"
5209                 ;;
5210             esac
5211             ;;
5212         esac
5213         ;;
5214     esac
5215   done
5216
5217   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5218 if test "${enable_stage1_languages+set}" = set; then
5219   enableval="$enable_stage1_languages"
5220   case ,${enable_stage1_languages}, in
5221     ,no,|,,)
5222       # Set it to something that will have no effect in the loop below
5223       enable_stage1_languages=c ;;
5224     ,yes,)
5225       enable_stage1_languages=`echo $new_enable_languages | \
5226         sed -e "s/^,//" -e "s/,$//" ` ;;
5227     *,all,*)
5228       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5229         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5230   esac
5231
5232   # Add "good" languages from enable_stage1_languages to stage1_languages,
5233   # while "bad" languages go in missing_languages.  Leave no duplicates.
5234   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5235     case $potential_languages in
5236       *,$i,*)
5237         case $stage1_languages in
5238           *,$i,*) ;;
5239           *) stage1_languages="$stage1_languages$i," ;;
5240         esac ;;
5241       *)
5242         case $missing_languages in
5243           *,$i,*) ;;
5244           *) missing_languages="$missing_languages$i," ;;
5245         esac ;;
5246      esac
5247   done
5248 fi;
5249
5250   # Remove leading/trailing commas that were added for simplicity
5251   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5252   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5253   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5254   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5255
5256   if test "x$missing_languages" != x; then
5257     { { echo "$as_me:$LINENO: error:
5258 The following requested languages could not be built: ${missing_languages}
5259 Supported languages are: ${potential_languages}" >&5
5260 echo "$as_me: error:
5261 The following requested languages could not be built: ${missing_languages}
5262 Supported languages are: ${potential_languages}" >&2;}
5263    { (exit 1); exit 1; }; }
5264   fi
5265   if test "x$new_enable_languages" != "x$enable_languages"; then
5266     echo The following languages will be built: ${new_enable_languages}
5267     enable_languages="$new_enable_languages"
5268   fi
5269
5270
5271   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5272 fi
5273
5274 # Handle --disable-<component> generically.
5275 for dir in $configdirs $build_configdirs $target_configdirs ; do
5276   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5277   varname=`echo $dirname | sed -e s/+/_/g`
5278   if eval test x\${enable_${varname}} "=" xno ; then
5279     noconfigdirs="$noconfigdirs $dir"
5280   fi
5281 done
5282
5283 # Check for Boehm's garbage collector
5284 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5285 if test "${enable_objc_gc+set}" = set; then
5286   enableval="$enable_objc_gc"
5287   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5288   *,objc,*:*:yes:*target-boehm-gc*)
5289     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5290 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5291    { (exit 1); exit 1; }; }
5292     ;;
5293 esac
5294 fi;
5295
5296 # Make sure we only build Boehm's garbage collector if required.
5297 case ,${enable_languages},:${enable_objc_gc} in
5298   *,objc,*:yes)
5299     # Keep target-boehm-gc if requested for Objective-C.
5300     ;;
5301   *)
5302     # Otherwise remove target-boehm-gc depending on target-libjava.
5303     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5304       noconfigdirs="$noconfigdirs target-boehm-gc"
5305     fi
5306     ;;
5307 esac
5308
5309 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5310 # $build_configdirs and $target_configdirs.
5311 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5312
5313 notsupp=""
5314 for dir in . $skipdirs $noconfigdirs ; do
5315   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5316   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5317     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5318     if test -r $srcdir/$dirname/configure ; then
5319       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5320         true
5321       else
5322         notsupp="$notsupp $dir"
5323       fi
5324     fi
5325   fi
5326   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5327     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5328     if test -r $srcdir/$dirname/configure ; then
5329       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5330         true
5331       else
5332         notsupp="$notsupp $dir"
5333       fi
5334     fi
5335   fi
5336   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5337     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5338     if test -r $srcdir/$dirname/configure ; then
5339       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5340         true
5341       else
5342         notsupp="$notsupp $dir"
5343       fi
5344     fi
5345   fi
5346 done
5347
5348 # Sometimes the tools are distributed with libiberty but with no other
5349 # libraries.  In that case, we don't want to build target-libiberty.
5350 # Don't let libgcc imply libiberty either.
5351 if test -n "${target_configdirs}" ; then
5352   libgcc=
5353   others=
5354   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5355     if test "$i" = "libgcc"; then
5356       libgcc=target-libgcc
5357     elif test "$i" != "libiberty" ; then
5358       if test -r $srcdir/$i/configure ; then
5359         others=yes;
5360         break;
5361       fi
5362     fi
5363   done
5364   if test -z "${others}" ; then
5365     target_configdirs=$libgcc
5366   fi
5367 fi
5368
5369 # Quietly strip out all directories which aren't configurable in this tree.
5370 # This relies on all configurable subdirectories being autoconfiscated, which
5371 # is now the case.
5372 build_configdirs_all="$build_configdirs"
5373 build_configdirs=
5374 for i in ${build_configdirs_all} ; do
5375   j=`echo $i | sed -e s/build-//g`
5376   if test -f ${srcdir}/$j/configure ; then
5377     build_configdirs="${build_configdirs} $i"
5378   fi
5379 done
5380
5381 configdirs_all="$configdirs"
5382 configdirs=
5383 for i in ${configdirs_all} ; do
5384   if test -f ${srcdir}/$i/configure ; then
5385     configdirs="${configdirs} $i"
5386   fi
5387 done
5388
5389 target_configdirs_all="$target_configdirs"
5390 target_configdirs=
5391 for i in ${target_configdirs_all} ; do
5392   j=`echo $i | sed -e s/target-//g`
5393   if test -f ${srcdir}/$j/configure ; then
5394     target_configdirs="${target_configdirs} $i"
5395   fi
5396 done
5397
5398 # Produce a warning message for the subdirs we can't configure.
5399 # This isn't especially interesting in the Cygnus tree, but in the individual
5400 # FSF releases, it's important to let people know when their machine isn't
5401 # supported by the one or two programs in a package.
5402
5403 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5404   # If $appdirs is non-empty, at least one of those directories must still
5405   # be configured, or we error out.  (E.g., if the gas release supports a
5406   # specified target in some subdirs but not the gas subdir, we shouldn't
5407   # pretend that all is well.)
5408   if test -n "$appdirs" ; then
5409     for dir in $appdirs ; do
5410       if test -r $dir/Makefile.in ; then
5411         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5412           appdirs=""
5413           break
5414         fi
5415         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5416           appdirs=""
5417           break
5418         fi
5419       fi
5420     done
5421     if test -n "$appdirs" ; then
5422       echo "*** This configuration is not supported by this package." 1>&2
5423       exit 1
5424     fi
5425   fi
5426   # Okay, some application will build, or we don't care to check.  Still
5427   # notify of subdirs not getting built.
5428   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5429   echo "    ${notsupp}" 1>&2
5430   echo "    (Any other directories should still work fine.)" 1>&2
5431 fi
5432
5433 case "$host" in
5434   *msdosdjgpp*)
5435     enable_gdbtk=no ;;
5436 esac
5437
5438 # To find our prefix, in gcc_cv_tool_prefix.
5439
5440 # The user is always right.
5441 if test "${PATH_SEPARATOR+set}" != set; then
5442   echo "#! /bin/sh" >conf$$.sh
5443   echo  "exit 0"   >>conf$$.sh
5444   chmod +x conf$$.sh
5445   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5446     PATH_SEPARATOR=';'
5447   else
5448     PATH_SEPARATOR=:
5449   fi
5450   rm -f conf$$.sh
5451 fi
5452
5453
5454
5455 if test "x$exec_prefix" = xNONE; then
5456         if test "x$prefix" = xNONE; then
5457                 gcc_cv_tool_prefix=$ac_default_prefix
5458         else
5459                 gcc_cv_tool_prefix=$prefix
5460         fi
5461 else
5462         gcc_cv_tool_prefix=$exec_prefix
5463 fi
5464
5465 # If there is no compiler in the tree, use the PATH only.  In any
5466 # case, if there is no compiler in the tree nobody should use
5467 # AS_FOR_TARGET and LD_FOR_TARGET.
5468 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5469     gcc_version=`cat $srcdir/gcc/BASE-VER`
5470     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5471     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5472     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5473     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5474     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5475     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5476 else
5477     gcc_cv_tool_dirs=
5478 fi
5479
5480 if test x$build = x$target && test -n "$md_exec_prefix"; then
5481         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5482 fi
5483
5484
5485
5486 copy_dirs=
5487
5488
5489 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5490 if test "${with_build_sysroot+set}" = set; then
5491   withval="$with_build_sysroot"
5492   if test x"$withval" != x ; then
5493      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5494    fi
5495 else
5496   SYSROOT_CFLAGS_FOR_TARGET=
5497 fi;
5498
5499
5500
5501 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5502 if test "${with_debug_prefix_map+set}" = set; then
5503   withval="$with_debug_prefix_map"
5504   if test x"$withval" != x; then
5505      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5506      for debug_map in $withval; do
5507        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5508      done
5509    fi
5510 else
5511   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5512 fi;
5513
5514
5515 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5516 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5517 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5518 # We want to ensure that TARGET libraries (which we know are built with
5519 # gcc) are built with "-O2 -g", so include those options when setting
5520 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5521 if test "x$CFLAGS_FOR_TARGET" = x; then
5522   CFLAGS_FOR_TARGET=$CFLAGS
5523   case " $CFLAGS " in
5524     *" -O2 "*) ;;
5525     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5526   esac
5527   case " $CFLAGS " in
5528     *" -g "* | *" -g3 "*) ;;
5529     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5530   esac
5531 fi
5532
5533
5534 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5535   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5536   case " $CXXFLAGS " in
5537     *" -O2 "*) ;;
5538     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5539   esac
5540   case " $CXXFLAGS " in
5541     *" -g "* | *" -g3 "*) ;;
5542     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5543   esac
5544 fi
5545
5546
5547 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5548 # the named directory are copied to $(tooldir)/sys-include.
5549 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5550   if test x${is_cross_compiler} = xno ; then
5551     echo 1>&2 '***' --with-headers is only supported when cross compiling
5552     exit 1
5553   fi
5554   if test x"${with_headers}" != xyes ; then
5555     x=${gcc_cv_tool_prefix}
5556     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5557   fi
5558 fi
5559
5560 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5561 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5562 # are permitted.
5563 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5564   if test x${is_cross_compiler} = xno ; then
5565     echo 1>&2 '***' --with-libs is only supported when cross compiling
5566     exit 1
5567   fi
5568   if test x"${with_libs}" != xyes ; then
5569     # Copy the libraries in reverse order, so that files in the first named
5570     # library override files in subsequent libraries.
5571     x=${gcc_cv_tool_prefix}
5572     for l in ${with_libs}; do
5573       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5574     done
5575   fi
5576 fi
5577
5578 # Set with_gnu_as and with_gnu_ld as appropriate.
5579 #
5580 # This is done by determining whether or not the appropriate directory
5581 # is available, and by checking whether or not specific configurations
5582 # have requested that this magic not happen.
5583 #
5584 # The command line options always override the explicit settings in
5585 # configure.in, and the settings in configure.in override this magic.
5586 #
5587 # If the default for a toolchain is to use GNU as and ld, and you don't
5588 # want to do that, then you should use the --without-gnu-as and
5589 # --without-gnu-ld options for the configure script.
5590
5591 if test x${use_gnu_as} = x &&
5592    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5593   with_gnu_as=yes
5594   extra_host_args="$extra_host_args --with-gnu-as"
5595 fi
5596
5597 if test x${use_gnu_ld} = x &&
5598    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5599   with_gnu_ld=yes
5600   extra_host_args="$extra_host_args --with-gnu-ld"
5601 fi
5602
5603 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5604 # can detect this case.
5605
5606 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5607   with_newlib=yes
5608   extra_host_args="$extra_host_args --with-newlib"
5609 fi
5610
5611 # Handle ${copy_dirs}
5612 set fnord ${copy_dirs}
5613 shift
5614 while test $# != 0 ; do
5615   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5616     :
5617   else
5618     echo Copying $1 to $2
5619
5620     # Use the install script to create the directory and all required
5621     # parent directories.
5622     if test -d $2 ; then
5623       :
5624     else
5625       echo >config.temp
5626       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5627     fi
5628
5629     # Copy the directory, assuming we have tar.
5630     # FIXME: Should we use B in the second tar?  Not all systems support it.
5631     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5632
5633     # It is the responsibility of the user to correctly adjust all
5634     # symlinks.  If somebody can figure out how to handle them correctly
5635     # here, feel free to add the code.
5636
5637     echo $1 > $2/COPIED
5638   fi
5639   shift; shift
5640 done
5641
5642 # Determine a target-dependent exec_prefix that the installed
5643 # gcc will search in.  Keep this list sorted by triplet, with
5644 # the *-*-osname triplets last.
5645 md_exec_prefix=
5646 case "${target}" in
5647   alpha*-*-*vms*)
5648     md_exec_prefix=/gnu/lib/gcc-lib
5649     ;;
5650   i[34567]86-pc-msdosdjgpp*)
5651     md_exec_prefix=/dev/env/DJDIR/bin
5652     ;;
5653   i[34567]86-*-sco3.2v5*)
5654     if test $with_gnu_as = yes; then
5655       md_exec_prefix=/usr/gnu/bin
5656     else
5657       md_exec_prefix=/usr/ccs/bin/elf
5658     fi
5659     ;;
5660
5661   mn10300-*-* | \
5662   powerpc-*-chorusos* | \
5663   powerpc*-*-eabi* | \
5664   powerpc*-*-sysv* | \
5665   powerpc*-*-kaos* | \
5666   s390x-ibm-tpf*)
5667     md_exec_prefix=/usr/ccs/bin
5668     ;;
5669   sparc64-*-elf*)
5670     ;;
5671   v850*-*-*)
5672     md_exec_prefix=/usr/ccs/bin
5673     ;;
5674   xtensa*-*-elf*)
5675     ;;
5676
5677   *-*-beos* | \
5678   *-*-elf* | \
5679   *-*-hpux* | \
5680   *-*-netware* | \
5681   *-*-nto-qnx* | \
5682   *-*-rtems* | \
5683   *-*-solaris2* | \
5684   *-*-sysv[45]* | \
5685   *-*-vxworks* | \
5686   *-wrs-windiss)
5687     md_exec_prefix=/usr/ccs/bin
5688     ;;
5689 esac
5690
5691 extra_arflags_for_target=
5692 extra_nmflags_for_target=
5693 extra_ranlibflags_for_target=
5694 target_makefile_frag=/dev/null
5695 case "${target}" in
5696   mep*-*-*)
5697     target_makefile_frag="config/mt-mep"
5698     ;;
5699   spu-*-*)
5700     target_makefile_frag="config/mt-spu"
5701     ;;
5702   mips*-sde-elf*)
5703     target_makefile_frag="config/mt-sde"
5704     ;;
5705   mipsisa*-*-elfoabi*)
5706     target_makefile_frag="config/mt-mips-elfoabi"
5707     ;;
5708   mips*-*-*linux* | mips*-*-gnu*)
5709     target_makefile_frag="config/mt-mips-gnu"
5710     ;;
5711   *-*-netware*)
5712     target_makefile_frag="config/mt-netware"
5713     ;;
5714   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | *-*-kopensolaris*-gnu)
5715     target_makefile_frag="config/mt-gnu"
5716     ;;
5717   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5718     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5719     # commands to handle both 32-bit and 64-bit objects.  These flags are
5720     # harmless if we're using GNU nm or ar.
5721     extra_arflags_for_target=" -X32_64"
5722     extra_nmflags_for_target=" -B -X32_64"
5723     ;;
5724   *-*-darwin*)
5725     # ranlib from Darwin requires the -c flag to look at common symbols.
5726     extra_ranlibflags_for_target=" -c"
5727     ;;
5728   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5729     target_makefile_frag="config/mt-wince"
5730     ;;
5731 esac
5732
5733 alphaieee_frag=/dev/null
5734 case $target in
5735   alpha*-*-*)
5736     # This just makes sure to use the -mieee option to build target libs.
5737     # This should probably be set individually by each library.
5738     alphaieee_frag="config/mt-alphaieee"
5739     ;;
5740 esac
5741
5742 # If --enable-target-optspace always use -Os instead of -O2 to build
5743 # the target libraries, similarly if it is not specified, use -Os
5744 # on selected platforms.
5745 ospace_frag=/dev/null
5746 case "${enable_target_optspace}:${target}" in
5747   yes:*)
5748     ospace_frag="config/mt-ospace"
5749     ;;
5750   :d30v-*)
5751     ospace_frag="config/mt-d30v"
5752     ;;
5753   :m32r-* | :d10v-* | :fr30-*)
5754     ospace_frag="config/mt-ospace"
5755     ;;
5756   no:* | :*)
5757     ;;
5758   *)
5759     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5760     ;;
5761 esac
5762
5763 # Default to using --with-stabs for certain targets.
5764 if test x${with_stabs} = x ; then
5765   case "${target}" in
5766   mips*-*-irix[56]*)
5767     ;;
5768   mips*-*-* | alpha*-*-osf*)
5769     with_stabs=yes;
5770     extra_host_args="${extra_host_args} --with-stabs"
5771     ;;
5772   esac
5773 fi
5774
5775 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5776 # them automatically.
5777 case "${host}" in
5778   hppa*64*-*-hpux11*)
5779     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5780     ;;
5781 esac
5782
5783 # Some systems (e.g., one of the i386-aix systems the gas testers are
5784 # using) don't handle "\$" correctly, so don't use it here.
5785 tooldir='${exec_prefix}'/${target_noncanonical}
5786 build_tooldir=${tooldir}
5787
5788 # Create a .gdbinit file which runs the one in srcdir
5789 # and tells GDB to look there for source files.
5790
5791 if test -r ${srcdir}/.gdbinit ; then
5792   case ${srcdir} in
5793     .) ;;
5794     *) cat > ./.gdbinit <<EOF
5795 # ${NO_EDIT}
5796 dir ${srcdir}
5797 dir .
5798 source ${srcdir}/.gdbinit
5799 EOF
5800     ;;
5801   esac
5802 fi
5803
5804 # Make sure that the compiler is able to generate an executable.  If it
5805 # can't, we are probably in trouble.  We don't care whether we can run the
5806 # executable--we might be using a cross compiler--we only care whether it
5807 # can be created.  At this point the main configure script has set CC.
5808 we_are_ok=no
5809 echo "int main () { return 0; }" > conftest.c
5810 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5811 if test $? = 0 ; then
5812   if test -s conftest || test -s conftest.exe ; then
5813     we_are_ok=yes
5814   fi
5815 fi
5816 case $we_are_ok in
5817   no)
5818     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5819     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5820     rm -f conftest*
5821     exit 1
5822     ;;
5823 esac
5824 rm -f conftest*
5825
5826 # The Solaris /usr/ucb/cc compiler does not appear to work.
5827 case "${host}" in
5828   sparc-sun-solaris2*)
5829       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5830       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5831           could_use=
5832           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5833           if test -d /opt/cygnus/bin ; then
5834               if test "$could_use" = "" ; then
5835                   could_use="/opt/cygnus/bin"
5836               else
5837                   could_use="$could_use or /opt/cygnus/bin"
5838               fi
5839           fi
5840         if test "$could_use" = "" ; then
5841             echo "Warning: compilation may fail because you're using"
5842             echo "/usr/ucb/cc.  You should change your PATH or CC "
5843             echo "variable and rerun configure."
5844         else
5845             echo "Warning: compilation may fail because you're using"
5846             echo "/usr/ucb/cc, when you should use the C compiler from"
5847             echo "$could_use.  You should change your"
5848             echo "PATH or CC variable and rerun configure."
5849         fi
5850       fi
5851   ;;
5852 esac
5853
5854 # Decide which environment variable is used to find dynamic libraries.
5855 case "${host}" in
5856   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5857   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5858   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5859   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5860 esac
5861
5862 # On systems where the dynamic library environment variable is PATH,
5863 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
5864 # built executables to PATH.
5865 if test "$RPATH_ENVVAR" = PATH; then
5866   GCC_SHLIB_SUBDIR=/shlib
5867 else
5868   GCC_SHLIB_SUBDIR=
5869 fi
5870
5871 # Record target_configdirs and the configure arguments for target and
5872 # build configuration in Makefile.
5873 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5874 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5875
5876 # Determine whether gdb needs tk/tcl or not.
5877 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5878 # and in that case we want gdb to be built without tk.  Ugh!
5879 # In fact I believe gdb is the *only* package directly dependent on tk,
5880 # so we should be able to put the 'maybe's in unconditionally and
5881 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5882 # 100% sure that that's safe though.
5883
5884 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5885 case "$enable_gdbtk" in
5886   no)
5887     GDB_TK="" ;;
5888   yes)
5889     GDB_TK="${gdb_tk}" ;;
5890   *)
5891     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5892     # distro.  Eventually someone will fix this and move Insight, nee
5893     # gdbtk to a separate directory.
5894     if test -d ${srcdir}/gdb/gdbtk ; then
5895       GDB_TK="${gdb_tk}"
5896     else
5897       GDB_TK=""
5898     fi
5899     ;;
5900 esac
5901 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5902 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5903
5904 # Strip out unwanted targets.
5905
5906 # While at that, we remove Makefiles if we were started for recursive
5907 # configuration, so that the top-level Makefile reconfigures them,
5908 # like we used to do when configure itself was recursive.
5909
5910 # Loop over modules.  $extrasub must be used with care, limiting as
5911 # much as possible the usage of range addresses.  That's because autoconf
5912 # splits the sed script to overcome limits in the number of commands,
5913 # and relying on carefully-timed sed passes may turn out to be very hard
5914 # to maintain later.  In this particular case, you just have to be careful
5915 # not to nest @if/@endif pairs, because configure will not warn you at all.
5916
5917 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5918 if test "${enable_bootstrap+set}" = set; then
5919   enableval="$enable_bootstrap"
5920
5921 else
5922   enable_bootstrap=default
5923 fi;
5924
5925 # Issue errors and warnings for invalid/strange bootstrap combinations.
5926 case "$configdirs" in
5927   *gcc*) have_compiler=yes ;;
5928   *) have_compiler=no ;;
5929 esac
5930
5931 case "$have_compiler:$host:$target:$enable_bootstrap" in
5932   *:*:*:no) ;;
5933
5934   # Default behavior.  Enable bootstrap if we have a compiler
5935   # and we are in a native configuration.
5936   yes:$build:$build:default)
5937     enable_bootstrap=yes ;;
5938
5939   *:*:*:default)
5940     enable_bootstrap=no ;;
5941
5942   # We have a compiler and we are in a native configuration, bootstrap is ok
5943   yes:$build:$build:yes)
5944     ;;
5945
5946   # Other configurations, but we have a compiler.  Assume the user knows
5947   # what he's doing.
5948   yes:*:*:yes)
5949     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5950 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5951     ;;
5952
5953   # No compiler: if they passed --enable-bootstrap explicitly, fail
5954   no:*:*:yes)
5955     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5956 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5957    { (exit 1); exit 1; }; } ;;
5958
5959   # Fail if wrong command line
5960   *)
5961     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5962 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5963    { (exit 1); exit 1; }; }
5964     ;;
5965 esac
5966
5967 # Adjust the toplevel makefile according to whether bootstrap was selected.
5968 case "$enable_bootstrap" in
5969   yes)
5970     bootstrap_suffix=bootstrap ;;
5971   no)
5972     bootstrap_suffix=no-bootstrap ;;
5973 esac
5974
5975 for module in ${build_configdirs} ; do
5976   if test -z "${no_recursion}" \
5977      && test -f ${build_subdir}/${module}/Makefile; then
5978     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5979     rm -f ${build_subdir}/${module}/Makefile
5980   fi
5981   extrasub="$extrasub
5982 /^@if build-$module\$/d
5983 /^@endif build-$module\$/d
5984 /^@if build-$module-$bootstrap_suffix\$/d
5985 /^@endif build-$module-$bootstrap_suffix\$/d"
5986 done
5987 for module in ${configdirs} ; do
5988   if test -z "${no_recursion}"; then
5989     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5990       if test -f ${file}; then
5991         echo 1>&2 "*** removing ${file} to force reconfigure"
5992         rm -f ${file}
5993       fi
5994     done
5995   fi
5996   extrasub="$extrasub
5997 /^@if $module\$/d
5998 /^@endif $module\$/d
5999 /^@if $module-$bootstrap_suffix\$/d
6000 /^@endif $module-$bootstrap_suffix\$/d"
6001 done
6002 for module in ${target_configdirs} ; do
6003   if test -z "${no_recursion}" \
6004      && test -f ${target_subdir}/${module}/Makefile; then
6005     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6006     rm -f ${target_subdir}/${module}/Makefile
6007   fi
6008   extrasub="$extrasub
6009 /^@if target-$module\$/d
6010 /^@endif target-$module\$/d
6011 /^@if target-$module-$bootstrap_suffix\$/d
6012 /^@endif target-$module-$bootstrap_suffix\$/d"
6013 done
6014
6015 extrasub="$extrasub
6016 /^@if /,/^@endif /d"
6017
6018 # Create the serialization dependencies.  This uses a temporary file.
6019
6020 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6021 if test "${enable_serial_configure+set}" = set; then
6022   enableval="$enable_serial_configure"
6023
6024 fi;
6025
6026 case ${enable_serial_configure} in
6027   yes)
6028     enable_serial_build_configure=yes
6029     enable_serial_host_configure=yes
6030     enable_serial_target_configure=yes
6031     ;;
6032 esac
6033
6034 # These force 'configure's to be done one at a time, to avoid problems
6035 # with contention over a shared config.cache.
6036 rm -f serdep.tmp
6037 echo '# serdep.tmp' > serdep.tmp
6038 olditem=
6039 test "x${enable_serial_build_configure}" = xyes &&
6040 for item in ${build_configdirs} ; do
6041   case ${olditem} in
6042     "") ;;
6043     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6044   esac
6045   olditem=${item}
6046 done
6047 olditem=
6048 test "x${enable_serial_host_configure}" = xyes &&
6049 for item in ${configdirs} ; do
6050   case ${olditem} in
6051     "") ;;
6052     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6053   esac
6054   olditem=${item}
6055 done
6056 olditem=
6057 test "x${enable_serial_target_configure}" = xyes &&
6058 for item in ${target_configdirs} ; do
6059   case ${olditem} in
6060     "") ;;
6061     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6062   esac
6063   olditem=${item}
6064 done
6065 serialization_dependencies=serdep.tmp
6066
6067
6068 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6069 # target, nonopt, and variable assignments.  These are the ones we
6070 # might not want to pass down to subconfigures.  Also strip
6071 # program-prefix, program-suffix, and program-transform-name, so that
6072 # we can pass down a consistent program-transform-name.
6073 baseargs=
6074 keep_next=no
6075 skip_next=no
6076 eval "set -- $ac_configure_args"
6077 for ac_arg
6078 do
6079   if test X"$skip_next" = X"yes"; then
6080     skip_next=no
6081     continue
6082   fi
6083   if test X"$keep_next" = X"yes"; then
6084     case $ac_arg in
6085       *\'*)
6086         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6087     esac
6088     baseargs="$baseargs '$ac_arg'"
6089     keep_next=no
6090     continue
6091   fi
6092
6093   # Handle separated arguments.  Based on the logic generated by
6094   # autoconf 2.59.
6095   case $ac_arg in
6096     *=* | --config-cache | -C | -disable-* | --disable-* \
6097       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6098       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6099       | -with-* | --with-* | -without-* | --without-* | --x)
6100       separate_arg=no
6101       ;;
6102     -*)
6103       separate_arg=yes
6104       ;;
6105     *)
6106       separate_arg=no
6107       ;;
6108   esac
6109
6110   case "$ac_arg" in
6111     --no*)
6112       continue
6113       ;;
6114     --c* | \
6115     --sr* | \
6116     --ho* | \
6117     --bu* | \
6118     --t* | \
6119     --program-* | \
6120     -cache_file* | \
6121     -srcdir* | \
6122     -host* | \
6123     -build* | \
6124     -target* | \
6125     -program-prefix* | \
6126     -program-suffix* | \
6127     -program-transform-name* )
6128       skip_next=$separate_arg
6129       continue
6130       ;;
6131     -*)
6132       # An option.  Add it.
6133       case $ac_arg in
6134         *\'*)
6135           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6136       esac
6137       baseargs="$baseargs '$ac_arg'"
6138       keep_next=$separate_arg
6139       ;;
6140     *)
6141       # Either a variable assignment, or a nonopt (triplet).  Don't
6142       # pass it down; let the Makefile handle this.
6143       continue
6144       ;;
6145   esac
6146 done
6147 # Remove the initial space we just introduced and, as these will be
6148 # expanded by make, quote '$'.
6149 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6150
6151 # Add in --program-transform-name, after --program-prefix and
6152 # --program-suffix have been applied to it.  Autoconf has already
6153 # doubled dollar signs and backslashes in program_transform_name; we want
6154 # the backslashes un-doubled, and then the entire thing wrapped in single
6155 # quotes, because this will be expanded first by make and then by the shell.
6156 # Also, because we want to override the logic in subdir configure scripts to
6157 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6158 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6159 ${program_transform_name}
6160 EOF_SED
6161 gcc_transform_name=`cat conftestsed.out`
6162 rm -f conftestsed.out
6163 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6164 if test "$silent" = yes; then
6165   baseargs="$baseargs --silent"
6166 fi
6167
6168 # For the build-side libraries, we just need to pretend we're native,
6169 # and not use the same cache file.  Multilibs are neither needed nor
6170 # desired.
6171 build_configargs="--cache-file=../config.cache ${baseargs}"
6172
6173 # For host modules, accept cache file option, or specification as blank.
6174 case "${cache_file}" in
6175 "") # empty
6176   cache_file_option="" ;;
6177 /* | [A-Za-z]:[\\/]* ) # absolute path
6178   cache_file_option="--cache-file=${cache_file}" ;;
6179 *) # relative path
6180   cache_file_option="--cache-file=../${cache_file}" ;;
6181 esac
6182
6183 # Host dirs don't like to share a cache file either, horribly enough.
6184 # This seems to be due to autoconf 2.5x stupidity.
6185 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6186
6187 target_configargs=${baseargs}
6188
6189 # Passing a --with-cross-host argument lets the target libraries know
6190 # whether they are being built with a cross-compiler or being built
6191 # native.  However, it would be better to use other mechanisms to make the
6192 # sorts of decisions they want to make on this basis.  Please consider
6193 # this option to be deprecated.  FIXME.
6194 if test x${is_cross_compiler} = xyes ; then
6195   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6196 fi
6197
6198 # Default to --enable-multilib.
6199 if test x${enable_multilib} = x ; then
6200   target_configargs="--enable-multilib ${target_configargs}"
6201 fi
6202
6203 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6204 # changed from the earlier setting of with_newlib.
6205 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6206   target_configargs="--with-newlib ${target_configargs}"
6207 fi
6208
6209 # Different target subdirs use different values of certain variables
6210 # (notably CXX).  Worse, multilibs use *lots* of different values.
6211 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6212 # it doesn't automatically accept command-line overrides of them.
6213 # This means it's not safe for target subdirs to share a cache file,
6214 # which is disgusting, but there you have it.  Hopefully this can be
6215 # fixed in future.  It's still worthwhile to use a cache file for each
6216 # directory.  I think.
6217
6218 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6219 # We need to pass --target, as newer autoconf's requires consistency
6220 # for target_alias and gcc doesn't manage it consistently.
6221 target_configargs="--cache-file=./config.cache ${target_configargs}"
6222
6223 FLAGS_FOR_TARGET=
6224 case " $target_configdirs " in
6225  *" newlib "*)
6226   case " $target_configargs " in
6227   *" --with-newlib "*)
6228    case "$target" in
6229    *-cygwin*)
6230      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' ;;
6231    esac
6232
6233    # If we're not building GCC, don't discard standard headers.
6234    if test -d ${srcdir}/gcc; then
6235      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6236
6237      if test "${build}" != "${host}"; then
6238        # On Canadian crosses, CC_FOR_TARGET will have already been set
6239        # by `configure', so we won't have an opportunity to add -Bgcc/
6240        # to it.  This is right: we don't want to search that directory
6241        # for binaries, but we want the header files in there, so add
6242        # them explicitly.
6243        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6244
6245        # Someone might think of using the pre-installed headers on
6246        # Canadian crosses, in case the installed compiler is not fully
6247        # compatible with the compiler being built.  In this case, it
6248        # would be better to flag an error than risking having
6249        # incompatible object files being constructed.  We can't
6250        # guarantee that an error will be flagged, but let's hope the
6251        # compiler will do it, when presented with incompatible header
6252        # files.
6253      fi
6254    fi
6255
6256    case "${target}-${is_cross_compiler}" in
6257    i[3456789]86-*-linux*-no)
6258       # Here host == target, so we don't need to build gcc,
6259       # so we don't want to discard standard headers.
6260       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6261       ;;
6262    *)
6263       # If we're building newlib, use its generic headers last, but search
6264       # for any libc-related directories first (so make it the last -B
6265       # switch).
6266       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6267
6268       # If we're building libgloss, find the startup file, simulator library
6269       # and linker script.
6270       case " $target_configdirs " in
6271         *" libgloss "*)
6272         # Look for startup file, simulator library and maybe linker script.
6273         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6274         # Look for libnosys.a in case the target needs it.
6275         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6276         # Most targets have the linker script in the source directory.
6277         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6278         ;;
6279       esac
6280       ;;
6281    esac
6282    ;;
6283   esac
6284   ;;
6285 esac
6286 case "$target" in
6287 *-mingw*)
6288   # Can't be handled as Cygwin above since Mingw does not use newlib.
6289   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' ;;
6290 esac
6291
6292 # Allow the user to override the flags for
6293 # our build compiler if desired.
6294 if test x"${build}" = x"${host}" ; then
6295   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6296   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6297   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6298 fi
6299
6300 # On Canadian crosses, we'll be searching the right directories for
6301 # the previously-installed cross compiler, so don't bother to add
6302 # flags for directories within the install tree of the compiler
6303 # being built; programs in there won't even run.
6304 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6305   # Search for pre-installed headers if nothing else fits.
6306   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6307 fi
6308
6309 if test "x${use_gnu_ld}" = x &&
6310    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6311   # Arrange for us to find uninstalled linker scripts.
6312   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6313 fi
6314
6315 # Search for other target-specific linker scripts and such.
6316 case "${target}" in
6317   mep*)
6318     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6319     ;;
6320 esac
6321
6322 # Makefile fragments.
6323 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6324 do
6325   eval fragval=\$$frag
6326   if test $fragval != /dev/null; then
6327     eval $frag=${srcdir}/$fragval
6328   fi
6329 done
6330
6331
6332
6333
6334
6335 # Miscellanea: directories, flags, etc.
6336
6337
6338
6339
6340
6341
6342
6343
6344 # Build module lists & subconfigure args.
6345
6346
6347
6348 # Host module lists & subconfigure args.
6349
6350
6351
6352 # Target module lists & subconfigure args.
6353
6354
6355
6356 # Build tools.
6357
6358
6359
6360
6361
6362
6363
6364
6365
6366
6367
6368
6369
6370
6371
6372
6373
6374 # Generate default definitions for YACC, M4, LEX and other programs that run
6375 # on the build machine.  These are used if the Makefile can't locate these
6376 # programs in objdir.
6377 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6378
6379 for ac_prog in 'bison -y' byacc yacc
6380 do
6381   # Extract the first word of "$ac_prog", so it can be a program name with args.
6382 set dummy $ac_prog; ac_word=$2
6383 echo "$as_me:$LINENO: checking for $ac_word" >&5
6384 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6385 if test "${ac_cv_prog_YACC+set}" = set; then
6386   echo $ECHO_N "(cached) $ECHO_C" >&6
6387 else
6388   if test -n "$YACC"; then
6389   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6390 else
6391 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6392 for as_dir in $PATH
6393 do
6394   IFS=$as_save_IFS
6395   test -z "$as_dir" && as_dir=.
6396   for ac_exec_ext in '' $ac_executable_extensions; do
6397   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6398     ac_cv_prog_YACC="$ac_prog"
6399     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6400     break 2
6401   fi
6402 done
6403 done
6404
6405 fi
6406 fi
6407 YACC=$ac_cv_prog_YACC
6408 if test -n "$YACC"; then
6409   echo "$as_me:$LINENO: result: $YACC" >&5
6410 echo "${ECHO_T}$YACC" >&6
6411 else
6412   echo "$as_me:$LINENO: result: no" >&5
6413 echo "${ECHO_T}no" >&6
6414 fi
6415
6416   test -n "$YACC" && break
6417 done
6418 test -n "$YACC" || YACC="$MISSING bison -y"
6419
6420 case " $build_configdirs " in
6421   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6422   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6423 esac
6424
6425 for ac_prog in bison
6426 do
6427   # Extract the first word of "$ac_prog", so it can be a program name with args.
6428 set dummy $ac_prog; ac_word=$2
6429 echo "$as_me:$LINENO: checking for $ac_word" >&5
6430 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6431 if test "${ac_cv_prog_BISON+set}" = set; then
6432   echo $ECHO_N "(cached) $ECHO_C" >&6
6433 else
6434   if test -n "$BISON"; then
6435   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6436 else
6437 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6438 for as_dir in $PATH
6439 do
6440   IFS=$as_save_IFS
6441   test -z "$as_dir" && as_dir=.
6442   for ac_exec_ext in '' $ac_executable_extensions; do
6443   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6444     ac_cv_prog_BISON="$ac_prog"
6445     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6446     break 2
6447   fi
6448 done
6449 done
6450
6451 fi
6452 fi
6453 BISON=$ac_cv_prog_BISON
6454 if test -n "$BISON"; then
6455   echo "$as_me:$LINENO: result: $BISON" >&5
6456 echo "${ECHO_T}$BISON" >&6
6457 else
6458   echo "$as_me:$LINENO: result: no" >&5
6459 echo "${ECHO_T}no" >&6
6460 fi
6461
6462   test -n "$BISON" && break
6463 done
6464 test -n "$BISON" || BISON="$MISSING bison"
6465
6466 case " $build_configdirs " in
6467   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6468 esac
6469
6470 for ac_prog in gm4 gnum4 m4
6471 do
6472   # Extract the first word of "$ac_prog", so it can be a program name with args.
6473 set dummy $ac_prog; ac_word=$2
6474 echo "$as_me:$LINENO: checking for $ac_word" >&5
6475 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6476 if test "${ac_cv_prog_M4+set}" = set; then
6477   echo $ECHO_N "(cached) $ECHO_C" >&6
6478 else
6479   if test -n "$M4"; then
6480   ac_cv_prog_M4="$M4" # Let the user override the test.
6481 else
6482 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6483 for as_dir in $PATH
6484 do
6485   IFS=$as_save_IFS
6486   test -z "$as_dir" && as_dir=.
6487   for ac_exec_ext in '' $ac_executable_extensions; do
6488   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6489     ac_cv_prog_M4="$ac_prog"
6490     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6491     break 2
6492   fi
6493 done
6494 done
6495
6496 fi
6497 fi
6498 M4=$ac_cv_prog_M4
6499 if test -n "$M4"; then
6500   echo "$as_me:$LINENO: result: $M4" >&5
6501 echo "${ECHO_T}$M4" >&6
6502 else
6503   echo "$as_me:$LINENO: result: no" >&5
6504 echo "${ECHO_T}no" >&6
6505 fi
6506
6507   test -n "$M4" && break
6508 done
6509 test -n "$M4" || M4="$MISSING m4"
6510
6511 case " $build_configdirs " in
6512   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6513 esac
6514
6515 for ac_prog in flex lex
6516 do
6517   # Extract the first word of "$ac_prog", so it can be a program name with args.
6518 set dummy $ac_prog; ac_word=$2
6519 echo "$as_me:$LINENO: checking for $ac_word" >&5
6520 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6521 if test "${ac_cv_prog_LEX+set}" = set; then
6522   echo $ECHO_N "(cached) $ECHO_C" >&6
6523 else
6524   if test -n "$LEX"; then
6525   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6526 else
6527 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6528 for as_dir in $PATH
6529 do
6530   IFS=$as_save_IFS
6531   test -z "$as_dir" && as_dir=.
6532   for ac_exec_ext in '' $ac_executable_extensions; do
6533   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6534     ac_cv_prog_LEX="$ac_prog"
6535     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6536     break 2
6537   fi
6538 done
6539 done
6540
6541 fi
6542 fi
6543 LEX=$ac_cv_prog_LEX
6544 if test -n "$LEX"; then
6545   echo "$as_me:$LINENO: result: $LEX" >&5
6546 echo "${ECHO_T}$LEX" >&6
6547 else
6548   echo "$as_me:$LINENO: result: no" >&5
6549 echo "${ECHO_T}no" >&6
6550 fi
6551
6552   test -n "$LEX" && break
6553 done
6554 test -n "$LEX" || LEX="$MISSING flex"
6555
6556 case " $build_configdirs " in
6557   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6558   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6559 esac
6560
6561 for ac_prog in flex
6562 do
6563   # Extract the first word of "$ac_prog", so it can be a program name with args.
6564 set dummy $ac_prog; ac_word=$2
6565 echo "$as_me:$LINENO: checking for $ac_word" >&5
6566 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6567 if test "${ac_cv_prog_FLEX+set}" = set; then
6568   echo $ECHO_N "(cached) $ECHO_C" >&6
6569 else
6570   if test -n "$FLEX"; then
6571   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6572 else
6573 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6574 for as_dir in $PATH
6575 do
6576   IFS=$as_save_IFS
6577   test -z "$as_dir" && as_dir=.
6578   for ac_exec_ext in '' $ac_executable_extensions; do
6579   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6580     ac_cv_prog_FLEX="$ac_prog"
6581     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6582     break 2
6583   fi
6584 done
6585 done
6586
6587 fi
6588 fi
6589 FLEX=$ac_cv_prog_FLEX
6590 if test -n "$FLEX"; then
6591   echo "$as_me:$LINENO: result: $FLEX" >&5
6592 echo "${ECHO_T}$FLEX" >&6
6593 else
6594   echo "$as_me:$LINENO: result: no" >&5
6595 echo "${ECHO_T}no" >&6
6596 fi
6597
6598   test -n "$FLEX" && break
6599 done
6600 test -n "$FLEX" || FLEX="$MISSING flex"
6601
6602 case " $build_configdirs " in
6603   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6604 esac
6605
6606 for ac_prog in makeinfo
6607 do
6608   # Extract the first word of "$ac_prog", so it can be a program name with args.
6609 set dummy $ac_prog; ac_word=$2
6610 echo "$as_me:$LINENO: checking for $ac_word" >&5
6611 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6612 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6613   echo $ECHO_N "(cached) $ECHO_C" >&6
6614 else
6615   if test -n "$MAKEINFO"; then
6616   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6617 else
6618 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6619 for as_dir in $PATH
6620 do
6621   IFS=$as_save_IFS
6622   test -z "$as_dir" && as_dir=.
6623   for ac_exec_ext in '' $ac_executable_extensions; do
6624   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6625     ac_cv_prog_MAKEINFO="$ac_prog"
6626     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6627     break 2
6628   fi
6629 done
6630 done
6631
6632 fi
6633 fi
6634 MAKEINFO=$ac_cv_prog_MAKEINFO
6635 if test -n "$MAKEINFO"; then
6636   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6637 echo "${ECHO_T}$MAKEINFO" >&6
6638 else
6639   echo "$as_me:$LINENO: result: no" >&5
6640 echo "${ECHO_T}no" >&6
6641 fi
6642
6643   test -n "$MAKEINFO" && break
6644 done
6645 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6646
6647 case " $build_configdirs " in
6648   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6649   *)
6650
6651     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6652     # higher, else we use the "missing" dummy.
6653     if ${MAKEINFO} --version \
6654        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6655       :
6656     else
6657       MAKEINFO="$MISSING makeinfo"
6658     fi
6659     ;;
6660
6661 esac
6662
6663 # FIXME: expect and dejagnu may become build tools?
6664
6665 for ac_prog in expect
6666 do
6667   # Extract the first word of "$ac_prog", so it can be a program name with args.
6668 set dummy $ac_prog; ac_word=$2
6669 echo "$as_me:$LINENO: checking for $ac_word" >&5
6670 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6671 if test "${ac_cv_prog_EXPECT+set}" = set; then
6672   echo $ECHO_N "(cached) $ECHO_C" >&6
6673 else
6674   if test -n "$EXPECT"; then
6675   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6676 else
6677 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6678 for as_dir in $PATH
6679 do
6680   IFS=$as_save_IFS
6681   test -z "$as_dir" && as_dir=.
6682   for ac_exec_ext in '' $ac_executable_extensions; do
6683   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6684     ac_cv_prog_EXPECT="$ac_prog"
6685     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6686     break 2
6687   fi
6688 done
6689 done
6690
6691 fi
6692 fi
6693 EXPECT=$ac_cv_prog_EXPECT
6694 if test -n "$EXPECT"; then
6695   echo "$as_me:$LINENO: result: $EXPECT" >&5
6696 echo "${ECHO_T}$EXPECT" >&6
6697 else
6698   echo "$as_me:$LINENO: result: no" >&5
6699 echo "${ECHO_T}no" >&6
6700 fi
6701
6702   test -n "$EXPECT" && break
6703 done
6704 test -n "$EXPECT" || EXPECT="expect"
6705
6706 case " $configdirs " in
6707   *" expect "*)
6708     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6709     ;;
6710 esac
6711
6712 for ac_prog in runtest
6713 do
6714   # Extract the first word of "$ac_prog", so it can be a program name with args.
6715 set dummy $ac_prog; ac_word=$2
6716 echo "$as_me:$LINENO: checking for $ac_word" >&5
6717 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6718 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6719   echo $ECHO_N "(cached) $ECHO_C" >&6
6720 else
6721   if test -n "$RUNTEST"; then
6722   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6723 else
6724 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6725 for as_dir in $PATH
6726 do
6727   IFS=$as_save_IFS
6728   test -z "$as_dir" && as_dir=.
6729   for ac_exec_ext in '' $ac_executable_extensions; do
6730   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6731     ac_cv_prog_RUNTEST="$ac_prog"
6732     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6733     break 2
6734   fi
6735 done
6736 done
6737
6738 fi
6739 fi
6740 RUNTEST=$ac_cv_prog_RUNTEST
6741 if test -n "$RUNTEST"; then
6742   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6743 echo "${ECHO_T}$RUNTEST" >&6
6744 else
6745   echo "$as_me:$LINENO: result: no" >&5
6746 echo "${ECHO_T}no" >&6
6747 fi
6748
6749   test -n "$RUNTEST" && break
6750 done
6751 test -n "$RUNTEST" || RUNTEST="runtest"
6752
6753 case " $configdirs " in
6754   *" dejagnu "*)
6755     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6756     ;;
6757 esac
6758
6759
6760 # Host tools.
6761 ncn_tool_prefix=
6762 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6763 ncn_target_tool_prefix=
6764 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6765
6766
6767
6768 if test -n "$AR"; then
6769   ac_cv_prog_AR=$AR
6770 elif test -n "$ac_cv_prog_AR"; then
6771   AR=$ac_cv_prog_AR
6772 fi
6773
6774 if test -n "$ac_cv_prog_AR"; then
6775   for ncn_progname in ar; do
6776     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6777 set dummy ${ncn_progname}; ac_word=$2
6778 echo "$as_me:$LINENO: checking for $ac_word" >&5
6779 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6780 if test "${ac_cv_prog_AR+set}" = set; then
6781   echo $ECHO_N "(cached) $ECHO_C" >&6
6782 else
6783   if test -n "$AR"; then
6784   ac_cv_prog_AR="$AR" # Let the user override the test.
6785 else
6786 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6787 for as_dir in $PATH
6788 do
6789   IFS=$as_save_IFS
6790   test -z "$as_dir" && as_dir=.
6791   for ac_exec_ext in '' $ac_executable_extensions; do
6792   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6793     ac_cv_prog_AR="${ncn_progname}"
6794     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6795     break 2
6796   fi
6797 done
6798 done
6799
6800 fi
6801 fi
6802 AR=$ac_cv_prog_AR
6803 if test -n "$AR"; then
6804   echo "$as_me:$LINENO: result: $AR" >&5
6805 echo "${ECHO_T}$AR" >&6
6806 else
6807   echo "$as_me:$LINENO: result: no" >&5
6808 echo "${ECHO_T}no" >&6
6809 fi
6810
6811   done
6812 fi
6813
6814 for ncn_progname in ar; do
6815   if test -n "$ncn_tool_prefix"; then
6816     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6817 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6818 echo "$as_me:$LINENO: checking for $ac_word" >&5
6819 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6820 if test "${ac_cv_prog_AR+set}" = set; then
6821   echo $ECHO_N "(cached) $ECHO_C" >&6
6822 else
6823   if test -n "$AR"; then
6824   ac_cv_prog_AR="$AR" # Let the user override the test.
6825 else
6826 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6827 for as_dir in $PATH
6828 do
6829   IFS=$as_save_IFS
6830   test -z "$as_dir" && as_dir=.
6831   for ac_exec_ext in '' $ac_executable_extensions; do
6832   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6833     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6834     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6835     break 2
6836   fi
6837 done
6838 done
6839
6840 fi
6841 fi
6842 AR=$ac_cv_prog_AR
6843 if test -n "$AR"; then
6844   echo "$as_me:$LINENO: result: $AR" >&5
6845 echo "${ECHO_T}$AR" >&6
6846 else
6847   echo "$as_me:$LINENO: result: no" >&5
6848 echo "${ECHO_T}no" >&6
6849 fi
6850
6851   fi
6852   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6853     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6854 set dummy ${ncn_progname}; ac_word=$2
6855 echo "$as_me:$LINENO: checking for $ac_word" >&5
6856 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6857 if test "${ac_cv_prog_AR+set}" = set; then
6858   echo $ECHO_N "(cached) $ECHO_C" >&6
6859 else
6860   if test -n "$AR"; then
6861   ac_cv_prog_AR="$AR" # Let the user override the test.
6862 else
6863 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6864 for as_dir in $PATH
6865 do
6866   IFS=$as_save_IFS
6867   test -z "$as_dir" && as_dir=.
6868   for ac_exec_ext in '' $ac_executable_extensions; do
6869   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6870     ac_cv_prog_AR="${ncn_progname}"
6871     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6872     break 2
6873   fi
6874 done
6875 done
6876
6877 fi
6878 fi
6879 AR=$ac_cv_prog_AR
6880 if test -n "$AR"; then
6881   echo "$as_me:$LINENO: result: $AR" >&5
6882 echo "${ECHO_T}$AR" >&6
6883 else
6884   echo "$as_me:$LINENO: result: no" >&5
6885 echo "${ECHO_T}no" >&6
6886 fi
6887
6888   fi
6889   test -n "$ac_cv_prog_AR" && break
6890 done
6891
6892 if test -z "$ac_cv_prog_AR" ; then
6893   set dummy ar
6894   if test $build = $host ; then
6895     AR="$2"
6896   else
6897     AR="${ncn_tool_prefix}$2"
6898   fi
6899 fi
6900
6901
6902
6903 if test -n "$AS"; then
6904   ac_cv_prog_AS=$AS
6905 elif test -n "$ac_cv_prog_AS"; then
6906   AS=$ac_cv_prog_AS
6907 fi
6908
6909 if test -n "$ac_cv_prog_AS"; then
6910   for ncn_progname in as; do
6911     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6912 set dummy ${ncn_progname}; ac_word=$2
6913 echo "$as_me:$LINENO: checking for $ac_word" >&5
6914 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6915 if test "${ac_cv_prog_AS+set}" = set; then
6916   echo $ECHO_N "(cached) $ECHO_C" >&6
6917 else
6918   if test -n "$AS"; then
6919   ac_cv_prog_AS="$AS" # Let the user override the test.
6920 else
6921 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6922 for as_dir in $PATH
6923 do
6924   IFS=$as_save_IFS
6925   test -z "$as_dir" && as_dir=.
6926   for ac_exec_ext in '' $ac_executable_extensions; do
6927   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6928     ac_cv_prog_AS="${ncn_progname}"
6929     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6930     break 2
6931   fi
6932 done
6933 done
6934
6935 fi
6936 fi
6937 AS=$ac_cv_prog_AS
6938 if test -n "$AS"; then
6939   echo "$as_me:$LINENO: result: $AS" >&5
6940 echo "${ECHO_T}$AS" >&6
6941 else
6942   echo "$as_me:$LINENO: result: no" >&5
6943 echo "${ECHO_T}no" >&6
6944 fi
6945
6946   done
6947 fi
6948
6949 for ncn_progname in as; do
6950   if test -n "$ncn_tool_prefix"; then
6951     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6952 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6953 echo "$as_me:$LINENO: checking for $ac_word" >&5
6954 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6955 if test "${ac_cv_prog_AS+set}" = set; then
6956   echo $ECHO_N "(cached) $ECHO_C" >&6
6957 else
6958   if test -n "$AS"; then
6959   ac_cv_prog_AS="$AS" # Let the user override the test.
6960 else
6961 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6962 for as_dir in $PATH
6963 do
6964   IFS=$as_save_IFS
6965   test -z "$as_dir" && as_dir=.
6966   for ac_exec_ext in '' $ac_executable_extensions; do
6967   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6968     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6969     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6970     break 2
6971   fi
6972 done
6973 done
6974
6975 fi
6976 fi
6977 AS=$ac_cv_prog_AS
6978 if test -n "$AS"; then
6979   echo "$as_me:$LINENO: result: $AS" >&5
6980 echo "${ECHO_T}$AS" >&6
6981 else
6982   echo "$as_me:$LINENO: result: no" >&5
6983 echo "${ECHO_T}no" >&6
6984 fi
6985
6986   fi
6987   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6988     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6989 set dummy ${ncn_progname}; ac_word=$2
6990 echo "$as_me:$LINENO: checking for $ac_word" >&5
6991 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6992 if test "${ac_cv_prog_AS+set}" = set; then
6993   echo $ECHO_N "(cached) $ECHO_C" >&6
6994 else
6995   if test -n "$AS"; then
6996   ac_cv_prog_AS="$AS" # Let the user override the test.
6997 else
6998 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6999 for as_dir in $PATH
7000 do
7001   IFS=$as_save_IFS
7002   test -z "$as_dir" && as_dir=.
7003   for ac_exec_ext in '' $ac_executable_extensions; do
7004   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7005     ac_cv_prog_AS="${ncn_progname}"
7006     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7007     break 2
7008   fi
7009 done
7010 done
7011
7012 fi
7013 fi
7014 AS=$ac_cv_prog_AS
7015 if test -n "$AS"; then
7016   echo "$as_me:$LINENO: result: $AS" >&5
7017 echo "${ECHO_T}$AS" >&6
7018 else
7019   echo "$as_me:$LINENO: result: no" >&5
7020 echo "${ECHO_T}no" >&6
7021 fi
7022
7023   fi
7024   test -n "$ac_cv_prog_AS" && break
7025 done
7026
7027 if test -z "$ac_cv_prog_AS" ; then
7028   set dummy as
7029   if test $build = $host ; then
7030     AS="$2"
7031   else
7032     AS="${ncn_tool_prefix}$2"
7033   fi
7034 fi
7035
7036
7037
7038 if test -n "$DLLTOOL"; then
7039   ac_cv_prog_DLLTOOL=$DLLTOOL
7040 elif test -n "$ac_cv_prog_DLLTOOL"; then
7041   DLLTOOL=$ac_cv_prog_DLLTOOL
7042 fi
7043
7044 if test -n "$ac_cv_prog_DLLTOOL"; then
7045   for ncn_progname in dlltool; do
7046     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7047 set dummy ${ncn_progname}; ac_word=$2
7048 echo "$as_me:$LINENO: checking for $ac_word" >&5
7049 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7050 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7051   echo $ECHO_N "(cached) $ECHO_C" >&6
7052 else
7053   if test -n "$DLLTOOL"; then
7054   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7055 else
7056 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7057 for as_dir in $PATH
7058 do
7059   IFS=$as_save_IFS
7060   test -z "$as_dir" && as_dir=.
7061   for ac_exec_ext in '' $ac_executable_extensions; do
7062   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7063     ac_cv_prog_DLLTOOL="${ncn_progname}"
7064     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7065     break 2
7066   fi
7067 done
7068 done
7069
7070 fi
7071 fi
7072 DLLTOOL=$ac_cv_prog_DLLTOOL
7073 if test -n "$DLLTOOL"; then
7074   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7075 echo "${ECHO_T}$DLLTOOL" >&6
7076 else
7077   echo "$as_me:$LINENO: result: no" >&5
7078 echo "${ECHO_T}no" >&6
7079 fi
7080
7081   done
7082 fi
7083
7084 for ncn_progname in dlltool; do
7085   if test -n "$ncn_tool_prefix"; then
7086     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7087 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7088 echo "$as_me:$LINENO: checking for $ac_word" >&5
7089 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7090 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7091   echo $ECHO_N "(cached) $ECHO_C" >&6
7092 else
7093   if test -n "$DLLTOOL"; then
7094   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7095 else
7096 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7097 for as_dir in $PATH
7098 do
7099   IFS=$as_save_IFS
7100   test -z "$as_dir" && as_dir=.
7101   for ac_exec_ext in '' $ac_executable_extensions; do
7102   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7103     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7104     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7105     break 2
7106   fi
7107 done
7108 done
7109
7110 fi
7111 fi
7112 DLLTOOL=$ac_cv_prog_DLLTOOL
7113 if test -n "$DLLTOOL"; then
7114   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7115 echo "${ECHO_T}$DLLTOOL" >&6
7116 else
7117   echo "$as_me:$LINENO: result: no" >&5
7118 echo "${ECHO_T}no" >&6
7119 fi
7120
7121   fi
7122   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7123     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7124 set dummy ${ncn_progname}; ac_word=$2
7125 echo "$as_me:$LINENO: checking for $ac_word" >&5
7126 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7127 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7128   echo $ECHO_N "(cached) $ECHO_C" >&6
7129 else
7130   if test -n "$DLLTOOL"; then
7131   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7132 else
7133 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7134 for as_dir in $PATH
7135 do
7136   IFS=$as_save_IFS
7137   test -z "$as_dir" && as_dir=.
7138   for ac_exec_ext in '' $ac_executable_extensions; do
7139   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7140     ac_cv_prog_DLLTOOL="${ncn_progname}"
7141     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7142     break 2
7143   fi
7144 done
7145 done
7146
7147 fi
7148 fi
7149 DLLTOOL=$ac_cv_prog_DLLTOOL
7150 if test -n "$DLLTOOL"; then
7151   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7152 echo "${ECHO_T}$DLLTOOL" >&6
7153 else
7154   echo "$as_me:$LINENO: result: no" >&5
7155 echo "${ECHO_T}no" >&6
7156 fi
7157
7158   fi
7159   test -n "$ac_cv_prog_DLLTOOL" && break
7160 done
7161
7162 if test -z "$ac_cv_prog_DLLTOOL" ; then
7163   set dummy dlltool
7164   if test $build = $host ; then
7165     DLLTOOL="$2"
7166   else
7167     DLLTOOL="${ncn_tool_prefix}$2"
7168   fi
7169 fi
7170
7171
7172
7173 if test -n "$LD"; then
7174   ac_cv_prog_LD=$LD
7175 elif test -n "$ac_cv_prog_LD"; then
7176   LD=$ac_cv_prog_LD
7177 fi
7178
7179 if test -n "$ac_cv_prog_LD"; then
7180   for ncn_progname in ld; do
7181     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7182 set dummy ${ncn_progname}; ac_word=$2
7183 echo "$as_me:$LINENO: checking for $ac_word" >&5
7184 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7185 if test "${ac_cv_prog_LD+set}" = set; then
7186   echo $ECHO_N "(cached) $ECHO_C" >&6
7187 else
7188   if test -n "$LD"; then
7189   ac_cv_prog_LD="$LD" # Let the user override the test.
7190 else
7191 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7192 for as_dir in $PATH
7193 do
7194   IFS=$as_save_IFS
7195   test -z "$as_dir" && as_dir=.
7196   for ac_exec_ext in '' $ac_executable_extensions; do
7197   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7198     ac_cv_prog_LD="${ncn_progname}"
7199     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7200     break 2
7201   fi
7202 done
7203 done
7204
7205 fi
7206 fi
7207 LD=$ac_cv_prog_LD
7208 if test -n "$LD"; then
7209   echo "$as_me:$LINENO: result: $LD" >&5
7210 echo "${ECHO_T}$LD" >&6
7211 else
7212   echo "$as_me:$LINENO: result: no" >&5
7213 echo "${ECHO_T}no" >&6
7214 fi
7215
7216   done
7217 fi
7218
7219 for ncn_progname in ld; do
7220   if test -n "$ncn_tool_prefix"; then
7221     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7222 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7223 echo "$as_me:$LINENO: checking for $ac_word" >&5
7224 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7225 if test "${ac_cv_prog_LD+set}" = set; then
7226   echo $ECHO_N "(cached) $ECHO_C" >&6
7227 else
7228   if test -n "$LD"; then
7229   ac_cv_prog_LD="$LD" # Let the user override the test.
7230 else
7231 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7232 for as_dir in $PATH
7233 do
7234   IFS=$as_save_IFS
7235   test -z "$as_dir" && as_dir=.
7236   for ac_exec_ext in '' $ac_executable_extensions; do
7237   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7238     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7239     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7240     break 2
7241   fi
7242 done
7243 done
7244
7245 fi
7246 fi
7247 LD=$ac_cv_prog_LD
7248 if test -n "$LD"; then
7249   echo "$as_me:$LINENO: result: $LD" >&5
7250 echo "${ECHO_T}$LD" >&6
7251 else
7252   echo "$as_me:$LINENO: result: no" >&5
7253 echo "${ECHO_T}no" >&6
7254 fi
7255
7256   fi
7257   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7258     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7259 set dummy ${ncn_progname}; ac_word=$2
7260 echo "$as_me:$LINENO: checking for $ac_word" >&5
7261 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7262 if test "${ac_cv_prog_LD+set}" = set; then
7263   echo $ECHO_N "(cached) $ECHO_C" >&6
7264 else
7265   if test -n "$LD"; then
7266   ac_cv_prog_LD="$LD" # Let the user override the test.
7267 else
7268 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7269 for as_dir in $PATH
7270 do
7271   IFS=$as_save_IFS
7272   test -z "$as_dir" && as_dir=.
7273   for ac_exec_ext in '' $ac_executable_extensions; do
7274   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7275     ac_cv_prog_LD="${ncn_progname}"
7276     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7277     break 2
7278   fi
7279 done
7280 done
7281
7282 fi
7283 fi
7284 LD=$ac_cv_prog_LD
7285 if test -n "$LD"; then
7286   echo "$as_me:$LINENO: result: $LD" >&5
7287 echo "${ECHO_T}$LD" >&6
7288 else
7289   echo "$as_me:$LINENO: result: no" >&5
7290 echo "${ECHO_T}no" >&6
7291 fi
7292
7293   fi
7294   test -n "$ac_cv_prog_LD" && break
7295 done
7296
7297 if test -z "$ac_cv_prog_LD" ; then
7298   set dummy ld
7299   if test $build = $host ; then
7300     LD="$2"
7301   else
7302     LD="${ncn_tool_prefix}$2"
7303   fi
7304 fi
7305
7306
7307
7308 if test -n "$LIPO"; then
7309   ac_cv_prog_LIPO=$LIPO
7310 elif test -n "$ac_cv_prog_LIPO"; then
7311   LIPO=$ac_cv_prog_LIPO
7312 fi
7313
7314 if test -n "$ac_cv_prog_LIPO"; then
7315   for ncn_progname in lipo; do
7316     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7317 set dummy ${ncn_progname}; ac_word=$2
7318 echo "$as_me:$LINENO: checking for $ac_word" >&5
7319 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7320 if test "${ac_cv_prog_LIPO+set}" = set; then
7321   echo $ECHO_N "(cached) $ECHO_C" >&6
7322 else
7323   if test -n "$LIPO"; then
7324   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7325 else
7326 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7327 for as_dir in $PATH
7328 do
7329   IFS=$as_save_IFS
7330   test -z "$as_dir" && as_dir=.
7331   for ac_exec_ext in '' $ac_executable_extensions; do
7332   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7333     ac_cv_prog_LIPO="${ncn_progname}"
7334     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7335     break 2
7336   fi
7337 done
7338 done
7339
7340 fi
7341 fi
7342 LIPO=$ac_cv_prog_LIPO
7343 if test -n "$LIPO"; then
7344   echo "$as_me:$LINENO: result: $LIPO" >&5
7345 echo "${ECHO_T}$LIPO" >&6
7346 else
7347   echo "$as_me:$LINENO: result: no" >&5
7348 echo "${ECHO_T}no" >&6
7349 fi
7350
7351   done
7352 fi
7353
7354 for ncn_progname in lipo; do
7355   if test -n "$ncn_tool_prefix"; then
7356     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7357 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7358 echo "$as_me:$LINENO: checking for $ac_word" >&5
7359 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7360 if test "${ac_cv_prog_LIPO+set}" = set; then
7361   echo $ECHO_N "(cached) $ECHO_C" >&6
7362 else
7363   if test -n "$LIPO"; then
7364   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7365 else
7366 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7367 for as_dir in $PATH
7368 do
7369   IFS=$as_save_IFS
7370   test -z "$as_dir" && as_dir=.
7371   for ac_exec_ext in '' $ac_executable_extensions; do
7372   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7373     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7374     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7375     break 2
7376   fi
7377 done
7378 done
7379
7380 fi
7381 fi
7382 LIPO=$ac_cv_prog_LIPO
7383 if test -n "$LIPO"; then
7384   echo "$as_me:$LINENO: result: $LIPO" >&5
7385 echo "${ECHO_T}$LIPO" >&6
7386 else
7387   echo "$as_me:$LINENO: result: no" >&5
7388 echo "${ECHO_T}no" >&6
7389 fi
7390
7391   fi
7392   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7393     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7394 set dummy ${ncn_progname}; ac_word=$2
7395 echo "$as_me:$LINENO: checking for $ac_word" >&5
7396 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7397 if test "${ac_cv_prog_LIPO+set}" = set; then
7398   echo $ECHO_N "(cached) $ECHO_C" >&6
7399 else
7400   if test -n "$LIPO"; then
7401   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7402 else
7403 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7404 for as_dir in $PATH
7405 do
7406   IFS=$as_save_IFS
7407   test -z "$as_dir" && as_dir=.
7408   for ac_exec_ext in '' $ac_executable_extensions; do
7409   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7410     ac_cv_prog_LIPO="${ncn_progname}"
7411     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7412     break 2
7413   fi
7414 done
7415 done
7416
7417 fi
7418 fi
7419 LIPO=$ac_cv_prog_LIPO
7420 if test -n "$LIPO"; then
7421   echo "$as_me:$LINENO: result: $LIPO" >&5
7422 echo "${ECHO_T}$LIPO" >&6
7423 else
7424   echo "$as_me:$LINENO: result: no" >&5
7425 echo "${ECHO_T}no" >&6
7426 fi
7427
7428   fi
7429   test -n "$ac_cv_prog_LIPO" && break
7430 done
7431
7432 if test -z "$ac_cv_prog_LIPO" ; then
7433   set dummy lipo
7434   if test $build = $host ; then
7435     LIPO="$2"
7436   else
7437     LIPO="${ncn_tool_prefix}$2"
7438   fi
7439 fi
7440
7441
7442
7443 if test -n "$NM"; then
7444   ac_cv_prog_NM=$NM
7445 elif test -n "$ac_cv_prog_NM"; then
7446   NM=$ac_cv_prog_NM
7447 fi
7448
7449 if test -n "$ac_cv_prog_NM"; then
7450   for ncn_progname in nm; do
7451     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7452 set dummy ${ncn_progname}; ac_word=$2
7453 echo "$as_me:$LINENO: checking for $ac_word" >&5
7454 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7455 if test "${ac_cv_prog_NM+set}" = set; then
7456   echo $ECHO_N "(cached) $ECHO_C" >&6
7457 else
7458   if test -n "$NM"; then
7459   ac_cv_prog_NM="$NM" # Let the user override the test.
7460 else
7461 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7462 for as_dir in $PATH
7463 do
7464   IFS=$as_save_IFS
7465   test -z "$as_dir" && as_dir=.
7466   for ac_exec_ext in '' $ac_executable_extensions; do
7467   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7468     ac_cv_prog_NM="${ncn_progname}"
7469     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7470     break 2
7471   fi
7472 done
7473 done
7474
7475 fi
7476 fi
7477 NM=$ac_cv_prog_NM
7478 if test -n "$NM"; then
7479   echo "$as_me:$LINENO: result: $NM" >&5
7480 echo "${ECHO_T}$NM" >&6
7481 else
7482   echo "$as_me:$LINENO: result: no" >&5
7483 echo "${ECHO_T}no" >&6
7484 fi
7485
7486   done
7487 fi
7488
7489 for ncn_progname in nm; do
7490   if test -n "$ncn_tool_prefix"; then
7491     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7492 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7493 echo "$as_me:$LINENO: checking for $ac_word" >&5
7494 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7495 if test "${ac_cv_prog_NM+set}" = set; then
7496   echo $ECHO_N "(cached) $ECHO_C" >&6
7497 else
7498   if test -n "$NM"; then
7499   ac_cv_prog_NM="$NM" # Let the user override the test.
7500 else
7501 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7502 for as_dir in $PATH
7503 do
7504   IFS=$as_save_IFS
7505   test -z "$as_dir" && as_dir=.
7506   for ac_exec_ext in '' $ac_executable_extensions; do
7507   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7508     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7509     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7510     break 2
7511   fi
7512 done
7513 done
7514
7515 fi
7516 fi
7517 NM=$ac_cv_prog_NM
7518 if test -n "$NM"; then
7519   echo "$as_me:$LINENO: result: $NM" >&5
7520 echo "${ECHO_T}$NM" >&6
7521 else
7522   echo "$as_me:$LINENO: result: no" >&5
7523 echo "${ECHO_T}no" >&6
7524 fi
7525
7526   fi
7527   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7528     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7529 set dummy ${ncn_progname}; ac_word=$2
7530 echo "$as_me:$LINENO: checking for $ac_word" >&5
7531 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7532 if test "${ac_cv_prog_NM+set}" = set; then
7533   echo $ECHO_N "(cached) $ECHO_C" >&6
7534 else
7535   if test -n "$NM"; then
7536   ac_cv_prog_NM="$NM" # Let the user override the test.
7537 else
7538 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7539 for as_dir in $PATH
7540 do
7541   IFS=$as_save_IFS
7542   test -z "$as_dir" && as_dir=.
7543   for ac_exec_ext in '' $ac_executable_extensions; do
7544   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7545     ac_cv_prog_NM="${ncn_progname}"
7546     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7547     break 2
7548   fi
7549 done
7550 done
7551
7552 fi
7553 fi
7554 NM=$ac_cv_prog_NM
7555 if test -n "$NM"; then
7556   echo "$as_me:$LINENO: result: $NM" >&5
7557 echo "${ECHO_T}$NM" >&6
7558 else
7559   echo "$as_me:$LINENO: result: no" >&5
7560 echo "${ECHO_T}no" >&6
7561 fi
7562
7563   fi
7564   test -n "$ac_cv_prog_NM" && break
7565 done
7566
7567 if test -z "$ac_cv_prog_NM" ; then
7568   set dummy nm
7569   if test $build = $host ; then
7570     NM="$2"
7571   else
7572     NM="${ncn_tool_prefix}$2"
7573   fi
7574 fi
7575
7576
7577
7578 if test -n "$RANLIB"; then
7579   ac_cv_prog_RANLIB=$RANLIB
7580 elif test -n "$ac_cv_prog_RANLIB"; then
7581   RANLIB=$ac_cv_prog_RANLIB
7582 fi
7583
7584 if test -n "$ac_cv_prog_RANLIB"; then
7585   for ncn_progname in ranlib; do
7586     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7587 set dummy ${ncn_progname}; ac_word=$2
7588 echo "$as_me:$LINENO: checking for $ac_word" >&5
7589 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7590 if test "${ac_cv_prog_RANLIB+set}" = set; then
7591   echo $ECHO_N "(cached) $ECHO_C" >&6
7592 else
7593   if test -n "$RANLIB"; then
7594   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7595 else
7596 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7597 for as_dir in $PATH
7598 do
7599   IFS=$as_save_IFS
7600   test -z "$as_dir" && as_dir=.
7601   for ac_exec_ext in '' $ac_executable_extensions; do
7602   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7603     ac_cv_prog_RANLIB="${ncn_progname}"
7604     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7605     break 2
7606   fi
7607 done
7608 done
7609
7610 fi
7611 fi
7612 RANLIB=$ac_cv_prog_RANLIB
7613 if test -n "$RANLIB"; then
7614   echo "$as_me:$LINENO: result: $RANLIB" >&5
7615 echo "${ECHO_T}$RANLIB" >&6
7616 else
7617   echo "$as_me:$LINENO: result: no" >&5
7618 echo "${ECHO_T}no" >&6
7619 fi
7620
7621   done
7622 fi
7623
7624 for ncn_progname in ranlib; do
7625   if test -n "$ncn_tool_prefix"; then
7626     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7627 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7628 echo "$as_me:$LINENO: checking for $ac_word" >&5
7629 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7630 if test "${ac_cv_prog_RANLIB+set}" = set; then
7631   echo $ECHO_N "(cached) $ECHO_C" >&6
7632 else
7633   if test -n "$RANLIB"; then
7634   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7635 else
7636 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7637 for as_dir in $PATH
7638 do
7639   IFS=$as_save_IFS
7640   test -z "$as_dir" && as_dir=.
7641   for ac_exec_ext in '' $ac_executable_extensions; do
7642   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7643     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7644     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7645     break 2
7646   fi
7647 done
7648 done
7649
7650 fi
7651 fi
7652 RANLIB=$ac_cv_prog_RANLIB
7653 if test -n "$RANLIB"; then
7654   echo "$as_me:$LINENO: result: $RANLIB" >&5
7655 echo "${ECHO_T}$RANLIB" >&6
7656 else
7657   echo "$as_me:$LINENO: result: no" >&5
7658 echo "${ECHO_T}no" >&6
7659 fi
7660
7661   fi
7662   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7663     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7664 set dummy ${ncn_progname}; ac_word=$2
7665 echo "$as_me:$LINENO: checking for $ac_word" >&5
7666 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7667 if test "${ac_cv_prog_RANLIB+set}" = set; then
7668   echo $ECHO_N "(cached) $ECHO_C" >&6
7669 else
7670   if test -n "$RANLIB"; then
7671   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7672 else
7673 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7674 for as_dir in $PATH
7675 do
7676   IFS=$as_save_IFS
7677   test -z "$as_dir" && as_dir=.
7678   for ac_exec_ext in '' $ac_executable_extensions; do
7679   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7680     ac_cv_prog_RANLIB="${ncn_progname}"
7681     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7682     break 2
7683   fi
7684 done
7685 done
7686
7687 fi
7688 fi
7689 RANLIB=$ac_cv_prog_RANLIB
7690 if test -n "$RANLIB"; then
7691   echo "$as_me:$LINENO: result: $RANLIB" >&5
7692 echo "${ECHO_T}$RANLIB" >&6
7693 else
7694   echo "$as_me:$LINENO: result: no" >&5
7695 echo "${ECHO_T}no" >&6
7696 fi
7697
7698   fi
7699   test -n "$ac_cv_prog_RANLIB" && break
7700 done
7701
7702 if test -z "$ac_cv_prog_RANLIB" ; then
7703   RANLIB=":"
7704 fi
7705
7706
7707
7708 if test -n "$STRIP"; then
7709   ac_cv_prog_STRIP=$STRIP
7710 elif test -n "$ac_cv_prog_STRIP"; then
7711   STRIP=$ac_cv_prog_STRIP
7712 fi
7713
7714 if test -n "$ac_cv_prog_STRIP"; then
7715   for ncn_progname in strip; do
7716     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7717 set dummy ${ncn_progname}; ac_word=$2
7718 echo "$as_me:$LINENO: checking for $ac_word" >&5
7719 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7720 if test "${ac_cv_prog_STRIP+set}" = set; then
7721   echo $ECHO_N "(cached) $ECHO_C" >&6
7722 else
7723   if test -n "$STRIP"; then
7724   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7725 else
7726 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7727 for as_dir in $PATH
7728 do
7729   IFS=$as_save_IFS
7730   test -z "$as_dir" && as_dir=.
7731   for ac_exec_ext in '' $ac_executable_extensions; do
7732   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7733     ac_cv_prog_STRIP="${ncn_progname}"
7734     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7735     break 2
7736   fi
7737 done
7738 done
7739
7740 fi
7741 fi
7742 STRIP=$ac_cv_prog_STRIP
7743 if test -n "$STRIP"; then
7744   echo "$as_me:$LINENO: result: $STRIP" >&5
7745 echo "${ECHO_T}$STRIP" >&6
7746 else
7747   echo "$as_me:$LINENO: result: no" >&5
7748 echo "${ECHO_T}no" >&6
7749 fi
7750
7751   done
7752 fi
7753
7754 for ncn_progname in strip; do
7755   if test -n "$ncn_tool_prefix"; then
7756     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7757 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7758 echo "$as_me:$LINENO: checking for $ac_word" >&5
7759 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7760 if test "${ac_cv_prog_STRIP+set}" = set; then
7761   echo $ECHO_N "(cached) $ECHO_C" >&6
7762 else
7763   if test -n "$STRIP"; then
7764   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7765 else
7766 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7767 for as_dir in $PATH
7768 do
7769   IFS=$as_save_IFS
7770   test -z "$as_dir" && as_dir=.
7771   for ac_exec_ext in '' $ac_executable_extensions; do
7772   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7773     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7774     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7775     break 2
7776   fi
7777 done
7778 done
7779
7780 fi
7781 fi
7782 STRIP=$ac_cv_prog_STRIP
7783 if test -n "$STRIP"; then
7784   echo "$as_me:$LINENO: result: $STRIP" >&5
7785 echo "${ECHO_T}$STRIP" >&6
7786 else
7787   echo "$as_me:$LINENO: result: no" >&5
7788 echo "${ECHO_T}no" >&6
7789 fi
7790
7791   fi
7792   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7793     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7794 set dummy ${ncn_progname}; ac_word=$2
7795 echo "$as_me:$LINENO: checking for $ac_word" >&5
7796 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7797 if test "${ac_cv_prog_STRIP+set}" = set; then
7798   echo $ECHO_N "(cached) $ECHO_C" >&6
7799 else
7800   if test -n "$STRIP"; then
7801   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7802 else
7803 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7804 for as_dir in $PATH
7805 do
7806   IFS=$as_save_IFS
7807   test -z "$as_dir" && as_dir=.
7808   for ac_exec_ext in '' $ac_executable_extensions; do
7809   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7810     ac_cv_prog_STRIP="${ncn_progname}"
7811     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7812     break 2
7813   fi
7814 done
7815 done
7816
7817 fi
7818 fi
7819 STRIP=$ac_cv_prog_STRIP
7820 if test -n "$STRIP"; then
7821   echo "$as_me:$LINENO: result: $STRIP" >&5
7822 echo "${ECHO_T}$STRIP" >&6
7823 else
7824   echo "$as_me:$LINENO: result: no" >&5
7825 echo "${ECHO_T}no" >&6
7826 fi
7827
7828   fi
7829   test -n "$ac_cv_prog_STRIP" && break
7830 done
7831
7832 if test -z "$ac_cv_prog_STRIP" ; then
7833   STRIP=":"
7834 fi
7835
7836
7837
7838 if test -n "$WINDRES"; then
7839   ac_cv_prog_WINDRES=$WINDRES
7840 elif test -n "$ac_cv_prog_WINDRES"; then
7841   WINDRES=$ac_cv_prog_WINDRES
7842 fi
7843
7844 if test -n "$ac_cv_prog_WINDRES"; then
7845   for ncn_progname in windres; do
7846     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7847 set dummy ${ncn_progname}; ac_word=$2
7848 echo "$as_me:$LINENO: checking for $ac_word" >&5
7849 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7850 if test "${ac_cv_prog_WINDRES+set}" = set; then
7851   echo $ECHO_N "(cached) $ECHO_C" >&6
7852 else
7853   if test -n "$WINDRES"; then
7854   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7855 else
7856 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7857 for as_dir in $PATH
7858 do
7859   IFS=$as_save_IFS
7860   test -z "$as_dir" && as_dir=.
7861   for ac_exec_ext in '' $ac_executable_extensions; do
7862   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7863     ac_cv_prog_WINDRES="${ncn_progname}"
7864     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7865     break 2
7866   fi
7867 done
7868 done
7869
7870 fi
7871 fi
7872 WINDRES=$ac_cv_prog_WINDRES
7873 if test -n "$WINDRES"; then
7874   echo "$as_me:$LINENO: result: $WINDRES" >&5
7875 echo "${ECHO_T}$WINDRES" >&6
7876 else
7877   echo "$as_me:$LINENO: result: no" >&5
7878 echo "${ECHO_T}no" >&6
7879 fi
7880
7881   done
7882 fi
7883
7884 for ncn_progname in windres; do
7885   if test -n "$ncn_tool_prefix"; then
7886     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7887 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7888 echo "$as_me:$LINENO: checking for $ac_word" >&5
7889 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7890 if test "${ac_cv_prog_WINDRES+set}" = set; then
7891   echo $ECHO_N "(cached) $ECHO_C" >&6
7892 else
7893   if test -n "$WINDRES"; then
7894   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7895 else
7896 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7897 for as_dir in $PATH
7898 do
7899   IFS=$as_save_IFS
7900   test -z "$as_dir" && as_dir=.
7901   for ac_exec_ext in '' $ac_executable_extensions; do
7902   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7903     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7904     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7905     break 2
7906   fi
7907 done
7908 done
7909
7910 fi
7911 fi
7912 WINDRES=$ac_cv_prog_WINDRES
7913 if test -n "$WINDRES"; then
7914   echo "$as_me:$LINENO: result: $WINDRES" >&5
7915 echo "${ECHO_T}$WINDRES" >&6
7916 else
7917   echo "$as_me:$LINENO: result: no" >&5
7918 echo "${ECHO_T}no" >&6
7919 fi
7920
7921   fi
7922   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7923     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7924 set dummy ${ncn_progname}; ac_word=$2
7925 echo "$as_me:$LINENO: checking for $ac_word" >&5
7926 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7927 if test "${ac_cv_prog_WINDRES+set}" = set; then
7928   echo $ECHO_N "(cached) $ECHO_C" >&6
7929 else
7930   if test -n "$WINDRES"; then
7931   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7932 else
7933 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7934 for as_dir in $PATH
7935 do
7936   IFS=$as_save_IFS
7937   test -z "$as_dir" && as_dir=.
7938   for ac_exec_ext in '' $ac_executable_extensions; do
7939   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7940     ac_cv_prog_WINDRES="${ncn_progname}"
7941     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7942     break 2
7943   fi
7944 done
7945 done
7946
7947 fi
7948 fi
7949 WINDRES=$ac_cv_prog_WINDRES
7950 if test -n "$WINDRES"; then
7951   echo "$as_me:$LINENO: result: $WINDRES" >&5
7952 echo "${ECHO_T}$WINDRES" >&6
7953 else
7954   echo "$as_me:$LINENO: result: no" >&5
7955 echo "${ECHO_T}no" >&6
7956 fi
7957
7958   fi
7959   test -n "$ac_cv_prog_WINDRES" && break
7960 done
7961
7962 if test -z "$ac_cv_prog_WINDRES" ; then
7963   set dummy windres
7964   if test $build = $host ; then
7965     WINDRES="$2"
7966   else
7967     WINDRES="${ncn_tool_prefix}$2"
7968   fi
7969 fi
7970
7971
7972
7973 if test -n "$WINDMC"; then
7974   ac_cv_prog_WINDMC=$WINDMC
7975 elif test -n "$ac_cv_prog_WINDMC"; then
7976   WINDMC=$ac_cv_prog_WINDMC
7977 fi
7978
7979 if test -n "$ac_cv_prog_WINDMC"; then
7980   for ncn_progname in windmc; do
7981     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7982 set dummy ${ncn_progname}; ac_word=$2
7983 echo "$as_me:$LINENO: checking for $ac_word" >&5
7984 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7985 if test "${ac_cv_prog_WINDMC+set}" = set; then
7986   echo $ECHO_N "(cached) $ECHO_C" >&6
7987 else
7988   if test -n "$WINDMC"; then
7989   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7990 else
7991 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7992 for as_dir in $PATH
7993 do
7994   IFS=$as_save_IFS
7995   test -z "$as_dir" && as_dir=.
7996   for ac_exec_ext in '' $ac_executable_extensions; do
7997   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7998     ac_cv_prog_WINDMC="${ncn_progname}"
7999     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8000     break 2
8001   fi
8002 done
8003 done
8004
8005 fi
8006 fi
8007 WINDMC=$ac_cv_prog_WINDMC
8008 if test -n "$WINDMC"; then
8009   echo "$as_me:$LINENO: result: $WINDMC" >&5
8010 echo "${ECHO_T}$WINDMC" >&6
8011 else
8012   echo "$as_me:$LINENO: result: no" >&5
8013 echo "${ECHO_T}no" >&6
8014 fi
8015
8016   done
8017 fi
8018
8019 for ncn_progname in windmc; do
8020   if test -n "$ncn_tool_prefix"; then
8021     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8022 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8023 echo "$as_me:$LINENO: checking for $ac_word" >&5
8024 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8025 if test "${ac_cv_prog_WINDMC+set}" = set; then
8026   echo $ECHO_N "(cached) $ECHO_C" >&6
8027 else
8028   if test -n "$WINDMC"; then
8029   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8030 else
8031 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8032 for as_dir in $PATH
8033 do
8034   IFS=$as_save_IFS
8035   test -z "$as_dir" && as_dir=.
8036   for ac_exec_ext in '' $ac_executable_extensions; do
8037   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8038     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8039     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8040     break 2
8041   fi
8042 done
8043 done
8044
8045 fi
8046 fi
8047 WINDMC=$ac_cv_prog_WINDMC
8048 if test -n "$WINDMC"; then
8049   echo "$as_me:$LINENO: result: $WINDMC" >&5
8050 echo "${ECHO_T}$WINDMC" >&6
8051 else
8052   echo "$as_me:$LINENO: result: no" >&5
8053 echo "${ECHO_T}no" >&6
8054 fi
8055
8056   fi
8057   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8058     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8059 set dummy ${ncn_progname}; ac_word=$2
8060 echo "$as_me:$LINENO: checking for $ac_word" >&5
8061 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8062 if test "${ac_cv_prog_WINDMC+set}" = set; then
8063   echo $ECHO_N "(cached) $ECHO_C" >&6
8064 else
8065   if test -n "$WINDMC"; then
8066   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8067 else
8068 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8069 for as_dir in $PATH
8070 do
8071   IFS=$as_save_IFS
8072   test -z "$as_dir" && as_dir=.
8073   for ac_exec_ext in '' $ac_executable_extensions; do
8074   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8075     ac_cv_prog_WINDMC="${ncn_progname}"
8076     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8077     break 2
8078   fi
8079 done
8080 done
8081
8082 fi
8083 fi
8084 WINDMC=$ac_cv_prog_WINDMC
8085 if test -n "$WINDMC"; then
8086   echo "$as_me:$LINENO: result: $WINDMC" >&5
8087 echo "${ECHO_T}$WINDMC" >&6
8088 else
8089   echo "$as_me:$LINENO: result: no" >&5
8090 echo "${ECHO_T}no" >&6
8091 fi
8092
8093   fi
8094   test -n "$ac_cv_prog_WINDMC" && break
8095 done
8096
8097 if test -z "$ac_cv_prog_WINDMC" ; then
8098   set dummy windmc
8099   if test $build = $host ; then
8100     WINDMC="$2"
8101   else
8102     WINDMC="${ncn_tool_prefix}$2"
8103   fi
8104 fi
8105
8106
8107
8108 if test -n "$OBJCOPY"; then
8109   ac_cv_prog_OBJCOPY=$OBJCOPY
8110 elif test -n "$ac_cv_prog_OBJCOPY"; then
8111   OBJCOPY=$ac_cv_prog_OBJCOPY
8112 fi
8113
8114 if test -n "$ac_cv_prog_OBJCOPY"; then
8115   for ncn_progname in objcopy; do
8116     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8117 set dummy ${ncn_progname}; ac_word=$2
8118 echo "$as_me:$LINENO: checking for $ac_word" >&5
8119 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8120 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8121   echo $ECHO_N "(cached) $ECHO_C" >&6
8122 else
8123   if test -n "$OBJCOPY"; then
8124   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8125 else
8126 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8127 for as_dir in $PATH
8128 do
8129   IFS=$as_save_IFS
8130   test -z "$as_dir" && as_dir=.
8131   for ac_exec_ext in '' $ac_executable_extensions; do
8132   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8133     ac_cv_prog_OBJCOPY="${ncn_progname}"
8134     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8135     break 2
8136   fi
8137 done
8138 done
8139
8140 fi
8141 fi
8142 OBJCOPY=$ac_cv_prog_OBJCOPY
8143 if test -n "$OBJCOPY"; then
8144   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8145 echo "${ECHO_T}$OBJCOPY" >&6
8146 else
8147   echo "$as_me:$LINENO: result: no" >&5
8148 echo "${ECHO_T}no" >&6
8149 fi
8150
8151   done
8152 fi
8153
8154 for ncn_progname in objcopy; do
8155   if test -n "$ncn_tool_prefix"; then
8156     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8157 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8158 echo "$as_me:$LINENO: checking for $ac_word" >&5
8159 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8160 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8161   echo $ECHO_N "(cached) $ECHO_C" >&6
8162 else
8163   if test -n "$OBJCOPY"; then
8164   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8165 else
8166 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8167 for as_dir in $PATH
8168 do
8169   IFS=$as_save_IFS
8170   test -z "$as_dir" && as_dir=.
8171   for ac_exec_ext in '' $ac_executable_extensions; do
8172   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8173     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8174     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8175     break 2
8176   fi
8177 done
8178 done
8179
8180 fi
8181 fi
8182 OBJCOPY=$ac_cv_prog_OBJCOPY
8183 if test -n "$OBJCOPY"; then
8184   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8185 echo "${ECHO_T}$OBJCOPY" >&6
8186 else
8187   echo "$as_me:$LINENO: result: no" >&5
8188 echo "${ECHO_T}no" >&6
8189 fi
8190
8191   fi
8192   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8193     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8194 set dummy ${ncn_progname}; ac_word=$2
8195 echo "$as_me:$LINENO: checking for $ac_word" >&5
8196 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8197 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8198   echo $ECHO_N "(cached) $ECHO_C" >&6
8199 else
8200   if test -n "$OBJCOPY"; then
8201   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8202 else
8203 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8204 for as_dir in $PATH
8205 do
8206   IFS=$as_save_IFS
8207   test -z "$as_dir" && as_dir=.
8208   for ac_exec_ext in '' $ac_executable_extensions; do
8209   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8210     ac_cv_prog_OBJCOPY="${ncn_progname}"
8211     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8212     break 2
8213   fi
8214 done
8215 done
8216
8217 fi
8218 fi
8219 OBJCOPY=$ac_cv_prog_OBJCOPY
8220 if test -n "$OBJCOPY"; then
8221   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8222 echo "${ECHO_T}$OBJCOPY" >&6
8223 else
8224   echo "$as_me:$LINENO: result: no" >&5
8225 echo "${ECHO_T}no" >&6
8226 fi
8227
8228   fi
8229   test -n "$ac_cv_prog_OBJCOPY" && break
8230 done
8231
8232 if test -z "$ac_cv_prog_OBJCOPY" ; then
8233   set dummy objcopy
8234   if test $build = $host ; then
8235     OBJCOPY="$2"
8236   else
8237     OBJCOPY="${ncn_tool_prefix}$2"
8238   fi
8239 fi
8240
8241
8242
8243 if test -n "$OBJDUMP"; then
8244   ac_cv_prog_OBJDUMP=$OBJDUMP
8245 elif test -n "$ac_cv_prog_OBJDUMP"; then
8246   OBJDUMP=$ac_cv_prog_OBJDUMP
8247 fi
8248
8249 if test -n "$ac_cv_prog_OBJDUMP"; then
8250   for ncn_progname in objdump; do
8251     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8252 set dummy ${ncn_progname}; ac_word=$2
8253 echo "$as_me:$LINENO: checking for $ac_word" >&5
8254 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8255 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8256   echo $ECHO_N "(cached) $ECHO_C" >&6
8257 else
8258   if test -n "$OBJDUMP"; then
8259   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8260 else
8261 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8262 for as_dir in $PATH
8263 do
8264   IFS=$as_save_IFS
8265   test -z "$as_dir" && as_dir=.
8266   for ac_exec_ext in '' $ac_executable_extensions; do
8267   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8268     ac_cv_prog_OBJDUMP="${ncn_progname}"
8269     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8270     break 2
8271   fi
8272 done
8273 done
8274
8275 fi
8276 fi
8277 OBJDUMP=$ac_cv_prog_OBJDUMP
8278 if test -n "$OBJDUMP"; then
8279   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8280 echo "${ECHO_T}$OBJDUMP" >&6
8281 else
8282   echo "$as_me:$LINENO: result: no" >&5
8283 echo "${ECHO_T}no" >&6
8284 fi
8285
8286   done
8287 fi
8288
8289 for ncn_progname in objdump; do
8290   if test -n "$ncn_tool_prefix"; then
8291     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8292 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8293 echo "$as_me:$LINENO: checking for $ac_word" >&5
8294 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8295 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8296   echo $ECHO_N "(cached) $ECHO_C" >&6
8297 else
8298   if test -n "$OBJDUMP"; then
8299   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8300 else
8301 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8302 for as_dir in $PATH
8303 do
8304   IFS=$as_save_IFS
8305   test -z "$as_dir" && as_dir=.
8306   for ac_exec_ext in '' $ac_executable_extensions; do
8307   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8308     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8309     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8310     break 2
8311   fi
8312 done
8313 done
8314
8315 fi
8316 fi
8317 OBJDUMP=$ac_cv_prog_OBJDUMP
8318 if test -n "$OBJDUMP"; then
8319   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8320 echo "${ECHO_T}$OBJDUMP" >&6
8321 else
8322   echo "$as_me:$LINENO: result: no" >&5
8323 echo "${ECHO_T}no" >&6
8324 fi
8325
8326   fi
8327   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8328     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8329 set dummy ${ncn_progname}; ac_word=$2
8330 echo "$as_me:$LINENO: checking for $ac_word" >&5
8331 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8332 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8333   echo $ECHO_N "(cached) $ECHO_C" >&6
8334 else
8335   if test -n "$OBJDUMP"; then
8336   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8337 else
8338 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8339 for as_dir in $PATH
8340 do
8341   IFS=$as_save_IFS
8342   test -z "$as_dir" && as_dir=.
8343   for ac_exec_ext in '' $ac_executable_extensions; do
8344   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8345     ac_cv_prog_OBJDUMP="${ncn_progname}"
8346     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8347     break 2
8348   fi
8349 done
8350 done
8351
8352 fi
8353 fi
8354 OBJDUMP=$ac_cv_prog_OBJDUMP
8355 if test -n "$OBJDUMP"; then
8356   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8357 echo "${ECHO_T}$OBJDUMP" >&6
8358 else
8359   echo "$as_me:$LINENO: result: no" >&5
8360 echo "${ECHO_T}no" >&6
8361 fi
8362
8363   fi
8364   test -n "$ac_cv_prog_OBJDUMP" && break
8365 done
8366
8367 if test -z "$ac_cv_prog_OBJDUMP" ; then
8368   set dummy objdump
8369   if test $build = $host ; then
8370     OBJDUMP="$2"
8371   else
8372     OBJDUMP="${ncn_tool_prefix}$2"
8373   fi
8374 fi
8375
8376
8377
8378
8379
8380
8381 # Target tools.
8382
8383 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8384 if test "${with_build_time_tools+set}" = set; then
8385   withval="$with_build_time_tools"
8386   case x"$withval" in
8387      x/*) ;;
8388      *)
8389        with_build_time_tools=
8390        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8391 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8392        ;;
8393    esac
8394 else
8395   with_build_time_tools=
8396 fi;
8397
8398
8399
8400 if test -n "$CC_FOR_TARGET"; then
8401   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8402 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8403   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8404 fi
8405
8406 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8407   for ncn_progname in cc gcc; do
8408     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8409 set dummy ${ncn_progname}; ac_word=$2
8410 echo "$as_me:$LINENO: checking for $ac_word" >&5
8411 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8412 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8413   echo $ECHO_N "(cached) $ECHO_C" >&6
8414 else
8415   if test -n "$CC_FOR_TARGET"; then
8416   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8417 else
8418 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8419 for as_dir in $PATH
8420 do
8421   IFS=$as_save_IFS
8422   test -z "$as_dir" && as_dir=.
8423   for ac_exec_ext in '' $ac_executable_extensions; do
8424   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8425     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8426     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8427     break 2
8428   fi
8429 done
8430 done
8431
8432 fi
8433 fi
8434 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8435 if test -n "$CC_FOR_TARGET"; then
8436   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8437 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8438 else
8439   echo "$as_me:$LINENO: result: no" >&5
8440 echo "${ECHO_T}no" >&6
8441 fi
8442
8443   done
8444 fi
8445
8446 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8447   for ncn_progname in cc gcc; do
8448     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8449 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8450     if test -x $with_build_time_tools/${ncn_progname}; then
8451       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8452       echo "$as_me:$LINENO: result: yes" >&5
8453 echo "${ECHO_T}yes" >&6
8454       break
8455     else
8456       echo "$as_me:$LINENO: result: no" >&5
8457 echo "${ECHO_T}no" >&6
8458     fi
8459   done
8460 fi
8461
8462 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8463   for ncn_progname in cc gcc; do
8464     if test -n "$ncn_target_tool_prefix"; then
8465       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8466 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8467 echo "$as_me:$LINENO: checking for $ac_word" >&5
8468 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8469 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8470   echo $ECHO_N "(cached) $ECHO_C" >&6
8471 else
8472   if test -n "$CC_FOR_TARGET"; then
8473   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8474 else
8475 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8476 for as_dir in $PATH
8477 do
8478   IFS=$as_save_IFS
8479   test -z "$as_dir" && as_dir=.
8480   for ac_exec_ext in '' $ac_executable_extensions; do
8481   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8482     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8483     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8484     break 2
8485   fi
8486 done
8487 done
8488
8489 fi
8490 fi
8491 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8492 if test -n "$CC_FOR_TARGET"; then
8493   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8494 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8495 else
8496   echo "$as_me:$LINENO: result: no" >&5
8497 echo "${ECHO_T}no" >&6
8498 fi
8499
8500     fi
8501     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8502       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8503 set dummy ${ncn_progname}; ac_word=$2
8504 echo "$as_me:$LINENO: checking for $ac_word" >&5
8505 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8506 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8507   echo $ECHO_N "(cached) $ECHO_C" >&6
8508 else
8509   if test -n "$CC_FOR_TARGET"; then
8510   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8511 else
8512 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8513 for as_dir in $PATH
8514 do
8515   IFS=$as_save_IFS
8516   test -z "$as_dir" && as_dir=.
8517   for ac_exec_ext in '' $ac_executable_extensions; do
8518   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8519     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8520     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8521     break 2
8522   fi
8523 done
8524 done
8525
8526 fi
8527 fi
8528 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8529 if test -n "$CC_FOR_TARGET"; then
8530   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8531 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8532 else
8533   echo "$as_me:$LINENO: result: no" >&5
8534 echo "${ECHO_T}no" >&6
8535 fi
8536
8537     fi
8538     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8539   done
8540 fi
8541
8542 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8543   set dummy cc gcc
8544   if test $build = $target ; then
8545     CC_FOR_TARGET="$2"
8546   else
8547     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8548   fi
8549 else
8550   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8551 fi
8552
8553
8554
8555 if test -n "$CXX_FOR_TARGET"; then
8556   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8557 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8558   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8559 fi
8560
8561 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8562   for ncn_progname in c++ g++ cxx gxx; do
8563     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8564 set dummy ${ncn_progname}; ac_word=$2
8565 echo "$as_me:$LINENO: checking for $ac_word" >&5
8566 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8567 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8568   echo $ECHO_N "(cached) $ECHO_C" >&6
8569 else
8570   if test -n "$CXX_FOR_TARGET"; then
8571   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8572 else
8573 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8574 for as_dir in $PATH
8575 do
8576   IFS=$as_save_IFS
8577   test -z "$as_dir" && as_dir=.
8578   for ac_exec_ext in '' $ac_executable_extensions; do
8579   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8580     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8581     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8582     break 2
8583   fi
8584 done
8585 done
8586
8587 fi
8588 fi
8589 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8590 if test -n "$CXX_FOR_TARGET"; then
8591   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8592 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8593 else
8594   echo "$as_me:$LINENO: result: no" >&5
8595 echo "${ECHO_T}no" >&6
8596 fi
8597
8598   done
8599 fi
8600
8601 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8602   for ncn_progname in c++ g++ cxx gxx; do
8603     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8604 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8605     if test -x $with_build_time_tools/${ncn_progname}; then
8606       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8607       echo "$as_me:$LINENO: result: yes" >&5
8608 echo "${ECHO_T}yes" >&6
8609       break
8610     else
8611       echo "$as_me:$LINENO: result: no" >&5
8612 echo "${ECHO_T}no" >&6
8613     fi
8614   done
8615 fi
8616
8617 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8618   for ncn_progname in c++ g++ cxx gxx; do
8619     if test -n "$ncn_target_tool_prefix"; then
8620       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8621 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8622 echo "$as_me:$LINENO: checking for $ac_word" >&5
8623 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8624 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8625   echo $ECHO_N "(cached) $ECHO_C" >&6
8626 else
8627   if test -n "$CXX_FOR_TARGET"; then
8628   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8629 else
8630 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8631 for as_dir in $PATH
8632 do
8633   IFS=$as_save_IFS
8634   test -z "$as_dir" && as_dir=.
8635   for ac_exec_ext in '' $ac_executable_extensions; do
8636   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8637     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8638     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8639     break 2
8640   fi
8641 done
8642 done
8643
8644 fi
8645 fi
8646 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8647 if test -n "$CXX_FOR_TARGET"; then
8648   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8649 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8650 else
8651   echo "$as_me:$LINENO: result: no" >&5
8652 echo "${ECHO_T}no" >&6
8653 fi
8654
8655     fi
8656     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8657       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8658 set dummy ${ncn_progname}; ac_word=$2
8659 echo "$as_me:$LINENO: checking for $ac_word" >&5
8660 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8661 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8662   echo $ECHO_N "(cached) $ECHO_C" >&6
8663 else
8664   if test -n "$CXX_FOR_TARGET"; then
8665   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8666 else
8667 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8668 for as_dir in $PATH
8669 do
8670   IFS=$as_save_IFS
8671   test -z "$as_dir" && as_dir=.
8672   for ac_exec_ext in '' $ac_executable_extensions; do
8673   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8674     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8675     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8676     break 2
8677   fi
8678 done
8679 done
8680
8681 fi
8682 fi
8683 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8684 if test -n "$CXX_FOR_TARGET"; then
8685   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8686 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8687 else
8688   echo "$as_me:$LINENO: result: no" >&5
8689 echo "${ECHO_T}no" >&6
8690 fi
8691
8692     fi
8693     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8694   done
8695 fi
8696
8697 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8698   set dummy c++ g++ cxx gxx
8699   if test $build = $target ; then
8700     CXX_FOR_TARGET="$2"
8701   else
8702     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8703   fi
8704 else
8705   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8706 fi
8707
8708
8709
8710 if test -n "$GCC_FOR_TARGET"; then
8711   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8712 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8713   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8714 fi
8715
8716 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8717   for ncn_progname in gcc; do
8718     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8719 set dummy ${ncn_progname}; ac_word=$2
8720 echo "$as_me:$LINENO: checking for $ac_word" >&5
8721 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8722 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8723   echo $ECHO_N "(cached) $ECHO_C" >&6
8724 else
8725   if test -n "$GCC_FOR_TARGET"; then
8726   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8727 else
8728 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8729 for as_dir in $PATH
8730 do
8731   IFS=$as_save_IFS
8732   test -z "$as_dir" && as_dir=.
8733   for ac_exec_ext in '' $ac_executable_extensions; do
8734   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8735     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8736     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8737     break 2
8738   fi
8739 done
8740 done
8741
8742 fi
8743 fi
8744 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8745 if test -n "$GCC_FOR_TARGET"; then
8746   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8747 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8748 else
8749   echo "$as_me:$LINENO: result: no" >&5
8750 echo "${ECHO_T}no" >&6
8751 fi
8752
8753   done
8754 fi
8755
8756 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8757   for ncn_progname in gcc; do
8758     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8759 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8760     if test -x $with_build_time_tools/${ncn_progname}; then
8761       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8762       echo "$as_me:$LINENO: result: yes" >&5
8763 echo "${ECHO_T}yes" >&6
8764       break
8765     else
8766       echo "$as_me:$LINENO: result: no" >&5
8767 echo "${ECHO_T}no" >&6
8768     fi
8769   done
8770 fi
8771
8772 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8773   for ncn_progname in gcc; do
8774     if test -n "$ncn_target_tool_prefix"; then
8775       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8776 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8777 echo "$as_me:$LINENO: checking for $ac_word" >&5
8778 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8779 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8780   echo $ECHO_N "(cached) $ECHO_C" >&6
8781 else
8782   if test -n "$GCC_FOR_TARGET"; then
8783   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8784 else
8785 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8786 for as_dir in $PATH
8787 do
8788   IFS=$as_save_IFS
8789   test -z "$as_dir" && as_dir=.
8790   for ac_exec_ext in '' $ac_executable_extensions; do
8791   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8792     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8793     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8794     break 2
8795   fi
8796 done
8797 done
8798
8799 fi
8800 fi
8801 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8802 if test -n "$GCC_FOR_TARGET"; then
8803   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8804 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8805 else
8806   echo "$as_me:$LINENO: result: no" >&5
8807 echo "${ECHO_T}no" >&6
8808 fi
8809
8810     fi
8811     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8812       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8813 set dummy ${ncn_progname}; ac_word=$2
8814 echo "$as_me:$LINENO: checking for $ac_word" >&5
8815 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8816 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8817   echo $ECHO_N "(cached) $ECHO_C" >&6
8818 else
8819   if test -n "$GCC_FOR_TARGET"; then
8820   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8821 else
8822 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8823 for as_dir in $PATH
8824 do
8825   IFS=$as_save_IFS
8826   test -z "$as_dir" && as_dir=.
8827   for ac_exec_ext in '' $ac_executable_extensions; do
8828   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8829     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8830     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8831     break 2
8832   fi
8833 done
8834 done
8835
8836 fi
8837 fi
8838 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8839 if test -n "$GCC_FOR_TARGET"; then
8840   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8841 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8842 else
8843   echo "$as_me:$LINENO: result: no" >&5
8844 echo "${ECHO_T}no" >&6
8845 fi
8846
8847     fi
8848     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8849   done
8850 fi
8851
8852 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8853   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8854 else
8855   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8856 fi
8857
8858
8859
8860 if test -n "$GCJ_FOR_TARGET"; then
8861   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8862 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8863   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8864 fi
8865
8866 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8867   for ncn_progname in gcj; do
8868     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8869 set dummy ${ncn_progname}; ac_word=$2
8870 echo "$as_me:$LINENO: checking for $ac_word" >&5
8871 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8872 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8873   echo $ECHO_N "(cached) $ECHO_C" >&6
8874 else
8875   if test -n "$GCJ_FOR_TARGET"; then
8876   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8877 else
8878 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8879 for as_dir in $PATH
8880 do
8881   IFS=$as_save_IFS
8882   test -z "$as_dir" && as_dir=.
8883   for ac_exec_ext in '' $ac_executable_extensions; do
8884   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8885     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8886     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8887     break 2
8888   fi
8889 done
8890 done
8891
8892 fi
8893 fi
8894 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8895 if test -n "$GCJ_FOR_TARGET"; then
8896   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8897 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8898 else
8899   echo "$as_me:$LINENO: result: no" >&5
8900 echo "${ECHO_T}no" >&6
8901 fi
8902
8903   done
8904 fi
8905
8906 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8907   for ncn_progname in gcj; do
8908     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8909 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8910     if test -x $with_build_time_tools/${ncn_progname}; then
8911       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8912       echo "$as_me:$LINENO: result: yes" >&5
8913 echo "${ECHO_T}yes" >&6
8914       break
8915     else
8916       echo "$as_me:$LINENO: result: no" >&5
8917 echo "${ECHO_T}no" >&6
8918     fi
8919   done
8920 fi
8921
8922 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8923   for ncn_progname in gcj; do
8924     if test -n "$ncn_target_tool_prefix"; then
8925       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8926 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8927 echo "$as_me:$LINENO: checking for $ac_word" >&5
8928 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8929 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8930   echo $ECHO_N "(cached) $ECHO_C" >&6
8931 else
8932   if test -n "$GCJ_FOR_TARGET"; then
8933   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8934 else
8935 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8936 for as_dir in $PATH
8937 do
8938   IFS=$as_save_IFS
8939   test -z "$as_dir" && as_dir=.
8940   for ac_exec_ext in '' $ac_executable_extensions; do
8941   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8942     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8943     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8944     break 2
8945   fi
8946 done
8947 done
8948
8949 fi
8950 fi
8951 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8952 if test -n "$GCJ_FOR_TARGET"; then
8953   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8954 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8955 else
8956   echo "$as_me:$LINENO: result: no" >&5
8957 echo "${ECHO_T}no" >&6
8958 fi
8959
8960     fi
8961     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8962       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8963 set dummy ${ncn_progname}; ac_word=$2
8964 echo "$as_me:$LINENO: checking for $ac_word" >&5
8965 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8966 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8967   echo $ECHO_N "(cached) $ECHO_C" >&6
8968 else
8969   if test -n "$GCJ_FOR_TARGET"; then
8970   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8971 else
8972 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8973 for as_dir in $PATH
8974 do
8975   IFS=$as_save_IFS
8976   test -z "$as_dir" && as_dir=.
8977   for ac_exec_ext in '' $ac_executable_extensions; do
8978   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8979     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8980     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8981     break 2
8982   fi
8983 done
8984 done
8985
8986 fi
8987 fi
8988 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8989 if test -n "$GCJ_FOR_TARGET"; then
8990   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8991 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8992 else
8993   echo "$as_me:$LINENO: result: no" >&5
8994 echo "${ECHO_T}no" >&6
8995 fi
8996
8997     fi
8998     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8999   done
9000 fi
9001
9002 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9003   set dummy gcj
9004   if test $build = $target ; then
9005     GCJ_FOR_TARGET="$2"
9006   else
9007     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9008   fi
9009 else
9010   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9011 fi
9012
9013
9014
9015 if test -n "$GFORTRAN_FOR_TARGET"; then
9016   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9017 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9018   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9019 fi
9020
9021 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9022   for ncn_progname in gfortran; do
9023     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9024 set dummy ${ncn_progname}; ac_word=$2
9025 echo "$as_me:$LINENO: checking for $ac_word" >&5
9026 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9027 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9028   echo $ECHO_N "(cached) $ECHO_C" >&6
9029 else
9030   if test -n "$GFORTRAN_FOR_TARGET"; then
9031   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9032 else
9033 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9034 for as_dir in $PATH
9035 do
9036   IFS=$as_save_IFS
9037   test -z "$as_dir" && as_dir=.
9038   for ac_exec_ext in '' $ac_executable_extensions; do
9039   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9040     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9041     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9042     break 2
9043   fi
9044 done
9045 done
9046
9047 fi
9048 fi
9049 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9050 if test -n "$GFORTRAN_FOR_TARGET"; then
9051   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9052 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9053 else
9054   echo "$as_me:$LINENO: result: no" >&5
9055 echo "${ECHO_T}no" >&6
9056 fi
9057
9058   done
9059 fi
9060
9061 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9062   for ncn_progname in gfortran; do
9063     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9064 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9065     if test -x $with_build_time_tools/${ncn_progname}; then
9066       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9067       echo "$as_me:$LINENO: result: yes" >&5
9068 echo "${ECHO_T}yes" >&6
9069       break
9070     else
9071       echo "$as_me:$LINENO: result: no" >&5
9072 echo "${ECHO_T}no" >&6
9073     fi
9074   done
9075 fi
9076
9077 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9078   for ncn_progname in gfortran; do
9079     if test -n "$ncn_target_tool_prefix"; then
9080       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9081 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9082 echo "$as_me:$LINENO: checking for $ac_word" >&5
9083 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9084 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9085   echo $ECHO_N "(cached) $ECHO_C" >&6
9086 else
9087   if test -n "$GFORTRAN_FOR_TARGET"; then
9088   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9089 else
9090 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9091 for as_dir in $PATH
9092 do
9093   IFS=$as_save_IFS
9094   test -z "$as_dir" && as_dir=.
9095   for ac_exec_ext in '' $ac_executable_extensions; do
9096   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9097     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9098     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9099     break 2
9100   fi
9101 done
9102 done
9103
9104 fi
9105 fi
9106 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9107 if test -n "$GFORTRAN_FOR_TARGET"; then
9108   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9109 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9110 else
9111   echo "$as_me:$LINENO: result: no" >&5
9112 echo "${ECHO_T}no" >&6
9113 fi
9114
9115     fi
9116     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9117       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9118 set dummy ${ncn_progname}; ac_word=$2
9119 echo "$as_me:$LINENO: checking for $ac_word" >&5
9120 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9121 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9122   echo $ECHO_N "(cached) $ECHO_C" >&6
9123 else
9124   if test -n "$GFORTRAN_FOR_TARGET"; then
9125   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9126 else
9127 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9128 for as_dir in $PATH
9129 do
9130   IFS=$as_save_IFS
9131   test -z "$as_dir" && as_dir=.
9132   for ac_exec_ext in '' $ac_executable_extensions; do
9133   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9134     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9135     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9136     break 2
9137   fi
9138 done
9139 done
9140
9141 fi
9142 fi
9143 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9144 if test -n "$GFORTRAN_FOR_TARGET"; then
9145   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9146 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9147 else
9148   echo "$as_me:$LINENO: result: no" >&5
9149 echo "${ECHO_T}no" >&6
9150 fi
9151
9152     fi
9153     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9154   done
9155 fi
9156
9157 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9158   set dummy gfortran
9159   if test $build = $target ; then
9160     GFORTRAN_FOR_TARGET="$2"
9161   else
9162     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9163   fi
9164 else
9165   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9166 fi
9167
9168
9169
9170 cat > conftest.c << \EOF
9171 #ifdef __GNUC__
9172   gcc_yay;
9173 #endif
9174 EOF
9175 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9176   have_gcc_for_target=yes
9177 else
9178   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9179   have_gcc_for_target=no
9180 fi
9181 rm conftest.c
9182
9183
9184
9185
9186 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9187   if test -n "$with_build_time_tools"; then
9188     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9189 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9190     if test -x $with_build_time_tools/ar; then
9191       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9192       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9193       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9194 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9195     else
9196       echo "$as_me:$LINENO: result: no" >&5
9197 echo "${ECHO_T}no" >&6
9198     fi
9199   elif test $build != $host && test $have_gcc_for_target = yes; then
9200     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9201     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9202     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9203   fi
9204 fi
9205 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9206   # Extract the first word of "ar", so it can be a program name with args.
9207 set dummy ar; ac_word=$2
9208 echo "$as_me:$LINENO: checking for $ac_word" >&5
9209 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9210 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9211   echo $ECHO_N "(cached) $ECHO_C" >&6
9212 else
9213   case $AR_FOR_TARGET in
9214   [\\/]* | ?:[\\/]*)
9215   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9216   ;;
9217   *)
9218   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9219 for as_dir in $gcc_cv_tool_dirs
9220 do
9221   IFS=$as_save_IFS
9222   test -z "$as_dir" && as_dir=.
9223   for ac_exec_ext in '' $ac_executable_extensions; do
9224   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9225     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9226     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9227     break 2
9228   fi
9229 done
9230 done
9231
9232   ;;
9233 esac
9234 fi
9235 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9236
9237 if test -n "$AR_FOR_TARGET"; then
9238   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9239 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9240 else
9241   echo "$as_me:$LINENO: result: no" >&5
9242 echo "${ECHO_T}no" >&6
9243 fi
9244
9245 fi
9246 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9247
9248
9249 if test -n "$AR_FOR_TARGET"; then
9250   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9251 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9252   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9253 fi
9254
9255 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9256   for ncn_progname in ar; do
9257     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9258 set dummy ${ncn_progname}; ac_word=$2
9259 echo "$as_me:$LINENO: checking for $ac_word" >&5
9260 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9261 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9262   echo $ECHO_N "(cached) $ECHO_C" >&6
9263 else
9264   if test -n "$AR_FOR_TARGET"; then
9265   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9266 else
9267 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9268 for as_dir in $PATH
9269 do
9270   IFS=$as_save_IFS
9271   test -z "$as_dir" && as_dir=.
9272   for ac_exec_ext in '' $ac_executable_extensions; do
9273   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9274     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9275     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9276     break 2
9277   fi
9278 done
9279 done
9280
9281 fi
9282 fi
9283 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9284 if test -n "$AR_FOR_TARGET"; then
9285   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9286 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9287 else
9288   echo "$as_me:$LINENO: result: no" >&5
9289 echo "${ECHO_T}no" >&6
9290 fi
9291
9292   done
9293 fi
9294
9295 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9296   for ncn_progname in ar; do
9297     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9298 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9299     if test -x $with_build_time_tools/${ncn_progname}; then
9300       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9301       echo "$as_me:$LINENO: result: yes" >&5
9302 echo "${ECHO_T}yes" >&6
9303       break
9304     else
9305       echo "$as_me:$LINENO: result: no" >&5
9306 echo "${ECHO_T}no" >&6
9307     fi
9308   done
9309 fi
9310
9311 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9312   for ncn_progname in ar; do
9313     if test -n "$ncn_target_tool_prefix"; then
9314       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9315 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9316 echo "$as_me:$LINENO: checking for $ac_word" >&5
9317 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9318 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9319   echo $ECHO_N "(cached) $ECHO_C" >&6
9320 else
9321   if test -n "$AR_FOR_TARGET"; then
9322   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9323 else
9324 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9325 for as_dir in $PATH
9326 do
9327   IFS=$as_save_IFS
9328   test -z "$as_dir" && as_dir=.
9329   for ac_exec_ext in '' $ac_executable_extensions; do
9330   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9331     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9332     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9333     break 2
9334   fi
9335 done
9336 done
9337
9338 fi
9339 fi
9340 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9341 if test -n "$AR_FOR_TARGET"; then
9342   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9343 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9344 else
9345   echo "$as_me:$LINENO: result: no" >&5
9346 echo "${ECHO_T}no" >&6
9347 fi
9348
9349     fi
9350     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9351       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9352 set dummy ${ncn_progname}; ac_word=$2
9353 echo "$as_me:$LINENO: checking for $ac_word" >&5
9354 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9355 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9356   echo $ECHO_N "(cached) $ECHO_C" >&6
9357 else
9358   if test -n "$AR_FOR_TARGET"; then
9359   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9360 else
9361 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9362 for as_dir in $PATH
9363 do
9364   IFS=$as_save_IFS
9365   test -z "$as_dir" && as_dir=.
9366   for ac_exec_ext in '' $ac_executable_extensions; do
9367   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9368     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9369     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9370     break 2
9371   fi
9372 done
9373 done
9374
9375 fi
9376 fi
9377 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9378 if test -n "$AR_FOR_TARGET"; then
9379   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9380 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9381 else
9382   echo "$as_me:$LINENO: result: no" >&5
9383 echo "${ECHO_T}no" >&6
9384 fi
9385
9386     fi
9387     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9388   done
9389 fi
9390
9391 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9392   set dummy ar
9393   if test $build = $target ; then
9394     AR_FOR_TARGET="$2"
9395   else
9396     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9397   fi
9398 else
9399   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9400 fi
9401
9402 else
9403   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9404 fi
9405
9406
9407
9408
9409 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9410   if test -n "$with_build_time_tools"; then
9411     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9412 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9413     if test -x $with_build_time_tools/as; then
9414       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9415       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9416       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9417 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9418     else
9419       echo "$as_me:$LINENO: result: no" >&5
9420 echo "${ECHO_T}no" >&6
9421     fi
9422   elif test $build != $host && test $have_gcc_for_target = yes; then
9423     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9424     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9425     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9426   fi
9427 fi
9428 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9429   # Extract the first word of "as", so it can be a program name with args.
9430 set dummy as; ac_word=$2
9431 echo "$as_me:$LINENO: checking for $ac_word" >&5
9432 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9433 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9434   echo $ECHO_N "(cached) $ECHO_C" >&6
9435 else
9436   case $AS_FOR_TARGET in
9437   [\\/]* | ?:[\\/]*)
9438   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9439   ;;
9440   *)
9441   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9442 for as_dir in $gcc_cv_tool_dirs
9443 do
9444   IFS=$as_save_IFS
9445   test -z "$as_dir" && as_dir=.
9446   for ac_exec_ext in '' $ac_executable_extensions; do
9447   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9448     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9449     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9450     break 2
9451   fi
9452 done
9453 done
9454
9455   ;;
9456 esac
9457 fi
9458 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9459
9460 if test -n "$AS_FOR_TARGET"; then
9461   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9462 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9463 else
9464   echo "$as_me:$LINENO: result: no" >&5
9465 echo "${ECHO_T}no" >&6
9466 fi
9467
9468 fi
9469 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9470
9471
9472 if test -n "$AS_FOR_TARGET"; then
9473   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9474 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9475   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9476 fi
9477
9478 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9479   for ncn_progname in as; do
9480     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9481 set dummy ${ncn_progname}; ac_word=$2
9482 echo "$as_me:$LINENO: checking for $ac_word" >&5
9483 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9484 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9485   echo $ECHO_N "(cached) $ECHO_C" >&6
9486 else
9487   if test -n "$AS_FOR_TARGET"; then
9488   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9489 else
9490 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9491 for as_dir in $PATH
9492 do
9493   IFS=$as_save_IFS
9494   test -z "$as_dir" && as_dir=.
9495   for ac_exec_ext in '' $ac_executable_extensions; do
9496   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9497     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9498     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9499     break 2
9500   fi
9501 done
9502 done
9503
9504 fi
9505 fi
9506 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9507 if test -n "$AS_FOR_TARGET"; then
9508   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9509 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9510 else
9511   echo "$as_me:$LINENO: result: no" >&5
9512 echo "${ECHO_T}no" >&6
9513 fi
9514
9515   done
9516 fi
9517
9518 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9519   for ncn_progname in as; do
9520     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9521 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9522     if test -x $with_build_time_tools/${ncn_progname}; then
9523       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9524       echo "$as_me:$LINENO: result: yes" >&5
9525 echo "${ECHO_T}yes" >&6
9526       break
9527     else
9528       echo "$as_me:$LINENO: result: no" >&5
9529 echo "${ECHO_T}no" >&6
9530     fi
9531   done
9532 fi
9533
9534 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9535   for ncn_progname in as; do
9536     if test -n "$ncn_target_tool_prefix"; then
9537       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9538 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9539 echo "$as_me:$LINENO: checking for $ac_word" >&5
9540 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9541 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9542   echo $ECHO_N "(cached) $ECHO_C" >&6
9543 else
9544   if test -n "$AS_FOR_TARGET"; then
9545   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9546 else
9547 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9548 for as_dir in $PATH
9549 do
9550   IFS=$as_save_IFS
9551   test -z "$as_dir" && as_dir=.
9552   for ac_exec_ext in '' $ac_executable_extensions; do
9553   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9554     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9555     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9556     break 2
9557   fi
9558 done
9559 done
9560
9561 fi
9562 fi
9563 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9564 if test -n "$AS_FOR_TARGET"; then
9565   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9566 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9567 else
9568   echo "$as_me:$LINENO: result: no" >&5
9569 echo "${ECHO_T}no" >&6
9570 fi
9571
9572     fi
9573     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9574       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9575 set dummy ${ncn_progname}; ac_word=$2
9576 echo "$as_me:$LINENO: checking for $ac_word" >&5
9577 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9578 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9579   echo $ECHO_N "(cached) $ECHO_C" >&6
9580 else
9581   if test -n "$AS_FOR_TARGET"; then
9582   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9583 else
9584 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9585 for as_dir in $PATH
9586 do
9587   IFS=$as_save_IFS
9588   test -z "$as_dir" && as_dir=.
9589   for ac_exec_ext in '' $ac_executable_extensions; do
9590   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9591     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9592     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9593     break 2
9594   fi
9595 done
9596 done
9597
9598 fi
9599 fi
9600 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9601 if test -n "$AS_FOR_TARGET"; then
9602   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9603 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9604 else
9605   echo "$as_me:$LINENO: result: no" >&5
9606 echo "${ECHO_T}no" >&6
9607 fi
9608
9609     fi
9610     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9611   done
9612 fi
9613
9614 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9615   set dummy as
9616   if test $build = $target ; then
9617     AS_FOR_TARGET="$2"
9618   else
9619     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9620   fi
9621 else
9622   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9623 fi
9624
9625 else
9626   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9627 fi
9628
9629
9630
9631
9632 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9633   if test -n "$with_build_time_tools"; then
9634     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9635 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9636     if test -x $with_build_time_tools/dlltool; then
9637       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9638       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9639       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9640 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9641     else
9642       echo "$as_me:$LINENO: result: no" >&5
9643 echo "${ECHO_T}no" >&6
9644     fi
9645   elif test $build != $host && test $have_gcc_for_target = yes; then
9646     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9647     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9648     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9649   fi
9650 fi
9651 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9652   # Extract the first word of "dlltool", so it can be a program name with args.
9653 set dummy dlltool; ac_word=$2
9654 echo "$as_me:$LINENO: checking for $ac_word" >&5
9655 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9656 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9657   echo $ECHO_N "(cached) $ECHO_C" >&6
9658 else
9659   case $DLLTOOL_FOR_TARGET in
9660   [\\/]* | ?:[\\/]*)
9661   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9662   ;;
9663   *)
9664   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9665 for as_dir in $gcc_cv_tool_dirs
9666 do
9667   IFS=$as_save_IFS
9668   test -z "$as_dir" && as_dir=.
9669   for ac_exec_ext in '' $ac_executable_extensions; do
9670   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9671     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9672     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9673     break 2
9674   fi
9675 done
9676 done
9677
9678   ;;
9679 esac
9680 fi
9681 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9682
9683 if test -n "$DLLTOOL_FOR_TARGET"; then
9684   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9685 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9686 else
9687   echo "$as_me:$LINENO: result: no" >&5
9688 echo "${ECHO_T}no" >&6
9689 fi
9690
9691 fi
9692 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9693
9694
9695 if test -n "$DLLTOOL_FOR_TARGET"; then
9696   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9697 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9698   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9699 fi
9700
9701 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9702   for ncn_progname in dlltool; do
9703     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9704 set dummy ${ncn_progname}; ac_word=$2
9705 echo "$as_me:$LINENO: checking for $ac_word" >&5
9706 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9707 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9708   echo $ECHO_N "(cached) $ECHO_C" >&6
9709 else
9710   if test -n "$DLLTOOL_FOR_TARGET"; then
9711   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9712 else
9713 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9714 for as_dir in $PATH
9715 do
9716   IFS=$as_save_IFS
9717   test -z "$as_dir" && as_dir=.
9718   for ac_exec_ext in '' $ac_executable_extensions; do
9719   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9720     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9721     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9722     break 2
9723   fi
9724 done
9725 done
9726
9727 fi
9728 fi
9729 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9730 if test -n "$DLLTOOL_FOR_TARGET"; then
9731   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9732 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9733 else
9734   echo "$as_me:$LINENO: result: no" >&5
9735 echo "${ECHO_T}no" >&6
9736 fi
9737
9738   done
9739 fi
9740
9741 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9742   for ncn_progname in dlltool; do
9743     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9744 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9745     if test -x $with_build_time_tools/${ncn_progname}; then
9746       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9747       echo "$as_me:$LINENO: result: yes" >&5
9748 echo "${ECHO_T}yes" >&6
9749       break
9750     else
9751       echo "$as_me:$LINENO: result: no" >&5
9752 echo "${ECHO_T}no" >&6
9753     fi
9754   done
9755 fi
9756
9757 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9758   for ncn_progname in dlltool; do
9759     if test -n "$ncn_target_tool_prefix"; then
9760       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9761 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9762 echo "$as_me:$LINENO: checking for $ac_word" >&5
9763 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9764 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9765   echo $ECHO_N "(cached) $ECHO_C" >&6
9766 else
9767   if test -n "$DLLTOOL_FOR_TARGET"; then
9768   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9769 else
9770 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9771 for as_dir in $PATH
9772 do
9773   IFS=$as_save_IFS
9774   test -z "$as_dir" && as_dir=.
9775   for ac_exec_ext in '' $ac_executable_extensions; do
9776   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9777     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9778     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9779     break 2
9780   fi
9781 done
9782 done
9783
9784 fi
9785 fi
9786 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9787 if test -n "$DLLTOOL_FOR_TARGET"; then
9788   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9789 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9790 else
9791   echo "$as_me:$LINENO: result: no" >&5
9792 echo "${ECHO_T}no" >&6
9793 fi
9794
9795     fi
9796     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9797       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9798 set dummy ${ncn_progname}; ac_word=$2
9799 echo "$as_me:$LINENO: checking for $ac_word" >&5
9800 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9801 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9802   echo $ECHO_N "(cached) $ECHO_C" >&6
9803 else
9804   if test -n "$DLLTOOL_FOR_TARGET"; then
9805   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9806 else
9807 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9808 for as_dir in $PATH
9809 do
9810   IFS=$as_save_IFS
9811   test -z "$as_dir" && as_dir=.
9812   for ac_exec_ext in '' $ac_executable_extensions; do
9813   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9814     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9815     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9816     break 2
9817   fi
9818 done
9819 done
9820
9821 fi
9822 fi
9823 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9824 if test -n "$DLLTOOL_FOR_TARGET"; then
9825   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9826 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9827 else
9828   echo "$as_me:$LINENO: result: no" >&5
9829 echo "${ECHO_T}no" >&6
9830 fi
9831
9832     fi
9833     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9834   done
9835 fi
9836
9837 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9838   set dummy dlltool
9839   if test $build = $target ; then
9840     DLLTOOL_FOR_TARGET="$2"
9841   else
9842     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9843   fi
9844 else
9845   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9846 fi
9847
9848 else
9849   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9850 fi
9851
9852
9853
9854
9855 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9856   if test -n "$with_build_time_tools"; then
9857     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9858 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9859     if test -x $with_build_time_tools/ld; then
9860       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9861       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9862       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9863 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9864     else
9865       echo "$as_me:$LINENO: result: no" >&5
9866 echo "${ECHO_T}no" >&6
9867     fi
9868   elif test $build != $host && test $have_gcc_for_target = yes; then
9869     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9870     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9871     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9872   fi
9873 fi
9874 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9875   # Extract the first word of "ld", so it can be a program name with args.
9876 set dummy ld; ac_word=$2
9877 echo "$as_me:$LINENO: checking for $ac_word" >&5
9878 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9879 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9880   echo $ECHO_N "(cached) $ECHO_C" >&6
9881 else
9882   case $LD_FOR_TARGET in
9883   [\\/]* | ?:[\\/]*)
9884   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9885   ;;
9886   *)
9887   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9888 for as_dir in $gcc_cv_tool_dirs
9889 do
9890   IFS=$as_save_IFS
9891   test -z "$as_dir" && as_dir=.
9892   for ac_exec_ext in '' $ac_executable_extensions; do
9893   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9894     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9895     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9896     break 2
9897   fi
9898 done
9899 done
9900
9901   ;;
9902 esac
9903 fi
9904 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9905
9906 if test -n "$LD_FOR_TARGET"; then
9907   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9908 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9909 else
9910   echo "$as_me:$LINENO: result: no" >&5
9911 echo "${ECHO_T}no" >&6
9912 fi
9913
9914 fi
9915 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9916
9917
9918 if test -n "$LD_FOR_TARGET"; then
9919   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9920 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9921   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9922 fi
9923
9924 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9925   for ncn_progname in ld; do
9926     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9927 set dummy ${ncn_progname}; ac_word=$2
9928 echo "$as_me:$LINENO: checking for $ac_word" >&5
9929 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9930 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9931   echo $ECHO_N "(cached) $ECHO_C" >&6
9932 else
9933   if test -n "$LD_FOR_TARGET"; then
9934   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9935 else
9936 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9937 for as_dir in $PATH
9938 do
9939   IFS=$as_save_IFS
9940   test -z "$as_dir" && as_dir=.
9941   for ac_exec_ext in '' $ac_executable_extensions; do
9942   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9943     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9944     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9945     break 2
9946   fi
9947 done
9948 done
9949
9950 fi
9951 fi
9952 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9953 if test -n "$LD_FOR_TARGET"; then
9954   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9955 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9956 else
9957   echo "$as_me:$LINENO: result: no" >&5
9958 echo "${ECHO_T}no" >&6
9959 fi
9960
9961   done
9962 fi
9963
9964 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9965   for ncn_progname in ld; do
9966     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9967 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9968     if test -x $with_build_time_tools/${ncn_progname}; then
9969       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9970       echo "$as_me:$LINENO: result: yes" >&5
9971 echo "${ECHO_T}yes" >&6
9972       break
9973     else
9974       echo "$as_me:$LINENO: result: no" >&5
9975 echo "${ECHO_T}no" >&6
9976     fi
9977   done
9978 fi
9979
9980 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9981   for ncn_progname in ld; do
9982     if test -n "$ncn_target_tool_prefix"; then
9983       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9984 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9985 echo "$as_me:$LINENO: checking for $ac_word" >&5
9986 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9987 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9988   echo $ECHO_N "(cached) $ECHO_C" >&6
9989 else
9990   if test -n "$LD_FOR_TARGET"; then
9991   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9992 else
9993 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9994 for as_dir in $PATH
9995 do
9996   IFS=$as_save_IFS
9997   test -z "$as_dir" && as_dir=.
9998   for ac_exec_ext in '' $ac_executable_extensions; do
9999   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10000     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10001     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10002     break 2
10003   fi
10004 done
10005 done
10006
10007 fi
10008 fi
10009 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10010 if test -n "$LD_FOR_TARGET"; then
10011   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10012 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10013 else
10014   echo "$as_me:$LINENO: result: no" >&5
10015 echo "${ECHO_T}no" >&6
10016 fi
10017
10018     fi
10019     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10020       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10021 set dummy ${ncn_progname}; ac_word=$2
10022 echo "$as_me:$LINENO: checking for $ac_word" >&5
10023 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10024 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10025   echo $ECHO_N "(cached) $ECHO_C" >&6
10026 else
10027   if test -n "$LD_FOR_TARGET"; then
10028   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10029 else
10030 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10031 for as_dir in $PATH
10032 do
10033   IFS=$as_save_IFS
10034   test -z "$as_dir" && as_dir=.
10035   for ac_exec_ext in '' $ac_executable_extensions; do
10036   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10037     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10038     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10039     break 2
10040   fi
10041 done
10042 done
10043
10044 fi
10045 fi
10046 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10047 if test -n "$LD_FOR_TARGET"; then
10048   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10049 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10050 else
10051   echo "$as_me:$LINENO: result: no" >&5
10052 echo "${ECHO_T}no" >&6
10053 fi
10054
10055     fi
10056     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10057   done
10058 fi
10059
10060 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10061   set dummy ld
10062   if test $build = $target ; then
10063     LD_FOR_TARGET="$2"
10064   else
10065     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10066   fi
10067 else
10068   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10069 fi
10070
10071 else
10072   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10073 fi
10074
10075
10076
10077
10078 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10079   if test -n "$with_build_time_tools"; then
10080     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10081 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10082     if test -x $with_build_time_tools/lipo; then
10083       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10084       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10085       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10086 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10087     else
10088       echo "$as_me:$LINENO: result: no" >&5
10089 echo "${ECHO_T}no" >&6
10090     fi
10091   elif test $build != $host && test $have_gcc_for_target = yes; then
10092     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10093     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10094     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10095   fi
10096 fi
10097 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10098   # Extract the first word of "lipo", so it can be a program name with args.
10099 set dummy lipo; ac_word=$2
10100 echo "$as_me:$LINENO: checking for $ac_word" >&5
10101 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10102 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10103   echo $ECHO_N "(cached) $ECHO_C" >&6
10104 else
10105   case $LIPO_FOR_TARGET in
10106   [\\/]* | ?:[\\/]*)
10107   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10108   ;;
10109   *)
10110   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10111 for as_dir in $gcc_cv_tool_dirs
10112 do
10113   IFS=$as_save_IFS
10114   test -z "$as_dir" && as_dir=.
10115   for ac_exec_ext in '' $ac_executable_extensions; do
10116   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10117     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10118     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10119     break 2
10120   fi
10121 done
10122 done
10123
10124   ;;
10125 esac
10126 fi
10127 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10128
10129 if test -n "$LIPO_FOR_TARGET"; then
10130   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10131 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10132 else
10133   echo "$as_me:$LINENO: result: no" >&5
10134 echo "${ECHO_T}no" >&6
10135 fi
10136
10137 fi
10138 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10139
10140
10141 if test -n "$LIPO_FOR_TARGET"; then
10142   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10143 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10144   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10145 fi
10146
10147 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10148   for ncn_progname in lipo; do
10149     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10150 set dummy ${ncn_progname}; ac_word=$2
10151 echo "$as_me:$LINENO: checking for $ac_word" >&5
10152 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10153 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10154   echo $ECHO_N "(cached) $ECHO_C" >&6
10155 else
10156   if test -n "$LIPO_FOR_TARGET"; then
10157   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10158 else
10159 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10160 for as_dir in $PATH
10161 do
10162   IFS=$as_save_IFS
10163   test -z "$as_dir" && as_dir=.
10164   for ac_exec_ext in '' $ac_executable_extensions; do
10165   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10166     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10167     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10168     break 2
10169   fi
10170 done
10171 done
10172
10173 fi
10174 fi
10175 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10176 if test -n "$LIPO_FOR_TARGET"; then
10177   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10178 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10179 else
10180   echo "$as_me:$LINENO: result: no" >&5
10181 echo "${ECHO_T}no" >&6
10182 fi
10183
10184   done
10185 fi
10186
10187 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10188   for ncn_progname in lipo; do
10189     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10190 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10191     if test -x $with_build_time_tools/${ncn_progname}; then
10192       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10193       echo "$as_me:$LINENO: result: yes" >&5
10194 echo "${ECHO_T}yes" >&6
10195       break
10196     else
10197       echo "$as_me:$LINENO: result: no" >&5
10198 echo "${ECHO_T}no" >&6
10199     fi
10200   done
10201 fi
10202
10203 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10204   for ncn_progname in lipo; do
10205     if test -n "$ncn_target_tool_prefix"; then
10206       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10207 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10208 echo "$as_me:$LINENO: checking for $ac_word" >&5
10209 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10210 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10211   echo $ECHO_N "(cached) $ECHO_C" >&6
10212 else
10213   if test -n "$LIPO_FOR_TARGET"; then
10214   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10215 else
10216 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10217 for as_dir in $PATH
10218 do
10219   IFS=$as_save_IFS
10220   test -z "$as_dir" && as_dir=.
10221   for ac_exec_ext in '' $ac_executable_extensions; do
10222   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10223     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10224     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10225     break 2
10226   fi
10227 done
10228 done
10229
10230 fi
10231 fi
10232 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10233 if test -n "$LIPO_FOR_TARGET"; then
10234   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10235 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10236 else
10237   echo "$as_me:$LINENO: result: no" >&5
10238 echo "${ECHO_T}no" >&6
10239 fi
10240
10241     fi
10242     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10243       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10244 set dummy ${ncn_progname}; ac_word=$2
10245 echo "$as_me:$LINENO: checking for $ac_word" >&5
10246 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10247 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10248   echo $ECHO_N "(cached) $ECHO_C" >&6
10249 else
10250   if test -n "$LIPO_FOR_TARGET"; then
10251   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10252 else
10253 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10254 for as_dir in $PATH
10255 do
10256   IFS=$as_save_IFS
10257   test -z "$as_dir" && as_dir=.
10258   for ac_exec_ext in '' $ac_executable_extensions; do
10259   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10260     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10261     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10262     break 2
10263   fi
10264 done
10265 done
10266
10267 fi
10268 fi
10269 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10270 if test -n "$LIPO_FOR_TARGET"; then
10271   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10272 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10273 else
10274   echo "$as_me:$LINENO: result: no" >&5
10275 echo "${ECHO_T}no" >&6
10276 fi
10277
10278     fi
10279     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10280   done
10281 fi
10282
10283 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10284   set dummy lipo
10285   if test $build = $target ; then
10286     LIPO_FOR_TARGET="$2"
10287   else
10288     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10289   fi
10290 else
10291   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10292 fi
10293
10294 else
10295   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10296 fi
10297
10298
10299
10300
10301 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10302   if test -n "$with_build_time_tools"; then
10303     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10304 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10305     if test -x $with_build_time_tools/nm; then
10306       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10307       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10308       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10309 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10310     else
10311       echo "$as_me:$LINENO: result: no" >&5
10312 echo "${ECHO_T}no" >&6
10313     fi
10314   elif test $build != $host && test $have_gcc_for_target = yes; then
10315     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10316     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10317     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10318   fi
10319 fi
10320 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10321   # Extract the first word of "nm", so it can be a program name with args.
10322 set dummy nm; ac_word=$2
10323 echo "$as_me:$LINENO: checking for $ac_word" >&5
10324 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10325 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10326   echo $ECHO_N "(cached) $ECHO_C" >&6
10327 else
10328   case $NM_FOR_TARGET in
10329   [\\/]* | ?:[\\/]*)
10330   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10331   ;;
10332   *)
10333   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10334 for as_dir in $gcc_cv_tool_dirs
10335 do
10336   IFS=$as_save_IFS
10337   test -z "$as_dir" && as_dir=.
10338   for ac_exec_ext in '' $ac_executable_extensions; do
10339   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10340     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10341     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10342     break 2
10343   fi
10344 done
10345 done
10346
10347   ;;
10348 esac
10349 fi
10350 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10351
10352 if test -n "$NM_FOR_TARGET"; then
10353   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10354 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10355 else
10356   echo "$as_me:$LINENO: result: no" >&5
10357 echo "${ECHO_T}no" >&6
10358 fi
10359
10360 fi
10361 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10362
10363
10364 if test -n "$NM_FOR_TARGET"; then
10365   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10366 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10367   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10368 fi
10369
10370 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10371   for ncn_progname in nm; do
10372     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10373 set dummy ${ncn_progname}; ac_word=$2
10374 echo "$as_me:$LINENO: checking for $ac_word" >&5
10375 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10376 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10377   echo $ECHO_N "(cached) $ECHO_C" >&6
10378 else
10379   if test -n "$NM_FOR_TARGET"; then
10380   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10381 else
10382 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10383 for as_dir in $PATH
10384 do
10385   IFS=$as_save_IFS
10386   test -z "$as_dir" && as_dir=.
10387   for ac_exec_ext in '' $ac_executable_extensions; do
10388   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10389     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10390     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10391     break 2
10392   fi
10393 done
10394 done
10395
10396 fi
10397 fi
10398 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10399 if test -n "$NM_FOR_TARGET"; then
10400   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10401 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10402 else
10403   echo "$as_me:$LINENO: result: no" >&5
10404 echo "${ECHO_T}no" >&6
10405 fi
10406
10407   done
10408 fi
10409
10410 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10411   for ncn_progname in nm; do
10412     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10413 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10414     if test -x $with_build_time_tools/${ncn_progname}; then
10415       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10416       echo "$as_me:$LINENO: result: yes" >&5
10417 echo "${ECHO_T}yes" >&6
10418       break
10419     else
10420       echo "$as_me:$LINENO: result: no" >&5
10421 echo "${ECHO_T}no" >&6
10422     fi
10423   done
10424 fi
10425
10426 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10427   for ncn_progname in nm; do
10428     if test -n "$ncn_target_tool_prefix"; then
10429       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10430 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10431 echo "$as_me:$LINENO: checking for $ac_word" >&5
10432 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10433 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10434   echo $ECHO_N "(cached) $ECHO_C" >&6
10435 else
10436   if test -n "$NM_FOR_TARGET"; then
10437   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10438 else
10439 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10440 for as_dir in $PATH
10441 do
10442   IFS=$as_save_IFS
10443   test -z "$as_dir" && as_dir=.
10444   for ac_exec_ext in '' $ac_executable_extensions; do
10445   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10446     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10447     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10448     break 2
10449   fi
10450 done
10451 done
10452
10453 fi
10454 fi
10455 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10456 if test -n "$NM_FOR_TARGET"; then
10457   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10458 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10459 else
10460   echo "$as_me:$LINENO: result: no" >&5
10461 echo "${ECHO_T}no" >&6
10462 fi
10463
10464     fi
10465     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10466       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10467 set dummy ${ncn_progname}; ac_word=$2
10468 echo "$as_me:$LINENO: checking for $ac_word" >&5
10469 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10470 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10471   echo $ECHO_N "(cached) $ECHO_C" >&6
10472 else
10473   if test -n "$NM_FOR_TARGET"; then
10474   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10475 else
10476 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10477 for as_dir in $PATH
10478 do
10479   IFS=$as_save_IFS
10480   test -z "$as_dir" && as_dir=.
10481   for ac_exec_ext in '' $ac_executable_extensions; do
10482   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10483     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10484     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10485     break 2
10486   fi
10487 done
10488 done
10489
10490 fi
10491 fi
10492 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10493 if test -n "$NM_FOR_TARGET"; then
10494   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10495 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10496 else
10497   echo "$as_me:$LINENO: result: no" >&5
10498 echo "${ECHO_T}no" >&6
10499 fi
10500
10501     fi
10502     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10503   done
10504 fi
10505
10506 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10507   set dummy nm
10508   if test $build = $target ; then
10509     NM_FOR_TARGET="$2"
10510   else
10511     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10512   fi
10513 else
10514   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10515 fi
10516
10517 else
10518   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10519 fi
10520
10521
10522
10523
10524 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10525   if test -n "$with_build_time_tools"; then
10526     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10527 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10528     if test -x $with_build_time_tools/objdump; then
10529       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10530       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10531       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10532 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10533     else
10534       echo "$as_me:$LINENO: result: no" >&5
10535 echo "${ECHO_T}no" >&6
10536     fi
10537   elif test $build != $host && test $have_gcc_for_target = yes; then
10538     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10539     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10540     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10541   fi
10542 fi
10543 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10544   # Extract the first word of "objdump", so it can be a program name with args.
10545 set dummy objdump; ac_word=$2
10546 echo "$as_me:$LINENO: checking for $ac_word" >&5
10547 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10548 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10549   echo $ECHO_N "(cached) $ECHO_C" >&6
10550 else
10551   case $OBJDUMP_FOR_TARGET in
10552   [\\/]* | ?:[\\/]*)
10553   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10554   ;;
10555   *)
10556   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10557 for as_dir in $gcc_cv_tool_dirs
10558 do
10559   IFS=$as_save_IFS
10560   test -z "$as_dir" && as_dir=.
10561   for ac_exec_ext in '' $ac_executable_extensions; do
10562   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10563     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10564     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10565     break 2
10566   fi
10567 done
10568 done
10569
10570   ;;
10571 esac
10572 fi
10573 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10574
10575 if test -n "$OBJDUMP_FOR_TARGET"; then
10576   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10577 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10578 else
10579   echo "$as_me:$LINENO: result: no" >&5
10580 echo "${ECHO_T}no" >&6
10581 fi
10582
10583 fi
10584 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10585
10586
10587 if test -n "$OBJDUMP_FOR_TARGET"; then
10588   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10589 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10590   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10591 fi
10592
10593 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10594   for ncn_progname in objdump; do
10595     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10596 set dummy ${ncn_progname}; ac_word=$2
10597 echo "$as_me:$LINENO: checking for $ac_word" >&5
10598 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10599 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10600   echo $ECHO_N "(cached) $ECHO_C" >&6
10601 else
10602   if test -n "$OBJDUMP_FOR_TARGET"; then
10603   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10604 else
10605 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10606 for as_dir in $PATH
10607 do
10608   IFS=$as_save_IFS
10609   test -z "$as_dir" && as_dir=.
10610   for ac_exec_ext in '' $ac_executable_extensions; do
10611   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10612     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10613     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10614     break 2
10615   fi
10616 done
10617 done
10618
10619 fi
10620 fi
10621 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10622 if test -n "$OBJDUMP_FOR_TARGET"; then
10623   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10624 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10625 else
10626   echo "$as_me:$LINENO: result: no" >&5
10627 echo "${ECHO_T}no" >&6
10628 fi
10629
10630   done
10631 fi
10632
10633 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10634   for ncn_progname in objdump; do
10635     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10636 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10637     if test -x $with_build_time_tools/${ncn_progname}; then
10638       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10639       echo "$as_me:$LINENO: result: yes" >&5
10640 echo "${ECHO_T}yes" >&6
10641       break
10642     else
10643       echo "$as_me:$LINENO: result: no" >&5
10644 echo "${ECHO_T}no" >&6
10645     fi
10646   done
10647 fi
10648
10649 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10650   for ncn_progname in objdump; do
10651     if test -n "$ncn_target_tool_prefix"; then
10652       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10653 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10654 echo "$as_me:$LINENO: checking for $ac_word" >&5
10655 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10656 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10657   echo $ECHO_N "(cached) $ECHO_C" >&6
10658 else
10659   if test -n "$OBJDUMP_FOR_TARGET"; then
10660   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10661 else
10662 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10663 for as_dir in $PATH
10664 do
10665   IFS=$as_save_IFS
10666   test -z "$as_dir" && as_dir=.
10667   for ac_exec_ext in '' $ac_executable_extensions; do
10668   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10669     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10670     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10671     break 2
10672   fi
10673 done
10674 done
10675
10676 fi
10677 fi
10678 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10679 if test -n "$OBJDUMP_FOR_TARGET"; then
10680   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10681 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10682 else
10683   echo "$as_me:$LINENO: result: no" >&5
10684 echo "${ECHO_T}no" >&6
10685 fi
10686
10687     fi
10688     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10689       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10690 set dummy ${ncn_progname}; ac_word=$2
10691 echo "$as_me:$LINENO: checking for $ac_word" >&5
10692 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10693 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10694   echo $ECHO_N "(cached) $ECHO_C" >&6
10695 else
10696   if test -n "$OBJDUMP_FOR_TARGET"; then
10697   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10698 else
10699 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10700 for as_dir in $PATH
10701 do
10702   IFS=$as_save_IFS
10703   test -z "$as_dir" && as_dir=.
10704   for ac_exec_ext in '' $ac_executable_extensions; do
10705   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10706     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10707     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10708     break 2
10709   fi
10710 done
10711 done
10712
10713 fi
10714 fi
10715 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10716 if test -n "$OBJDUMP_FOR_TARGET"; then
10717   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10718 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10719 else
10720   echo "$as_me:$LINENO: result: no" >&5
10721 echo "${ECHO_T}no" >&6
10722 fi
10723
10724     fi
10725     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10726   done
10727 fi
10728
10729 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10730   set dummy objdump
10731   if test $build = $target ; then
10732     OBJDUMP_FOR_TARGET="$2"
10733   else
10734     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10735   fi
10736 else
10737   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10738 fi
10739
10740 else
10741   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10742 fi
10743
10744
10745
10746
10747 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10748   if test -n "$with_build_time_tools"; then
10749     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10750 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10751     if test -x $with_build_time_tools/ranlib; then
10752       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10753       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10754       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10755 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10756     else
10757       echo "$as_me:$LINENO: result: no" >&5
10758 echo "${ECHO_T}no" >&6
10759     fi
10760   elif test $build != $host && test $have_gcc_for_target = yes; then
10761     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10762     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10763     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10764   fi
10765 fi
10766 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10767   # Extract the first word of "ranlib", so it can be a program name with args.
10768 set dummy ranlib; ac_word=$2
10769 echo "$as_me:$LINENO: checking for $ac_word" >&5
10770 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10771 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10772   echo $ECHO_N "(cached) $ECHO_C" >&6
10773 else
10774   case $RANLIB_FOR_TARGET in
10775   [\\/]* | ?:[\\/]*)
10776   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10777   ;;
10778   *)
10779   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10780 for as_dir in $gcc_cv_tool_dirs
10781 do
10782   IFS=$as_save_IFS
10783   test -z "$as_dir" && as_dir=.
10784   for ac_exec_ext in '' $ac_executable_extensions; do
10785   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10786     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10787     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10788     break 2
10789   fi
10790 done
10791 done
10792
10793   ;;
10794 esac
10795 fi
10796 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10797
10798 if test -n "$RANLIB_FOR_TARGET"; then
10799   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10800 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10801 else
10802   echo "$as_me:$LINENO: result: no" >&5
10803 echo "${ECHO_T}no" >&6
10804 fi
10805
10806 fi
10807 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10808
10809
10810 if test -n "$RANLIB_FOR_TARGET"; then
10811   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10812 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10813   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10814 fi
10815
10816 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10817   for ncn_progname in ranlib; do
10818     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10819 set dummy ${ncn_progname}; ac_word=$2
10820 echo "$as_me:$LINENO: checking for $ac_word" >&5
10821 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10822 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10823   echo $ECHO_N "(cached) $ECHO_C" >&6
10824 else
10825   if test -n "$RANLIB_FOR_TARGET"; then
10826   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10827 else
10828 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10829 for as_dir in $PATH
10830 do
10831   IFS=$as_save_IFS
10832   test -z "$as_dir" && as_dir=.
10833   for ac_exec_ext in '' $ac_executable_extensions; do
10834   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10835     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10836     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10837     break 2
10838   fi
10839 done
10840 done
10841
10842 fi
10843 fi
10844 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10845 if test -n "$RANLIB_FOR_TARGET"; then
10846   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10847 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10848 else
10849   echo "$as_me:$LINENO: result: no" >&5
10850 echo "${ECHO_T}no" >&6
10851 fi
10852
10853   done
10854 fi
10855
10856 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10857   for ncn_progname in ranlib; do
10858     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10859 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10860     if test -x $with_build_time_tools/${ncn_progname}; then
10861       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10862       echo "$as_me:$LINENO: result: yes" >&5
10863 echo "${ECHO_T}yes" >&6
10864       break
10865     else
10866       echo "$as_me:$LINENO: result: no" >&5
10867 echo "${ECHO_T}no" >&6
10868     fi
10869   done
10870 fi
10871
10872 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10873   for ncn_progname in ranlib; do
10874     if test -n "$ncn_target_tool_prefix"; then
10875       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10876 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10877 echo "$as_me:$LINENO: checking for $ac_word" >&5
10878 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10879 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10880   echo $ECHO_N "(cached) $ECHO_C" >&6
10881 else
10882   if test -n "$RANLIB_FOR_TARGET"; then
10883   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10884 else
10885 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10886 for as_dir in $PATH
10887 do
10888   IFS=$as_save_IFS
10889   test -z "$as_dir" && as_dir=.
10890   for ac_exec_ext in '' $ac_executable_extensions; do
10891   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10892     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10893     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10894     break 2
10895   fi
10896 done
10897 done
10898
10899 fi
10900 fi
10901 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10902 if test -n "$RANLIB_FOR_TARGET"; then
10903   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10904 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10905 else
10906   echo "$as_me:$LINENO: result: no" >&5
10907 echo "${ECHO_T}no" >&6
10908 fi
10909
10910     fi
10911     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10912       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10913 set dummy ${ncn_progname}; ac_word=$2
10914 echo "$as_me:$LINENO: checking for $ac_word" >&5
10915 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10916 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10917   echo $ECHO_N "(cached) $ECHO_C" >&6
10918 else
10919   if test -n "$RANLIB_FOR_TARGET"; then
10920   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10921 else
10922 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10923 for as_dir in $PATH
10924 do
10925   IFS=$as_save_IFS
10926   test -z "$as_dir" && as_dir=.
10927   for ac_exec_ext in '' $ac_executable_extensions; do
10928   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10929     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10930     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10931     break 2
10932   fi
10933 done
10934 done
10935
10936 fi
10937 fi
10938 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10939 if test -n "$RANLIB_FOR_TARGET"; then
10940   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10941 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10942 else
10943   echo "$as_me:$LINENO: result: no" >&5
10944 echo "${ECHO_T}no" >&6
10945 fi
10946
10947     fi
10948     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10949   done
10950 fi
10951
10952 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10953   set dummy ranlib
10954   if test $build = $target ; then
10955     RANLIB_FOR_TARGET="$2"
10956   else
10957     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10958   fi
10959 else
10960   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10961 fi
10962
10963 else
10964   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10965 fi
10966
10967
10968
10969
10970 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10971   if test -n "$with_build_time_tools"; then
10972     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10973 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10974     if test -x $with_build_time_tools/strip; then
10975       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10976       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10977       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10978 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10979     else
10980       echo "$as_me:$LINENO: result: no" >&5
10981 echo "${ECHO_T}no" >&6
10982     fi
10983   elif test $build != $host && test $have_gcc_for_target = yes; then
10984     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10985     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10986     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10987   fi
10988 fi
10989 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10990   # Extract the first word of "strip", so it can be a program name with args.
10991 set dummy strip; ac_word=$2
10992 echo "$as_me:$LINENO: checking for $ac_word" >&5
10993 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10994 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10995   echo $ECHO_N "(cached) $ECHO_C" >&6
10996 else
10997   case $STRIP_FOR_TARGET in
10998   [\\/]* | ?:[\\/]*)
10999   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11000   ;;
11001   *)
11002   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11003 for as_dir in $gcc_cv_tool_dirs
11004 do
11005   IFS=$as_save_IFS
11006   test -z "$as_dir" && as_dir=.
11007   for ac_exec_ext in '' $ac_executable_extensions; do
11008   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11009     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11010     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11011     break 2
11012   fi
11013 done
11014 done
11015
11016   ;;
11017 esac
11018 fi
11019 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11020
11021 if test -n "$STRIP_FOR_TARGET"; then
11022   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11023 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11024 else
11025   echo "$as_me:$LINENO: result: no" >&5
11026 echo "${ECHO_T}no" >&6
11027 fi
11028
11029 fi
11030 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11031
11032
11033 if test -n "$STRIP_FOR_TARGET"; then
11034   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11035 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11036   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11037 fi
11038
11039 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11040   for ncn_progname in strip; do
11041     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11042 set dummy ${ncn_progname}; ac_word=$2
11043 echo "$as_me:$LINENO: checking for $ac_word" >&5
11044 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11045 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11046   echo $ECHO_N "(cached) $ECHO_C" >&6
11047 else
11048   if test -n "$STRIP_FOR_TARGET"; then
11049   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11050 else
11051 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11052 for as_dir in $PATH
11053 do
11054   IFS=$as_save_IFS
11055   test -z "$as_dir" && as_dir=.
11056   for ac_exec_ext in '' $ac_executable_extensions; do
11057   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11058     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11059     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11060     break 2
11061   fi
11062 done
11063 done
11064
11065 fi
11066 fi
11067 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11068 if test -n "$STRIP_FOR_TARGET"; then
11069   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11070 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11071 else
11072   echo "$as_me:$LINENO: result: no" >&5
11073 echo "${ECHO_T}no" >&6
11074 fi
11075
11076   done
11077 fi
11078
11079 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11080   for ncn_progname in strip; do
11081     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11082 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11083     if test -x $with_build_time_tools/${ncn_progname}; then
11084       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11085       echo "$as_me:$LINENO: result: yes" >&5
11086 echo "${ECHO_T}yes" >&6
11087       break
11088     else
11089       echo "$as_me:$LINENO: result: no" >&5
11090 echo "${ECHO_T}no" >&6
11091     fi
11092   done
11093 fi
11094
11095 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11096   for ncn_progname in strip; do
11097     if test -n "$ncn_target_tool_prefix"; then
11098       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11099 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11100 echo "$as_me:$LINENO: checking for $ac_word" >&5
11101 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11102 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11103   echo $ECHO_N "(cached) $ECHO_C" >&6
11104 else
11105   if test -n "$STRIP_FOR_TARGET"; then
11106   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11107 else
11108 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11109 for as_dir in $PATH
11110 do
11111   IFS=$as_save_IFS
11112   test -z "$as_dir" && as_dir=.
11113   for ac_exec_ext in '' $ac_executable_extensions; do
11114   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11115     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11116     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11117     break 2
11118   fi
11119 done
11120 done
11121
11122 fi
11123 fi
11124 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11125 if test -n "$STRIP_FOR_TARGET"; then
11126   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11127 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11128 else
11129   echo "$as_me:$LINENO: result: no" >&5
11130 echo "${ECHO_T}no" >&6
11131 fi
11132
11133     fi
11134     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11135       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11136 set dummy ${ncn_progname}; ac_word=$2
11137 echo "$as_me:$LINENO: checking for $ac_word" >&5
11138 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11139 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11140   echo $ECHO_N "(cached) $ECHO_C" >&6
11141 else
11142   if test -n "$STRIP_FOR_TARGET"; then
11143   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11144 else
11145 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11146 for as_dir in $PATH
11147 do
11148   IFS=$as_save_IFS
11149   test -z "$as_dir" && as_dir=.
11150   for ac_exec_ext in '' $ac_executable_extensions; do
11151   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11152     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11153     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11154     break 2
11155   fi
11156 done
11157 done
11158
11159 fi
11160 fi
11161 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11162 if test -n "$STRIP_FOR_TARGET"; then
11163   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11164 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11165 else
11166   echo "$as_me:$LINENO: result: no" >&5
11167 echo "${ECHO_T}no" >&6
11168 fi
11169
11170     fi
11171     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11172   done
11173 fi
11174
11175 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11176   set dummy strip
11177   if test $build = $target ; then
11178     STRIP_FOR_TARGET="$2"
11179   else
11180     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11181   fi
11182 else
11183   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11184 fi
11185
11186 else
11187   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11188 fi
11189
11190
11191
11192
11193 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11194   if test -n "$with_build_time_tools"; then
11195     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11196 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11197     if test -x $with_build_time_tools/windres; then
11198       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11199       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11200       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11201 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11202     else
11203       echo "$as_me:$LINENO: result: no" >&5
11204 echo "${ECHO_T}no" >&6
11205     fi
11206   elif test $build != $host && test $have_gcc_for_target = yes; then
11207     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11208     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11209     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11210   fi
11211 fi
11212 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11213   # Extract the first word of "windres", so it can be a program name with args.
11214 set dummy windres; ac_word=$2
11215 echo "$as_me:$LINENO: checking for $ac_word" >&5
11216 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11217 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11218   echo $ECHO_N "(cached) $ECHO_C" >&6
11219 else
11220   case $WINDRES_FOR_TARGET in
11221   [\\/]* | ?:[\\/]*)
11222   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11223   ;;
11224   *)
11225   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11226 for as_dir in $gcc_cv_tool_dirs
11227 do
11228   IFS=$as_save_IFS
11229   test -z "$as_dir" && as_dir=.
11230   for ac_exec_ext in '' $ac_executable_extensions; do
11231   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11232     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11233     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11234     break 2
11235   fi
11236 done
11237 done
11238
11239   ;;
11240 esac
11241 fi
11242 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11243
11244 if test -n "$WINDRES_FOR_TARGET"; then
11245   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11246 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11247 else
11248   echo "$as_me:$LINENO: result: no" >&5
11249 echo "${ECHO_T}no" >&6
11250 fi
11251
11252 fi
11253 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11254
11255
11256 if test -n "$WINDRES_FOR_TARGET"; then
11257   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11258 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11259   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11260 fi
11261
11262 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11263   for ncn_progname in windres; do
11264     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11265 set dummy ${ncn_progname}; ac_word=$2
11266 echo "$as_me:$LINENO: checking for $ac_word" >&5
11267 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11268 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11269   echo $ECHO_N "(cached) $ECHO_C" >&6
11270 else
11271   if test -n "$WINDRES_FOR_TARGET"; then
11272   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11273 else
11274 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11275 for as_dir in $PATH
11276 do
11277   IFS=$as_save_IFS
11278   test -z "$as_dir" && as_dir=.
11279   for ac_exec_ext in '' $ac_executable_extensions; do
11280   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11281     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11282     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11283     break 2
11284   fi
11285 done
11286 done
11287
11288 fi
11289 fi
11290 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11291 if test -n "$WINDRES_FOR_TARGET"; then
11292   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11293 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11294 else
11295   echo "$as_me:$LINENO: result: no" >&5
11296 echo "${ECHO_T}no" >&6
11297 fi
11298
11299   done
11300 fi
11301
11302 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11303   for ncn_progname in windres; do
11304     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11305 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11306     if test -x $with_build_time_tools/${ncn_progname}; then
11307       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11308       echo "$as_me:$LINENO: result: yes" >&5
11309 echo "${ECHO_T}yes" >&6
11310       break
11311     else
11312       echo "$as_me:$LINENO: result: no" >&5
11313 echo "${ECHO_T}no" >&6
11314     fi
11315   done
11316 fi
11317
11318 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11319   for ncn_progname in windres; do
11320     if test -n "$ncn_target_tool_prefix"; then
11321       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11322 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11323 echo "$as_me:$LINENO: checking for $ac_word" >&5
11324 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11325 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11326   echo $ECHO_N "(cached) $ECHO_C" >&6
11327 else
11328   if test -n "$WINDRES_FOR_TARGET"; then
11329   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11330 else
11331 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11332 for as_dir in $PATH
11333 do
11334   IFS=$as_save_IFS
11335   test -z "$as_dir" && as_dir=.
11336   for ac_exec_ext in '' $ac_executable_extensions; do
11337   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11338     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11339     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11340     break 2
11341   fi
11342 done
11343 done
11344
11345 fi
11346 fi
11347 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11348 if test -n "$WINDRES_FOR_TARGET"; then
11349   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11350 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11351 else
11352   echo "$as_me:$LINENO: result: no" >&5
11353 echo "${ECHO_T}no" >&6
11354 fi
11355
11356     fi
11357     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11358       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11359 set dummy ${ncn_progname}; ac_word=$2
11360 echo "$as_me:$LINENO: checking for $ac_word" >&5
11361 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11362 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11363   echo $ECHO_N "(cached) $ECHO_C" >&6
11364 else
11365   if test -n "$WINDRES_FOR_TARGET"; then
11366   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11367 else
11368 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11369 for as_dir in $PATH
11370 do
11371   IFS=$as_save_IFS
11372   test -z "$as_dir" && as_dir=.
11373   for ac_exec_ext in '' $ac_executable_extensions; do
11374   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11375     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11376     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11377     break 2
11378   fi
11379 done
11380 done
11381
11382 fi
11383 fi
11384 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11385 if test -n "$WINDRES_FOR_TARGET"; then
11386   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11387 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11388 else
11389   echo "$as_me:$LINENO: result: no" >&5
11390 echo "${ECHO_T}no" >&6
11391 fi
11392
11393     fi
11394     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11395   done
11396 fi
11397
11398 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11399   set dummy windres
11400   if test $build = $target ; then
11401     WINDRES_FOR_TARGET="$2"
11402   else
11403     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11404   fi
11405 else
11406   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11407 fi
11408
11409 else
11410   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11411 fi
11412
11413
11414
11415
11416 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11417   if test -n "$with_build_time_tools"; then
11418     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11419 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11420     if test -x $with_build_time_tools/windmc; then
11421       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11422       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11423       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11424 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11425     else
11426       echo "$as_me:$LINENO: result: no" >&5
11427 echo "${ECHO_T}no" >&6
11428     fi
11429   elif test $build != $host && test $have_gcc_for_target = yes; then
11430     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11431     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11432     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11433   fi
11434 fi
11435 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11436   # Extract the first word of "windmc", so it can be a program name with args.
11437 set dummy windmc; ac_word=$2
11438 echo "$as_me:$LINENO: checking for $ac_word" >&5
11439 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11440 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11441   echo $ECHO_N "(cached) $ECHO_C" >&6
11442 else
11443   case $WINDMC_FOR_TARGET in
11444   [\\/]* | ?:[\\/]*)
11445   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11446   ;;
11447   *)
11448   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11449 for as_dir in $gcc_cv_tool_dirs
11450 do
11451   IFS=$as_save_IFS
11452   test -z "$as_dir" && as_dir=.
11453   for ac_exec_ext in '' $ac_executable_extensions; do
11454   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11455     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11456     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11457     break 2
11458   fi
11459 done
11460 done
11461
11462   ;;
11463 esac
11464 fi
11465 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11466
11467 if test -n "$WINDMC_FOR_TARGET"; then
11468   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11469 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11470 else
11471   echo "$as_me:$LINENO: result: no" >&5
11472 echo "${ECHO_T}no" >&6
11473 fi
11474
11475 fi
11476 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11477
11478
11479 if test -n "$WINDMC_FOR_TARGET"; then
11480   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11481 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11482   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11483 fi
11484
11485 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11486   for ncn_progname in windmc; do
11487     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11488 set dummy ${ncn_progname}; ac_word=$2
11489 echo "$as_me:$LINENO: checking for $ac_word" >&5
11490 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11491 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11492   echo $ECHO_N "(cached) $ECHO_C" >&6
11493 else
11494   if test -n "$WINDMC_FOR_TARGET"; then
11495   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11496 else
11497 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11498 for as_dir in $PATH
11499 do
11500   IFS=$as_save_IFS
11501   test -z "$as_dir" && as_dir=.
11502   for ac_exec_ext in '' $ac_executable_extensions; do
11503   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11504     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11505     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11506     break 2
11507   fi
11508 done
11509 done
11510
11511 fi
11512 fi
11513 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11514 if test -n "$WINDMC_FOR_TARGET"; then
11515   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11516 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11517 else
11518   echo "$as_me:$LINENO: result: no" >&5
11519 echo "${ECHO_T}no" >&6
11520 fi
11521
11522   done
11523 fi
11524
11525 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11526   for ncn_progname in windmc; do
11527     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11528 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11529     if test -x $with_build_time_tools/${ncn_progname}; then
11530       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11531       echo "$as_me:$LINENO: result: yes" >&5
11532 echo "${ECHO_T}yes" >&6
11533       break
11534     else
11535       echo "$as_me:$LINENO: result: no" >&5
11536 echo "${ECHO_T}no" >&6
11537     fi
11538   done
11539 fi
11540
11541 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11542   for ncn_progname in windmc; do
11543     if test -n "$ncn_target_tool_prefix"; then
11544       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11545 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11546 echo "$as_me:$LINENO: checking for $ac_word" >&5
11547 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11548 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11549   echo $ECHO_N "(cached) $ECHO_C" >&6
11550 else
11551   if test -n "$WINDMC_FOR_TARGET"; then
11552   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11553 else
11554 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11555 for as_dir in $PATH
11556 do
11557   IFS=$as_save_IFS
11558   test -z "$as_dir" && as_dir=.
11559   for ac_exec_ext in '' $ac_executable_extensions; do
11560   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11561     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11562     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11563     break 2
11564   fi
11565 done
11566 done
11567
11568 fi
11569 fi
11570 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11571 if test -n "$WINDMC_FOR_TARGET"; then
11572   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11573 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11574 else
11575   echo "$as_me:$LINENO: result: no" >&5
11576 echo "${ECHO_T}no" >&6
11577 fi
11578
11579     fi
11580     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11581       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11582 set dummy ${ncn_progname}; ac_word=$2
11583 echo "$as_me:$LINENO: checking for $ac_word" >&5
11584 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11585 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11586   echo $ECHO_N "(cached) $ECHO_C" >&6
11587 else
11588   if test -n "$WINDMC_FOR_TARGET"; then
11589   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11590 else
11591 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11592 for as_dir in $PATH
11593 do
11594   IFS=$as_save_IFS
11595   test -z "$as_dir" && as_dir=.
11596   for ac_exec_ext in '' $ac_executable_extensions; do
11597   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11598     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11599     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11600     break 2
11601   fi
11602 done
11603 done
11604
11605 fi
11606 fi
11607 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11608 if test -n "$WINDMC_FOR_TARGET"; then
11609   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11610 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11611 else
11612   echo "$as_me:$LINENO: result: no" >&5
11613 echo "${ECHO_T}no" >&6
11614 fi
11615
11616     fi
11617     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11618   done
11619 fi
11620
11621 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11622   set dummy windmc
11623   if test $build = $target ; then
11624     WINDMC_FOR_TARGET="$2"
11625   else
11626     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11627   fi
11628 else
11629   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11630 fi
11631
11632 else
11633   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11634 fi
11635
11636
11637 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11638
11639 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11640 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11641 if test "x${build}" != "x${host}" ; then
11642   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11643     # We already found the complete path
11644     ac_dir=`dirname $AR_FOR_TARGET`
11645     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11646 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11647   else
11648     # Canadian cross, just use what we found
11649     echo "$as_me:$LINENO: result: pre-installed" >&5
11650 echo "${ECHO_T}pre-installed" >&6
11651   fi
11652 else
11653   ok=yes
11654   case " ${configdirs} " in
11655     *" binutils "*) ;;
11656     *) ok=no ;;
11657   esac
11658
11659   if test $ok = yes; then
11660     # An in-tree tool is available and we can use it
11661     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11662     echo "$as_me:$LINENO: result: just compiled" >&5
11663 echo "${ECHO_T}just compiled" >&6
11664   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11665     # We already found the complete path
11666     ac_dir=`dirname $AR_FOR_TARGET`
11667     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11668 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11669   elif test "x$target" = "x$host"; then
11670     # We can use an host tool
11671     AR_FOR_TARGET='$(AR)'
11672     echo "$as_me:$LINENO: result: host tool" >&5
11673 echo "${ECHO_T}host tool" >&6
11674   else
11675     # We need a cross tool
11676     echo "$as_me:$LINENO: result: pre-installed" >&5
11677 echo "${ECHO_T}pre-installed" >&6
11678   fi
11679 fi
11680
11681 echo "$as_me:$LINENO: checking where to find the target as" >&5
11682 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11683 if test "x${build}" != "x${host}" ; then
11684   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11685     # We already found the complete path
11686     ac_dir=`dirname $AS_FOR_TARGET`
11687     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11688 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11689   else
11690     # Canadian cross, just use what we found
11691     echo "$as_me:$LINENO: result: pre-installed" >&5
11692 echo "${ECHO_T}pre-installed" >&6
11693   fi
11694 else
11695   ok=yes
11696   case " ${configdirs} " in
11697     *" gas "*) ;;
11698     *) ok=no ;;
11699   esac
11700
11701   if test $ok = yes; then
11702     # An in-tree tool is available and we can use it
11703     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11704     echo "$as_me:$LINENO: result: just compiled" >&5
11705 echo "${ECHO_T}just compiled" >&6
11706   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11707     # We already found the complete path
11708     ac_dir=`dirname $AS_FOR_TARGET`
11709     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11710 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11711   elif test "x$target" = "x$host"; then
11712     # We can use an host tool
11713     AS_FOR_TARGET='$(AS)'
11714     echo "$as_me:$LINENO: result: host tool" >&5
11715 echo "${ECHO_T}host tool" >&6
11716   else
11717     # We need a cross tool
11718     echo "$as_me:$LINENO: result: pre-installed" >&5
11719 echo "${ECHO_T}pre-installed" >&6
11720   fi
11721 fi
11722
11723 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11724 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11725 if test "x${build}" != "x${host}" ; then
11726   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11727     # We already found the complete path
11728     ac_dir=`dirname $CC_FOR_TARGET`
11729     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11730 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11731   else
11732     # Canadian cross, just use what we found
11733     echo "$as_me:$LINENO: result: pre-installed" >&5
11734 echo "${ECHO_T}pre-installed" >&6
11735   fi
11736 else
11737   ok=yes
11738   case " ${configdirs} " in
11739     *" gcc "*) ;;
11740     *) ok=no ;;
11741   esac
11742
11743   if test $ok = yes; then
11744     # An in-tree tool is available and we can use it
11745     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11746     echo "$as_me:$LINENO: result: just compiled" >&5
11747 echo "${ECHO_T}just compiled" >&6
11748   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11749     # We already found the complete path
11750     ac_dir=`dirname $CC_FOR_TARGET`
11751     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11752 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11753   elif test "x$target" = "x$host"; then
11754     # We can use an host tool
11755     CC_FOR_TARGET='$(CC)'
11756     echo "$as_me:$LINENO: result: host tool" >&5
11757 echo "${ECHO_T}host tool" >&6
11758   else
11759     # We need a cross tool
11760     echo "$as_me:$LINENO: result: pre-installed" >&5
11761 echo "${ECHO_T}pre-installed" >&6
11762   fi
11763 fi
11764
11765 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11766 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11767 if test "x${build}" != "x${host}" ; then
11768   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11769     # We already found the complete path
11770     ac_dir=`dirname $CXX_FOR_TARGET`
11771     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11772 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11773   else
11774     # Canadian cross, just use what we found
11775     echo "$as_me:$LINENO: result: pre-installed" >&5
11776 echo "${ECHO_T}pre-installed" >&6
11777   fi
11778 else
11779   ok=yes
11780   case " ${configdirs} " in
11781     *" gcc "*) ;;
11782     *) ok=no ;;
11783   esac
11784   case ,${enable_languages}, in
11785     *,c++,*) ;;
11786     *) ok=no ;;
11787   esac
11788   if test $ok = yes; then
11789     # An in-tree tool is available and we can use it
11790     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'
11791     echo "$as_me:$LINENO: result: just compiled" >&5
11792 echo "${ECHO_T}just compiled" >&6
11793   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11794     # We already found the complete path
11795     ac_dir=`dirname $CXX_FOR_TARGET`
11796     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11797 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11798   elif test "x$target" = "x$host"; then
11799     # We can use an host tool
11800     CXX_FOR_TARGET='$(CXX)'
11801     echo "$as_me:$LINENO: result: host tool" >&5
11802 echo "${ECHO_T}host tool" >&6
11803   else
11804     # We need a cross tool
11805     echo "$as_me:$LINENO: result: pre-installed" >&5
11806 echo "${ECHO_T}pre-installed" >&6
11807   fi
11808 fi
11809
11810 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11811 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11812 if test "x${build}" != "x${host}" ; then
11813   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11814     # We already found the complete path
11815     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11816     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11817 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11818   else
11819     # Canadian cross, just use what we found
11820     echo "$as_me:$LINENO: result: pre-installed" >&5
11821 echo "${ECHO_T}pre-installed" >&6
11822   fi
11823 else
11824   ok=yes
11825   case " ${configdirs} " in
11826     *" gcc "*) ;;
11827     *) ok=no ;;
11828   esac
11829   case ,${enable_languages}, in
11830     *,c++,*) ;;
11831     *) ok=no ;;
11832   esac
11833   if test $ok = yes; then
11834     # An in-tree tool is available and we can use it
11835     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'
11836     echo "$as_me:$LINENO: result: just compiled" >&5
11837 echo "${ECHO_T}just compiled" >&6
11838   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11839     # We already found the complete path
11840     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11841     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11842 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11843   elif test "x$target" = "x$host"; then
11844     # We can use an host tool
11845     RAW_CXX_FOR_TARGET='$(CXX)'
11846     echo "$as_me:$LINENO: result: host tool" >&5
11847 echo "${ECHO_T}host tool" >&6
11848   else
11849     # We need a cross tool
11850     echo "$as_me:$LINENO: result: pre-installed" >&5
11851 echo "${ECHO_T}pre-installed" >&6
11852   fi
11853 fi
11854
11855 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11856 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11857 if test "x${build}" != "x${host}" ; then
11858   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11859     # We already found the complete path
11860     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11861     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11862 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11863   else
11864     # Canadian cross, just use what we found
11865     echo "$as_me:$LINENO: result: pre-installed" >&5
11866 echo "${ECHO_T}pre-installed" >&6
11867   fi
11868 else
11869   ok=yes
11870   case " ${configdirs} " in
11871     *" binutils "*) ;;
11872     *) ok=no ;;
11873   esac
11874
11875   if test $ok = yes; then
11876     # An in-tree tool is available and we can use it
11877     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11878     echo "$as_me:$LINENO: result: just compiled" >&5
11879 echo "${ECHO_T}just compiled" >&6
11880   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11881     # We already found the complete path
11882     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11883     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11884 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11885   elif test "x$target" = "x$host"; then
11886     # We can use an host tool
11887     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11888     echo "$as_me:$LINENO: result: host tool" >&5
11889 echo "${ECHO_T}host tool" >&6
11890   else
11891     # We need a cross tool
11892     echo "$as_me:$LINENO: result: pre-installed" >&5
11893 echo "${ECHO_T}pre-installed" >&6
11894   fi
11895 fi
11896
11897 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11898 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11899 if test "x${build}" != "x${host}" ; then
11900   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11901     # We already found the complete path
11902     ac_dir=`dirname $GCC_FOR_TARGET`
11903     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11904 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11905   else
11906     # Canadian cross, just use what we found
11907     echo "$as_me:$LINENO: result: pre-installed" >&5
11908 echo "${ECHO_T}pre-installed" >&6
11909   fi
11910 else
11911   ok=yes
11912   case " ${configdirs} " in
11913     *" gcc "*) ;;
11914     *) ok=no ;;
11915   esac
11916
11917   if test $ok = yes; then
11918     # An in-tree tool is available and we can use it
11919     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11920     echo "$as_me:$LINENO: result: just compiled" >&5
11921 echo "${ECHO_T}just compiled" >&6
11922   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11923     # We already found the complete path
11924     ac_dir=`dirname $GCC_FOR_TARGET`
11925     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11926 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11927   elif test "x$target" = "x$host"; then
11928     # We can use an host tool
11929     GCC_FOR_TARGET='$()'
11930     echo "$as_me:$LINENO: result: host tool" >&5
11931 echo "${ECHO_T}host tool" >&6
11932   else
11933     # We need a cross tool
11934     echo "$as_me:$LINENO: result: pre-installed" >&5
11935 echo "${ECHO_T}pre-installed" >&6
11936   fi
11937 fi
11938
11939 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11940 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11941 if test "x${build}" != "x${host}" ; then
11942   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11943     # We already found the complete path
11944     ac_dir=`dirname $GCJ_FOR_TARGET`
11945     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11946 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11947   else
11948     # Canadian cross, just use what we found
11949     echo "$as_me:$LINENO: result: pre-installed" >&5
11950 echo "${ECHO_T}pre-installed" >&6
11951   fi
11952 else
11953   ok=yes
11954   case " ${configdirs} " in
11955     *" gcc "*) ;;
11956     *) ok=no ;;
11957   esac
11958   case ,${enable_languages}, in
11959     *,java,*) ;;
11960     *) ok=no ;;
11961   esac
11962   if test $ok = yes; then
11963     # An in-tree tool is available and we can use it
11964     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11965     echo "$as_me:$LINENO: result: just compiled" >&5
11966 echo "${ECHO_T}just compiled" >&6
11967   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11968     # We already found the complete path
11969     ac_dir=`dirname $GCJ_FOR_TARGET`
11970     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11971 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11972   elif test "x$target" = "x$host"; then
11973     # We can use an host tool
11974     GCJ_FOR_TARGET='$(GCJ)'
11975     echo "$as_me:$LINENO: result: host tool" >&5
11976 echo "${ECHO_T}host tool" >&6
11977   else
11978     # We need a cross tool
11979     echo "$as_me:$LINENO: result: pre-installed" >&5
11980 echo "${ECHO_T}pre-installed" >&6
11981   fi
11982 fi
11983
11984 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11985 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11986 if test "x${build}" != "x${host}" ; then
11987   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11988     # We already found the complete path
11989     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11990     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11991 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11992   else
11993     # Canadian cross, just use what we found
11994     echo "$as_me:$LINENO: result: pre-installed" >&5
11995 echo "${ECHO_T}pre-installed" >&6
11996   fi
11997 else
11998   ok=yes
11999   case " ${configdirs} " in
12000     *" gcc "*) ;;
12001     *) ok=no ;;
12002   esac
12003   case ,${enable_languages}, in
12004     *,fortran,*) ;;
12005     *) ok=no ;;
12006   esac
12007   if test $ok = yes; then
12008     # An in-tree tool is available and we can use it
12009     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12010     echo "$as_me:$LINENO: result: just compiled" >&5
12011 echo "${ECHO_T}just compiled" >&6
12012   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12013     # We already found the complete path
12014     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12015     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12016 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12017   elif test "x$target" = "x$host"; then
12018     # We can use an host tool
12019     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12020     echo "$as_me:$LINENO: result: host tool" >&5
12021 echo "${ECHO_T}host tool" >&6
12022   else
12023     # We need a cross tool
12024     echo "$as_me:$LINENO: result: pre-installed" >&5
12025 echo "${ECHO_T}pre-installed" >&6
12026   fi
12027 fi
12028
12029 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12030 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12031 if test "x${build}" != "x${host}" ; then
12032   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12033     # We already found the complete path
12034     ac_dir=`dirname $LD_FOR_TARGET`
12035     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12036 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12037   else
12038     # Canadian cross, just use what we found
12039     echo "$as_me:$LINENO: result: pre-installed" >&5
12040 echo "${ECHO_T}pre-installed" >&6
12041   fi
12042 else
12043   ok=yes
12044   case " ${configdirs} " in
12045     *" ld "*) ;;
12046     *) ok=no ;;
12047   esac
12048
12049   if test $ok = yes; then
12050     # An in-tree tool is available and we can use it
12051     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12052     echo "$as_me:$LINENO: result: just compiled" >&5
12053 echo "${ECHO_T}just compiled" >&6
12054   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12055     # We already found the complete path
12056     ac_dir=`dirname $LD_FOR_TARGET`
12057     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12058 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12059   elif test "x$target" = "x$host"; then
12060     # We can use an host tool
12061     LD_FOR_TARGET='$(LD)'
12062     echo "$as_me:$LINENO: result: host tool" >&5
12063 echo "${ECHO_T}host tool" >&6
12064   else
12065     # We need a cross tool
12066     echo "$as_me:$LINENO: result: pre-installed" >&5
12067 echo "${ECHO_T}pre-installed" >&6
12068   fi
12069 fi
12070
12071 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12072 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12073 if test "x${build}" != "x${host}" ; then
12074   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12075     # We already found the complete path
12076     ac_dir=`dirname $LIPO_FOR_TARGET`
12077     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12078 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12079   else
12080     # Canadian cross, just use what we found
12081     echo "$as_me:$LINENO: result: pre-installed" >&5
12082 echo "${ECHO_T}pre-installed" >&6
12083   fi
12084 else
12085   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12086     # We already found the complete path
12087     ac_dir=`dirname $LIPO_FOR_TARGET`
12088     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12089 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12090   elif test "x$target" = "x$host"; then
12091     # We can use an host tool
12092     LIPO_FOR_TARGET='$(LIPO)'
12093     echo "$as_me:$LINENO: result: host tool" >&5
12094 echo "${ECHO_T}host tool" >&6
12095   else
12096     # We need a cross tool
12097     echo "$as_me:$LINENO: result: pre-installed" >&5
12098 echo "${ECHO_T}pre-installed" >&6
12099   fi
12100 fi
12101
12102 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12103 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12104 if test "x${build}" != "x${host}" ; then
12105   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12106     # We already found the complete path
12107     ac_dir=`dirname $NM_FOR_TARGET`
12108     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12109 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12110   else
12111     # Canadian cross, just use what we found
12112     echo "$as_me:$LINENO: result: pre-installed" >&5
12113 echo "${ECHO_T}pre-installed" >&6
12114   fi
12115 else
12116   ok=yes
12117   case " ${configdirs} " in
12118     *" binutils "*) ;;
12119     *) ok=no ;;
12120   esac
12121
12122   if test $ok = yes; then
12123     # An in-tree tool is available and we can use it
12124     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12125     echo "$as_me:$LINENO: result: just compiled" >&5
12126 echo "${ECHO_T}just compiled" >&6
12127   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12128     # We already found the complete path
12129     ac_dir=`dirname $NM_FOR_TARGET`
12130     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12131 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12132   elif test "x$target" = "x$host"; then
12133     # We can use an host tool
12134     NM_FOR_TARGET='$(NM)'
12135     echo "$as_me:$LINENO: result: host tool" >&5
12136 echo "${ECHO_T}host tool" >&6
12137   else
12138     # We need a cross tool
12139     echo "$as_me:$LINENO: result: pre-installed" >&5
12140 echo "${ECHO_T}pre-installed" >&6
12141   fi
12142 fi
12143
12144 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12145 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12146 if test "x${build}" != "x${host}" ; then
12147   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12148     # We already found the complete path
12149     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12150     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12151 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12152   else
12153     # Canadian cross, just use what we found
12154     echo "$as_me:$LINENO: result: pre-installed" >&5
12155 echo "${ECHO_T}pre-installed" >&6
12156   fi
12157 else
12158   ok=yes
12159   case " ${configdirs} " in
12160     *" binutils "*) ;;
12161     *) ok=no ;;
12162   esac
12163
12164   if test $ok = yes; then
12165     # An in-tree tool is available and we can use it
12166     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12167     echo "$as_me:$LINENO: result: just compiled" >&5
12168 echo "${ECHO_T}just compiled" >&6
12169   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12170     # We already found the complete path
12171     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12172     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12173 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12174   elif test "x$target" = "x$host"; then
12175     # We can use an host tool
12176     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12177     echo "$as_me:$LINENO: result: host tool" >&5
12178 echo "${ECHO_T}host tool" >&6
12179   else
12180     # We need a cross tool
12181     echo "$as_me:$LINENO: result: pre-installed" >&5
12182 echo "${ECHO_T}pre-installed" >&6
12183   fi
12184 fi
12185
12186 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12187 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12188 if test "x${build}" != "x${host}" ; then
12189   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12190     # We already found the complete path
12191     ac_dir=`dirname $RANLIB_FOR_TARGET`
12192     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12193 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12194   else
12195     # Canadian cross, just use what we found
12196     echo "$as_me:$LINENO: result: pre-installed" >&5
12197 echo "${ECHO_T}pre-installed" >&6
12198   fi
12199 else
12200   ok=yes
12201   case " ${configdirs} " in
12202     *" binutils "*) ;;
12203     *) ok=no ;;
12204   esac
12205
12206   if test $ok = yes; then
12207     # An in-tree tool is available and we can use it
12208     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12209     echo "$as_me:$LINENO: result: just compiled" >&5
12210 echo "${ECHO_T}just compiled" >&6
12211   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12212     # We already found the complete path
12213     ac_dir=`dirname $RANLIB_FOR_TARGET`
12214     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12215 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12216   elif test "x$target" = "x$host"; then
12217     # We can use an host tool
12218     RANLIB_FOR_TARGET='$(RANLIB)'
12219     echo "$as_me:$LINENO: result: host tool" >&5
12220 echo "${ECHO_T}host tool" >&6
12221   else
12222     # We need a cross tool
12223     echo "$as_me:$LINENO: result: pre-installed" >&5
12224 echo "${ECHO_T}pre-installed" >&6
12225   fi
12226 fi
12227
12228 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12229 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12230 if test "x${build}" != "x${host}" ; then
12231   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12232     # We already found the complete path
12233     ac_dir=`dirname $STRIP_FOR_TARGET`
12234     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12235 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12236   else
12237     # Canadian cross, just use what we found
12238     echo "$as_me:$LINENO: result: pre-installed" >&5
12239 echo "${ECHO_T}pre-installed" >&6
12240   fi
12241 else
12242   ok=yes
12243   case " ${configdirs} " in
12244     *" binutils "*) ;;
12245     *) ok=no ;;
12246   esac
12247
12248   if test $ok = yes; then
12249     # An in-tree tool is available and we can use it
12250     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12251     echo "$as_me:$LINENO: result: just compiled" >&5
12252 echo "${ECHO_T}just compiled" >&6
12253   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12254     # We already found the complete path
12255     ac_dir=`dirname $STRIP_FOR_TARGET`
12256     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12257 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12258   elif test "x$target" = "x$host"; then
12259     # We can use an host tool
12260     STRIP_FOR_TARGET='$(STRIP)'
12261     echo "$as_me:$LINENO: result: host tool" >&5
12262 echo "${ECHO_T}host tool" >&6
12263   else
12264     # We need a cross tool
12265     echo "$as_me:$LINENO: result: pre-installed" >&5
12266 echo "${ECHO_T}pre-installed" >&6
12267   fi
12268 fi
12269
12270 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12271 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12272 if test "x${build}" != "x${host}" ; then
12273   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12274     # We already found the complete path
12275     ac_dir=`dirname $WINDRES_FOR_TARGET`
12276     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12277 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12278   else
12279     # Canadian cross, just use what we found
12280     echo "$as_me:$LINENO: result: pre-installed" >&5
12281 echo "${ECHO_T}pre-installed" >&6
12282   fi
12283 else
12284   ok=yes
12285   case " ${configdirs} " in
12286     *" binutils "*) ;;
12287     *) ok=no ;;
12288   esac
12289
12290   if test $ok = yes; then
12291     # An in-tree tool is available and we can use it
12292     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12293     echo "$as_me:$LINENO: result: just compiled" >&5
12294 echo "${ECHO_T}just compiled" >&6
12295   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12296     # We already found the complete path
12297     ac_dir=`dirname $WINDRES_FOR_TARGET`
12298     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12299 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12300   elif test "x$target" = "x$host"; then
12301     # We can use an host tool
12302     WINDRES_FOR_TARGET='$(WINDRES)'
12303     echo "$as_me:$LINENO: result: host tool" >&5
12304 echo "${ECHO_T}host tool" >&6
12305   else
12306     # We need a cross tool
12307     echo "$as_me:$LINENO: result: pre-installed" >&5
12308 echo "${ECHO_T}pre-installed" >&6
12309   fi
12310 fi
12311
12312 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12313 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12314 if test "x${build}" != "x${host}" ; then
12315   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12316     # We already found the complete path
12317     ac_dir=`dirname $WINDMC_FOR_TARGET`
12318     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12319 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12320   else
12321     # Canadian cross, just use what we found
12322     echo "$as_me:$LINENO: result: pre-installed" >&5
12323 echo "${ECHO_T}pre-installed" >&6
12324   fi
12325 else
12326   ok=yes
12327   case " ${configdirs} " in
12328     *" binutils "*) ;;
12329     *) ok=no ;;
12330   esac
12331
12332   if test $ok = yes; then
12333     # An in-tree tool is available and we can use it
12334     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12335     echo "$as_me:$LINENO: result: just compiled" >&5
12336 echo "${ECHO_T}just compiled" >&6
12337   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12338     # We already found the complete path
12339     ac_dir=`dirname $WINDMC_FOR_TARGET`
12340     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12341 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12342   elif test "x$target" = "x$host"; then
12343     # We can use an host tool
12344     WINDMC_FOR_TARGET='$(WINDMC)'
12345     echo "$as_me:$LINENO: result: host tool" >&5
12346 echo "${ECHO_T}host tool" >&6
12347   else
12348     # We need a cross tool
12349     echo "$as_me:$LINENO: result: pre-installed" >&5
12350 echo "${ECHO_T}pre-installed" >&6
12351   fi
12352 fi
12353
12354
12355
12356
12357
12358 # Certain tools may need extra flags.
12359 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12360 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12361 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12362
12363 # When building target libraries, except in a Canadian cross, we use
12364 # the same toolchain as the compiler we just built.
12365 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12366 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12367 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12368 if test $host = $build; then
12369   case " $configdirs " in
12370     *" gcc "*)
12371       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12372       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12373       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12374       ;;
12375   esac
12376 fi
12377
12378
12379
12380
12381
12382 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12383 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12384 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12385 if test "${enable_maintainer_mode+set}" = set; then
12386   enableval="$enable_maintainer_mode"
12387   USE_MAINTAINER_MODE=$enableval
12388 else
12389   USE_MAINTAINER_MODE=no
12390 fi;
12391 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12392 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12393
12394
12395 if test "$USE_MAINTAINER_MODE" = yes; then
12396   MAINTAINER_MODE_TRUE=
12397   MAINTAINER_MODE_FALSE='#'
12398 else
12399   MAINTAINER_MODE_TRUE='#'
12400   MAINTAINER_MODE_FALSE=
12401 fi
12402 MAINT=$MAINTAINER_MODE_TRUE
12403
12404 # ---------------------
12405 # GCC bootstrap support
12406 # ---------------------
12407
12408 # Stage specific cflags for build.
12409 stage1_cflags="-g"
12410 case $build in
12411   vax-*-*)
12412     case ${GCC} in
12413       yes) stage1_cflags="-g -Wa,-J" ;;
12414       *) stage1_cflags="-g -J" ;;
12415     esac ;;
12416 esac
12417
12418 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12419 if test "$GCC" = yes; then
12420   saved_CFLAGS="$CFLAGS"
12421
12422   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12423   CFLAGS="$CFLAGS -fkeep-inline-functions"
12424   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12425 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12426   cat >conftest.$ac_ext <<_ACEOF
12427 /* confdefs.h.  */
12428 _ACEOF
12429 cat confdefs.h >>conftest.$ac_ext
12430 cat >>conftest.$ac_ext <<_ACEOF
12431 /* end confdefs.h.  */
12432
12433 #if (__GNUC__ < 3) \
12434     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12435                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12436 #error http://gcc.gnu.org/PR29382
12437 #endif
12438
12439 int
12440 main ()
12441 {
12442
12443   ;
12444   return 0;
12445 }
12446 _ACEOF
12447 rm -f conftest.$ac_objext
12448 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12449   (eval $ac_compile) 2>conftest.er1
12450   ac_status=$?
12451   grep -v '^ *+' conftest.er1 >conftest.err
12452   rm -f conftest.er1
12453   cat conftest.err >&5
12454   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12455   (exit $ac_status); } &&
12456          { ac_try='test -z "$ac_c_werror_flag"
12457                          || test ! -s conftest.err'
12458   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12459   (eval $ac_try) 2>&5
12460   ac_status=$?
12461   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12462   (exit $ac_status); }; } &&
12463          { ac_try='test -s conftest.$ac_objext'
12464   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12465   (eval $ac_try) 2>&5
12466   ac_status=$?
12467   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12468   (exit $ac_status); }; }; then
12469   echo "$as_me:$LINENO: result: yes" >&5
12470 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12471 else
12472   echo "$as_me: failed program was:" >&5
12473 sed 's/^/| /' conftest.$ac_ext >&5
12474
12475 echo "$as_me:$LINENO: result: no" >&5
12476 echo "${ECHO_T}no" >&6
12477 fi
12478 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12479
12480   CFLAGS="$saved_CFLAGS"
12481 fi
12482
12483
12484
12485 # Enable --enable-checking in stage1 of the compiler.
12486 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12487 if test "${enable_stage1_checking+set}" = set; then
12488   enableval="$enable_stage1_checking"
12489   stage1_checking=--enable-checking=${enable_stage1_checking}
12490 else
12491   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12492   stage1_checking=--enable-checking=yes,types
12493 else
12494   stage1_checking=--enable-checking=$enable_checking,types
12495 fi
12496 fi;
12497
12498
12499 # Enable -Werror in bootstrap stage2 and later.
12500 # Check whether --enable-werror or --disable-werror was given.
12501 if test "${enable_werror+set}" = set; then
12502   enableval="$enable_werror"
12503
12504 else
12505   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12506   enable_werror=yes
12507 else
12508   enable_werror=no
12509 fi
12510 fi;
12511 case ${enable_werror} in
12512   yes) stage2_werror_flag="--enable-werror-always" ;;
12513   *) stage2_werror_flag="" ;;
12514 esac
12515
12516
12517 # Flags needed to enable html installing and building
12518
12519 # Check whether --with-datarootdir or --without-datarootdir was given.
12520 if test "${with_datarootdir+set}" = set; then
12521   withval="$with_datarootdir"
12522   datarootdir="\${prefix}/${withval}"
12523 else
12524   datarootdir="\${prefix}/share"
12525 fi;
12526
12527
12528 # Check whether --with-docdir or --without-docdir was given.
12529 if test "${with_docdir+set}" = set; then
12530   withval="$with_docdir"
12531   docdir="\${prefix}/${withval}"
12532 else
12533   docdir="\${datarootdir}/doc"
12534 fi;
12535
12536
12537 # Check whether --with-pdfdir or --without-pdfdir was given.
12538 if test "${with_pdfdir+set}" = set; then
12539   withval="$with_pdfdir"
12540   pdfdir="\${prefix}/${withval}"
12541 else
12542   pdfdir="\${docdir}"
12543 fi;
12544
12545
12546 # Check whether --with-htmldir or --without-htmldir was given.
12547 if test "${with_htmldir+set}" = set; then
12548   withval="$with_htmldir"
12549   htmldir="\${prefix}/${withval}"
12550 else
12551   htmldir="\${docdir}"
12552 fi;
12553
12554
12555
12556
12557
12558
12559           ac_config_files="$ac_config_files Makefile"
12560 cat >confcache <<\_ACEOF
12561 # This file is a shell script that caches the results of configure
12562 # tests run on this system so they can be shared between configure
12563 # scripts and configure runs, see configure's option --config-cache.
12564 # It is not useful on other systems.  If it contains results you don't
12565 # want to keep, you may remove or edit it.
12566 #
12567 # config.status only pays attention to the cache file if you give it
12568 # the --recheck option to rerun configure.
12569 #
12570 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12571 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12572 # following values.
12573
12574 _ACEOF
12575
12576 # The following way of writing the cache mishandles newlines in values,
12577 # but we know of no workaround that is simple, portable, and efficient.
12578 # So, don't put newlines in cache variables' values.
12579 # Ultrix sh set writes to stderr and can't be redirected directly,
12580 # and sets the high bit in the cache file unless we assign to the vars.
12581 {
12582   (set) 2>&1 |
12583     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12584     *ac_space=\ *)
12585       # `set' does not quote correctly, so add quotes (double-quote
12586       # substitution turns \\\\ into \\, and sed turns \\ into \).
12587       sed -n \
12588         "s/'/'\\\\''/g;
12589           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12590       ;;
12591     *)
12592       # `set' quotes correctly as required by POSIX, so do not add quotes.
12593       sed -n \
12594         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12595       ;;
12596     esac;
12597 } |
12598   sed '
12599      t clear
12600      : clear
12601      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12602      t end
12603      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12604      : end' >>confcache
12605 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12606   if test -w $cache_file; then
12607     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12608     cat confcache >$cache_file
12609   else
12610     echo "not updating unwritable cache $cache_file"
12611   fi
12612 fi
12613 rm -f confcache
12614
12615 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12616 # Let make expand exec_prefix.
12617 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12618
12619 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12620 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12621 # trailing colons and then remove the whole line if VPATH becomes empty
12622 # (actually we leave an empty line to preserve line numbers).
12623 if test "x$srcdir" = x.; then
12624   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12625 s/:*\$(srcdir):*/:/;
12626 s/:*\${srcdir}:*/:/;
12627 s/:*@srcdir@:*/:/;
12628 s/^\([^=]*=[     ]*\):*/\1/;
12629 s/:*$//;
12630 s/^[^=]*=[       ]*$//;
12631 }'
12632 fi
12633
12634 # Transform confdefs.h into DEFS.
12635 # Protect against shell expansion while executing Makefile rules.
12636 # Protect against Makefile macro expansion.
12637 #
12638 # If the first sed substitution is executed (which looks for macros that
12639 # take arguments), then we branch to the quote section.  Otherwise,
12640 # look for a macro that doesn't take arguments.
12641 cat >confdef2opt.sed <<\_ACEOF
12642 t clear
12643 : clear
12644 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12645 t quote
12646 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12647 t quote
12648 d
12649 : quote
12650 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12651 s,\[,\\&,g
12652 s,\],\\&,g
12653 s,\$,$$,g
12654 p
12655 _ACEOF
12656 # We use echo to avoid assuming a particular line-breaking character.
12657 # The extra dot is to prevent the shell from consuming trailing
12658 # line-breaks from the sub-command output.  A line-break within
12659 # single-quotes doesn't work because, if this script is created in a
12660 # platform that uses two characters for line-breaks (e.g., DOS), tr
12661 # would break.
12662 ac_LF_and_DOT=`echo; echo .`
12663 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12664 rm -f confdef2opt.sed
12665
12666
12667 ac_libobjs=
12668 ac_ltlibobjs=
12669 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12670   # 1. Remove the extension, and $U if already installed.
12671   ac_i=`echo "$ac_i" |
12672          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12673   # 2. Add them.
12674   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12675   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12676 done
12677 LIBOBJS=$ac_libobjs
12678
12679 LTLIBOBJS=$ac_ltlibobjs
12680
12681
12682
12683 : ${CONFIG_STATUS=./config.status}
12684 ac_clean_files_save=$ac_clean_files
12685 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12686 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12687 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12688 cat >$CONFIG_STATUS <<_ACEOF
12689 #! $SHELL
12690 # Generated by $as_me.
12691 # Run this file to recreate the current configuration.
12692 # Compiler output produced by configure, useful for debugging
12693 # configure, is in config.log if it exists.
12694
12695 debug=false
12696 ac_cs_recheck=false
12697 ac_cs_silent=false
12698 SHELL=\${CONFIG_SHELL-$SHELL}
12699 _ACEOF
12700
12701 cat >>$CONFIG_STATUS <<\_ACEOF
12702 ## --------------------- ##
12703 ## M4sh Initialization.  ##
12704 ## --------------------- ##
12705
12706 # Be Bourne compatible
12707 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12708   emulate sh
12709   NULLCMD=:
12710   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12711   # is contrary to our usage.  Disable this feature.
12712   alias -g '${1+"$@"}'='"$@"'
12713 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12714   set -o posix
12715 fi
12716 DUALCASE=1; export DUALCASE # for MKS sh
12717
12718 # Support unset when possible.
12719 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12720   as_unset=unset
12721 else
12722   as_unset=false
12723 fi
12724
12725
12726 # Work around bugs in pre-3.0 UWIN ksh.
12727 $as_unset ENV MAIL MAILPATH
12728 PS1='$ '
12729 PS2='> '
12730 PS4='+ '
12731
12732 # NLS nuisances.
12733 for as_var in \
12734   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12735   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12736   LC_TELEPHONE LC_TIME
12737 do
12738   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12739     eval $as_var=C; export $as_var
12740   else
12741     $as_unset $as_var
12742   fi
12743 done
12744
12745 # Required to use basename.
12746 if expr a : '\(a\)' >/dev/null 2>&1; then
12747   as_expr=expr
12748 else
12749   as_expr=false
12750 fi
12751
12752 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12753   as_basename=basename
12754 else
12755   as_basename=false
12756 fi
12757
12758
12759 # Name of the executable.
12760 as_me=`$as_basename "$0" ||
12761 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12762          X"$0" : 'X\(//\)$' \| \
12763          X"$0" : 'X\(/\)$' \| \
12764          .     : '\(.\)' 2>/dev/null ||
12765 echo X/"$0" |
12766     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12767           /^X\/\(\/\/\)$/{ s//\1/; q; }
12768           /^X\/\(\/\).*/{ s//\1/; q; }
12769           s/.*/./; q'`
12770
12771
12772 # PATH needs CR, and LINENO needs CR and PATH.
12773 # Avoid depending upon Character Ranges.
12774 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12775 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12776 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12777 as_cr_digits='0123456789'
12778 as_cr_alnum=$as_cr_Letters$as_cr_digits
12779
12780 # The user is always right.
12781 if test "${PATH_SEPARATOR+set}" != set; then
12782   echo "#! /bin/sh" >conf$$.sh
12783   echo  "exit 0"   >>conf$$.sh
12784   chmod +x conf$$.sh
12785   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12786     PATH_SEPARATOR=';'
12787   else
12788     PATH_SEPARATOR=:
12789   fi
12790   rm -f conf$$.sh
12791 fi
12792
12793
12794   as_lineno_1=$LINENO
12795   as_lineno_2=$LINENO
12796   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12797   test "x$as_lineno_1" != "x$as_lineno_2" &&
12798   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12799   # Find who we are.  Look in the path if we contain no path at all
12800   # relative or not.
12801   case $0 in
12802     *[\\/]* ) as_myself=$0 ;;
12803     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12804 for as_dir in $PATH
12805 do
12806   IFS=$as_save_IFS
12807   test -z "$as_dir" && as_dir=.
12808   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12809 done
12810
12811        ;;
12812   esac
12813   # We did not find ourselves, most probably we were run as `sh COMMAND'
12814   # in which case we are not to be found in the path.
12815   if test "x$as_myself" = x; then
12816     as_myself=$0
12817   fi
12818   if test ! -f "$as_myself"; then
12819     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12820 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12821    { (exit 1); exit 1; }; }
12822   fi
12823   case $CONFIG_SHELL in
12824   '')
12825     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12826 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12827 do
12828   IFS=$as_save_IFS
12829   test -z "$as_dir" && as_dir=.
12830   for as_base in sh bash ksh sh5; do
12831          case $as_dir in
12832          /*)
12833            if ("$as_dir/$as_base" -c '
12834   as_lineno_1=$LINENO
12835   as_lineno_2=$LINENO
12836   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12837   test "x$as_lineno_1" != "x$as_lineno_2" &&
12838   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12839              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12840              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12841              CONFIG_SHELL=$as_dir/$as_base
12842              export CONFIG_SHELL
12843              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12844            fi;;
12845          esac
12846        done
12847 done
12848 ;;
12849   esac
12850
12851   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12852   # uniformly replaced by the line number.  The first 'sed' inserts a
12853   # line-number line before each line; the second 'sed' does the real
12854   # work.  The second script uses 'N' to pair each line-number line
12855   # with the numbered line, and appends trailing '-' during
12856   # substitution so that $LINENO is not a special case at line end.
12857   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12858   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12859   sed '=' <$as_myself |
12860     sed '
12861       N
12862       s,$,-,
12863       : loop
12864       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12865       t loop
12866       s,-$,,
12867       s,^['$as_cr_digits']*\n,,
12868     ' >$as_me.lineno &&
12869   chmod +x $as_me.lineno ||
12870     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12871 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12872    { (exit 1); exit 1; }; }
12873
12874   # Don't try to exec as it changes $[0], causing all sort of problems
12875   # (the dirname of $[0] is not the place where we might find the
12876   # original and so on.  Autoconf is especially sensible to this).
12877   . ./$as_me.lineno
12878   # Exit status is that of the last command.
12879   exit
12880 }
12881
12882
12883 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12884   *c*,-n*) ECHO_N= ECHO_C='
12885 ' ECHO_T='      ' ;;
12886   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12887   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12888 esac
12889
12890 if expr a : '\(a\)' >/dev/null 2>&1; then
12891   as_expr=expr
12892 else
12893   as_expr=false
12894 fi
12895
12896 rm -f conf$$ conf$$.exe conf$$.file
12897 echo >conf$$.file
12898 if ln -s conf$$.file conf$$ 2>/dev/null; then
12899   # We could just check for DJGPP; but this test a) works b) is more generic
12900   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12901   if test -f conf$$.exe; then
12902     # Don't use ln at all; we don't have any links
12903     as_ln_s='cp -p'
12904   else
12905     as_ln_s='ln -s'
12906   fi
12907 elif ln conf$$.file conf$$ 2>/dev/null; then
12908   as_ln_s=ln
12909 else
12910   as_ln_s='cp -p'
12911 fi
12912 rm -f conf$$ conf$$.exe conf$$.file
12913
12914 if mkdir -p . 2>/dev/null; then
12915   as_mkdir_p=:
12916 else
12917   test -d ./-p && rmdir ./-p
12918   as_mkdir_p=false
12919 fi
12920
12921 as_executable_p="test -f"
12922
12923 # Sed expression to map a string onto a valid CPP name.
12924 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12925
12926 # Sed expression to map a string onto a valid variable name.
12927 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12928
12929
12930 # IFS
12931 # We need space, tab and new line, in precisely that order.
12932 as_nl='
12933 '
12934 IFS="   $as_nl"
12935
12936 # CDPATH.
12937 $as_unset CDPATH
12938
12939 exec 6>&1
12940
12941 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12942 # report actual input values of CONFIG_FILES etc. instead of their
12943 # values after options handling.  Logging --version etc. is OK.
12944 exec 5>>config.log
12945 {
12946   echo
12947   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12948 ## Running $as_me. ##
12949 _ASBOX
12950 } >&5
12951 cat >&5 <<_CSEOF
12952
12953 This file was extended by $as_me, which was
12954 generated by GNU Autoconf 2.59.  Invocation command line was
12955
12956   CONFIG_FILES    = $CONFIG_FILES
12957   CONFIG_HEADERS  = $CONFIG_HEADERS
12958   CONFIG_LINKS    = $CONFIG_LINKS
12959   CONFIG_COMMANDS = $CONFIG_COMMANDS
12960   $ $0 $@
12961
12962 _CSEOF
12963 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12964 echo >&5
12965 _ACEOF
12966
12967 # Files that config.status was made for.
12968 if test -n "$ac_config_files"; then
12969   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12970 fi
12971
12972 if test -n "$ac_config_headers"; then
12973   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12974 fi
12975
12976 if test -n "$ac_config_links"; then
12977   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12978 fi
12979
12980 if test -n "$ac_config_commands"; then
12981   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12982 fi
12983
12984 cat >>$CONFIG_STATUS <<\_ACEOF
12985
12986 ac_cs_usage="\
12987 \`$as_me' instantiates files from templates according to the
12988 current configuration.
12989
12990 Usage: $0 [OPTIONS] [FILE]...
12991
12992   -h, --help       print this help, then exit
12993   -V, --version    print version number, then exit
12994   -q, --quiet      do not print progress messages
12995   -d, --debug      don't remove temporary files
12996       --recheck    update $as_me by reconfiguring in the same conditions
12997   --file=FILE[:TEMPLATE]
12998                    instantiate the configuration file FILE
12999
13000 Configuration files:
13001 $config_files
13002
13003 Report bugs to <bug-autoconf@gnu.org>."
13004 _ACEOF
13005
13006 cat >>$CONFIG_STATUS <<_ACEOF
13007 ac_cs_version="\\
13008 config.status
13009 configured by $0, generated by GNU Autoconf 2.59,
13010   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13011
13012 Copyright (C) 2003 Free Software Foundation, Inc.
13013 This config.status script is free software; the Free Software Foundation
13014 gives unlimited permission to copy, distribute and modify it."
13015 srcdir=$srcdir
13016 INSTALL="$INSTALL"
13017 _ACEOF
13018
13019 cat >>$CONFIG_STATUS <<\_ACEOF
13020 # If no file are specified by the user, then we need to provide default
13021 # value.  By we need to know if files were specified by the user.
13022 ac_need_defaults=:
13023 while test $# != 0
13024 do
13025   case $1 in
13026   --*=*)
13027     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13028     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13029     ac_shift=:
13030     ;;
13031   -*)
13032     ac_option=$1
13033     ac_optarg=$2
13034     ac_shift=shift
13035     ;;
13036   *) # This is not an option, so the user has probably given explicit
13037      # arguments.
13038      ac_option=$1
13039      ac_need_defaults=false;;
13040   esac
13041
13042   case $ac_option in
13043   # Handling of the options.
13044 _ACEOF
13045 cat >>$CONFIG_STATUS <<\_ACEOF
13046   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13047     ac_cs_recheck=: ;;
13048   --version | --vers* | -V )
13049     echo "$ac_cs_version"; exit 0 ;;
13050   --he | --h)
13051     # Conflict between --help and --header
13052     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13053 Try \`$0 --help' for more information." >&5
13054 echo "$as_me: error: ambiguous option: $1
13055 Try \`$0 --help' for more information." >&2;}
13056    { (exit 1); exit 1; }; };;
13057   --help | --hel | -h )
13058     echo "$ac_cs_usage"; exit 0 ;;
13059   --debug | --d* | -d )
13060     debug=: ;;
13061   --file | --fil | --fi | --f )
13062     $ac_shift
13063     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13064     ac_need_defaults=false;;
13065   --header | --heade | --head | --hea )
13066     $ac_shift
13067     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13068     ac_need_defaults=false;;
13069   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13070   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13071     ac_cs_silent=: ;;
13072
13073   # This is an error.
13074   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13075 Try \`$0 --help' for more information." >&5
13076 echo "$as_me: error: unrecognized option: $1
13077 Try \`$0 --help' for more information." >&2;}
13078    { (exit 1); exit 1; }; } ;;
13079
13080   *) ac_config_targets="$ac_config_targets $1" ;;
13081
13082   esac
13083   shift
13084 done
13085
13086 ac_configure_extra_args=
13087
13088 if $ac_cs_silent; then
13089   exec 6>/dev/null
13090   ac_configure_extra_args="$ac_configure_extra_args --silent"
13091 fi
13092
13093 _ACEOF
13094 cat >>$CONFIG_STATUS <<_ACEOF
13095 if \$ac_cs_recheck; then
13096   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13097   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13098 fi
13099
13100 _ACEOF
13101
13102
13103
13104
13105
13106 cat >>$CONFIG_STATUS <<\_ACEOF
13107 for ac_config_target in $ac_config_targets
13108 do
13109   case "$ac_config_target" in
13110   # Handling of arguments.
13111   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13112   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13113 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13114    { (exit 1); exit 1; }; };;
13115   esac
13116 done
13117
13118 # If the user did not use the arguments to specify the items to instantiate,
13119 # then the envvar interface is used.  Set only those that are not.
13120 # We use the long form for the default assignment because of an extremely
13121 # bizarre bug on SunOS 4.1.3.
13122 if $ac_need_defaults; then
13123   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13124 fi
13125
13126 # Have a temporary directory for convenience.  Make it in the build tree
13127 # simply because there is no reason to put it here, and in addition,
13128 # creating and moving files from /tmp can sometimes cause problems.
13129 # Create a temporary directory, and hook for its removal unless debugging.
13130 $debug ||
13131 {
13132   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13133   trap '{ (exit 1); exit 1; }' 1 2 13 15
13134 }
13135
13136 # Create a (secure) tmp directory for tmp files.
13137
13138 {
13139   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13140   test -n "$tmp" && test -d "$tmp"
13141 }  ||
13142 {
13143   tmp=./confstat$$-$RANDOM
13144   (umask 077 && mkdir $tmp)
13145 } ||
13146 {
13147    echo "$me: cannot create a temporary directory in ." >&2
13148    { (exit 1); exit 1; }
13149 }
13150
13151 _ACEOF
13152
13153 cat >>$CONFIG_STATUS <<_ACEOF
13154
13155 #
13156 # CONFIG_FILES section.
13157 #
13158
13159 # No need to generate the scripts if there are no CONFIG_FILES.
13160 # This happens for instance when ./config.status config.h
13161 if test -n "\$CONFIG_FILES"; then
13162   # Protect against being on the right side of a sed subst in config.status.
13163   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13164    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13165 s,@SHELL@,$SHELL,;t t
13166 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13167 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13168 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13169 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13170 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13171 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13172 s,@exec_prefix@,$exec_prefix,;t t
13173 s,@prefix@,$prefix,;t t
13174 s,@program_transform_name@,$program_transform_name,;t t
13175 s,@bindir@,$bindir,;t t
13176 s,@sbindir@,$sbindir,;t t
13177 s,@libexecdir@,$libexecdir,;t t
13178 s,@datadir@,$datadir,;t t
13179 s,@sysconfdir@,$sysconfdir,;t t
13180 s,@sharedstatedir@,$sharedstatedir,;t t
13181 s,@localstatedir@,$localstatedir,;t t
13182 s,@libdir@,$libdir,;t t
13183 s,@includedir@,$includedir,;t t
13184 s,@oldincludedir@,$oldincludedir,;t t
13185 s,@infodir@,$infodir,;t t
13186 s,@mandir@,$mandir,;t t
13187 s,@build_alias@,$build_alias,;t t
13188 s,@host_alias@,$host_alias,;t t
13189 s,@target_alias@,$target_alias,;t t
13190 s,@DEFS@,$DEFS,;t t
13191 s,@ECHO_C@,$ECHO_C,;t t
13192 s,@ECHO_N@,$ECHO_N,;t t
13193 s,@ECHO_T@,$ECHO_T,;t t
13194 s,@LIBS@,$LIBS,;t t
13195 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13196 s,@build@,$build,;t t
13197 s,@build_cpu@,$build_cpu,;t t
13198 s,@build_vendor@,$build_vendor,;t t
13199 s,@build_os@,$build_os,;t t
13200 s,@build_noncanonical@,$build_noncanonical,;t t
13201 s,@host_noncanonical@,$host_noncanonical,;t t
13202 s,@target_noncanonical@,$target_noncanonical,;t t
13203 s,@host@,$host,;t t
13204 s,@host_cpu@,$host_cpu,;t t
13205 s,@host_vendor@,$host_vendor,;t t
13206 s,@host_os@,$host_os,;t t
13207 s,@target@,$target,;t t
13208 s,@target_cpu@,$target_cpu,;t t
13209 s,@target_vendor@,$target_vendor,;t t
13210 s,@target_os@,$target_os,;t t
13211 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13212 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13213 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13214 s,@LN@,$LN,;t t
13215 s,@LN_S@,$LN_S,;t t
13216 s,@build_libsubdir@,$build_libsubdir,;t t
13217 s,@build_subdir@,$build_subdir,;t t
13218 s,@host_subdir@,$host_subdir,;t t
13219 s,@target_subdir@,$target_subdir,;t t
13220 s,@CC@,$CC,;t t
13221 s,@CFLAGS@,$CFLAGS,;t t
13222 s,@LDFLAGS@,$LDFLAGS,;t t
13223 s,@CPPFLAGS@,$CPPFLAGS,;t t
13224 s,@ac_ct_CC@,$ac_ct_CC,;t t
13225 s,@EXEEXT@,$EXEEXT,;t t
13226 s,@OBJEXT@,$OBJEXT,;t t
13227 s,@CXX@,$CXX,;t t
13228 s,@CXXFLAGS@,$CXXFLAGS,;t t
13229 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13230 s,@GNATBIND@,$GNATBIND,;t t
13231 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13232 s,@GNATMAKE@,$GNATMAKE,;t t
13233 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13234 s,@do_compare@,$do_compare,;t t
13235 s,@gmplibs@,$gmplibs,;t t
13236 s,@gmpinc@,$gmpinc,;t t
13237 s,@ppllibs@,$ppllibs,;t t
13238 s,@pplinc@,$pplinc,;t t
13239 s,@clooglibs@,$clooglibs,;t t
13240 s,@clooginc@,$clooginc,;t t
13241 s,@stage1_languages@,$stage1_languages,;t t
13242 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13243 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13244 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13245 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13246 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13247 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13248 s,@tooldir@,$tooldir,;t t
13249 s,@build_tooldir@,$build_tooldir,;t t
13250 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13251 s,@GDB_TK@,$GDB_TK,;t t
13252 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13253 s,@build_configargs@,$build_configargs,;t t
13254 s,@build_configdirs@,$build_configdirs,;t t
13255 s,@host_configargs@,$host_configargs,;t t
13256 s,@configdirs@,$configdirs,;t t
13257 s,@target_configargs@,$target_configargs,;t t
13258 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13259 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13260 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13261 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13262 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13263 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13264 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13265 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13266 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13267 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13268 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13269 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13270 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13271 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13272 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13273 s,@config_shell@,$config_shell,;t t
13274 s,@YACC@,$YACC,;t t
13275 s,@BISON@,$BISON,;t t
13276 s,@M4@,$M4,;t t
13277 s,@LEX@,$LEX,;t t
13278 s,@FLEX@,$FLEX,;t t
13279 s,@MAKEINFO@,$MAKEINFO,;t t
13280 s,@EXPECT@,$EXPECT,;t t
13281 s,@RUNTEST@,$RUNTEST,;t t
13282 s,@AR@,$AR,;t t
13283 s,@AS@,$AS,;t t
13284 s,@DLLTOOL@,$DLLTOOL,;t t
13285 s,@LD@,$LD,;t t
13286 s,@LIPO@,$LIPO,;t t
13287 s,@NM@,$NM,;t t
13288 s,@RANLIB@,$RANLIB,;t t
13289 s,@STRIP@,$STRIP,;t t
13290 s,@WINDRES@,$WINDRES,;t t
13291 s,@WINDMC@,$WINDMC,;t t
13292 s,@OBJCOPY@,$OBJCOPY,;t t
13293 s,@OBJDUMP@,$OBJDUMP,;t t
13294 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13295 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13296 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13297 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13298 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13299 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13300 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13301 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13302 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13303 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13304 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13305 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13306 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13307 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13308 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13309 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13310 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13311 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13312 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13313 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13314 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13315 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13316 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13317 s,@MAINT@,$MAINT,;t t
13318 s,@stage1_cflags@,$stage1_cflags,;t t
13319 s,@stage1_checking@,$stage1_checking,;t t
13320 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13321 s,@datarootdir@,$datarootdir,;t t
13322 s,@docdir@,$docdir,;t t
13323 s,@pdfdir@,$pdfdir,;t t
13324 s,@htmldir@,$htmldir,;t t
13325 s,@LIBOBJS@,$LIBOBJS,;t t
13326 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13327 /@serialization_dependencies@/r $serialization_dependencies
13328 s,@serialization_dependencies@,,;t t
13329 /@host_makefile_frag@/r $host_makefile_frag
13330 s,@host_makefile_frag@,,;t t
13331 /@target_makefile_frag@/r $target_makefile_frag
13332 s,@target_makefile_frag@,,;t t
13333 /@alphaieee_frag@/r $alphaieee_frag
13334 s,@alphaieee_frag@,,;t t
13335 /@ospace_frag@/r $ospace_frag
13336 s,@ospace_frag@,,;t t
13337 CEOF
13338
13339 _ACEOF
13340
13341   cat >>$CONFIG_STATUS <<\_ACEOF
13342   # Split the substitutions into bite-sized pieces for seds with
13343   # small command number limits, like on Digital OSF/1 and HP-UX.
13344   ac_max_sed_lines=48
13345   ac_sed_frag=1 # Number of current file.
13346   ac_beg=1 # First line for current file.
13347   ac_end=$ac_max_sed_lines # Line after last line for current file.
13348   ac_more_lines=:
13349   ac_sed_cmds=
13350   while $ac_more_lines; do
13351     if test $ac_beg -gt 1; then
13352       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13353     else
13354       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13355     fi
13356     if test ! -s $tmp/subs.frag; then
13357       ac_more_lines=false
13358     else
13359       # The purpose of the label and of the branching condition is to
13360       # speed up the sed processing (if there are no `@' at all, there
13361       # is no need to browse any of the substitutions).
13362       # These are the two extra sed commands mentioned above.
13363       (echo ':t
13364   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13365       if test -z "$ac_sed_cmds"; then
13366         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13367       else
13368         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13369       fi
13370       ac_sed_frag=`expr $ac_sed_frag + 1`
13371       ac_beg=$ac_end
13372       ac_end=`expr $ac_end + $ac_max_sed_lines`
13373     fi
13374   done
13375   if test -z "$ac_sed_cmds"; then
13376     ac_sed_cmds=cat
13377   fi
13378 fi # test -n "$CONFIG_FILES"
13379
13380 _ACEOF
13381 cat >>$CONFIG_STATUS <<\_ACEOF
13382 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13383   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13384   case $ac_file in
13385   - | *:- | *:-:* ) # input from stdin
13386         cat >$tmp/stdin
13387         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13388         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13389   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13390         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13391   * )   ac_file_in=$ac_file.in ;;
13392   esac
13393
13394   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13395   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13396 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13397          X"$ac_file" : 'X\(//\)[^/]' \| \
13398          X"$ac_file" : 'X\(//\)$' \| \
13399          X"$ac_file" : 'X\(/\)' \| \
13400          .     : '\(.\)' 2>/dev/null ||
13401 echo X"$ac_file" |
13402     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13403           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13404           /^X\(\/\/\)$/{ s//\1/; q; }
13405           /^X\(\/\).*/{ s//\1/; q; }
13406           s/.*/./; q'`
13407   { if $as_mkdir_p; then
13408     mkdir -p "$ac_dir"
13409   else
13410     as_dir="$ac_dir"
13411     as_dirs=
13412     while test ! -d "$as_dir"; do
13413       as_dirs="$as_dir $as_dirs"
13414       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13415 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13416          X"$as_dir" : 'X\(//\)[^/]' \| \
13417          X"$as_dir" : 'X\(//\)$' \| \
13418          X"$as_dir" : 'X\(/\)' \| \
13419          .     : '\(.\)' 2>/dev/null ||
13420 echo X"$as_dir" |
13421     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13422           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13423           /^X\(\/\/\)$/{ s//\1/; q; }
13424           /^X\(\/\).*/{ s//\1/; q; }
13425           s/.*/./; q'`
13426     done
13427     test ! -n "$as_dirs" || mkdir $as_dirs
13428   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13429 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13430    { (exit 1); exit 1; }; }; }
13431
13432   ac_builddir=.
13433
13434 if test "$ac_dir" != .; then
13435   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13436   # A "../" for each directory in $ac_dir_suffix.
13437   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13438 else
13439   ac_dir_suffix= ac_top_builddir=
13440 fi
13441
13442 case $srcdir in
13443   .)  # No --srcdir option.  We are building in place.
13444     ac_srcdir=.
13445     if test -z "$ac_top_builddir"; then
13446        ac_top_srcdir=.
13447     else
13448        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13449     fi ;;
13450   [\\/]* | ?:[\\/]* )  # Absolute path.
13451     ac_srcdir=$srcdir$ac_dir_suffix;
13452     ac_top_srcdir=$srcdir ;;
13453   *) # Relative path.
13454     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13455     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13456 esac
13457
13458 # Do not use `cd foo && pwd` to compute absolute paths, because
13459 # the directories may not exist.
13460 case `pwd` in
13461 .) ac_abs_builddir="$ac_dir";;
13462 *)
13463   case "$ac_dir" in
13464   .) ac_abs_builddir=`pwd`;;
13465   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13466   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13467   esac;;
13468 esac
13469 case $ac_abs_builddir in
13470 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13471 *)
13472   case ${ac_top_builddir}. in
13473   .) ac_abs_top_builddir=$ac_abs_builddir;;
13474   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13475   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13476   esac;;
13477 esac
13478 case $ac_abs_builddir in
13479 .) ac_abs_srcdir=$ac_srcdir;;
13480 *)
13481   case $ac_srcdir in
13482   .) ac_abs_srcdir=$ac_abs_builddir;;
13483   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13484   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13485   esac;;
13486 esac
13487 case $ac_abs_builddir in
13488 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13489 *)
13490   case $ac_top_srcdir in
13491   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13492   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13493   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13494   esac;;
13495 esac
13496
13497
13498   case $INSTALL in
13499   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13500   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13501   esac
13502
13503   if test x"$ac_file" != x-; then
13504     { echo "$as_me:$LINENO: creating $ac_file" >&5
13505 echo "$as_me: creating $ac_file" >&6;}
13506     rm -f "$ac_file"
13507   fi
13508   # Let's still pretend it is `configure' which instantiates (i.e., don't
13509   # use $as_me), people would be surprised to read:
13510   #    /* config.h.  Generated by config.status.  */
13511   if test x"$ac_file" = x-; then
13512     configure_input=
13513   else
13514     configure_input="$ac_file.  "
13515   fi
13516   configure_input=$configure_input"Generated from `echo $ac_file_in |
13517                                      sed 's,.*/,,'` by configure."
13518
13519   # First look for the input files in the build tree, otherwise in the
13520   # src tree.
13521   ac_file_inputs=`IFS=:
13522     for f in $ac_file_in; do
13523       case $f in
13524       -) echo $tmp/stdin ;;
13525       [\\/$]*)
13526          # Absolute (can't be DOS-style, as IFS=:)
13527          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13528 echo "$as_me: error: cannot find input file: $f" >&2;}
13529    { (exit 1); exit 1; }; }
13530          echo "$f";;
13531       *) # Relative
13532          if test -f "$f"; then
13533            # Build tree
13534            echo "$f"
13535          elif test -f "$srcdir/$f"; then
13536            # Source tree
13537            echo "$srcdir/$f"
13538          else
13539            # /dev/null tree
13540            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13541 echo "$as_me: error: cannot find input file: $f" >&2;}
13542    { (exit 1); exit 1; }; }
13543          fi;;
13544       esac
13545     done` || { (exit 1); exit 1; }
13546 _ACEOF
13547 cat >>$CONFIG_STATUS <<_ACEOF
13548   sed "$ac_vpsub
13549 $extrasub
13550 _ACEOF
13551 cat >>$CONFIG_STATUS <<\_ACEOF
13552 :t
13553 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13554 s,@configure_input@,$configure_input,;t t
13555 s,@srcdir@,$ac_srcdir,;t t
13556 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13557 s,@top_srcdir@,$ac_top_srcdir,;t t
13558 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13559 s,@builddir@,$ac_builddir,;t t
13560 s,@abs_builddir@,$ac_abs_builddir,;t t
13561 s,@top_builddir@,$ac_top_builddir,;t t
13562 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13563 s,@INSTALL@,$ac_INSTALL,;t t
13564 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13565   rm -f $tmp/stdin
13566   if test x"$ac_file" != x-; then
13567     mv $tmp/out $ac_file
13568   else
13569     cat $tmp/out
13570     rm -f $tmp/out
13571   fi
13572
13573 done
13574 _ACEOF
13575
13576 cat >>$CONFIG_STATUS <<\_ACEOF
13577
13578 { (exit 0); exit 0; }
13579 _ACEOF
13580 chmod +x $CONFIG_STATUS
13581 ac_clean_files=$ac_clean_files_save
13582
13583
13584 # configure is writing to config.log, and then calls config.status.
13585 # config.status does its own redirection, appending to config.log.
13586 # Unfortunately, on DOS this fails, as config.log is still kept open
13587 # by configure, so config.status won't be able to write to it; its
13588 # output is simply discarded.  So we exec the FD to /dev/null,
13589 # effectively closing config.log, so it can be properly (re)opened and
13590 # appended to by config.status.  When coming back to configure, we
13591 # need to make the FD available again.
13592 if test "$no_create" != yes; then
13593   ac_cs_success=:
13594   ac_config_status_args=
13595   test "$silent" = yes &&
13596     ac_config_status_args="$ac_config_status_args --quiet"
13597   exec 5>/dev/null
13598   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13599   exec 5>>config.log
13600   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13601   # would make configure fail if this is the last instruction.
13602   $ac_cs_success || { (exit 1); exit 1; }
13603 fi
13604