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 CPPFLAGS_FOR_TARGET LDFLAGS_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 CPPFLAGS_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-cloog-polylib=PATH Specify prefix directory for the installed CLooG-PolyLib package
 983   --with-build-sysroot=SYSROOT
 984                           use sysroot as the system root during the build
 985   --with-debug-prefix-map='A=B C=D ...'
 986                              map A to B, C to D ... in debug information
 987   --with-build-time-tools=PATH
 988                           use given path to find target tools during the build
 989   --with-datarootdir      use datarootdir as the data root directory.
 990   --with-docdir           install documentation in this directory.
 991   --with-pdfdir           install pdf in this directory.
 992   --with-htmldir          install html in this directory.
 993
 994 Some influential environment variables:
 995   CC          C compiler command
 996   CFLAGS      C compiler flags
 997   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 998               nonstandard directory <lib dir>
 999   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
1000               headers in a nonstandard directory <include dir>
1001   CXX         C++ compiler command
1002   CXXFLAGS    C++ compiler flags
1003   AR          AR for the host
1004   AS          AS for the host
1005   DLLTOOL     DLLTOOL for the host
1006   LD          LD for the host
1007   LIPO        LIPO for the host
1008   NM          NM for the host
1009   RANLIB      RANLIB for the host
1010   STRIP       STRIP for the host
1011   WINDRES     WINDRES for the host
1012   WINDMC      WINDMC for the host
1013   OBJCOPY     OBJCOPY for the host
1014   OBJDUMP     OBJDUMP for the host
1015   CC_FOR_TARGET
1016               CC for the target
1017   CXX_FOR_TARGET
1018               CXX for the target
1019   GCC_FOR_TARGET
1020               GCC for the target
1021   GCJ_FOR_TARGET
1022               GCJ for the target
1023   GFORTRAN_FOR_TARGET
1024               GFORTRAN for the target
1025   AR_FOR_TARGET
1026               AR for the target
1027   AS_FOR_TARGET
1028               AS for the target
1029   DLLTOOL_FOR_TARGET
1030               DLLTOOL for the target
1031   LD_FOR_TARGET
1032               LD for the target
1033   LIPO_FOR_TARGET
1034               LIPO for the target
1035   NM_FOR_TARGET
1036               NM for the target
1037   OBJDUMP_FOR_TARGET
1038               OBJDUMP for the target
1039   RANLIB_FOR_TARGET
1040               RANLIB for the target
1041   STRIP_FOR_TARGET
1042               STRIP for the target
1043   WINDRES_FOR_TARGET
1044               WINDRES for the target
1045   WINDMC_FOR_TARGET
1046               WINDMC for the target
1047
1048 Use these variables to override the choices made by `configure' or to help
1049 it to find libraries and programs with nonstandard names/locations.
1050
1051 _ACEOF
1052 fi
1053
1054 if test "$ac_init_help" = "recursive"; then
1055   # If there are subdirs, report their specific --help.
1056   ac_popdir=`pwd`
1057   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1058     test -d $ac_dir || continue
1059     ac_builddir=.
1060
1061 if test "$ac_dir" != .; then
1062   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1063   # A "../" for each directory in $ac_dir_suffix.
1064   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1065 else
1066   ac_dir_suffix= ac_top_builddir=
1067 fi
1068
1069 case $srcdir in
1070   .)  # No --srcdir option.  We are building in place.
1071     ac_srcdir=.
1072     if test -z "$ac_top_builddir"; then
1073        ac_top_srcdir=.
1074     else
1075        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1076     fi ;;
1077   [\\/]* | ?:[\\/]* )  # Absolute path.
1078     ac_srcdir=$srcdir$ac_dir_suffix;
1079     ac_top_srcdir=$srcdir ;;
1080   *) # Relative path.
1081     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1082     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1083 esac
1084
1085 # Do not use `cd foo && pwd` to compute absolute paths, because
1086 # the directories may not exist.
1087 case `pwd` in
1088 .) ac_abs_builddir="$ac_dir";;
1089 *)
1090   case "$ac_dir" in
1091   .) ac_abs_builddir=`pwd`;;
1092   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1093   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1094   esac;;
1095 esac
1096 case $ac_abs_builddir in
1097 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1098 *)
1099   case ${ac_top_builddir}. in
1100   .) ac_abs_top_builddir=$ac_abs_builddir;;
1101   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1102   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1103   esac;;
1104 esac
1105 case $ac_abs_builddir in
1106 .) ac_abs_srcdir=$ac_srcdir;;
1107 *)
1108   case $ac_srcdir in
1109   .) ac_abs_srcdir=$ac_abs_builddir;;
1110   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1111   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1112   esac;;
1113 esac
1114 case $ac_abs_builddir in
1115 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1116 *)
1117   case $ac_top_srcdir in
1118   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1119   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1120   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1121   esac;;
1122 esac
1123
1124     cd $ac_dir
1125     # Check for guested configure; otherwise get Cygnus style configure.
1126     if test -f $ac_srcdir/configure.gnu; then
1127       echo
1128       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1129     elif test -f $ac_srcdir/configure; then
1130       echo
1131       $SHELL $ac_srcdir/configure  --help=recursive
1132     elif test -f $ac_srcdir/configure.ac ||
1133            test -f $ac_srcdir/configure.in; then
1134       echo
1135       $ac_configure --help
1136     else
1137       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1138     fi
1139     cd $ac_popdir
1140   done
1141 fi
1142
1143 test -n "$ac_init_help" && exit 0
1144 if $ac_init_version; then
1145   cat <<\_ACEOF
1146
1147 Copyright (C) 2003 Free Software Foundation, Inc.
1148 This configure script is free software; the Free Software Foundation
1149 gives unlimited permission to copy, distribute and modify it.
1150 _ACEOF
1151   exit 0
1152 fi
1153 exec 5>config.log
1154 cat >&5 <<_ACEOF
1155 This file contains any messages produced by compilers while
1156 running configure, to aid debugging if configure makes a mistake.
1157
1158 It was created by $as_me, which was
1159 generated by GNU Autoconf 2.59.  Invocation command line was
1160
1161   $ $0 $@
1162
1163 _ACEOF
1164 {
1165 cat <<_ASUNAME
1166 ## --------- ##
1167 ## Platform. ##
1168 ## --------- ##
1169
1170 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1171 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1172 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1173 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1174 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1175
1176 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1177 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1178
1179 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1180 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1181 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1182 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1183 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1184 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1185 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1186
1187 _ASUNAME
1188
1189 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1190 for as_dir in $PATH
1191 do
1192   IFS=$as_save_IFS
1193   test -z "$as_dir" && as_dir=.
1194   echo "PATH: $as_dir"
1195 done
1196
1197 } >&5
1198
1199 cat >&5 <<_ACEOF
1200
1201
1202 ## ----------- ##
1203 ## Core tests. ##
1204 ## ----------- ##
1205
1206 _ACEOF
1207
1208
1209 # Keep a trace of the command line.
1210 # Strip out --no-create and --no-recursion so they do not pile up.
1211 # Strip out --silent because we don't want to record it for future runs.
1212 # Also quote any args containing shell meta-characters.
1213 # Make two passes to allow for proper duplicate-argument suppression.
1214 ac_configure_args=
1215 ac_configure_args0=
1216 ac_configure_args1=
1217 ac_sep=
1218 ac_must_keep_next=false
1219 for ac_pass in 1 2
1220 do
1221   for ac_arg
1222   do
1223     case $ac_arg in
1224     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1225     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1226     | -silent | --silent | --silen | --sile | --sil)
1227       continue ;;
1228     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1229       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1230     esac
1231     case $ac_pass in
1232     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1233     2)
1234       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1235       if test $ac_must_keep_next = true; then
1236         ac_must_keep_next=false # Got value, back to normal.
1237       else
1238         case $ac_arg in
1239           *=* | --config-cache | -C | -disable-* | --disable-* \
1240           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1241           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1242           | -with-* | --with-* | -without-* | --without-* | --x)
1243             case "$ac_configure_args0 " in
1244               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1245             esac
1246             ;;
1247           -* ) ac_must_keep_next=true ;;
1248         esac
1249       fi
1250       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1251       # Get rid of the leading space.
1252       ac_sep=" "
1253       ;;
1254     esac
1255   done
1256 done
1257 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1258 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1259
1260 # When interrupted or exit'd, cleanup temporary files, and complete
1261 # config.log.  We remove comments because anyway the quotes in there
1262 # would cause problems or look ugly.
1263 # WARNING: Be sure not to use single quotes in there, as some shells,
1264 # such as our DU 5.0 friend, will then `close' the trap.
1265 trap 'exit_status=$?
1266   # Save into config.log some information that might help in debugging.
1267   {
1268     echo
1269
1270     cat <<\_ASBOX
1271 ## ---------------- ##
1272 ## Cache variables. ##
1273 ## ---------------- ##
1274 _ASBOX
1275     echo
1276     # The following way of writing the cache mishandles newlines in values,
1277 {
1278   (set) 2>&1 |
1279     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1280     *ac_space=\ *)
1281       sed -n \
1282         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1283           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1284       ;;
1285     *)
1286       sed -n \
1287         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1288       ;;
1289     esac;
1290 }
1291     echo
1292
1293     cat <<\_ASBOX
1294 ## ----------------- ##
1295 ## Output variables. ##
1296 ## ----------------- ##
1297 _ASBOX
1298     echo
1299     for ac_var in $ac_subst_vars
1300     do
1301       eval ac_val=$`echo $ac_var`
1302       echo "$ac_var='"'"'$ac_val'"'"'"
1303     done | sort
1304     echo
1305
1306     if test -n "$ac_subst_files"; then
1307       cat <<\_ASBOX
1308 ## ------------- ##
1309 ## Output files. ##
1310 ## ------------- ##
1311 _ASBOX
1312       echo
1313       for ac_var in $ac_subst_files
1314       do
1315         eval ac_val=$`echo $ac_var`
1316         echo "$ac_var='"'"'$ac_val'"'"'"
1317       done | sort
1318       echo
1319     fi
1320
1321     if test -s confdefs.h; then
1322       cat <<\_ASBOX
1323 ## ----------- ##
1324 ## confdefs.h. ##
1325 ## ----------- ##
1326 _ASBOX
1327       echo
1328       sed "/^$/d" confdefs.h | sort
1329       echo
1330     fi
1331     test "$ac_signal" != 0 &&
1332       echo "$as_me: caught signal $ac_signal"
1333     echo "$as_me: exit $exit_status"
1334   } >&5
1335   rm -f core *.core &&
1336   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1337     exit $exit_status
1338      ' 0
1339 for ac_signal in 1 2 13 15; do
1340   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1341 done
1342 ac_signal=0
1343
1344 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1345 rm -rf conftest* confdefs.h
1346 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1347 echo >confdefs.h
1348
1349 # Predefined preprocessor variables.
1350
1351 cat >>confdefs.h <<_ACEOF
1352 #define PACKAGE_NAME "$PACKAGE_NAME"
1353 _ACEOF
1354
1355
1356 cat >>confdefs.h <<_ACEOF
1357 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1358 _ACEOF
1359
1360
1361 cat >>confdefs.h <<_ACEOF
1362 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1363 _ACEOF
1364
1365
1366 cat >>confdefs.h <<_ACEOF
1367 #define PACKAGE_STRING "$PACKAGE_STRING"
1368 _ACEOF
1369
1370
1371 cat >>confdefs.h <<_ACEOF
1372 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1373 _ACEOF
1374
1375
1376 # Let the site file select an alternate cache file if it wants to.
1377 # Prefer explicitly selected file to automatically selected ones.
1378 if test -z "$CONFIG_SITE"; then
1379   if test "x$prefix" != xNONE; then
1380     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1381   else
1382     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1383   fi
1384 fi
1385 for ac_site_file in $CONFIG_SITE; do
1386   if test -r "$ac_site_file"; then
1387     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1388 echo "$as_me: loading site script $ac_site_file" >&6;}
1389     sed 's/^/| /' "$ac_site_file" >&5
1390     . "$ac_site_file"
1391   fi
1392 done
1393
1394 if test -r "$cache_file"; then
1395   # Some versions of bash will fail to source /dev/null (special
1396   # files actually), so we avoid doing that.
1397   if test -f "$cache_file"; then
1398     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1399 echo "$as_me: loading cache $cache_file" >&6;}
1400     case $cache_file in
1401       [\\/]* | ?:[\\/]* ) . $cache_file;;
1402       *)                      . ./$cache_file;;
1403     esac
1404   fi
1405 else
1406   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1407 echo "$as_me: creating cache $cache_file" >&6;}
1408   >$cache_file
1409 fi
1410
1411 # Check that the precious variables saved in the cache have kept the same
1412 # value.
1413 ac_cache_corrupted=false
1414 for ac_var in `(set) 2>&1 |
1415                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1416   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1417   eval ac_new_set=\$ac_env_${ac_var}_set
1418   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1419   eval ac_new_val="\$ac_env_${ac_var}_value"
1420   case $ac_old_set,$ac_new_set in
1421     set,)
1422       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1423 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1424       ac_cache_corrupted=: ;;
1425     ,set)
1426       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1427 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1428       ac_cache_corrupted=: ;;
1429     ,);;
1430     *)
1431       if test "x$ac_old_val" != "x$ac_new_val"; then
1432         # differences in whitespace do not lead to failure.
1433         ac_old_val_w=`echo x $ac_old_val`
1434         ac_new_val_w=`echo x $ac_new_val`
1435         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1436           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1437 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1438           ac_cache_corrupted=:
1439         else
1440           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1441 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1442           eval $ac_var=\$ac_old_val
1443         fi
1444         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1445 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1446         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1447 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1448       fi;;
1449   esac
1450   # Pass precious variables to config.status.
1451   if test "$ac_new_set" = set; then
1452     case $ac_new_val in
1453     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1454       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1455     *) ac_arg=$ac_var=$ac_new_val ;;
1456     esac
1457     case " $ac_configure_args " in
1458       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1459       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1460     esac
1461   fi
1462 done
1463 if $ac_cache_corrupted; then
1464   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1465 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1466   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1467 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1468   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1469 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1470    { (exit 1); exit 1; }; }
1471 fi
1472
1473 ac_ext=c
1474 ac_cpp='$CPP $CPPFLAGS'
1475 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1476 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1477 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502 progname=$0
1503 # if PWD already has a value, it is probably wrong.
1504 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1505
1506 # Export original configure arguments for use by sub-configures.
1507 # Quote arguments with shell meta charatcers.
1508 TOPLEVEL_CONFIGURE_ARGUMENTS=
1509 set -- "$progname" "$@"
1510 for ac_arg
1511 do
1512   case "$ac_arg" in
1513   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1514     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1515     # if the argument is of the form -foo=baz, quote the baz part only
1516     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1517   *) ;;
1518   esac
1519   # Add the quoted argument to the list.
1520   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1521 done
1522 if test "$silent" = yes; then
1523   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1524 fi
1525 # Remove the initial space we just introduced and, as these will be
1526 # expanded by make, quote '$'.
1527 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1528
1529
1530 # Find the build, host, and target systems.
1531 ac_aux_dir=
1532 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1533   if test -f $ac_dir/install-sh; then
1534     ac_aux_dir=$ac_dir
1535     ac_install_sh="$ac_aux_dir/install-sh -c"
1536     break
1537   elif test -f $ac_dir/install.sh; then
1538     ac_aux_dir=$ac_dir
1539     ac_install_sh="$ac_aux_dir/install.sh -c"
1540     break
1541   elif test -f $ac_dir/shtool; then
1542     ac_aux_dir=$ac_dir
1543     ac_install_sh="$ac_aux_dir/shtool install -c"
1544     break
1545   fi
1546 done
1547 if test -z "$ac_aux_dir"; then
1548   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1549 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1550    { (exit 1); exit 1; }; }
1551 fi
1552 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1553 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1554 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1555
1556 # Make sure we can run config.sub.
1557 $ac_config_sub sun4 >/dev/null 2>&1 ||
1558   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1559 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1560    { (exit 1); exit 1; }; }
1561
1562 echo "$as_me:$LINENO: checking build system type" >&5
1563 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1564 if test "${ac_cv_build+set}" = set; then
1565   echo $ECHO_N "(cached) $ECHO_C" >&6
1566 else
1567   ac_cv_build_alias=$build_alias
1568 test -z "$ac_cv_build_alias" &&
1569   ac_cv_build_alias=`$ac_config_guess`
1570 test -z "$ac_cv_build_alias" &&
1571   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1572 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1573    { (exit 1); exit 1; }; }
1574 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1575   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1576 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1577    { (exit 1); exit 1; }; }
1578
1579 fi
1580 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1581 echo "${ECHO_T}$ac_cv_build" >&6
1582 build=$ac_cv_build
1583 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1584 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1585 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1586
1587
1588  case ${build_alias} in
1589   "") build_noncanonical=${build} ;;
1590   *) build_noncanonical=${build_alias} ;;
1591 esac
1592
1593
1594
1595  case ${host_alias} in
1596   "") host_noncanonical=${build_noncanonical} ;;
1597   *) host_noncanonical=${host_alias} ;;
1598 esac
1599
1600
1601
1602  case ${target_alias} in
1603   "") target_noncanonical=${host_noncanonical} ;;
1604   *) target_noncanonical=${target_alias} ;;
1605 esac
1606
1607
1608
1609
1610 test "$host_noncanonical" = "$target_noncanonical" &&
1611   test "$program_prefix$program_suffix$program_transform_name" = \
1612     NONENONEs,x,x, &&
1613   program_transform_name=s,y,y,
1614
1615 echo "$as_me:$LINENO: checking host system type" >&5
1616 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1617 if test "${ac_cv_host+set}" = set; then
1618   echo $ECHO_N "(cached) $ECHO_C" >&6
1619 else
1620   ac_cv_host_alias=$host_alias
1621 test -z "$ac_cv_host_alias" &&
1622   ac_cv_host_alias=$ac_cv_build_alias
1623 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1624   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1625 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1626    { (exit 1); exit 1; }; }
1627
1628 fi
1629 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1630 echo "${ECHO_T}$ac_cv_host" >&6
1631 host=$ac_cv_host
1632 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1633 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1634 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1635
1636
1637 echo "$as_me:$LINENO: checking target system type" >&5
1638 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1639 if test "${ac_cv_target+set}" = set; then
1640   echo $ECHO_N "(cached) $ECHO_C" >&6
1641 else
1642   ac_cv_target_alias=$target_alias
1643 test "x$ac_cv_target_alias" = "x" &&
1644   ac_cv_target_alias=$ac_cv_host_alias
1645 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1646   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1647 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1648    { (exit 1); exit 1; }; }
1649
1650 fi
1651 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1652 echo "${ECHO_T}$ac_cv_target" >&6
1653 target=$ac_cv_target
1654 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1655 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1656 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1657
1658
1659 # The aliases save the names the user supplied, while $host etc.
1660 # will get canonicalized.
1661 test -n "$target_alias" &&
1662   test "$program_prefix$program_suffix$program_transform_name" = \
1663     NONENONEs,x,x, &&
1664   program_prefix=${target_alias}-
1665 test "$program_prefix" != NONE &&
1666   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1667 # Use a double $ so make ignores it.
1668 test "$program_suffix" != NONE &&
1669   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1670 # Double any \ or $.  echo might interpret backslashes.
1671 # By default was `s,x,x', remove it if useless.
1672 cat <<\_ACEOF >conftest.sed
1673 s/[\\$]/&&/g;s/;s,x,x,$//
1674 _ACEOF
1675 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1676 rm conftest.sed
1677
1678
1679
1680 # Get 'install' or 'install-sh' and its variants.
1681 # Find a good install program.  We prefer a C program (faster),
1682 # so one script is as good as another.  But avoid the broken or
1683 # incompatible versions:
1684 # SysV /etc/install, /usr/sbin/install
1685 # SunOS /usr/etc/install
1686 # IRIX /sbin/install
1687 # AIX /bin/install
1688 # AmigaOS /C/install, which installs bootblocks on floppy discs
1689 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1690 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1691 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1692 # OS/2's system install, which has a completely different semantic
1693 # ./install, which can be erroneously created by make from ./install.sh.
1694 # Reject install programs that cannot install multiple files.
1695 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1696 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1697 if test -z "$INSTALL"; then
1698 if test "${ac_cv_path_install+set}" = set; then
1699   echo $ECHO_N "(cached) $ECHO_C" >&6
1700 else
1701   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1702 for as_dir in $PATH
1703 do
1704   IFS=$as_save_IFS
1705   test -z "$as_dir" && as_dir=.
1706   # Account for people who put trailing slashes in PATH elements.
1707 case $as_dir/ in
1708   ./ | .// | /cC/* | \
1709   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1710   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1711   /usr/ucb/* ) ;;
1712   *)
1713     # OSF1 and SCO ODT 3.0 have their own names for install.
1714     # Don't use installbsd from OSF since it installs stuff as root
1715     # by default.
1716     for ac_prog in ginstall scoinst install; do
1717       for ac_exec_ext in '' $ac_executable_extensions; do
1718         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1719           if test $ac_prog = install &&
1720             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1721             # AIX install.  It has an incompatible calling convention.
1722             :
1723           elif test $ac_prog = install &&
1724             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1725             # program-specific install script used by HP pwplus--don't use.
1726             :
1727           else
1728             rm -rf conftest.one conftest.two conftest.dir
1729             echo one > conftest.one
1730             echo two > conftest.two
1731             mkdir conftest.dir
1732             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1733               test -s conftest.one && test -s conftest.two &&
1734               test -s conftest.dir/conftest.one &&
1735               test -s conftest.dir/conftest.two
1736             then
1737               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1738               break 3
1739             fi
1740           fi
1741         fi
1742       done
1743     done
1744     ;;
1745 esac
1746 done
1747
1748 rm -rf conftest.one conftest.two conftest.dir
1749
1750 fi
1751   if test "${ac_cv_path_install+set}" = set; then
1752     INSTALL=$ac_cv_path_install
1753   else
1754     # As a last resort, use the slow shell script.  Don't cache a
1755     # value for INSTALL within a source directory, because that will
1756     # break other packages using the cache if that directory is
1757     # removed, or if the value is a relative name.
1758     INSTALL=$ac_install_sh
1759   fi
1760 fi
1761 echo "$as_me:$LINENO: result: $INSTALL" >&5
1762 echo "${ECHO_T}$INSTALL" >&6
1763
1764 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1765 # It thinks the first close brace ends the variable substitution.
1766 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1767
1768 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1769
1770 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1771
1772 echo "$as_me:$LINENO: checking whether ln works" >&5
1773 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1774 if test "${acx_cv_prog_LN+set}" = set; then
1775   echo $ECHO_N "(cached) $ECHO_C" >&6
1776 else
1777   rm -f conftestdata_t
1778 echo >conftestdata_f
1779 if ln conftestdata_f conftestdata_t 2>/dev/null
1780 then
1781   acx_cv_prog_LN=ln
1782 else
1783   acx_cv_prog_LN=no
1784 fi
1785 rm -f conftestdata_f conftestdata_t
1786
1787 fi
1788 if test $acx_cv_prog_LN = no; then
1789   LN="cp"
1790   echo "$as_me:$LINENO: result: no, using $LN" >&5
1791 echo "${ECHO_T}no, using $LN" >&6
1792 else
1793   LN="$acx_cv_prog_LN"
1794   echo "$as_me:$LINENO: result: yes" >&5
1795 echo "${ECHO_T}yes" >&6
1796 fi
1797
1798 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1799 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1800 LN_S=$as_ln_s
1801 if test "$LN_S" = "ln -s"; then
1802   echo "$as_me:$LINENO: result: yes" >&5
1803 echo "${ECHO_T}yes" >&6
1804 else
1805   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1806 echo "${ECHO_T}no, using $LN_S" >&6
1807 fi
1808
1809
1810 ### we might need to use some other shell than /bin/sh for running subshells
1811 ### If we are on Windows, search for the shell.  This will permit people
1812 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1813 ### without also having to set CONFIG_SHELL.  This code will work when
1814 ### using bash, which sets OSTYPE.
1815 case "${OSTYPE}" in
1816 *win32*)
1817   if test x${CONFIG_SHELL} = x ; then
1818     if test ! -f /bin/sh ; then
1819       if test x${SHELL} != x && test -f ${SHELL} ; then
1820         CONFIG_SHELL=${SHELL}
1821         export CONFIG_SHELL
1822       else
1823         for prog in sh sh.exe bash bash.exe; do
1824           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1825           for dir in $PATH; do
1826             test -z "$dir" && dir=.
1827             if test -f $dir/$prog; then
1828               CONFIG_SHELL=$dir/$prog
1829               export CONFIG_SHELL
1830               break
1831             fi
1832           done
1833           IFS="$save_ifs"
1834           test -n "${CONFIG_SHELL}" && break
1835         done
1836       fi
1837     fi
1838   fi
1839   ;;
1840 esac
1841
1842 config_shell=${CONFIG_SHELL-/bin/sh}
1843
1844 moveifchange=${srcdir}/move-if-change
1845
1846 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1847
1848 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1849 # a relative path.
1850 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1851   INSTALL="${srcpwd}/install-sh -c"
1852 fi
1853
1854 # Set srcdir to "." if that's what it is.
1855 # This is important for multilib support.
1856 pwd=`${PWDCMD-pwd}`
1857 if test "${pwd}" = "${srcpwd}" ; then
1858   srcdir=.
1859 fi
1860
1861 topsrcdir=$srcpwd
1862
1863 extra_host_args=
1864
1865 ### To add a new directory to the tree, first choose whether it is a target
1866 ### or a host dependent tool.  Then put it into the appropriate list
1867 ### (library or tools, host or target), doing a dependency sort.
1868
1869 # Subdirs will be configured in the order listed in build_configdirs,
1870 # configdirs, or target_configdirs; see the serialization section below.
1871
1872 # Dependency sorting is only needed when *configuration* must be done in
1873 # a particular order.  In all cases a dependency should be specified in
1874 # the Makefile, whether or not it's implicitly specified here.
1875
1876 # Double entries in build_configdirs, configdirs, or target_configdirs may
1877 # cause circular dependencies and break everything horribly.
1878
1879 # these library is used by various programs built for the build
1880 # environment
1881 #
1882 build_libs="build-libiberty"
1883
1884 # these tools are built for the build environment
1885 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1886
1887 # these libraries are used by various programs built for the host environment
1888 #
1889 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr ppl cloog"
1890
1891 # these tools are built for the host environment
1892 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1893 # know that we are building the simulator.
1894 # binutils, gas and ld appear in that order because it makes sense to run
1895 # "make check" in that particular order.
1896 # If --enable-gold is used, "gold" will replace "ld".
1897 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"
1898
1899 # libgcj represents the runtime libraries only used by gcj.
1900 libgcj="target-libffi \
1901         target-zlib \
1902         target-qthreads \
1903         target-libjava"
1904
1905 # these libraries are built for the target environment, and are built after
1906 # the host libraries and the host tools (which may be a cross compiler)
1907 #
1908 target_libraries="target-libgcc \
1909                 target-libiberty \
1910                 target-libgloss \
1911                 target-newlib \
1912                 target-libgomp \
1913                 target-libstdc++-v3 \
1914                 target-libmudflap \
1915                 target-libssp \
1916                 target-libgfortran \
1917                 target-boehm-gc \
1918                 ${libgcj} \
1919                 target-libobjc \
1920                 target-libada"
1921
1922 # these tools are built using the target libraries, and are intended to
1923 # run only in the target environment
1924 #
1925 # note: any program that *uses* libraries that are in the "target_libraries"
1926 # list belongs in this list.  those programs are also very likely
1927 # candidates for the "native_only" list which follows
1928 #
1929 target_tools="target-examples target-groff target-gperf target-rda"
1930
1931 ################################################################################
1932
1933 ## All tools belong in one of the four categories, and are assigned above
1934 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1935 ## is important because configure will choke if they ever get through.
1936 ## ${configdirs} is directories we build using the host tools.
1937 ## ${target_configdirs} is directories we build using the target tools.
1938 configdirs=`echo ${host_libs} ${host_tools}`
1939 target_configdirs=`echo ${target_libraries} ${target_tools}`
1940 build_configdirs=`echo ${build_libs} ${build_tools}`
1941
1942
1943
1944 ################################################################################
1945
1946 srcname="gnu development package"
1947
1948 # This gets set non-empty for some net releases of packages.
1949 appdirs=""
1950
1951 # Define is_cross_compiler to save on calls to 'test'.
1952 is_cross_compiler=
1953 if test x"${host}" = x"${target}" ; then
1954   is_cross_compiler=no
1955 else
1956   is_cross_compiler=yes
1957 fi
1958
1959 # Find the build and target subdir names.
1960
1961 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1962 # have matching libraries, they should use host libraries: Makefile.tpl
1963 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1964 # However, they still use the build modules, because the corresponding
1965 # host modules (e.g. bison) are only built for the host when bootstrap
1966 # finishes. So:
1967 # - build_subdir is where we find build modules, and never changes.
1968 # - build_libsubdir is where we find build libraries, and can be overridden.
1969
1970 # Prefix 'build-' so this never conflicts with target_subdir.
1971 build_subdir="build-${build_noncanonical}"
1972
1973 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1974 if test "${with_build_libsubdir+set}" = set; then
1975   withval="$with_build_libsubdir"
1976   build_libsubdir="$withval"
1977 else
1978   build_libsubdir="$build_subdir"
1979 fi;
1980 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1981 if ( test $srcdir = . && test -d gcc ) \
1982    || test -d $srcdir/../host-${host_noncanonical}; then
1983   host_subdir="host-${host_noncanonical}"
1984 else
1985   host_subdir=.
1986 fi
1987 # No prefix.
1988 target_subdir=${target_noncanonical}
1989
1990
1991 # Skipdirs are removed silently.
1992 skipdirs=
1993 # Noconfigdirs are removed loudly.
1994 noconfigdirs=""
1995
1996 use_gnu_ld=
1997 # Make sure we don't let GNU ld be added if we didn't want it.
1998 if test x$with_gnu_ld = xno ; then
1999   use_gnu_ld=no
2000   noconfigdirs="$noconfigdirs ld gold"
2001 fi
2002
2003 use_gnu_as=
2004 # Make sure we don't let GNU as be added if we didn't want it.
2005 if test x$with_gnu_as = xno ; then
2006   use_gnu_as=no
2007   noconfigdirs="$noconfigdirs gas"
2008 fi
2009
2010 # some tools are so dependent upon X11 that if we're not building with X,
2011 # it's not even worth trying to configure, much less build, that tool.
2012
2013 case ${with_x} in
2014   yes | "") ;; # the default value for this tree is that X11 is available
2015   no)
2016     skipdirs="${skipdirs} tk itcl libgui"
2017     # We won't be able to build gdbtk without X.
2018     enable_gdbtk=no
2019     ;;
2020   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2021 esac
2022
2023 # Some tools are only suitable for building in a "native" situation.
2024 # Remove these if host!=target.
2025 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"
2026
2027 # Similarly, some are only suitable for cross toolchains.
2028 # Remove these if host=target.
2029 cross_only="target-libgloss target-newlib target-opcodes"
2030
2031 case $is_cross_compiler in
2032   no) skipdirs="${skipdirs} ${cross_only}" ;;
2033   yes) skipdirs="${skipdirs} ${native_only}" ;;
2034 esac
2035
2036 # If both --with-headers and --with-libs are specified, default to
2037 # --without-newlib.
2038 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2039    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2040   if test x"${with_newlib}" = x ; then
2041     with_newlib=no
2042   fi
2043 fi
2044
2045 # Recognize --with-newlib/--without-newlib.
2046 case ${with_newlib} in
2047   no) skipdirs="${skipdirs} target-newlib" ;;
2048   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2049 esac
2050
2051 # Handle --enable-gold.
2052
2053 # Check whether --enable-gold or --disable-gold was given.
2054 if test "${enable_gold+set}" = set; then
2055   enableval="$enable_gold"
2056   ENABLE_GOLD=$enableval
2057 else
2058   ENABLE_GOLD=no
2059 fi;
2060 if test "${ENABLE_GOLD}" = "yes"; then
2061   # Check for ELF target.
2062   is_elf=no
2063   case "${target}" in
2064     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2065     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2066     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2067       case "${target}" in
2068         *-*-linux*aout* | *-*-linux*oldld*)
2069           ;;
2070         *)
2071           is_elf=yes
2072           ;;
2073       esac
2074   esac
2075
2076   if test "$is_elf" = "yes"; then
2077     # Check for target supported by gold.
2078     case "${target}" in
2079       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-*)
2080         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2081         ;;
2082     esac
2083   fi
2084 fi
2085
2086 # Configure extra directories which are host specific
2087
2088 case "${host}" in
2089   *-cygwin*)
2090     configdirs="$configdirs libtermcap" ;;
2091 esac
2092
2093 # A target can indicate whether a language isn't supported for some reason.
2094 # Only spaces may be used in this macro; not newlines or tabs.
2095 unsupported_languages=
2096
2097 # Remove more programs from consideration, based on the host or
2098 # target this usually means that a port of the program doesn't
2099 # exist yet.
2100
2101 case "${host}" in
2102   hppa*64*-*-*)
2103     noconfigdirs="$noconfigdirs byacc"
2104     ;;
2105   i[3456789]86-*-vsta)
2106     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2107     ;;
2108   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2109     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2110     ;;
2111   x86_64-*-mingw*)
2112     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2113     ;;
2114   i[3456789]86-*-mingw32*)
2115     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2116     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2117     ;;
2118   i[3456789]86-*-beos*)
2119     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2120     ;;
2121   *-*-cygwin*)
2122     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2123     ;;
2124   *-*-netbsd*)
2125     noconfigdirs="$noconfigdirs rcs"
2126     ;;
2127   ppc*-*-pe)
2128     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2129     ;;
2130   powerpc-*-beos*)
2131     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2132     ;;
2133 esac
2134
2135
2136 # Check whether --enable-libada or --disable-libada was given.
2137 if test "${enable_libada+set}" = set; then
2138   enableval="$enable_libada"
2139   ENABLE_LIBADA=$enableval
2140 else
2141   ENABLE_LIBADA=yes
2142 fi;
2143 if test "${ENABLE_LIBADA}" != "yes" ; then
2144   noconfigdirs="$noconfigdirs gnattools"
2145 fi
2146
2147 # Check whether --enable-libssp or --disable-libssp was given.
2148 if test "${enable_libssp+set}" = set; then
2149   enableval="$enable_libssp"
2150   ENABLE_LIBSSP=$enableval
2151 else
2152   ENABLE_LIBSSP=yes
2153 fi;
2154
2155 # Save it here so that, even in case of --enable-libgcj, if the Java
2156 # front-end isn't enabled, we still get libgcj disabled.
2157 libgcj_saved=$libgcj
2158 case $enable_libgcj in
2159 yes)
2160   # If we reset it here, it won't get added to noconfigdirs in the
2161   # target-specific build rules, so it will be forcibly enabled
2162   # (unless the Java language itself isn't enabled).
2163   libgcj=
2164   ;;
2165 no)
2166   # Make sure we get it printed in the list of not supported target libs.
2167   noconfigdirs="$noconfigdirs ${libgcj}"
2168   ;;
2169 esac
2170
2171
2172 # Disable libmudflap on some systems.
2173 if test x$enable_libmudflap = x ; then
2174     case "${target}" in
2175     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2176         # Enable libmudflap by default in GNU and friends.
2177         ;;
2178     *-*-freebsd*)
2179         # Enable libmudflap by default in FreeBSD.
2180         ;;
2181     *)
2182         # Disable it by default everywhere else.
2183         noconfigdirs="$noconfigdirs target-libmudflap"
2184         ;;
2185     esac
2186 fi
2187
2188 # Disable libgomp on non POSIX hosted systems.
2189 if test x$enable_libgomp = x ; then
2190     # Enable libgomp by default on hosted POSIX systems.
2191     case "${target}" in
2192     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2193         ;;
2194     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2195         ;;
2196     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2197         ;;
2198     *-*-darwin* | *-*-aix*)
2199         ;;
2200     *)
2201         noconfigdirs="$noconfigdirs target-libgomp"
2202         ;;
2203     esac
2204 fi
2205
2206 # Default libgloss CPU subdirectory.
2207 libgloss_dir="$target_cpu"
2208
2209 case "${target}" in
2210   *-*-chorusos)
2211     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2212     ;;
2213   powerpc-*-darwin* | i[3456789]86-*-darwin* | x86_64-*-darwin9*)
2214     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2215     noconfigdirs="$noconfigdirs sim target-rda"
2216     ;;
2217   *-*-darwin*)
2218     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2219     noconfigdirs="$noconfigdirs sim target-rda"
2220     noconfigdirs="$noconfigdirs ${libgcj}"
2221     ;;
2222   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2223     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2224     ;;
2225   *-*-freebsd*)
2226     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2227     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2228         && test -f /usr/local/include/gmp.h; then
2229       with_gmp=/usr/local
2230     fi
2231
2232     # Skip some stuff that's unsupported on some FreeBSD configurations.
2233     case "${target}" in
2234       i*86-*-*) ;;
2235       alpha*-*-*) ;;
2236       *)
2237         noconfigdirs="$noconfigdirs ${libgcj}"
2238         ;;
2239     esac
2240     ;;
2241   *-*-kaos*)
2242     # Remove unsupported stuff on all kaOS configurations.
2243     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2244     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2245     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2246     noconfigdirs="$noconfigdirs target-libgloss"
2247     ;;
2248   *-*-netbsd*)
2249     # Skip some stuff on all NetBSD configurations.
2250     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2251
2252     # Skip some stuff that's unsupported on some NetBSD configurations.
2253     case "${target}" in
2254       i*86-*-netbsdelf*) ;;
2255       arm*-*-netbsdelf*) ;;
2256       *)
2257         noconfigdirs="$noconfigdirs ${libgcj}"
2258         ;;
2259     esac
2260     ;;
2261   *-*-netware*)
2262     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2263     ;;
2264   *-*-rtems*)
2265     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2266     ;;
2267     # The tpf target doesn't support gdb yet.
2268   *-*-tpf*)
2269     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2270     ;;
2271   *-*-uclinux*)
2272     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2273     ;;
2274   *-*-vxworks*)
2275     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2276     ;;
2277   alpha*-dec-osf*)
2278     # ld works, but does not support shared libraries.
2279     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2280     # gas doesn't generate exception information.
2281     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2282     ;;
2283   alpha*-*-*vms*)
2284     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2285     ;;
2286   alpha*-*-linux*)
2287     # newlib is not 64 bit ready
2288     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2289     ;;
2290   alpha*-*-*)
2291     # newlib is not 64 bit ready
2292     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2293     ;;
2294   am33_2.0-*-linux*)
2295     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2296     ;;
2297   sh-*-linux*)
2298     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2299     ;;
2300   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2301     noconfigdirs="$noconfigdirs ${libgcj}"
2302     noconfigdirs="$noconfigdirs target-examples"
2303     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2304     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2305     noconfigdirs="$noconfigdirs expect dejagnu"
2306     # the C++ libraries don't build on top of CE's C libraries
2307     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2308     noconfigdirs="$noconfigdirs target-newlib"
2309     case "${host}" in
2310       *-*-cygwin*) ;; # keep gdb and readline
2311       *) noconfigdirs="$noconfigdirs gdb readline"
2312          ;;
2313     esac
2314     libgloss_dir=wince
2315     ;;
2316   arc-*-*)
2317     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2318     ;;
2319   arm-semi-aof )
2320     ;;
2321   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2322     noconfigdirs="$noconfigdirs ${libgcj}"
2323     libgloss_dir=arm
2324     ;;
2325   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2326     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2327     libgloss_dir=arm
2328     ;;
2329   arm*-*-linux-gnueabi)
2330     noconfigdirs="$noconfigdirs target-qthreads"
2331     case ${with_newlib} in
2332       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2333     esac
2334     libgloss_dir=arm
2335     ;;
2336   arm*-*-symbianelf*)
2337     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2338     libgloss_dir=arm
2339     ;;
2340   arm-*-pe*)
2341     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2342     ;;
2343   thumb-*-coff)
2344     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2345     ;;
2346   thumb-*-elf)
2347     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2348     ;;
2349   thumb-*-pe)
2350     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2351     ;;
2352   arm-*-riscix*)
2353     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2354     ;;
2355   avr-*-*)
2356     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2357     ;;
2358   bfin-*-*)
2359     noconfigdirs="$noconfigdirs gdb"
2360     if test x${is_cross_compiler} != xno ; then
2361       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2362     fi
2363     ;;
2364   c4x-*-* | tic4x-*-*)
2365     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2366     ;;
2367   c54x*-*-* | tic54x-*-*)
2368     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2369     ;;
2370   cr16-*-*)
2371     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2372     ;;
2373   cris-*-* | crisv32-*-*)
2374     unsupported_languages="$unsupported_languages java"
2375     case "${target}" in
2376       *-*-aout)
2377         unsupported_languages="$unsupported_languages fortran"
2378         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2379       *-*-elf)
2380         noconfigdirs="$noconfigdirs target-boehm-gc";;
2381       *-*-linux*)
2382         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2383       *)
2384         unsupported_languages="$unsupported_languages fortran"
2385         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2386     esac
2387     libgloss_dir=cris
2388     ;;
2389   crx-*-*)
2390     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2391     ;;
2392   d10v-*-*)
2393     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2394     ;;
2395   d30v-*-*)
2396     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2397     ;;
2398   ep9312-*-elf | ep9312-*-coff)
2399     libgloss_dir=arm
2400     ;;
2401   fr30-*-elf*)
2402     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2403     ;;
2404   frv-*-*)
2405     noconfigdirs="$noconfigdirs ${libgcj}"
2406     ;;
2407   h8300*-*-*)
2408     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2409     ;;
2410   h8500-*-*)
2411     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2412     ;;
2413   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2414     ;;
2415   hppa*64*-*-linux* | parisc*64*-*-linux*)
2416     # In this case, it's because the hppa64-linux target is for
2417     # the kernel only at this point and has no libc, and thus no
2418     # headers, crt*.o, etc., all of which are needed by these.
2419     noconfigdirs="$noconfigdirs target-zlib"
2420     ;;
2421   parisc*-*-linux* | hppa*-*-linux*)
2422     ;;
2423   hppa*-*-*elf* | \
2424   hppa*-*-lites* | \
2425   hppa*-*-openbsd* | \
2426   hppa*64*-*-*)
2427     noconfigdirs="$noconfigdirs ${libgcj}"
2428     ;;
2429   hppa*-hp-hpux11*)
2430     noconfigdirs="$noconfigdirs ld shellutils"
2431     ;;
2432   hppa*-*-pro*)
2433     libgloss_dir=pa
2434     ;;
2435   hppa*-*-*)
2436     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2437     # build on HP-UX 10.20.
2438     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2439     ;;
2440   i960-*-*)
2441     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2442     ;;
2443   ia64*-*-elf*)
2444     # No gdb support yet.
2445     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2446     ;;
2447   ia64*-**-hpux*)
2448     # No gdb or ld support yet.
2449     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2450     ;;
2451   i370-*-opened*)
2452     ;;
2453   i[3456789]86-*-coff | i[3456789]86-*-elf)
2454     noconfigdirs="$noconfigdirs ${libgcj}"
2455     libgloss_dir=i386
2456     ;;
2457   i[3456789]86-*-linux*)
2458     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2459     # not build java stuff by default.
2460     case "${target}" in
2461       *-*-*libc1*)
2462         noconfigdirs="$noconfigdirs ${libgcj}";;
2463     esac
2464
2465     # This section makes it possible to build newlib natively on linux.
2466     # If we are using a cross compiler then don't configure newlib.
2467     if test x${is_cross_compiler} != xno ; then
2468       noconfigdirs="$noconfigdirs target-newlib"
2469     fi
2470     noconfigdirs="$noconfigdirs target-libgloss"
2471     # If we are not using a cross compiler, do configure newlib.
2472     # Note however, that newlib will only be configured in this situation
2473     # if the --with-newlib option has been given, because otherwise
2474     # 'target-newlib' will appear in skipdirs.
2475     ;;
2476   i[3456789]86-*-mingw32*)
2477     target_configdirs="$target_configdirs target-winsup"
2478     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2479     ;;
2480   x86_64-*-mingw*)
2481     target_configdirs="$target_configdirs target-winsup"
2482     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2483     ;;
2484   *-*-cygwin*)
2485     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2486     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2487     # always build newlib if winsup directory is present.
2488     if test -d "$srcdir/winsup/cygwin"; then
2489       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2490     elif test -d "$srcdir/newlib"; then
2491       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2492     fi
2493     ;;
2494   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2495   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2496     ;;
2497   i[3456789]86-*-pe)
2498     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2499     ;;
2500   i[3456789]86-*-sco3.2v5*)
2501     # The linker does not yet know about weak symbols in COFF,
2502     # and is not configured to handle mixed ELF and COFF.
2503     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2504     ;;
2505   i[3456789]86-*-sco*)
2506     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2507     ;;
2508   i[3456789]86-*-solaris2*)
2509     noconfigdirs="$noconfigdirs target-libgloss"
2510     ;;
2511   i[3456789]86-*-sysv4*)
2512     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2513     ;;
2514   i[3456789]86-*-beos*)
2515     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2516     ;;
2517   i[3456789]86-*-rdos*)
2518     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2519     ;;
2520   m32r-*-*)
2521     noconfigdirs="$noconfigdirs ${libgcj}"
2522     ;;
2523   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2524     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2525     libgloss_dir=m68hc11
2526     ;;
2527   m68k-*-elf*)
2528     noconfigdirs="$noconfigdirs ${libgcj}"
2529     ;;
2530   m68k-*-coff*)
2531     noconfigdirs="$noconfigdirs ${libgcj}"
2532     ;;
2533   m68*-*-* | fido-*-*)
2534     libgloss_dir=m68k
2535     ;;
2536   mcore-*-pe*)
2537   # The EPOC C++ environment does not support exceptions or rtti,
2538   # and so building libstdc++-v3 tends not to always work.
2539     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2540     ;;
2541   mmix-*-*)
2542     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2543     unsupported_languages="$unsupported_languages fortran java"
2544     ;;
2545   mn10200-*-*)
2546     noconfigdirs="$noconfigdirs ${libgcj}"
2547     ;;
2548   mn10300-*-*)
2549     noconfigdirs="$noconfigdirs ${libgcj}"
2550     ;;
2551   mt-*-*)
2552     noconfigdirs="$noconfigdirs sim"
2553     ;;
2554   powerpc-*-aix*)
2555     # copied from rs6000-*-* entry
2556     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2557     ;;
2558   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2559     target_configdirs="$target_configdirs target-winsup"
2560     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2561     # always build newlib.
2562     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2563     ;;
2564     # This is temporary until we can link against shared libraries
2565   powerpcle-*-solaris*)
2566     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2567     libgloss_dir=rs6000
2568     ;;
2569   powerpc-*-beos*)
2570     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2571     ;;
2572   powerpc-*-eabi)
2573     noconfigdirs="$noconfigdirs ${libgcj}"
2574     libgloss_dir=rs6000
2575     ;;
2576   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2577     libgloss_dir=rs6000
2578     ;;
2579   rs6000-*-lynxos*)
2580     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2581     ;;
2582   rs6000-*-aix*)
2583     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2584     ;;
2585   rs6000-*-*)
2586     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2587     ;;
2588   m68k-apollo-*)
2589     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2590     ;;
2591   mips*-sde-elf*)
2592     skipdirs="$skipdirs target-libiberty"
2593     noconfigdirs="$noconfigdirs ${libgcj}"
2594     if test x$with_newlib = xyes; then
2595       noconfigdirs="$noconfigdirs gprof"
2596     fi
2597     libgloss_dir=mips
2598     ;;
2599   mips*-*-irix5*)
2600     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2601     ;;
2602   mips*-*-irix6*)
2603     # Linking libjava exceeds command-line length limits on at least
2604     # IRIX 6.2, but not on IRIX 6.5.
2605     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2606     # <oldham@codesourcery.com>
2607     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2608     ;;
2609   mips*-*-bsd*)
2610     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2611     ;;
2612   mips*-*-linux*)
2613     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2614     ;;
2615   mips*-*-*)
2616     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2617     libgloss_dir=mips
2618     ;;
2619   romp-*-*)
2620     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2621     ;;
2622   sh-*-* | sh64-*-*)
2623     case "${host}" in
2624       i[3456789]86-*-vsta) ;; # don't add gprof back in
2625       i[3456789]86-*-go32*) ;; # don't add gprof back in
2626       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2627       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2628     esac
2629     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2630     ;;
2631   sparclet-*-aout* | sparc86x-*-*)
2632     libgloss_dir=sparc
2633     ;;
2634   sparc-*-elf*)
2635     noconfigdirs="$noconfigdirs ${libgcj}"
2636     ;;
2637   sparc64-*-elf*)
2638     noconfigdirs="$noconfigdirs ${libgcj}"
2639     libgloss_dir=sparc
2640     ;;
2641   sparclite-*-*)
2642     noconfigdirs="$noconfigdirs ${libgcj}"
2643     libgloss_dir=sparc
2644     ;;
2645   sparc-*-sunos4*)
2646     noconfigdirs="$noconfigdirs ${libgcj}"
2647     if test x${is_cross_compiler} != xno ; then
2648            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2649     else
2650            use_gnu_ld=no
2651     fi
2652     ;;
2653   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2654     noconfigdirs="$noconfigdirs ${libgcj}"
2655     ;;
2656   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2657     ;;
2658   spu-*-*)
2659     ;;
2660   v810-*-*)
2661     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2662     ;;
2663   v850-*-*)
2664     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2665     ;;
2666   v850e-*-*)
2667     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2668     ;;
2669   v850ea-*-*)
2670     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2671     ;;
2672   vax-*-vms)
2673     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2674     ;;
2675   vax-*-*)
2676     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2677     ;;
2678   xtensa*-*-*)
2679     noconfigdirs="$noconfigdirs ${libgcj}"
2680     ;;
2681   ip2k-*-*)
2682     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2683     ;;
2684   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2685     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2686     ;;
2687   *-*-lynxos*)
2688     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2689     ;;
2690   *-*-*)
2691     noconfigdirs="$noconfigdirs ${libgcj}"
2692     ;;
2693 esac
2694
2695 # If we aren't building newlib, then don't build libgloss, since libgloss
2696 # depends upon some newlib header files.
2697 case "${noconfigdirs}" in
2698   *target-libgloss*) ;;
2699   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2700 esac
2701
2702 # Work in distributions that contain no compiler tools, like Autoconf.
2703 tentative_cc=""
2704 host_makefile_frag=/dev/null
2705 if test -d ${srcdir}/config ; then
2706 case "${host}" in
2707   m68k-hp-hpux*)
2708     # Avoid "too much defining" errors from HPUX compiler.
2709     tentative_cc="cc -Wp,-H256000"
2710     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2711     # If it's HP/UX ar, this should be harmless.
2712     RANLIB="ar ts"
2713     ;;
2714   m68k-apollo-sysv*)
2715     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2716     ;;
2717   m68k-apollo-bsd*)
2718     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2719     # chokes on bfd, the compiler won't let you assign integers to enums, and
2720     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2721     # the apollo compiler" (the preferred version of GCC could be called cc,
2722     # or whatever), but I'm not sure leaving CC as cc is any better...
2723     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2724     # Used to have BISON=yacc.
2725     tentative_cc=gcc
2726     ;;
2727   m88k-dg-dgux*)
2728     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2729     ;;
2730   m88k-harris-cxux*)
2731     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2732     tentative_cc="cc -Xa"
2733     host_makefile_frag="config/mh-cxux"
2734     ;;
2735   m88k-motorola-sysv*)
2736     ;;
2737   mips*-dec-ultrix*)
2738     tentative_cc="cc -Wf,-XNg1000"
2739     host_makefile_frag="config/mh-decstation"
2740     ;;
2741   mips*-nec-sysv4*)
2742     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2743     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2744     host_makefile_frag="config/mh-necv4"
2745     ;;
2746   mips*-sgi-irix4*)
2747     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2748     # environment.  Also bump switch table size so that cp-parse will
2749     # compile.  Bump string length limit so linker builds.
2750     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2751     ;;
2752   mips*-*-sysv4*)
2753     host_makefile_frag="config/mh-sysv4"
2754     ;;
2755   mips*-*-sysv*)
2756     # This is for a MIPS running RISC/os 4.52C.
2757
2758     # This is needed for GDB, but needs to be in the top-level make because
2759     # if a library is compiled with the bsd headers and gets linked with the
2760     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2761     # a different size).
2762     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2763     # known except to select the sysv environment.  Could we use /proc instead?
2764     # These "sysv environments" and "bsd environments" often end up being a pain.
2765     #
2766     # This is not part of CFLAGS because perhaps not all C compilers have this
2767     # option.
2768     tentative_cc="cc -systype sysv"
2769     ;;
2770   i370-ibm-opened*)
2771     tentative_cc="c89"
2772     ;;
2773   i[3456789]86-*-sysv5*)
2774     host_makefile_frag="config/mh-sysv5"
2775     ;;
2776   i[3456789]86-*-dgux*)
2777     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2778     host_makefile_frag="config/mh-dgux386"
2779     ;;
2780   i[3456789]86-ncr-sysv4.3*)
2781     # The MetaWare compiler will generate a copyright message unless you
2782     # turn it off by adding the -Hnocopyr flag.
2783     tentative_cc="cc -Hnocopyr"
2784     ;;
2785   i[3456789]86-ncr-sysv4*)
2786     # for an NCR 3000 (i486/SVR4) system.
2787     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2788     # This compiler not only emits obnoxious copyright messages every time
2789     # you run it, but it chokes and dies on a whole bunch of GNU source
2790     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2791     tentative_cc="/usr/ccs/ATT/cc"
2792     host_makefile_frag="config/mh-ncr3000"
2793     ;;
2794   i[3456789]86-*-sco3.2v5*)
2795     ;;
2796   i[3456789]86-*-sco*)
2797     # The native C compiler botches some simple uses of const.  Unfortunately,
2798     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2799     tentative_cc="cc -Dconst="
2800     host_makefile_frag="config/mh-sco"
2801     ;;
2802   i[3456789]86-*-udk*)
2803     host_makefile_frag="config/mh-sysv5"
2804     ;;
2805   i[3456789]86-*-solaris2*)
2806     host_makefile_frag="config/mh-sysv4"
2807     ;;
2808   i[3456789]86-*-msdosdjgpp*)
2809     host_makefile_frag="config/mh-djgpp"
2810     ;;
2811   *-cygwin*)
2812
2813 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2814 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2815 echo a >cygwin-cat-check
2816 if test `cat cygwin-cat-check` == a ; then
2817   rm cygwin-cat-check
2818   echo "$as_me:$LINENO: result: yes" >&5
2819 echo "${ECHO_T}yes" >&6
2820 else
2821   rm cygwin-cat-check
2822   echo "$as_me:$LINENO: result: no" >&5
2823 echo "${ECHO_T}no" >&6
2824   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2825   Please either mount the build directory in binary mode or run the following
2826   commands before running any configure script:
2827 set -o igncr
2828 export SHELLOPTS
2829   " >&5
2830 echo "$as_me: error: The cat command does not ignore carriage return characters.
2831   Please either mount the build directory in binary mode or run the following
2832   commands before running any configure script:
2833 set -o igncr
2834 export SHELLOPTS
2835   " >&2;}
2836    { (exit 1); exit 1; }; }
2837 fi
2838
2839     host_makefile_frag="config/mh-cygwin"
2840     ;;
2841   *-mingw*)
2842     host_makefile_frag="config/mh-mingw"
2843     ;;
2844   *-interix*)
2845     host_makefile_frag="config/mh-interix"
2846     ;;
2847   vax-*-ultrix2*)
2848     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2849     tentative_cc=gcc
2850     ;;
2851   *-*-solaris2*)
2852     host_makefile_frag="config/mh-solaris"
2853     ;;
2854   m68k-sun-sunos*)
2855     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2856     # without overflowing the jump tables (-J says to use a 32 bit table)
2857     tentative_cc="cc -J"
2858     ;;
2859   hppa*-hp-hpux10*)
2860     tentative_cc="cc -Wp,-H256000"
2861     host_makefile_frag="config/mh-pa-hpux10"
2862     ;;
2863   hppa*-hp-hpux* | hppa*-*-hiux*)
2864     tentative_cc="cc -Wp,-H256000"
2865     host_makefile_frag="config/mh-pa"
2866     ;;
2867   hppa*-*)
2868     host_makefile_frag="config/mh-pa"
2869     ;;
2870   *-hp-hpux* | *-*-hiux*)
2871     tentative_cc="cc -Wp,-H256000"
2872     ;;
2873   rs6000-*-lynxos*)
2874     # /bin/cc is less than useful for our purposes.  Always use GCC
2875     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2876     host_makefile_frag="config/mh-lynxrs6k"
2877     ;;
2878   powerpc-*-darwin*)
2879     host_makefile_frag="config/mh-ppc-darwin"
2880     ;;
2881   powerpc-*-aix*)
2882     host_makefile_frag="config/mh-ppc-aix"
2883     ;;
2884   rs6000-*-aix*)
2885     host_makefile_frag="config/mh-ppc-aix"
2886     ;;
2887   *-*-lynxos*)
2888     # /bin/cc is less than useful for our purposes.  Always use GCC
2889     tentative_cc="/bin/gcc"
2890     ;;
2891   *-*-sysv4*)
2892     host_makefile_frag="config/mh-sysv4"
2893     ;;
2894   # This is placed last to prevent interfering with the cases above.
2895   i[3456789]86-*-*)
2896     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2897     host_makefile_frag="config/mh-x86omitfp"
2898     ;;
2899 esac
2900 fi
2901
2902 # If we aren't going to be using gcc, see if we can extract a definition
2903 # of CC from the fragment.
2904 # Actually, use the 'pre-extracted' version above.
2905 if test -z "${CC}" && test "${build}" = "${host}" ; then
2906   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2907   found=
2908   for dir in $PATH; do
2909     test -z "$dir" && dir=.
2910     if test -f $dir/gcc; then
2911       found=yes
2912       break
2913     fi
2914   done
2915   IFS="$save_ifs"
2916   if test -z "${found}" && test -n "${tentative_cc}" ; then
2917     CC=$tentative_cc
2918   fi
2919 fi
2920
2921 if test "${build}" != "${host}" ; then
2922   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2923   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2924   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2925   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2926   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2927   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2928   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2929   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2930   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2931   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2932   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2933   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2934 else
2935   AR_FOR_BUILD="\$(AR)"
2936   AS_FOR_BUILD="\$(AS)"
2937   CC_FOR_BUILD="\$(CC)"
2938   CXX_FOR_BUILD="\$(CXX)"
2939   GCJ_FOR_BUILD="\$(GCJ)"
2940   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2941   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2942   LD_FOR_BUILD="\$(LD)"
2943   NM_FOR_BUILD="\$(NM)"
2944   RANLIB_FOR_BUILD="\$(RANLIB)"
2945   WINDRES_FOR_BUILD="\$(WINDRES)"
2946   WINDMC_FOR_BUILD="\$(WINDMC)"
2947 fi
2948
2949 ac_ext=c
2950 ac_cpp='$CPP $CPPFLAGS'
2951 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2952 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2953 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2954 if test -n "$ac_tool_prefix"; then
2955   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2956 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2957 echo "$as_me:$LINENO: checking for $ac_word" >&5
2958 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2959 if test "${ac_cv_prog_CC+set}" = set; then
2960   echo $ECHO_N "(cached) $ECHO_C" >&6
2961 else
2962   if test -n "$CC"; then
2963   ac_cv_prog_CC="$CC" # Let the user override the test.
2964 else
2965 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2966 for as_dir in $PATH
2967 do
2968   IFS=$as_save_IFS
2969   test -z "$as_dir" && as_dir=.
2970   for ac_exec_ext in '' $ac_executable_extensions; do
2971   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2972     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2973     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2974     break 2
2975   fi
2976 done
2977 done
2978
2979 fi
2980 fi
2981 CC=$ac_cv_prog_CC
2982 if test -n "$CC"; then
2983   echo "$as_me:$LINENO: result: $CC" >&5
2984 echo "${ECHO_T}$CC" >&6
2985 else
2986   echo "$as_me:$LINENO: result: no" >&5
2987 echo "${ECHO_T}no" >&6
2988 fi
2989
2990 fi
2991 if test -z "$ac_cv_prog_CC"; then
2992   ac_ct_CC=$CC
2993   # Extract the first word of "gcc", so it can be a program name with args.
2994 set dummy gcc; ac_word=$2
2995 echo "$as_me:$LINENO: checking for $ac_word" >&5
2996 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2997 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2998   echo $ECHO_N "(cached) $ECHO_C" >&6
2999 else
3000   if test -n "$ac_ct_CC"; then
3001   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3002 else
3003 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3004 for as_dir in $PATH
3005 do
3006   IFS=$as_save_IFS
3007   test -z "$as_dir" && as_dir=.
3008   for ac_exec_ext in '' $ac_executable_extensions; do
3009   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3010     ac_cv_prog_ac_ct_CC="gcc"
3011     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3012     break 2
3013   fi
3014 done
3015 done
3016
3017 fi
3018 fi
3019 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3020 if test -n "$ac_ct_CC"; then
3021   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3022 echo "${ECHO_T}$ac_ct_CC" >&6
3023 else
3024   echo "$as_me:$LINENO: result: no" >&5
3025 echo "${ECHO_T}no" >&6
3026 fi
3027
3028   CC=$ac_ct_CC
3029 else
3030   CC="$ac_cv_prog_CC"
3031 fi
3032
3033 if test -z "$CC"; then
3034   if test -n "$ac_tool_prefix"; then
3035   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3036 set dummy ${ac_tool_prefix}cc; ac_word=$2
3037 echo "$as_me:$LINENO: checking for $ac_word" >&5
3038 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3039 if test "${ac_cv_prog_CC+set}" = set; then
3040   echo $ECHO_N "(cached) $ECHO_C" >&6
3041 else
3042   if test -n "$CC"; then
3043   ac_cv_prog_CC="$CC" # Let the user override the test.
3044 else
3045 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3046 for as_dir in $PATH
3047 do
3048   IFS=$as_save_IFS
3049   test -z "$as_dir" && as_dir=.
3050   for ac_exec_ext in '' $ac_executable_extensions; do
3051   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3052     ac_cv_prog_CC="${ac_tool_prefix}cc"
3053     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3054     break 2
3055   fi
3056 done
3057 done
3058
3059 fi
3060 fi
3061 CC=$ac_cv_prog_CC
3062 if test -n "$CC"; then
3063   echo "$as_me:$LINENO: result: $CC" >&5
3064 echo "${ECHO_T}$CC" >&6
3065 else
3066   echo "$as_me:$LINENO: result: no" >&5
3067 echo "${ECHO_T}no" >&6
3068 fi
3069
3070 fi
3071 if test -z "$ac_cv_prog_CC"; then
3072   ac_ct_CC=$CC
3073   # Extract the first word of "cc", so it can be a program name with args.
3074 set dummy cc; ac_word=$2
3075 echo "$as_me:$LINENO: checking for $ac_word" >&5
3076 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3077 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3078   echo $ECHO_N "(cached) $ECHO_C" >&6
3079 else
3080   if test -n "$ac_ct_CC"; then
3081   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3082 else
3083 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3084 for as_dir in $PATH
3085 do
3086   IFS=$as_save_IFS
3087   test -z "$as_dir" && as_dir=.
3088   for ac_exec_ext in '' $ac_executable_extensions; do
3089   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3090     ac_cv_prog_ac_ct_CC="cc"
3091     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3092     break 2
3093   fi
3094 done
3095 done
3096
3097 fi
3098 fi
3099 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3100 if test -n "$ac_ct_CC"; then
3101   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3102 echo "${ECHO_T}$ac_ct_CC" >&6
3103 else
3104   echo "$as_me:$LINENO: result: no" >&5
3105 echo "${ECHO_T}no" >&6
3106 fi
3107
3108   CC=$ac_ct_CC
3109 else
3110   CC="$ac_cv_prog_CC"
3111 fi
3112
3113 fi
3114 if test -z "$CC"; then
3115   # Extract the first word of "cc", so it can be a program name with args.
3116 set dummy cc; ac_word=$2
3117 echo "$as_me:$LINENO: checking for $ac_word" >&5
3118 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3119 if test "${ac_cv_prog_CC+set}" = set; then
3120   echo $ECHO_N "(cached) $ECHO_C" >&6
3121 else
3122   if test -n "$CC"; then
3123   ac_cv_prog_CC="$CC" # Let the user override the test.
3124 else
3125   ac_prog_rejected=no
3126 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3127 for as_dir in $PATH
3128 do
3129   IFS=$as_save_IFS
3130   test -z "$as_dir" && as_dir=.
3131   for ac_exec_ext in '' $ac_executable_extensions; do
3132   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3133     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3134        ac_prog_rejected=yes
3135        continue
3136      fi
3137     ac_cv_prog_CC="cc"
3138     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3139     break 2
3140   fi
3141 done
3142 done
3143
3144 if test $ac_prog_rejected = yes; then
3145   # We found a bogon in the path, so make sure we never use it.
3146   set dummy $ac_cv_prog_CC
3147   shift
3148   if test $# != 0; then
3149     # We chose a different compiler from the bogus one.
3150     # However, it has the same basename, so the bogon will be chosen
3151     # first if we set CC to just the basename; use the full file name.
3152     shift
3153     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3154   fi
3155 fi
3156 fi
3157 fi
3158 CC=$ac_cv_prog_CC
3159 if test -n "$CC"; then
3160   echo "$as_me:$LINENO: result: $CC" >&5
3161 echo "${ECHO_T}$CC" >&6
3162 else
3163   echo "$as_me:$LINENO: result: no" >&5
3164 echo "${ECHO_T}no" >&6
3165 fi
3166
3167 fi
3168 if test -z "$CC"; then
3169   if test -n "$ac_tool_prefix"; then
3170   for ac_prog in cl
3171   do
3172     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3173 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3174 echo "$as_me:$LINENO: checking for $ac_word" >&5
3175 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3176 if test "${ac_cv_prog_CC+set}" = set; then
3177   echo $ECHO_N "(cached) $ECHO_C" >&6
3178 else
3179   if test -n "$CC"; then
3180   ac_cv_prog_CC="$CC" # Let the user override the test.
3181 else
3182 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3183 for as_dir in $PATH
3184 do
3185   IFS=$as_save_IFS
3186   test -z "$as_dir" && as_dir=.
3187   for ac_exec_ext in '' $ac_executable_extensions; do
3188   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3189     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3190     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3191     break 2
3192   fi
3193 done
3194 done
3195
3196 fi
3197 fi
3198 CC=$ac_cv_prog_CC
3199 if test -n "$CC"; then
3200   echo "$as_me:$LINENO: result: $CC" >&5
3201 echo "${ECHO_T}$CC" >&6
3202 else
3203   echo "$as_me:$LINENO: result: no" >&5
3204 echo "${ECHO_T}no" >&6
3205 fi
3206
3207     test -n "$CC" && break
3208   done
3209 fi
3210 if test -z "$CC"; then
3211   ac_ct_CC=$CC
3212   for ac_prog in cl
3213 do
3214   # Extract the first word of "$ac_prog", so it can be a program name with args.
3215 set dummy $ac_prog; ac_word=$2
3216 echo "$as_me:$LINENO: checking for $ac_word" >&5
3217 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3218 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3219   echo $ECHO_N "(cached) $ECHO_C" >&6
3220 else
3221   if test -n "$ac_ct_CC"; then
3222   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3223 else
3224 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3225 for as_dir in $PATH
3226 do
3227   IFS=$as_save_IFS
3228   test -z "$as_dir" && as_dir=.
3229   for ac_exec_ext in '' $ac_executable_extensions; do
3230   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3231     ac_cv_prog_ac_ct_CC="$ac_prog"
3232     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3233     break 2
3234   fi
3235 done
3236 done
3237
3238 fi
3239 fi
3240 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3241 if test -n "$ac_ct_CC"; then
3242   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3243 echo "${ECHO_T}$ac_ct_CC" >&6
3244 else
3245   echo "$as_me:$LINENO: result: no" >&5
3246 echo "${ECHO_T}no" >&6
3247 fi
3248
3249   test -n "$ac_ct_CC" && break
3250 done
3251
3252   CC=$ac_ct_CC
3253 fi
3254
3255 fi
3256
3257
3258 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3259 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3260 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3261 See \`config.log' for more details." >&5
3262 echo "$as_me: error: no acceptable C compiler found in \$PATH
3263 See \`config.log' for more details." >&2;}
3264    { (exit 1); exit 1; }; }; }
3265
3266 # Provide some information about the compiler.
3267 echo "$as_me:$LINENO:" \
3268      "checking for C compiler version" >&5
3269 ac_compiler=`set X $ac_compile; echo $2`
3270 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3271   (eval $ac_compiler --version </dev/null >&5) 2>&5
3272   ac_status=$?
3273   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3274   (exit $ac_status); }
3275 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3276   (eval $ac_compiler -v </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
3286 cat >conftest.$ac_ext <<_ACEOF
3287 /* confdefs.h.  */
3288 _ACEOF
3289 cat confdefs.h >>conftest.$ac_ext
3290 cat >>conftest.$ac_ext <<_ACEOF
3291 /* end confdefs.h.  */
3292
3293 int
3294 main ()
3295 {
3296
3297   ;
3298   return 0;
3299 }
3300 _ACEOF
3301 ac_clean_files_save=$ac_clean_files
3302 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3303 # Try to create an executable without -o first, disregard a.out.
3304 # It will help us diagnose broken compilers, and finding out an intuition
3305 # of exeext.
3306 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3307 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3308 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3309 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3310   (eval $ac_link_default) 2>&5
3311   ac_status=$?
3312   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3313   (exit $ac_status); }; then
3314   # Find the output, starting from the most likely.  This scheme is
3315 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3316 # resort.
3317
3318 # Be careful to initialize this variable, since it used to be cached.
3319 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3320 ac_cv_exeext=
3321 # b.out is created by i960 compilers.
3322 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3323 do
3324   test -f "$ac_file" || continue
3325   case $ac_file in
3326     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3327         ;;
3328     conftest.$ac_ext )
3329         # This is the source file.
3330         ;;
3331     [ab].out )
3332         # We found the default executable, but exeext='' is most
3333         # certainly right.
3334         break;;
3335     *.* )
3336         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3337         # FIXME: I believe we export ac_cv_exeext for Libtool,
3338         # but it would be cool to find out if it's true.  Does anybody
3339         # maintain Libtool? --akim.
3340         export ac_cv_exeext
3341         break;;
3342     * )
3343         break;;
3344   esac
3345 done
3346 else
3347   echo "$as_me: failed program was:" >&5
3348 sed 's/^/| /' conftest.$ac_ext >&5
3349
3350 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3351 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3352 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3353 See \`config.log' for more details." >&5
3354 echo "$as_me: error: C compiler cannot create executables
3355 See \`config.log' for more details." >&2;}
3356    { (exit 77); exit 77; }; }; }
3357 fi
3358
3359 ac_exeext=$ac_cv_exeext
3360 echo "$as_me:$LINENO: result: $ac_file" >&5
3361 echo "${ECHO_T}$ac_file" >&6
3362
3363 # Check the compiler produces executables we can run.  If not, either
3364 # the compiler is broken, or we cross compile.
3365 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3366 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3367 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3368 # If not cross compiling, check that we can run a simple program.
3369 if test "$cross_compiling" != yes; then
3370   if { ac_try='./$ac_file'
3371   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3372   (eval $ac_try) 2>&5
3373   ac_status=$?
3374   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3375   (exit $ac_status); }; }; then
3376     cross_compiling=no
3377   else
3378     if test "$cross_compiling" = maybe; then
3379         cross_compiling=yes
3380     else
3381         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3382 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3383 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3384 If you meant to cross compile, use \`--host'.
3385 See \`config.log' for more details." >&5
3386 echo "$as_me: error: cannot run C compiled programs.
3387 If you meant to cross compile, use \`--host'.
3388 See \`config.log' for more details." >&2;}
3389    { (exit 1); exit 1; }; }; }
3390     fi
3391   fi
3392 fi
3393 echo "$as_me:$LINENO: result: yes" >&5
3394 echo "${ECHO_T}yes" >&6
3395
3396 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3397 ac_clean_files=$ac_clean_files_save
3398 # Check the compiler produces executables we can run.  If not, either
3399 # the compiler is broken, or we cross compile.
3400 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3401 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3402 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3403 echo "${ECHO_T}$cross_compiling" >&6
3404
3405 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3406 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3407 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3408   (eval $ac_link) 2>&5
3409   ac_status=$?
3410   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3411   (exit $ac_status); }; then
3412   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3413 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3414 # work properly (i.e., refer to `conftest.exe'), while it won't with
3415 # `rm'.
3416 for ac_file in conftest.exe conftest conftest.*; do
3417   test -f "$ac_file" || continue
3418   case $ac_file in
3419     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3420     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3421           export ac_cv_exeext
3422           break;;
3423     * ) break;;
3424   esac
3425 done
3426 else
3427   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3428 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3429 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3430 See \`config.log' for more details." >&5
3431 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3432 See \`config.log' for more details." >&2;}
3433    { (exit 1); exit 1; }; }; }
3434 fi
3435
3436 rm -f conftest$ac_cv_exeext
3437 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3438 echo "${ECHO_T}$ac_cv_exeext" >&6
3439
3440 rm -f conftest.$ac_ext
3441 EXEEXT=$ac_cv_exeext
3442 ac_exeext=$EXEEXT
3443 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3444 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3445 if test "${ac_cv_objext+set}" = set; then
3446   echo $ECHO_N "(cached) $ECHO_C" >&6
3447 else
3448   cat >conftest.$ac_ext <<_ACEOF
3449 /* confdefs.h.  */
3450 _ACEOF
3451 cat confdefs.h >>conftest.$ac_ext
3452 cat >>conftest.$ac_ext <<_ACEOF
3453 /* end confdefs.h.  */
3454
3455 int
3456 main ()
3457 {
3458
3459   ;
3460   return 0;
3461 }
3462 _ACEOF
3463 rm -f conftest.o conftest.obj
3464 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3465   (eval $ac_compile) 2>&5
3466   ac_status=$?
3467   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3468   (exit $ac_status); }; then
3469   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3470   case $ac_file in
3471     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3472     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3473        break;;
3474   esac
3475 done
3476 else
3477   echo "$as_me: failed program was:" >&5
3478 sed 's/^/| /' conftest.$ac_ext >&5
3479
3480 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3481 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3482 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3483 See \`config.log' for more details." >&5
3484 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3485 See \`config.log' for more details." >&2;}
3486    { (exit 1); exit 1; }; }; }
3487 fi
3488
3489 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3490 fi
3491 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3492 echo "${ECHO_T}$ac_cv_objext" >&6
3493 OBJEXT=$ac_cv_objext
3494 ac_objext=$OBJEXT
3495 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3496 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3497 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3498   echo $ECHO_N "(cached) $ECHO_C" >&6
3499 else
3500   cat >conftest.$ac_ext <<_ACEOF
3501 /* confdefs.h.  */
3502 _ACEOF
3503 cat confdefs.h >>conftest.$ac_ext
3504 cat >>conftest.$ac_ext <<_ACEOF
3505 /* end confdefs.h.  */
3506
3507 int
3508 main ()
3509 {
3510 #ifndef __GNUC__
3511        choke me
3512 #endif
3513
3514   ;
3515   return 0;
3516 }
3517 _ACEOF
3518 rm -f conftest.$ac_objext
3519 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3520   (eval $ac_compile) 2>conftest.er1
3521   ac_status=$?
3522   grep -v '^ *+' conftest.er1 >conftest.err
3523   rm -f conftest.er1
3524   cat conftest.err >&5
3525   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3526   (exit $ac_status); } &&
3527          { ac_try='test -z "$ac_c_werror_flag"
3528                          || test ! -s conftest.err'
3529   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3530   (eval $ac_try) 2>&5
3531   ac_status=$?
3532   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3533   (exit $ac_status); }; } &&
3534          { ac_try='test -s conftest.$ac_objext'
3535   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3536   (eval $ac_try) 2>&5
3537   ac_status=$?
3538   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3539   (exit $ac_status); }; }; then
3540   ac_compiler_gnu=yes
3541 else
3542   echo "$as_me: failed program was:" >&5
3543 sed 's/^/| /' conftest.$ac_ext >&5
3544
3545 ac_compiler_gnu=no
3546 fi
3547 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3548 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3549
3550 fi
3551 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3552 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3553 GCC=`test $ac_compiler_gnu = yes && echo yes`
3554 ac_test_CFLAGS=${CFLAGS+set}
3555 ac_save_CFLAGS=$CFLAGS
3556 CFLAGS="-g"
3557 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3558 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3559 if test "${ac_cv_prog_cc_g+set}" = set; then
3560   echo $ECHO_N "(cached) $ECHO_C" >&6
3561 else
3562   cat >conftest.$ac_ext <<_ACEOF
3563 /* confdefs.h.  */
3564 _ACEOF
3565 cat confdefs.h >>conftest.$ac_ext
3566 cat >>conftest.$ac_ext <<_ACEOF
3567 /* end confdefs.h.  */
3568
3569 int
3570 main ()
3571 {
3572
3573   ;
3574   return 0;
3575 }
3576 _ACEOF
3577 rm -f conftest.$ac_objext
3578 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3579   (eval $ac_compile) 2>conftest.er1
3580   ac_status=$?
3581   grep -v '^ *+' conftest.er1 >conftest.err
3582   rm -f conftest.er1
3583   cat conftest.err >&5
3584   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3585   (exit $ac_status); } &&
3586          { ac_try='test -z "$ac_c_werror_flag"
3587                          || test ! -s conftest.err'
3588   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3589   (eval $ac_try) 2>&5
3590   ac_status=$?
3591   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3592   (exit $ac_status); }; } &&
3593          { ac_try='test -s conftest.$ac_objext'
3594   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3595   (eval $ac_try) 2>&5
3596   ac_status=$?
3597   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3598   (exit $ac_status); }; }; then
3599   ac_cv_prog_cc_g=yes
3600 else
3601   echo "$as_me: failed program was:" >&5
3602 sed 's/^/| /' conftest.$ac_ext >&5
3603
3604 ac_cv_prog_cc_g=no
3605 fi
3606 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3607 fi
3608 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3609 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3610 if test "$ac_test_CFLAGS" = set; then
3611   CFLAGS=$ac_save_CFLAGS
3612 elif test $ac_cv_prog_cc_g = yes; then
3613   if test "$GCC" = yes; then
3614     CFLAGS="-g -O2"
3615   else
3616     CFLAGS="-g"
3617   fi
3618 else
3619   if test "$GCC" = yes; then
3620     CFLAGS="-O2"
3621   else
3622     CFLAGS=
3623   fi
3624 fi
3625 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3626 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3627 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3628   echo $ECHO_N "(cached) $ECHO_C" >&6
3629 else
3630   ac_cv_prog_cc_stdc=no
3631 ac_save_CC=$CC
3632 cat >conftest.$ac_ext <<_ACEOF
3633 /* confdefs.h.  */
3634 _ACEOF
3635 cat confdefs.h >>conftest.$ac_ext
3636 cat >>conftest.$ac_ext <<_ACEOF
3637 /* end confdefs.h.  */
3638 #include <stdarg.h>
3639 #include <stdio.h>
3640 #include <sys/types.h>
3641 #include <sys/stat.h>
3642 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3643 struct buf { int x; };
3644 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3645 static char *e (p, i)
3646      char **p;
3647      int i;
3648 {
3649   return p[i];
3650 }
3651 static char *f (char * (*g) (char **, int), char **p, ...)
3652 {
3653   char *s;
3654   va_list v;
3655   va_start (v,p);
3656   s = g (p, va_arg (v,int));
3657   va_end (v);
3658   return s;
3659 }
3660
3661 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3662    function prototypes and stuff, but not '\xHH' hex character constants.
3663    These don't provoke an error unfortunately, instead are silently treated
3664    as 'x'.  The following induces an error, until -std1 is added to get
3665    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3666    array size at least.  It's necessary to write '\x00'==0 to get something
3667    that's true only with -std1.  */
3668 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3669
3670 int test (int i, double x);
3671 struct s1 {int (*f) (int a);};
3672 struct s2 {int (*f) (double a);};
3673 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3674 int argc;
3675 char **argv;
3676 int
3677 main ()
3678 {
3679 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3680   ;
3681   return 0;
3682 }
3683 _ACEOF
3684 # Don't try gcc -ansi; that turns off useful extensions and
3685 # breaks some systems' header files.
3686 # AIX                   -qlanglvl=ansi
3687 # Ultrix and OSF/1      -std1
3688 # HP-UX 10.20 and later -Ae
3689 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3690 # SVR4                  -Xc -D__EXTENSIONS__
3691 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3692 do
3693   CC="$ac_save_CC $ac_arg"
3694   rm -f conftest.$ac_objext
3695 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3696   (eval $ac_compile) 2>conftest.er1
3697   ac_status=$?
3698   grep -v '^ *+' conftest.er1 >conftest.err
3699   rm -f conftest.er1
3700   cat conftest.err >&5
3701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3702   (exit $ac_status); } &&
3703          { ac_try='test -z "$ac_c_werror_flag"
3704                          || test ! -s conftest.err'
3705   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3706   (eval $ac_try) 2>&5
3707   ac_status=$?
3708   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3709   (exit $ac_status); }; } &&
3710          { ac_try='test -s conftest.$ac_objext'
3711   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3712   (eval $ac_try) 2>&5
3713   ac_status=$?
3714   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3715   (exit $ac_status); }; }; then
3716   ac_cv_prog_cc_stdc=$ac_arg
3717 break
3718 else
3719   echo "$as_me: failed program was:" >&5
3720 sed 's/^/| /' conftest.$ac_ext >&5
3721
3722 fi
3723 rm -f conftest.err conftest.$ac_objext
3724 done
3725 rm -f conftest.$ac_ext conftest.$ac_objext
3726 CC=$ac_save_CC
3727
3728 fi
3729
3730 case "x$ac_cv_prog_cc_stdc" in
3731   x|xno)
3732     echo "$as_me:$LINENO: result: none needed" >&5
3733 echo "${ECHO_T}none needed" >&6 ;;
3734   *)
3735     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3736 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3737     CC="$CC $ac_cv_prog_cc_stdc" ;;
3738 esac
3739
3740 # Some people use a C++ compiler to compile C.  Since we use `exit',
3741 # in C++ we need to declare it.  In case someone uses the same compiler
3742 # for both compiling C and C++ we need to have the C++ compiler decide
3743 # the declaration of exit, since it's the most demanding environment.
3744 cat >conftest.$ac_ext <<_ACEOF
3745 #ifndef __cplusplus
3746   choke me
3747 #endif
3748 _ACEOF
3749 rm -f conftest.$ac_objext
3750 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3751   (eval $ac_compile) 2>conftest.er1
3752   ac_status=$?
3753   grep -v '^ *+' conftest.er1 >conftest.err
3754   rm -f conftest.er1
3755   cat conftest.err >&5
3756   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3757   (exit $ac_status); } &&
3758          { ac_try='test -z "$ac_c_werror_flag"
3759                          || test ! -s conftest.err'
3760   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3761   (eval $ac_try) 2>&5
3762   ac_status=$?
3763   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3764   (exit $ac_status); }; } &&
3765          { ac_try='test -s conftest.$ac_objext'
3766   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3767   (eval $ac_try) 2>&5
3768   ac_status=$?
3769   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3770   (exit $ac_status); }; }; then
3771   for ac_declaration in \
3772    '' \
3773    'extern "C" void std::exit (int) throw (); using std::exit;' \
3774    'extern "C" void std::exit (int); using std::exit;' \
3775    'extern "C" void exit (int) throw ();' \
3776    'extern "C" void exit (int);' \
3777    'void exit (int);'
3778 do
3779   cat >conftest.$ac_ext <<_ACEOF
3780 /* confdefs.h.  */
3781 _ACEOF
3782 cat confdefs.h >>conftest.$ac_ext
3783 cat >>conftest.$ac_ext <<_ACEOF
3784 /* end confdefs.h.  */
3785 $ac_declaration
3786 #include <stdlib.h>
3787 int
3788 main ()
3789 {
3790 exit (42);
3791   ;
3792   return 0;
3793 }
3794 _ACEOF
3795 rm -f conftest.$ac_objext
3796 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3797   (eval $ac_compile) 2>conftest.er1
3798   ac_status=$?
3799   grep -v '^ *+' conftest.er1 >conftest.err
3800   rm -f conftest.er1
3801   cat conftest.err >&5
3802   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3803   (exit $ac_status); } &&
3804          { ac_try='test -z "$ac_c_werror_flag"
3805                          || test ! -s conftest.err'
3806   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3807   (eval $ac_try) 2>&5
3808   ac_status=$?
3809   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3810   (exit $ac_status); }; } &&
3811          { ac_try='test -s conftest.$ac_objext'
3812   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3813   (eval $ac_try) 2>&5
3814   ac_status=$?
3815   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3816   (exit $ac_status); }; }; then
3817   :
3818 else
3819   echo "$as_me: failed program was:" >&5
3820 sed 's/^/| /' conftest.$ac_ext >&5
3821
3822 continue
3823 fi
3824 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3825   cat >conftest.$ac_ext <<_ACEOF
3826 /* confdefs.h.  */
3827 _ACEOF
3828 cat confdefs.h >>conftest.$ac_ext
3829 cat >>conftest.$ac_ext <<_ACEOF
3830 /* end confdefs.h.  */
3831 $ac_declaration
3832 int
3833 main ()
3834 {
3835 exit (42);
3836   ;
3837   return 0;
3838 }
3839 _ACEOF
3840 rm -f conftest.$ac_objext
3841 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3842   (eval $ac_compile) 2>conftest.er1
3843   ac_status=$?
3844   grep -v '^ *+' conftest.er1 >conftest.err
3845   rm -f conftest.er1
3846   cat conftest.err >&5
3847   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3848   (exit $ac_status); } &&
3849          { ac_try='test -z "$ac_c_werror_flag"
3850                          || test ! -s conftest.err'
3851   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3852   (eval $ac_try) 2>&5
3853   ac_status=$?
3854   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3855   (exit $ac_status); }; } &&
3856          { ac_try='test -s conftest.$ac_objext'
3857   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3858   (eval $ac_try) 2>&5
3859   ac_status=$?
3860   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3861   (exit $ac_status); }; }; then
3862   break
3863 else
3864   echo "$as_me: failed program was:" >&5
3865 sed 's/^/| /' conftest.$ac_ext >&5
3866
3867 fi
3868 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3869 done
3870 rm -f conftest*
3871 if test -n "$ac_declaration"; then
3872   echo '#ifdef __cplusplus' >>confdefs.h
3873   echo $ac_declaration      >>confdefs.h
3874   echo '#endif'             >>confdefs.h
3875 fi
3876
3877 else
3878   echo "$as_me: failed program was:" >&5
3879 sed 's/^/| /' conftest.$ac_ext >&5
3880
3881 fi
3882 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3883 ac_ext=c
3884 ac_cpp='$CPP $CPPFLAGS'
3885 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3886 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3887 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3888
3889 ac_ext=cc
3890 ac_cpp='$CXXCPP $CPPFLAGS'
3891 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3892 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3893 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3894 if test -n "$ac_tool_prefix"; then
3895   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3896   do
3897     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3898 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3899 echo "$as_me:$LINENO: checking for $ac_word" >&5
3900 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3901 if test "${ac_cv_prog_CXX+set}" = set; then
3902   echo $ECHO_N "(cached) $ECHO_C" >&6
3903 else
3904   if test -n "$CXX"; then
3905   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3906 else
3907 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3908 for as_dir in $PATH
3909 do
3910   IFS=$as_save_IFS
3911   test -z "$as_dir" && as_dir=.
3912   for ac_exec_ext in '' $ac_executable_extensions; do
3913   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3914     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3915     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3916     break 2
3917   fi
3918 done
3919 done
3920
3921 fi
3922 fi
3923 CXX=$ac_cv_prog_CXX
3924 if test -n "$CXX"; then
3925   echo "$as_me:$LINENO: result: $CXX" >&5
3926 echo "${ECHO_T}$CXX" >&6
3927 else
3928   echo "$as_me:$LINENO: result: no" >&5
3929 echo "${ECHO_T}no" >&6
3930 fi
3931
3932     test -n "$CXX" && break
3933   done
3934 fi
3935 if test -z "$CXX"; then
3936   ac_ct_CXX=$CXX
3937   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3938 do
3939   # Extract the first word of "$ac_prog", so it can be a program name with args.
3940 set dummy $ac_prog; ac_word=$2
3941 echo "$as_me:$LINENO: checking for $ac_word" >&5
3942 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3943 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3944   echo $ECHO_N "(cached) $ECHO_C" >&6
3945 else
3946   if test -n "$ac_ct_CXX"; then
3947   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3948 else
3949 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3950 for as_dir in $PATH
3951 do
3952   IFS=$as_save_IFS
3953   test -z "$as_dir" && as_dir=.
3954   for ac_exec_ext in '' $ac_executable_extensions; do
3955   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3956     ac_cv_prog_ac_ct_CXX="$ac_prog"
3957     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3958     break 2
3959   fi
3960 done
3961 done
3962
3963 fi
3964 fi
3965 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3966 if test -n "$ac_ct_CXX"; then
3967   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3968 echo "${ECHO_T}$ac_ct_CXX" >&6
3969 else
3970   echo "$as_me:$LINENO: result: no" >&5
3971 echo "${ECHO_T}no" >&6
3972 fi
3973
3974   test -n "$ac_ct_CXX" && break
3975 done
3976 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3977
3978   CXX=$ac_ct_CXX
3979 fi
3980
3981
3982 # Provide some information about the compiler.
3983 echo "$as_me:$LINENO:" \
3984      "checking for C++ compiler version" >&5
3985 ac_compiler=`set X $ac_compile; echo $2`
3986 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3987   (eval $ac_compiler --version </dev/null >&5) 2>&5
3988   ac_status=$?
3989   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3990   (exit $ac_status); }
3991 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3992   (eval $ac_compiler -v </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
4002 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4003 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4004 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4005   echo $ECHO_N "(cached) $ECHO_C" >&6
4006 else
4007   cat >conftest.$ac_ext <<_ACEOF
4008 /* confdefs.h.  */
4009 _ACEOF
4010 cat confdefs.h >>conftest.$ac_ext
4011 cat >>conftest.$ac_ext <<_ACEOF
4012 /* end confdefs.h.  */
4013
4014 int
4015 main ()
4016 {
4017 #ifndef __GNUC__
4018        choke me
4019 #endif
4020
4021   ;
4022   return 0;
4023 }
4024 _ACEOF
4025 rm -f conftest.$ac_objext
4026 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4027   (eval $ac_compile) 2>conftest.er1
4028   ac_status=$?
4029   grep -v '^ *+' conftest.er1 >conftest.err
4030   rm -f conftest.er1
4031   cat conftest.err >&5
4032   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4033   (exit $ac_status); } &&
4034          { ac_try='test -z "$ac_cxx_werror_flag"
4035                          || test ! -s conftest.err'
4036   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4037   (eval $ac_try) 2>&5
4038   ac_status=$?
4039   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4040   (exit $ac_status); }; } &&
4041          { ac_try='test -s conftest.$ac_objext'
4042   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4043   (eval $ac_try) 2>&5
4044   ac_status=$?
4045   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4046   (exit $ac_status); }; }; then
4047   ac_compiler_gnu=yes
4048 else
4049   echo "$as_me: failed program was:" >&5
4050 sed 's/^/| /' conftest.$ac_ext >&5
4051
4052 ac_compiler_gnu=no
4053 fi
4054 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4055 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4056
4057 fi
4058 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4059 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4060 GXX=`test $ac_compiler_gnu = yes && echo yes`
4061 ac_test_CXXFLAGS=${CXXFLAGS+set}
4062 ac_save_CXXFLAGS=$CXXFLAGS
4063 CXXFLAGS="-g"
4064 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4065 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4066 if test "${ac_cv_prog_cxx_g+set}" = set; then
4067   echo $ECHO_N "(cached) $ECHO_C" >&6
4068 else
4069   cat >conftest.$ac_ext <<_ACEOF
4070 /* confdefs.h.  */
4071 _ACEOF
4072 cat confdefs.h >>conftest.$ac_ext
4073 cat >>conftest.$ac_ext <<_ACEOF
4074 /* end confdefs.h.  */
4075
4076 int
4077 main ()
4078 {
4079
4080   ;
4081   return 0;
4082 }
4083 _ACEOF
4084 rm -f conftest.$ac_objext
4085 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4086   (eval $ac_compile) 2>conftest.er1
4087   ac_status=$?
4088   grep -v '^ *+' conftest.er1 >conftest.err
4089   rm -f conftest.er1
4090   cat conftest.err >&5
4091   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4092   (exit $ac_status); } &&
4093          { ac_try='test -z "$ac_cxx_werror_flag"
4094                          || test ! -s conftest.err'
4095   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4096   (eval $ac_try) 2>&5
4097   ac_status=$?
4098   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4099   (exit $ac_status); }; } &&
4100          { ac_try='test -s conftest.$ac_objext'
4101   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4102   (eval $ac_try) 2>&5
4103   ac_status=$?
4104   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4105   (exit $ac_status); }; }; then
4106   ac_cv_prog_cxx_g=yes
4107 else
4108   echo "$as_me: failed program was:" >&5
4109 sed 's/^/| /' conftest.$ac_ext >&5
4110
4111 ac_cv_prog_cxx_g=no
4112 fi
4113 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4114 fi
4115 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4116 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4117 if test "$ac_test_CXXFLAGS" = set; then
4118   CXXFLAGS=$ac_save_CXXFLAGS
4119 elif test $ac_cv_prog_cxx_g = yes; then
4120   if test "$GXX" = yes; then
4121     CXXFLAGS="-g -O2"
4122   else
4123     CXXFLAGS="-g"
4124   fi
4125 else
4126   if test "$GXX" = yes; then
4127     CXXFLAGS="-O2"
4128   else
4129     CXXFLAGS=
4130   fi
4131 fi
4132 for ac_declaration in \
4133    '' \
4134    'extern "C" void std::exit (int) throw (); using std::exit;' \
4135    'extern "C" void std::exit (int); using std::exit;' \
4136    'extern "C" void exit (int) throw ();' \
4137    'extern "C" void exit (int);' \
4138    'void exit (int);'
4139 do
4140   cat >conftest.$ac_ext <<_ACEOF
4141 /* confdefs.h.  */
4142 _ACEOF
4143 cat confdefs.h >>conftest.$ac_ext
4144 cat >>conftest.$ac_ext <<_ACEOF
4145 /* end confdefs.h.  */
4146 $ac_declaration
4147 #include <stdlib.h>
4148 int
4149 main ()
4150 {
4151 exit (42);
4152   ;
4153   return 0;
4154 }
4155 _ACEOF
4156 rm -f conftest.$ac_objext
4157 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4158   (eval $ac_compile) 2>conftest.er1
4159   ac_status=$?
4160   grep -v '^ *+' conftest.er1 >conftest.err
4161   rm -f conftest.er1
4162   cat conftest.err >&5
4163   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4164   (exit $ac_status); } &&
4165          { ac_try='test -z "$ac_cxx_werror_flag"
4166                          || test ! -s conftest.err'
4167   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4168   (eval $ac_try) 2>&5
4169   ac_status=$?
4170   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4171   (exit $ac_status); }; } &&
4172          { ac_try='test -s conftest.$ac_objext'
4173   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4174   (eval $ac_try) 2>&5
4175   ac_status=$?
4176   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4177   (exit $ac_status); }; }; then
4178   :
4179 else
4180   echo "$as_me: failed program was:" >&5
4181 sed 's/^/| /' conftest.$ac_ext >&5
4182
4183 continue
4184 fi
4185 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4186   cat >conftest.$ac_ext <<_ACEOF
4187 /* confdefs.h.  */
4188 _ACEOF
4189 cat confdefs.h >>conftest.$ac_ext
4190 cat >>conftest.$ac_ext <<_ACEOF
4191 /* end confdefs.h.  */
4192 $ac_declaration
4193 int
4194 main ()
4195 {
4196 exit (42);
4197   ;
4198   return 0;
4199 }
4200 _ACEOF
4201 rm -f conftest.$ac_objext
4202 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4203   (eval $ac_compile) 2>conftest.er1
4204   ac_status=$?
4205   grep -v '^ *+' conftest.er1 >conftest.err
4206   rm -f conftest.er1
4207   cat conftest.err >&5
4208   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4209   (exit $ac_status); } &&
4210          { ac_try='test -z "$ac_cxx_werror_flag"
4211                          || test ! -s conftest.err'
4212   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4213   (eval $ac_try) 2>&5
4214   ac_status=$?
4215   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4216   (exit $ac_status); }; } &&
4217          { ac_try='test -s conftest.$ac_objext'
4218   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4219   (eval $ac_try) 2>&5
4220   ac_status=$?
4221   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4222   (exit $ac_status); }; }; then
4223   break
4224 else
4225   echo "$as_me: failed program was:" >&5
4226 sed 's/^/| /' conftest.$ac_ext >&5
4227
4228 fi
4229 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4230 done
4231 rm -f conftest*
4232 if test -n "$ac_declaration"; then
4233   echo '#ifdef __cplusplus' >>confdefs.h
4234   echo $ac_declaration      >>confdefs.h
4235   echo '#endif'             >>confdefs.h
4236 fi
4237
4238 ac_ext=c
4239 ac_cpp='$CPP $CPPFLAGS'
4240 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4241 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4242 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4243
4244
4245 # We must set the default linker to the linker used by gcc for the correct
4246 # operation of libtool.  If LD is not defined and we are using gcc, try to
4247 # set the LD default to the ld used by gcc.
4248 if test -z "$LD"; then
4249   if test "$GCC" = yes; then
4250     case $build in
4251     *-*-mingw*)
4252       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4253     *)
4254       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4255     esac
4256     case $gcc_prog_ld in
4257     # Accept absolute paths.
4258     [\\/]* | [A-Za-z]:[\\/]*)
4259       LD="$gcc_prog_ld" ;;
4260     esac
4261   fi
4262 fi
4263
4264
4265
4266
4267 if test -n "$ac_tool_prefix"; then
4268   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4269 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4270 echo "$as_me:$LINENO: checking for $ac_word" >&5
4271 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4272 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4273   echo $ECHO_N "(cached) $ECHO_C" >&6
4274 else
4275   if test -n "$GNATBIND"; then
4276   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4277 else
4278 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4279 for as_dir in $PATH
4280 do
4281   IFS=$as_save_IFS
4282   test -z "$as_dir" && as_dir=.
4283   for ac_exec_ext in '' $ac_executable_extensions; do
4284   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4285     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4286     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4287     break 2
4288   fi
4289 done
4290 done
4291
4292 fi
4293 fi
4294 GNATBIND=$ac_cv_prog_GNATBIND
4295 if test -n "$GNATBIND"; then
4296   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4297 echo "${ECHO_T}$GNATBIND" >&6
4298 else
4299   echo "$as_me:$LINENO: result: no" >&5
4300 echo "${ECHO_T}no" >&6
4301 fi
4302
4303 fi
4304 if test -z "$ac_cv_prog_GNATBIND"; then
4305   ac_ct_GNATBIND=$GNATBIND
4306   # Extract the first word of "gnatbind", so it can be a program name with args.
4307 set dummy gnatbind; ac_word=$2
4308 echo "$as_me:$LINENO: checking for $ac_word" >&5
4309 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4310 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4311   echo $ECHO_N "(cached) $ECHO_C" >&6
4312 else
4313   if test -n "$ac_ct_GNATBIND"; then
4314   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4315 else
4316 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4317 for as_dir in $PATH
4318 do
4319   IFS=$as_save_IFS
4320   test -z "$as_dir" && as_dir=.
4321   for ac_exec_ext in '' $ac_executable_extensions; do
4322   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4323     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4324     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4325     break 2
4326   fi
4327 done
4328 done
4329
4330   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4331 fi
4332 fi
4333 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4334 if test -n "$ac_ct_GNATBIND"; then
4335   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4336 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4337 else
4338   echo "$as_me:$LINENO: result: no" >&5
4339 echo "${ECHO_T}no" >&6
4340 fi
4341
4342   GNATBIND=$ac_ct_GNATBIND
4343 else
4344   GNATBIND="$ac_cv_prog_GNATBIND"
4345 fi
4346
4347 if test -n "$ac_tool_prefix"; then
4348   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4349 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4350 echo "$as_me:$LINENO: checking for $ac_word" >&5
4351 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4352 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4353   echo $ECHO_N "(cached) $ECHO_C" >&6
4354 else
4355   if test -n "$GNATMAKE"; then
4356   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4357 else
4358 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4359 for as_dir in $PATH
4360 do
4361   IFS=$as_save_IFS
4362   test -z "$as_dir" && as_dir=.
4363   for ac_exec_ext in '' $ac_executable_extensions; do
4364   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4365     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4366     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4367     break 2
4368   fi
4369 done
4370 done
4371
4372 fi
4373 fi
4374 GNATMAKE=$ac_cv_prog_GNATMAKE
4375 if test -n "$GNATMAKE"; then
4376   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4377 echo "${ECHO_T}$GNATMAKE" >&6
4378 else
4379   echo "$as_me:$LINENO: result: no" >&5
4380 echo "${ECHO_T}no" >&6
4381 fi
4382
4383 fi
4384 if test -z "$ac_cv_prog_GNATMAKE"; then
4385   ac_ct_GNATMAKE=$GNATMAKE
4386   # Extract the first word of "gnatmake", so it can be a program name with args.
4387 set dummy gnatmake; ac_word=$2
4388 echo "$as_me:$LINENO: checking for $ac_word" >&5
4389 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4390 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4391   echo $ECHO_N "(cached) $ECHO_C" >&6
4392 else
4393   if test -n "$ac_ct_GNATMAKE"; then
4394   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4395 else
4396 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4397 for as_dir in $PATH
4398 do
4399   IFS=$as_save_IFS
4400   test -z "$as_dir" && as_dir=.
4401   for ac_exec_ext in '' $ac_executable_extensions; do
4402   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4403     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4404     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4405     break 2
4406   fi
4407 done
4408 done
4409
4410   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4411 fi
4412 fi
4413 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4414 if test -n "$ac_ct_GNATMAKE"; then
4415   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4416 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4417 else
4418   echo "$as_me:$LINENO: result: no" >&5
4419 echo "${ECHO_T}no" >&6
4420 fi
4421
4422   GNATMAKE=$ac_ct_GNATMAKE
4423 else
4424   GNATMAKE="$ac_cv_prog_GNATMAKE"
4425 fi
4426
4427 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4428 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4429 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4430   echo $ECHO_N "(cached) $ECHO_C" >&6
4431 else
4432   cat >conftest.adb <<EOF
4433 procedure conftest is begin null; end conftest;
4434 EOF
4435 acx_cv_cc_gcc_supports_ada=no
4436 # There is a bug in old released versions of GCC which causes the
4437 # driver to exit successfully when the appropriate language module
4438 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4439 # Therefore we must check for the error message as well as an
4440 # unsuccessful exit.
4441 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4442 # given a .adb file, but produce no object file.  So we must check
4443 # if an object file was really produced to guard against this.
4444 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4445 if test x"$errors" = x && test -f conftest.$ac_objext; then
4446   acx_cv_cc_gcc_supports_ada=yes
4447 fi
4448 rm -f conftest.*
4449 fi
4450 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4451 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4452
4453 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4454   have_gnat=yes
4455 else
4456   have_gnat=no
4457 fi
4458
4459 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4460 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4461 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4462   echo $ECHO_N "(cached) $ECHO_C" >&6
4463 else
4464    echo abfoo >t1
4465   echo cdfoo >t2
4466   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4467   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4468     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4469       :
4470     else
4471       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4472     fi
4473   fi
4474   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4475     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4476       :
4477     else
4478       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4479     fi
4480   fi
4481   rm t1 t2
4482
4483 fi
4484 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4485 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4486 do_compare="$gcc_cv_prog_cmp_skip"
4487
4488
4489
4490 # Check for GMP and MPFR
4491 gmplibs="-lmpfr -lgmp"
4492 gmpinc=
4493 have_gmp=no
4494
4495 # Specify a location for mpfr
4496 # check for this first so it ends up on the link line before gmp.
4497
4498 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4499 if test "${with_mpfr_dir+set}" = set; then
4500   withval="$with_mpfr_dir"
4501   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4502 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4503 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4504 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4505    { (exit 1); exit 1; }; }
4506 fi;
4507
4508
4509 # Check whether --with-mpfr or --without-mpfr was given.
4510 if test "${with_mpfr+set}" = set; then
4511   withval="$with_mpfr"
4512
4513 fi;
4514
4515 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4516 if test "${with_mpfr_include+set}" = set; then
4517   withval="$with_mpfr_include"
4518
4519 fi;
4520
4521 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4522 if test "${with_mpfr_lib+set}" = set; then
4523   withval="$with_mpfr_lib"
4524
4525 fi;
4526
4527 if test "x$with_mpfr" != x; then
4528   gmplibs="-L$with_mpfr/lib $gmplibs"
4529   gmpinc="-I$with_mpfr/include"
4530 fi
4531 if test "x$with_mpfr_include" != x; then
4532   gmpinc="-I$with_mpfr_include"
4533 fi
4534 if test "x$with_mpfr_lib" != x; then
4535   gmplibs="-L$with_mpfr_lib $gmplibs"
4536 fi
4537 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4538   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4539   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4540   # Do not test the mpfr version.  Assume that it is sufficient, since
4541   # it is in the source tree, and the library has not been built yet
4542   # but it would be included on the link line in the version check below
4543   # hence making the test fail.
4544   have_gmp=yes
4545 fi
4546
4547 # Specify a location for gmp
4548
4549 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4550 if test "${with_gmp_dir+set}" = set; then
4551   withval="$with_gmp_dir"
4552   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4553 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4554 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4555 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4556    { (exit 1); exit 1; }; }
4557 fi;
4558
4559
4560 # Check whether --with-gmp or --without-gmp was given.
4561 if test "${with_gmp+set}" = set; then
4562   withval="$with_gmp"
4563
4564 fi;
4565
4566 # Check whether --with-gmp_include or --without-gmp_include was given.
4567 if test "${with_gmp_include+set}" = set; then
4568   withval="$with_gmp_include"
4569
4570 fi;
4571
4572 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4573 if test "${with_gmp_lib+set}" = set; then
4574   withval="$with_gmp_lib"
4575
4576 fi;
4577
4578
4579 if test "x$with_gmp" != x; then
4580   gmplibs="-L$with_gmp/lib $gmplibs"
4581   gmpinc="-I$with_gmp/include $gmpinc"
4582 fi
4583 if test "x$with_gmp_include" != x; then
4584   gmpinc="-I$with_gmp_include $gmpinc"
4585 fi
4586 if test "x$with_gmp_lib" != x; then
4587   gmplibs="-L$with_gmp_lib $gmplibs"
4588 fi
4589 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4590   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4591   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4592   # Do not test the gmp version.  Assume that it is sufficient, since
4593   # it is in the source tree, and the library has not been built yet
4594   # but it would be included on the link line in the version check below
4595   # hence making the test fail.
4596   have_gmp=yes
4597 fi
4598
4599 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4600   have_gmp=yes
4601   saved_CFLAGS="$CFLAGS"
4602   CFLAGS="$CFLAGS $gmpinc"
4603   # Check GMP actually works
4604   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4605 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4606
4607 cat >conftest.$ac_ext <<_ACEOF
4608 /* confdefs.h.  */
4609 _ACEOF
4610 cat confdefs.h >>conftest.$ac_ext
4611 cat >>conftest.$ac_ext <<_ACEOF
4612 /* end confdefs.h.  */
4613 #include "gmp.h"
4614 int
4615 main ()
4616 {
4617
4618   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4619   choke me
4620   #endif
4621
4622   ;
4623   return 0;
4624 }
4625 _ACEOF
4626 rm -f conftest.$ac_objext
4627 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4628   (eval $ac_compile) 2>conftest.er1
4629   ac_status=$?
4630   grep -v '^ *+' conftest.er1 >conftest.err
4631   rm -f conftest.er1
4632   cat conftest.err >&5
4633   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4634   (exit $ac_status); } &&
4635          { ac_try='test -z "$ac_c_werror_flag"
4636                          || test ! -s conftest.err'
4637   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4638   (eval $ac_try) 2>&5
4639   ac_status=$?
4640   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4641   (exit $ac_status); }; } &&
4642          { ac_try='test -s conftest.$ac_objext'
4643   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4644   (eval $ac_try) 2>&5
4645   ac_status=$?
4646   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4647   (exit $ac_status); }; }; then
4648   echo "$as_me:$LINENO: result: yes" >&5
4649 echo "${ECHO_T}yes" >&6
4650 else
4651   echo "$as_me: failed program was:" >&5
4652 sed 's/^/| /' conftest.$ac_ext >&5
4653
4654 echo "$as_me:$LINENO: result: no" >&5
4655 echo "${ECHO_T}no" >&6; have_gmp=no
4656 fi
4657 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4658
4659   if test x"$have_gmp" = xyes; then
4660     saved_LIBS="$LIBS"
4661     LIBS="$LIBS $gmplibs"
4662         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4663 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4664     cat >conftest.$ac_ext <<_ACEOF
4665 /* confdefs.h.  */
4666 _ACEOF
4667 cat confdefs.h >>conftest.$ac_ext
4668 cat >>conftest.$ac_ext <<_ACEOF
4669 /* end confdefs.h.  */
4670 #include <gmp.h>
4671     #include <mpfr.h>
4672 int
4673 main ()
4674 {
4675
4676     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4677     choke me
4678     #endif
4679     mpfr_t n;
4680     mpfr_t x;
4681     int t;
4682     mpfr_init (n);
4683     mpfr_init (x);
4684     mpfr_atan2 (n, n, x, GMP_RNDN);
4685     mpfr_erfc (n, x, GMP_RNDN);
4686     mpfr_subnormalize (x, t, GMP_RNDN);
4687
4688   ;
4689   return 0;
4690 }
4691 _ACEOF
4692 rm -f conftest.$ac_objext conftest$ac_exeext
4693 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4694   (eval $ac_link) 2>conftest.er1
4695   ac_status=$?
4696   grep -v '^ *+' conftest.er1 >conftest.err
4697   rm -f conftest.er1
4698   cat conftest.err >&5
4699   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4700   (exit $ac_status); } &&
4701          { ac_try='test -z "$ac_c_werror_flag"
4702                          || test ! -s conftest.err'
4703   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4704   (eval $ac_try) 2>&5
4705   ac_status=$?
4706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4707   (exit $ac_status); }; } &&
4708          { ac_try='test -s conftest$ac_exeext'
4709   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4710   (eval $ac_try) 2>&5
4711   ac_status=$?
4712   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4713   (exit $ac_status); }; }; then
4714   cat >conftest.$ac_ext <<_ACEOF
4715 /* confdefs.h.  */
4716 _ACEOF
4717 cat confdefs.h >>conftest.$ac_ext
4718 cat >>conftest.$ac_ext <<_ACEOF
4719 /* end confdefs.h.  */
4720 #include <gmp.h>
4721     #include <mpfr.h>
4722 int
4723 main ()
4724 {
4725
4726     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4727     choke me
4728     #endif
4729     mpfr_t n; mpfr_init(n);
4730
4731   ;
4732   return 0;
4733 }
4734 _ACEOF
4735 rm -f conftest.$ac_objext conftest$ac_exeext
4736 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4737   (eval $ac_link) 2>conftest.er1
4738   ac_status=$?
4739   grep -v '^ *+' conftest.er1 >conftest.err
4740   rm -f conftest.er1
4741   cat conftest.err >&5
4742   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4743   (exit $ac_status); } &&
4744          { ac_try='test -z "$ac_c_werror_flag"
4745                          || test ! -s conftest.err'
4746   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4747   (eval $ac_try) 2>&5
4748   ac_status=$?
4749   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4750   (exit $ac_status); }; } &&
4751          { ac_try='test -s conftest$ac_exeext'
4752   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4753   (eval $ac_try) 2>&5
4754   ac_status=$?
4755   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4756   (exit $ac_status); }; }; then
4757   echo "$as_me:$LINENO: result: yes" >&5
4758 echo "${ECHO_T}yes" >&6
4759 else
4760   echo "$as_me: failed program was:" >&5
4761 sed 's/^/| /' conftest.$ac_ext >&5
4762
4763 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4764 echo "${ECHO_T}buggy but acceptable" >&6
4765 fi
4766 rm -f conftest.err conftest.$ac_objext \
4767       conftest$ac_exeext conftest.$ac_ext
4768 else
4769   echo "$as_me: failed program was:" >&5
4770 sed 's/^/| /' conftest.$ac_ext >&5
4771
4772 echo "$as_me:$LINENO: result: no" >&5
4773 echo "${ECHO_T}no" >&6; have_gmp=no
4774 fi
4775 rm -f conftest.err conftest.$ac_objext \
4776       conftest$ac_exeext conftest.$ac_ext
4777       LIBS="$saved_LIBS"
4778   fi
4779   CFLAGS="$saved_CFLAGS"
4780
4781   if test x$have_gmp != xyes; then
4782     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.2+.
4783 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4784 Copies of these libraries' source code can be found at their respective
4785 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4786 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4787 If you obtained GMP and/or MPFR from a vendor distribution package, make
4788 sure that you have installed both the libraries and the header files.
4789 They may be located in separate packages." >&5
4790 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.2+.
4791 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4792 Copies of these libraries' source code can be found at their respective
4793 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4794 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4795 If you obtained GMP and/or MPFR from a vendor distribution package, make
4796 sure that you have installed both the libraries and the header files.
4797 They may be located in separate packages." >&2;}
4798    { (exit 1); exit 1; }; }
4799   fi
4800 fi
4801
4802 # Flags needed for both GMP and/or MPFR
4803
4804
4805
4806
4807 # Check for PPL
4808 ppl_major_version=0
4809 ppl_minor_version=10
4810 ppllibs=
4811 pplinc=
4812
4813
4814 # Check whether --with-ppl or --without-ppl was given.
4815 if test "${with_ppl+set}" = set; then
4816   withval="$with_ppl"
4817
4818 fi;
4819
4820 # Check whether --with-ppl_include or --without-ppl_include was given.
4821 if test "${with_ppl_include+set}" = set; then
4822   withval="$with_ppl_include"
4823
4824 fi;
4825
4826 # Check whether --with-ppl_lib or --without-ppl_lib was given.
4827 if test "${with_ppl_lib+set}" = set; then
4828   withval="$with_ppl_lib"
4829
4830 fi;
4831
4832 if test "x$with_ppl" != x; then
4833   ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx"
4834   pplinc="-I$with_ppl/include $pplinc"
4835   LIBS="$ppllibs $LIBS"
4836 fi
4837 if test "x$with_ppl_include" != x; then
4838   pplinc="-I$with_ppl_include $pplinc"
4839 fi
4840 if test "x$with_ppl_lib" != x; then
4841   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx"
4842   LIBS="$ppllibs $LIBS"
4843 fi
4844 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
4845   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '
4846   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
4847   LIBS="$ppllibs $LIBS"
4848 fi
4849
4850 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
4851 if test "${enable_ppl_version_check+set}" = set; then
4852   enableval="$enable_ppl_version_check"
4853   ENABLE_PPL_CHECK=$enableval
4854 else
4855   ENABLE_PPL_CHECK=yes
4856 fi;
4857
4858 if test "${ENABLE_PPL_CHECK}" = "yes"; then
4859   saved_CFLAGS="$CFLAGS"
4860   CFLAGS="$CFLAGS $pplinc $gmpinc"
4861   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
4862 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
4863   cat >conftest.$ac_ext <<_ACEOF
4864 /* confdefs.h.  */
4865 _ACEOF
4866 cat confdefs.h >>conftest.$ac_ext
4867 cat >>conftest.$ac_ext <<_ACEOF
4868 /* end confdefs.h.  */
4869 #include "ppl_c.h"
4870 int
4871 main ()
4872 {
4873
4874   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
4875   choke me
4876   #endif
4877
4878   ;
4879   return 0;
4880 }
4881 _ACEOF
4882 rm -f conftest.$ac_objext
4883 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4884   (eval $ac_compile) 2>conftest.er1
4885   ac_status=$?
4886   grep -v '^ *+' conftest.er1 >conftest.err
4887   rm -f conftest.er1
4888   cat conftest.err >&5
4889   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4890   (exit $ac_status); } &&
4891          { ac_try='test -z "$ac_c_werror_flag"
4892                          || test ! -s conftest.err'
4893   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4894   (eval $ac_try) 2>&5
4895   ac_status=$?
4896   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4897   (exit $ac_status); }; } &&
4898          { ac_try='test -s conftest.$ac_objext'
4899   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4900   (eval $ac_try) 2>&5
4901   ac_status=$?
4902   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4903   (exit $ac_status); }; }; then
4904   echo "$as_me:$LINENO: result: yes" >&5
4905 echo "${ECHO_T}yes" >&6
4906 else
4907   echo "$as_me: failed program was:" >&5
4908 sed 's/^/| /' conftest.$ac_ext >&5
4909
4910 echo "$as_me:$LINENO: result: no" >&5
4911 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
4912 fi
4913 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4914   CFLAGS="$saved_CFLAGS"
4915 fi
4916
4917 # Flags needed for PPL
4918
4919
4920
4921
4922 # Check for CLOOG
4923 clooglibs=" -lcloog "
4924 clooginc=" -DCLOOG_PPL_BACKEND "
4925
4926
4927 # Check whether --with-cloog or --without-cloog was given.
4928 if test "${with_cloog+set}" = set; then
4929   withval="$with_cloog"
4930
4931 fi;
4932
4933 # Check whether --with-cloog_include or --without-cloog_include was given.
4934 if test "${with_cloog_include+set}" = set; then
4935   withval="$with_cloog_include"
4936
4937 fi;
4938
4939 # Check whether --with-cloog_lib or --without-cloog_lib was given.
4940 if test "${with_cloog_lib+set}" = set; then
4941   withval="$with_cloog_lib"
4942
4943 fi;
4944
4945 # Check whether --with-cloog-polylib or --without-cloog-polylib was given.
4946 if test "${with_cloog_polylib+set}" = set; then
4947   withval="$with_cloog_polylib"
4948
4949 fi;
4950
4951 if test "x$with_cloog" != x; then
4952   clooglibs="-L$with_cloog/lib -lcloog"
4953   clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
4954   LIBS="$clooglibs $LIBS"
4955 fi
4956 if test "x$with_cloog_polylib" != x; then
4957   clooglibs="-L$with_cloog/lib -lcloog"
4958   clooginc="-I$with_cloog/include "
4959   LIBS="$clooglibs $LIBS"
4960 fi
4961 if test "x$with_cloog_include" != x; then
4962   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
4963 fi
4964 if test "x$with_cloog_lib" != x; then
4965   clooglibs="-L$with_cloog_lib -lcloog"
4966   LIBS="$clooglibs $LIBS"
4967 fi
4968 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
4969   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
4970   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
4971   LIBS="$clooglibs $LIBS"
4972 fi
4973
4974 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
4975 if test "${enable_cloog_version_check+set}" = set; then
4976   enableval="$enable_cloog_version_check"
4977   ENABLE_CLOOG_CHECK=$enableval
4978 else
4979   ENABLE_CLOOG_CHECK=yes
4980 fi;
4981
4982 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
4983   saved_CFLAGS="$CFLAGS"
4984   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
4985   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
4986 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
4987   cat >conftest.$ac_ext <<_ACEOF
4988 /* confdefs.h.  */
4989 _ACEOF
4990 cat confdefs.h >>conftest.$ac_ext
4991 cat >>conftest.$ac_ext <<_ACEOF
4992 /* end confdefs.h.  */
4993 #include "cloog/cloog.h"
4994 int
4995 main ()
4996 {
4997
4998   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
4999   choke me
5000   #endif
5001
5002   ;
5003   return 0;
5004 }
5005 _ACEOF
5006 rm -f conftest.$ac_objext
5007 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5008   (eval $ac_compile) 2>conftest.er1
5009   ac_status=$?
5010   grep -v '^ *+' conftest.er1 >conftest.err
5011   rm -f conftest.er1
5012   cat conftest.err >&5
5013   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5014   (exit $ac_status); } &&
5015          { ac_try='test -z "$ac_c_werror_flag"
5016                          || test ! -s conftest.err'
5017   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5018   (eval $ac_try) 2>&5
5019   ac_status=$?
5020   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5021   (exit $ac_status); }; } &&
5022          { ac_try='test -s conftest.$ac_objext'
5023   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5024   (eval $ac_try) 2>&5
5025   ac_status=$?
5026   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5027   (exit $ac_status); }; }; then
5028   echo "$as_me:$LINENO: result: yes" >&5
5029 echo "${ECHO_T}yes" >&6
5030 else
5031   echo "$as_me: failed program was:" >&5
5032 sed 's/^/| /' conftest.$ac_ext >&5
5033
5034 echo "$as_me:$LINENO: result: no" >&5
5035 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5036 fi
5037 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5038   CFLAGS="$saved_CFLAGS"
5039 fi
5040
5041 # Flags needed for CLOOG
5042
5043
5044
5045
5046 # By default, C is the only stage 1 language.
5047 stage1_languages=,c,
5048
5049 # Figure out what language subdirectories are present.
5050 # Look if the user specified --enable-languages="..."; if not, use
5051 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5052 # go away some day.
5053 # NB:  embedded tabs in this IF block -- do not untabify
5054 if test -d ${srcdir}/gcc; then
5055   if test x"${enable_languages+set}" != xset; then
5056     if test x"${LANGUAGES+set}" = xset; then
5057       enable_languages="${LANGUAGES}"
5058         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5059     else
5060       enable_languages=all
5061     fi
5062   else
5063     if test x"${enable_languages}" = x ||
5064        test x"${enable_languages}" = xyes;
5065        then
5066       echo configure.in: --enable-languages needs at least one language argument 1>&2
5067       exit 1
5068     fi
5069   fi
5070   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5071
5072   # 'f95' is the old name for the 'fortran' language. We issue a warning
5073   # and make the substitution.
5074   case ,${enable_languages}, in
5075     *,f95,*)
5076       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5077       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5078       ;;
5079   esac
5080
5081   # First scan to see if an enabled language requires some other language.
5082   # We assume that a given config-lang.in will list all the language
5083   # front ends it requires, even if some are required indirectly.
5084   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5085     case ${lang_frag} in
5086       ..) ;;
5087       # The odd quoting in the next line works around
5088       # an apparent bug in bash 1.12 on linux.
5089       ${srcdir}/gcc/[*]/config-lang.in) ;;
5090       *)
5091         # From the config-lang.in, get $language, $lang_requires
5092         language=
5093         lang_requires=
5094         . ${lang_frag}
5095         for other in ${lang_requires} ; do
5096           case ,${enable_languages}, in
5097             *,$other,*) ;;
5098             *,all,*) ;;
5099             *,$language,*)
5100               echo " \`$other' language required by \`$language'; enabling" 1>&2
5101               enable_languages="${enable_languages},${other}"
5102               ;;
5103           esac
5104         done
5105         ;;
5106     esac
5107   done
5108
5109   new_enable_languages=,c,
5110   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5111   potential_languages=,c,
5112
5113   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5114     case ${lang_frag} in
5115       ..) ;;
5116       # The odd quoting in the next line works around
5117       # an apparent bug in bash 1.12 on linux.
5118       ${srcdir}/gcc/[*]/config-lang.in) ;;
5119       *)
5120         # From the config-lang.in, get $language, $target_libs,
5121         # $lang_dirs, $boot_language, and $build_by_default
5122         language=
5123         target_libs=
5124         lang_dirs=
5125         subdir_requires=
5126         boot_language=no
5127         build_by_default=yes
5128         . ${lang_frag}
5129         if test x${language} = x; then
5130           echo "${lang_frag} doesn't set \$language." 1>&2
5131           exit 1
5132         fi
5133
5134         case ,${enable_languages}, in
5135           *,${language},*)
5136             # Language was explicitly selected; include it.
5137             add_this_lang=yes
5138             ;;
5139           *,all,*)
5140             # 'all' was selected, select it if it is a default language
5141             add_this_lang=${build_by_default}
5142             ;;
5143           *)
5144             add_this_lang=no
5145             ;;
5146         esac
5147
5148         # Disable languages that need other directories if these aren't available.
5149         for i in $subdir_requires; do
5150           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5151           case ,${enable_languages}, in
5152             *,${language},*)
5153               # Specifically requested language; tell them.
5154               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5155 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5156    { (exit 1); exit 1; }; }
5157               ;;
5158             *)
5159               # Silently disable.
5160               add_this_lang=unsupported
5161               ;;
5162           esac
5163         done
5164
5165         # Disable Ada if no preexisting GNAT is available.
5166         case ,${enable_languages},:${language}:${have_gnat} in
5167           *,${language},*:ada:no)
5168             # Specifically requested language; tell them.
5169             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5170 echo "$as_me: error: GNAT is required to build $language" >&2;}
5171    { (exit 1); exit 1; }; }
5172             ;;
5173           *:ada:no)
5174             # Silently disable.
5175             add_this_lang=unsupported
5176             ;;
5177         esac
5178
5179         # Disable a language that is unsupported by the target.
5180         case " $unsupported_languages " in
5181           *" $language "*)
5182             add_this_lang=unsupported
5183             ;;
5184         esac
5185
5186         case $add_this_lang in
5187           unsupported)
5188             # Remove language-dependent dirs.
5189             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5190             ;;
5191           no)
5192             # Remove language-dependent dirs; still show language as supported.
5193             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5194             potential_languages="${potential_languages}${language},"
5195             ;;
5196           yes)
5197             new_enable_languages="${new_enable_languages}${language},"
5198             potential_languages="${potential_languages}${language},"
5199             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5200             case ${boot_language} in
5201               yes)
5202                 # Add to (comma-separated) list of stage 1 languages.
5203                 stage1_languages="${stage1_languages}${language},"
5204                 ;;
5205             esac
5206             ;;
5207         esac
5208         ;;
5209     esac
5210   done
5211
5212   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5213 if test "${enable_stage1_languages+set}" = set; then
5214   enableval="$enable_stage1_languages"
5215   case ,${enable_stage1_languages}, in
5216     ,no,|,,)
5217       # Set it to something that will have no effect in the loop below
5218       enable_stage1_languages=c ;;
5219     ,yes,)
5220       enable_stage1_languages=`echo $new_enable_languages | \
5221         sed -e "s/^,//" -e "s/,$//" ` ;;
5222     *,all,*)
5223       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5224         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5225   esac
5226
5227   # Add "good" languages from enable_stage1_languages to stage1_languages,
5228   # while "bad" languages go in missing_languages.  Leave no duplicates.
5229   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5230     case $potential_languages in
5231       *,$i,*)
5232         case $stage1_languages in
5233           *,$i,*) ;;
5234           *) stage1_languages="$stage1_languages$i," ;;
5235         esac ;;
5236       *)
5237         case $missing_languages in
5238           *,$i,*) ;;
5239           *) missing_languages="$missing_languages$i," ;;
5240         esac ;;
5241      esac
5242   done
5243 fi;
5244
5245   # Remove leading/trailing commas that were added for simplicity
5246   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5247   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5248   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5249   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5250
5251   if test "x$missing_languages" != x; then
5252     { { echo "$as_me:$LINENO: error:
5253 The following requested languages could not be built: ${missing_languages}
5254 Supported languages are: ${potential_languages}" >&5
5255 echo "$as_me: error:
5256 The following requested languages could not be built: ${missing_languages}
5257 Supported languages are: ${potential_languages}" >&2;}
5258    { (exit 1); exit 1; }; }
5259   fi
5260   if test "x$new_enable_languages" != "x$enable_languages"; then
5261     echo The following languages will be built: ${new_enable_languages}
5262     enable_languages="$new_enable_languages"
5263   fi
5264
5265
5266   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5267 fi
5268
5269 # Handle --disable-<component> generically.
5270 for dir in $configdirs $build_configdirs $target_configdirs ; do
5271   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5272   varname=`echo $dirname | sed -e s/+/_/g`
5273   if eval test x\${enable_${varname}} "=" xno ; then
5274     noconfigdirs="$noconfigdirs $dir"
5275   fi
5276 done
5277
5278 # Check for Boehm's garbage collector
5279 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5280 if test "${enable_objc_gc+set}" = set; then
5281   enableval="$enable_objc_gc"
5282   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5283   *,objc,*:*:yes:*target-boehm-gc*)
5284     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5285 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5286    { (exit 1); exit 1; }; }
5287     ;;
5288 esac
5289 fi;
5290
5291 # Make sure we only build Boehm's garbage collector if required.
5292 case ,${enable_languages},:${enable_objc_gc} in
5293   *,objc,*:yes)
5294     # Keep target-boehm-gc if requested for Objective-C.
5295     ;;
5296   *)
5297     # Otherwise remove target-boehm-gc depending on target-libjava.
5298     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5299       noconfigdirs="$noconfigdirs target-boehm-gc"
5300     fi
5301     ;;
5302 esac
5303
5304 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5305 # $build_configdirs and $target_configdirs.
5306 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5307
5308 notsupp=""
5309 for dir in . $skipdirs $noconfigdirs ; do
5310   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5311   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5312     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5313     if test -r $srcdir/$dirname/configure ; then
5314       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5315         true
5316       else
5317         notsupp="$notsupp $dir"
5318       fi
5319     fi
5320   fi
5321   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5322     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5323     if test -r $srcdir/$dirname/configure ; then
5324       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5325         true
5326       else
5327         notsupp="$notsupp $dir"
5328       fi
5329     fi
5330   fi
5331   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5332     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5333     if test -r $srcdir/$dirname/configure ; then
5334       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5335         true
5336       else
5337         notsupp="$notsupp $dir"
5338       fi
5339     fi
5340   fi
5341 done
5342
5343 # Sometimes the tools are distributed with libiberty but with no other
5344 # libraries.  In that case, we don't want to build target-libiberty.
5345 # Don't let libgcc imply libiberty either.
5346 if test -n "${target_configdirs}" ; then
5347   libgcc=
5348   others=
5349   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5350     if test "$i" = "libgcc"; then
5351       libgcc=target-libgcc
5352     elif test "$i" != "libiberty" ; then
5353       if test -r $srcdir/$i/configure ; then
5354         others=yes;
5355         break;
5356       fi
5357     fi
5358   done
5359   if test -z "${others}" ; then
5360     target_configdirs=$libgcc
5361   fi
5362 fi
5363
5364 # Quietly strip out all directories which aren't configurable in this tree.
5365 # This relies on all configurable subdirectories being autoconfiscated, which
5366 # is now the case.
5367 build_configdirs_all="$build_configdirs"
5368 build_configdirs=
5369 for i in ${build_configdirs_all} ; do
5370   j=`echo $i | sed -e s/build-//g`
5371   if test -f ${srcdir}/$j/configure ; then
5372     build_configdirs="${build_configdirs} $i"
5373   fi
5374 done
5375
5376 configdirs_all="$configdirs"
5377 configdirs=
5378 for i in ${configdirs_all} ; do
5379   if test -f ${srcdir}/$i/configure ; then
5380     configdirs="${configdirs} $i"
5381   fi
5382 done
5383
5384 target_configdirs_all="$target_configdirs"
5385 target_configdirs=
5386 for i in ${target_configdirs_all} ; do
5387   j=`echo $i | sed -e s/target-//g`
5388   if test -f ${srcdir}/$j/configure ; then
5389     target_configdirs="${target_configdirs} $i"
5390   fi
5391 done
5392
5393 # Produce a warning message for the subdirs we can't configure.
5394 # This isn't especially interesting in the Cygnus tree, but in the individual
5395 # FSF releases, it's important to let people know when their machine isn't
5396 # supported by the one or two programs in a package.
5397
5398 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5399   # If $appdirs is non-empty, at least one of those directories must still
5400   # be configured, or we error out.  (E.g., if the gas release supports a
5401   # specified target in some subdirs but not the gas subdir, we shouldn't
5402   # pretend that all is well.)
5403   if test -n "$appdirs" ; then
5404     for dir in $appdirs ; do
5405       if test -r $dir/Makefile.in ; then
5406         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5407           appdirs=""
5408           break
5409         fi
5410         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5411           appdirs=""
5412           break
5413         fi
5414       fi
5415     done
5416     if test -n "$appdirs" ; then
5417       echo "*** This configuration is not supported by this package." 1>&2
5418       exit 1
5419     fi
5420   fi
5421   # Okay, some application will build, or we don't care to check.  Still
5422   # notify of subdirs not getting built.
5423   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5424   echo "    ${notsupp}" 1>&2
5425   echo "    (Any other directories should still work fine.)" 1>&2
5426 fi
5427
5428 case "$host" in
5429   *msdosdjgpp*)
5430     enable_gdbtk=no ;;
5431 esac
5432
5433 # To find our prefix, in gcc_cv_tool_prefix.
5434
5435 # The user is always right.
5436 if test "${PATH_SEPARATOR+set}" != set; then
5437   echo "#! /bin/sh" >conf$$.sh
5438   echo  "exit 0"   >>conf$$.sh
5439   chmod +x conf$$.sh
5440   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5441     PATH_SEPARATOR=';'
5442   else
5443     PATH_SEPARATOR=:
5444   fi
5445   rm -f conf$$.sh
5446 fi
5447
5448
5449
5450 if test "x$exec_prefix" = xNONE; then
5451         if test "x$prefix" = xNONE; then
5452                 gcc_cv_tool_prefix=$ac_default_prefix
5453         else
5454                 gcc_cv_tool_prefix=$prefix
5455         fi
5456 else
5457         gcc_cv_tool_prefix=$exec_prefix
5458 fi
5459
5460 # If there is no compiler in the tree, use the PATH only.  In any
5461 # case, if there is no compiler in the tree nobody should use
5462 # AS_FOR_TARGET and LD_FOR_TARGET.
5463 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5464     gcc_version=`cat $srcdir/gcc/BASE-VER`
5465     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5466     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5467     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5468     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5469     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5470     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5471 else
5472     gcc_cv_tool_dirs=
5473 fi
5474
5475 if test x$build = x$target && test -n "$md_exec_prefix"; then
5476         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5477 fi
5478
5479
5480
5481 copy_dirs=
5482
5483
5484 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5485 if test "${with_build_sysroot+set}" = set; then
5486   withval="$with_build_sysroot"
5487   if test x"$withval" != x ; then
5488      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5489    fi
5490 else
5491   SYSROOT_CFLAGS_FOR_TARGET=
5492 fi;
5493
5494
5495
5496 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5497 if test "${with_debug_prefix_map+set}" = set; then
5498   withval="$with_debug_prefix_map"
5499   if test x"$withval" != x; then
5500      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5501      for debug_map in $withval; do
5502        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5503      done
5504    fi
5505 else
5506   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5507 fi;
5508
5509
5510 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5511 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5512 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5513 # We want to ensure that TARGET libraries (which we know are built with
5514 # gcc) are built with "-O2 -g", so include those options when setting
5515 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5516 if test "x$CFLAGS_FOR_TARGET" = x; then
5517   CFLAGS_FOR_TARGET=$CFLAGS
5518   case " $CFLAGS " in
5519     *" -O2 "*) ;;
5520     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5521   esac
5522   case " $CFLAGS " in
5523     *" -g "* | *" -g3 "*) ;;
5524     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5525   esac
5526 fi
5527
5528
5529 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5530   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5531   case " $CXXFLAGS " in
5532     *" -O2 "*) ;;
5533     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5534   esac
5535   case " $CXXFLAGS " in
5536     *" -g "* | *" -g3 "*) ;;
5537     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5538   esac
5539 fi
5540
5541
5542 # Other target tools.
5543 CPPFLAGS_FOR_TARGET=${CPPFLAGS_FOR_TARGET-${CPPFLAGS}}
5544
5545 LDFLAGS_FOR_TARGET=${LDFLAGS_FOR_TARGET-${LDFLAGS}}
5546
5547
5548 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5549 # the named directory are copied to $(tooldir)/sys-include.
5550 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5551   if test x${is_cross_compiler} = xno ; then
5552     echo 1>&2 '***' --with-headers is only supported when cross compiling
5553     exit 1
5554   fi
5555   if test x"${with_headers}" != xyes ; then
5556     x=${gcc_cv_tool_prefix}
5557     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5558   fi
5559 fi
5560
5561 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5562 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5563 # are permitted.
5564 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5565   if test x${is_cross_compiler} = xno ; then
5566     echo 1>&2 '***' --with-libs is only supported when cross compiling
5567     exit 1
5568   fi
5569   if test x"${with_libs}" != xyes ; then
5570     # Copy the libraries in reverse order, so that files in the first named
5571     # library override files in subsequent libraries.
5572     x=${gcc_cv_tool_prefix}
5573     for l in ${with_libs}; do
5574       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5575     done
5576   fi
5577 fi
5578
5579 # Set with_gnu_as and with_gnu_ld as appropriate.
5580 #
5581 # This is done by determining whether or not the appropriate directory
5582 # is available, and by checking whether or not specific configurations
5583 # have requested that this magic not happen.
5584 #
5585 # The command line options always override the explicit settings in
5586 # configure.in, and the settings in configure.in override this magic.
5587 #
5588 # If the default for a toolchain is to use GNU as and ld, and you don't
5589 # want to do that, then you should use the --without-gnu-as and
5590 # --without-gnu-ld options for the configure script.
5591
5592 if test x${use_gnu_as} = x &&
5593    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5594   with_gnu_as=yes
5595   extra_host_args="$extra_host_args --with-gnu-as"
5596 fi
5597
5598 if test x${use_gnu_ld} = x &&
5599    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5600   with_gnu_ld=yes
5601   extra_host_args="$extra_host_args --with-gnu-ld"
5602 fi
5603
5604 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5605 # can detect this case.
5606
5607 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5608   with_newlib=yes
5609   extra_host_args="$extra_host_args --with-newlib"
5610 fi
5611
5612 # Handle ${copy_dirs}
5613 set fnord ${copy_dirs}
5614 shift
5615 while test $# != 0 ; do
5616   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5617     :
5618   else
5619     echo Copying $1 to $2
5620
5621     # Use the install script to create the directory and all required
5622     # parent directories.
5623     if test -d $2 ; then
5624       :
5625     else
5626       echo >config.temp
5627       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5628     fi
5629
5630     # Copy the directory, assuming we have tar.
5631     # FIXME: Should we use B in the second tar?  Not all systems support it.
5632     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5633
5634     # It is the responsibility of the user to correctly adjust all
5635     # symlinks.  If somebody can figure out how to handle them correctly
5636     # here, feel free to add the code.
5637
5638     echo $1 > $2/COPIED
5639   fi
5640   shift; shift
5641 done
5642
5643 # Determine a target-dependent exec_prefix that the installed
5644 # gcc will search in.  Keep this list sorted by triplet, with
5645 # the *-*-osname triplets last.
5646 md_exec_prefix=
5647 case "${target}" in
5648   alpha*-*-*vms*)
5649     md_exec_prefix=/gnu/lib/gcc-lib
5650     ;;
5651   i[34567]86-pc-msdosdjgpp*)
5652     md_exec_prefix=/dev/env/DJDIR/bin
5653     ;;
5654   i[34567]86-*-sco3.2v5*)
5655     if test $with_gnu_as = yes; then
5656       md_exec_prefix=/usr/gnu/bin
5657     else
5658       md_exec_prefix=/usr/ccs/bin/elf
5659     fi
5660     ;;
5661
5662   mn10300-*-* | \
5663   powerpc-*-chorusos* | \
5664   powerpc*-*-eabi* | \
5665   powerpc*-*-sysv* | \
5666   powerpc*-*-kaos* | \
5667   s390x-ibm-tpf*)
5668     md_exec_prefix=/usr/ccs/bin
5669     ;;
5670   sparc64-*-elf*)
5671     ;;
5672   v850*-*-*)
5673     md_exec_prefix=/usr/ccs/bin
5674     ;;
5675   xtensa*-*-elf*)
5676     ;;
5677
5678   *-*-beos* | \
5679   *-*-elf* | \
5680   *-*-hpux* | \
5681   *-*-netware* | \
5682   *-*-nto-qnx* | \
5683   *-*-rtems* | \
5684   *-*-solaris2* | \
5685   *-*-sysv[45]* | \
5686   *-*-vxworks* | \
5687   *-wrs-windiss)
5688     md_exec_prefix=/usr/ccs/bin
5689     ;;
5690 esac
5691
5692 extra_arflags_for_target=
5693 extra_nmflags_for_target=
5694 extra_ranlibflags_for_target=
5695 target_makefile_frag=/dev/null
5696 case "${target}" in
5697   mep*-*-*)
5698     target_makefile_frag="config/mt-mep"
5699     ;;
5700   spu-*-*)
5701     target_makefile_frag="config/mt-spu"
5702     ;;
5703   mips*-sde-elf*)
5704     target_makefile_frag="config/mt-sde"
5705     ;;
5706   mipsisa*-*-elfoabi*)
5707     target_makefile_frag="config/mt-mips-elfoabi"
5708     ;;
5709   mips*-*-*linux* | mips*-*-gnu*)
5710     target_makefile_frag="config/mt-mips-gnu"
5711     ;;
5712   *-*-netware*)
5713     target_makefile_frag="config/mt-netware"
5714     ;;
5715   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5716     target_makefile_frag="config/mt-gnu"
5717     ;;
5718   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5719     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5720     # commands to handle both 32-bit and 64-bit objects.  These flags are
5721     # harmless if we're using GNU nm or ar.
5722     extra_arflags_for_target=" -X32_64"
5723     extra_nmflags_for_target=" -B -X32_64"
5724     ;;
5725   *-*-darwin*)
5726     # ranlib from Darwin requires the -c flag to look at common symbols.
5727     extra_ranlibflags_for_target=" -c"
5728     ;;
5729   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5730     target_makefile_frag="config/mt-wince"
5731     ;;
5732 esac
5733
5734 alphaieee_frag=/dev/null
5735 case $target in
5736   alpha*-*-*)
5737     # This just makes sure to use the -mieee option to build target libs.
5738     # This should probably be set individually by each library.
5739     alphaieee_frag="config/mt-alphaieee"
5740     ;;
5741 esac
5742
5743 # If --enable-target-optspace always use -Os instead of -O2 to build
5744 # the target libraries, similarly if it is not specified, use -Os
5745 # on selected platforms.
5746 ospace_frag=/dev/null
5747 case "${enable_target_optspace}:${target}" in
5748   yes:*)
5749     ospace_frag="config/mt-ospace"
5750     ;;
5751   :d30v-*)
5752     ospace_frag="config/mt-d30v"
5753     ;;
5754   :m32r-* | :d10v-* | :fr30-*)
5755     ospace_frag="config/mt-ospace"
5756     ;;
5757   no:* | :*)
5758     ;;
5759   *)
5760     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5761     ;;
5762 esac
5763
5764 # Default to using --with-stabs for certain targets.
5765 if test x${with_stabs} = x ; then
5766   case "${target}" in
5767   mips*-*-irix[56]*)
5768     ;;
5769   mips*-*-* | alpha*-*-osf*)
5770     with_stabs=yes;
5771     extra_host_args="${extra_host_args} --with-stabs"
5772     ;;
5773   esac
5774 fi
5775
5776 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5777 # them automatically.
5778 case "${host}" in
5779   hppa*64*-*-hpux11*)
5780     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5781     ;;
5782 esac
5783
5784 # Some systems (e.g., one of the i386-aix systems the gas testers are
5785 # using) don't handle "\$" correctly, so don't use it here.
5786 tooldir='${exec_prefix}'/${target_noncanonical}
5787 build_tooldir=${tooldir}
5788
5789 # Create a .gdbinit file which runs the one in srcdir
5790 # and tells GDB to look there for source files.
5791
5792 if test -r ${srcdir}/.gdbinit ; then
5793   case ${srcdir} in
5794     .) ;;
5795     *) cat > ./.gdbinit <<EOF
5796 # ${NO_EDIT}
5797 dir ${srcdir}
5798 dir .
5799 source ${srcdir}/.gdbinit
5800 EOF
5801     ;;
5802   esac
5803 fi
5804
5805 # Make sure that the compiler is able to generate an executable.  If it
5806 # can't, we are probably in trouble.  We don't care whether we can run the
5807 # executable--we might be using a cross compiler--we only care whether it
5808 # can be created.  At this point the main configure script has set CC.
5809 we_are_ok=no
5810 echo "int main () { return 0; }" > conftest.c
5811 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5812 if test $? = 0 ; then
5813   if test -s conftest || test -s conftest.exe ; then
5814     we_are_ok=yes
5815   fi
5816 fi
5817 case $we_are_ok in
5818   no)
5819     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5820     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5821     rm -f conftest*
5822     exit 1
5823     ;;
5824 esac
5825 rm -f conftest*
5826
5827 # The Solaris /usr/ucb/cc compiler does not appear to work.
5828 case "${host}" in
5829   sparc-sun-solaris2*)
5830       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5831       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5832           could_use=
5833           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5834           if test -d /opt/cygnus/bin ; then
5835               if test "$could_use" = "" ; then
5836                   could_use="/opt/cygnus/bin"
5837               else
5838                   could_use="$could_use or /opt/cygnus/bin"
5839               fi
5840           fi
5841         if test "$could_use" = "" ; then
5842             echo "Warning: compilation may fail because you're using"
5843             echo "/usr/ucb/cc.  You should change your PATH or CC "
5844             echo "variable and rerun configure."
5845         else
5846             echo "Warning: compilation may fail because you're using"
5847             echo "/usr/ucb/cc, when you should use the C compiler from"
5848             echo "$could_use.  You should change your"
5849             echo "PATH or CC variable and rerun configure."
5850         fi
5851       fi
5852   ;;
5853 esac
5854
5855 # Decide which environment variable is used to find dynamic libraries.
5856 case "${host}" in
5857   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5858   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5859   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5860   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5861 esac
5862
5863 # On systems where the dynamic library environment variable is PATH,
5864 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
5865 # built executables to PATH.
5866 if test "$RPATH_ENVVAR" = PATH; then
5867   GCC_SHLIB_SUBDIR=/shlib
5868 else
5869   GCC_SHLIB_SUBDIR=
5870 fi
5871
5872 # Record target_configdirs and the configure arguments for target and
5873 # build configuration in Makefile.
5874 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5875 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5876
5877 # Determine whether gdb needs tk/tcl or not.
5878 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5879 # and in that case we want gdb to be built without tk.  Ugh!
5880 # In fact I believe gdb is the *only* package directly dependent on tk,
5881 # so we should be able to put the 'maybe's in unconditionally and
5882 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5883 # 100% sure that that's safe though.
5884
5885 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5886 case "$enable_gdbtk" in
5887   no)
5888     GDB_TK="" ;;
5889   yes)
5890     GDB_TK="${gdb_tk}" ;;
5891   *)
5892     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5893     # distro.  Eventually someone will fix this and move Insight, nee
5894     # gdbtk to a separate directory.
5895     if test -d ${srcdir}/gdb/gdbtk ; then
5896       GDB_TK="${gdb_tk}"
5897     else
5898       GDB_TK=""
5899     fi
5900     ;;
5901 esac
5902 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5903 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5904
5905 # Strip out unwanted targets.
5906
5907 # While at that, we remove Makefiles if we were started for recursive
5908 # configuration, so that the top-level Makefile reconfigures them,
5909 # like we used to do when configure itself was recursive.
5910
5911 # Loop over modules.  $extrasub must be used with care, limiting as
5912 # much as possible the usage of range addresses.  That's because autoconf
5913 # splits the sed script to overcome limits in the number of commands,
5914 # and relying on carefully-timed sed passes may turn out to be very hard
5915 # to maintain later.  In this particular case, you just have to be careful
5916 # not to nest @if/@endif pairs, because configure will not warn you at all.
5917
5918 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5919 if test "${enable_bootstrap+set}" = set; then
5920   enableval="$enable_bootstrap"
5921
5922 else
5923   enable_bootstrap=default
5924 fi;
5925
5926 # Issue errors and warnings for invalid/strange bootstrap combinations.
5927 case "$configdirs" in
5928   *gcc*) have_compiler=yes ;;
5929   *) have_compiler=no ;;
5930 esac
5931
5932 case "$have_compiler:$host:$target:$enable_bootstrap" in
5933   *:*:*:no) ;;
5934
5935   # Default behavior.  Enable bootstrap if we have a compiler
5936   # and we are in a native configuration.
5937   yes:$build:$build:default)
5938     enable_bootstrap=yes ;;
5939
5940   *:*:*:default)
5941     enable_bootstrap=no ;;
5942
5943   # We have a compiler and we are in a native configuration, bootstrap is ok
5944   yes:$build:$build:yes)
5945     ;;
5946
5947   # Other configurations, but we have a compiler.  Assume the user knows
5948   # what he's doing.
5949   yes:*:*:yes)
5950     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5951 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5952     ;;
5953
5954   # No compiler: if they passed --enable-bootstrap explicitly, fail
5955   no:*:*:yes)
5956     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5957 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5958    { (exit 1); exit 1; }; } ;;
5959
5960   # Fail if wrong command line
5961   *)
5962     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5963 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5964    { (exit 1); exit 1; }; }
5965     ;;
5966 esac
5967
5968 # Adjust the toplevel makefile according to whether bootstrap was selected.
5969 case "$enable_bootstrap" in
5970   yes)
5971     bootstrap_suffix=bootstrap ;;
5972   no)
5973     bootstrap_suffix=no-bootstrap ;;
5974 esac
5975
5976 for module in ${build_configdirs} ; do
5977   if test -z "${no_recursion}" \
5978      && test -f ${build_subdir}/${module}/Makefile; then
5979     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5980     rm -f ${build_subdir}/${module}/Makefile
5981   fi
5982   extrasub="$extrasub
5983 /^@if build-$module\$/d
5984 /^@endif build-$module\$/d
5985 /^@if build-$module-$bootstrap_suffix\$/d
5986 /^@endif build-$module-$bootstrap_suffix\$/d"
5987 done
5988 for module in ${configdirs} ; do
5989   if test -z "${no_recursion}"; then
5990     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5991       if test -f ${file}; then
5992         echo 1>&2 "*** removing ${file} to force reconfigure"
5993         rm -f ${file}
5994       fi
5995     done
5996   fi
5997   extrasub="$extrasub
5998 /^@if $module\$/d
5999 /^@endif $module\$/d
6000 /^@if $module-$bootstrap_suffix\$/d
6001 /^@endif $module-$bootstrap_suffix\$/d"
6002 done
6003 for module in ${target_configdirs} ; do
6004   if test -z "${no_recursion}" \
6005      && test -f ${target_subdir}/${module}/Makefile; then
6006     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6007     rm -f ${target_subdir}/${module}/Makefile
6008   fi
6009   extrasub="$extrasub
6010 /^@if target-$module\$/d
6011 /^@endif target-$module\$/d
6012 /^@if target-$module-$bootstrap_suffix\$/d
6013 /^@endif target-$module-$bootstrap_suffix\$/d"
6014 done
6015
6016 extrasub="$extrasub
6017 /^@if /,/^@endif /d"
6018
6019 # Create the serialization dependencies.  This uses a temporary file.
6020
6021 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6022 if test "${enable_serial_configure+set}" = set; then
6023   enableval="$enable_serial_configure"
6024
6025 fi;
6026
6027 case ${enable_serial_configure} in
6028   yes)
6029     enable_serial_build_configure=yes
6030     enable_serial_host_configure=yes
6031     enable_serial_target_configure=yes
6032     ;;
6033 esac
6034
6035 # These force 'configure's to be done one at a time, to avoid problems
6036 # with contention over a shared config.cache.
6037 rm -f serdep.tmp
6038 echo '# serdep.tmp' > serdep.tmp
6039 olditem=
6040 test "x${enable_serial_build_configure}" = xyes &&
6041 for item in ${build_configdirs} ; do
6042   case ${olditem} in
6043     "") ;;
6044     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6045   esac
6046   olditem=${item}
6047 done
6048 olditem=
6049 test "x${enable_serial_host_configure}" = xyes &&
6050 for item in ${configdirs} ; do
6051   case ${olditem} in
6052     "") ;;
6053     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6054   esac
6055   olditem=${item}
6056 done
6057 olditem=
6058 test "x${enable_serial_target_configure}" = xyes &&
6059 for item in ${target_configdirs} ; do
6060   case ${olditem} in
6061     "") ;;
6062     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6063   esac
6064   olditem=${item}
6065 done
6066 serialization_dependencies=serdep.tmp
6067
6068
6069 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6070 # target, nonopt, and variable assignments.  These are the ones we
6071 # might not want to pass down to subconfigures.  Also strip
6072 # program-prefix, program-suffix, and program-transform-name, so that
6073 # we can pass down a consistent program-transform-name.
6074 baseargs=
6075 keep_next=no
6076 skip_next=no
6077 eval "set -- $ac_configure_args"
6078 for ac_arg
6079 do
6080   if test X"$skip_next" = X"yes"; then
6081     skip_next=no
6082     continue
6083   fi
6084   if test X"$keep_next" = X"yes"; then
6085     case $ac_arg in
6086       *\'*)
6087         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6088     esac
6089     baseargs="$baseargs '$ac_arg'"
6090     keep_next=no
6091     continue
6092   fi
6093
6094   # Handle separated arguments.  Based on the logic generated by
6095   # autoconf 2.59.
6096   case $ac_arg in
6097     *=* | --config-cache | -C | -disable-* | --disable-* \
6098       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6099       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6100       | -with-* | --with-* | -without-* | --without-* | --x)
6101       separate_arg=no
6102       ;;
6103     -*)
6104       separate_arg=yes
6105       ;;
6106     *)
6107       separate_arg=no
6108       ;;
6109   esac
6110
6111   case "$ac_arg" in
6112     --no*)
6113       continue
6114       ;;
6115     --c* | \
6116     --sr* | \
6117     --ho* | \
6118     --bu* | \
6119     --t* | \
6120     --program-* | \
6121     -cache_file* | \
6122     -srcdir* | \
6123     -host* | \
6124     -build* | \
6125     -target* | \
6126     -program-prefix* | \
6127     -program-suffix* | \
6128     -program-transform-name* )
6129       skip_next=$separate_arg
6130       continue
6131       ;;
6132     -*)
6133       # An option.  Add it.
6134       case $ac_arg in
6135         *\'*)
6136           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6137       esac
6138       baseargs="$baseargs '$ac_arg'"
6139       keep_next=$separate_arg
6140       ;;
6141     *)
6142       # Either a variable assignment, or a nonopt (triplet).  Don't
6143       # pass it down; let the Makefile handle this.
6144       continue
6145       ;;
6146   esac
6147 done
6148 # Remove the initial space we just introduced and, as these will be
6149 # expanded by make, quote '$'.
6150 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6151
6152 # Add in --program-transform-name, after --program-prefix and
6153 # --program-suffix have been applied to it.  Autoconf has already
6154 # doubled dollar signs and backslashes in program_transform_name; we want
6155 # the backslashes un-doubled, and then the entire thing wrapped in single
6156 # quotes, because this will be expanded first by make and then by the shell.
6157 # Also, because we want to override the logic in subdir configure scripts to
6158 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6159 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6160 ${program_transform_name}
6161 EOF_SED
6162 gcc_transform_name=`cat conftestsed.out`
6163 rm -f conftestsed.out
6164 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6165 if test "$silent" = yes; then
6166   baseargs="$baseargs --silent"
6167 fi
6168
6169 # For the build-side libraries, we just need to pretend we're native,
6170 # and not use the same cache file.  Multilibs are neither needed nor
6171 # desired.
6172 build_configargs="--cache-file=../config.cache ${baseargs}"
6173
6174 # For host modules, accept cache file option, or specification as blank.
6175 case "${cache_file}" in
6176 "") # empty
6177   cache_file_option="" ;;
6178 /* | [A-Za-z]:[\\/]* ) # absolute path
6179   cache_file_option="--cache-file=${cache_file}" ;;
6180 *) # relative path
6181   cache_file_option="--cache-file=../${cache_file}" ;;
6182 esac
6183
6184 # Host dirs don't like to share a cache file either, horribly enough.
6185 # This seems to be due to autoconf 2.5x stupidity.
6186 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6187
6188 target_configargs=${baseargs}
6189
6190 # Passing a --with-cross-host argument lets the target libraries know
6191 # whether they are being built with a cross-compiler or being built
6192 # native.  However, it would be better to use other mechanisms to make the
6193 # sorts of decisions they want to make on this basis.  Please consider
6194 # this option to be deprecated.  FIXME.
6195 if test x${is_cross_compiler} = xyes ; then
6196   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6197 fi
6198
6199 # Default to --enable-multilib.
6200 if test x${enable_multilib} = x ; then
6201   target_configargs="--enable-multilib ${target_configargs}"
6202 fi
6203
6204 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6205 # changed from the earlier setting of with_newlib.
6206 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6207   target_configargs="--with-newlib ${target_configargs}"
6208 fi
6209
6210 # Different target subdirs use different values of certain variables
6211 # (notably CXX).  Worse, multilibs use *lots* of different values.
6212 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6213 # it doesn't automatically accept command-line overrides of them.
6214 # This means it's not safe for target subdirs to share a cache file,
6215 # which is disgusting, but there you have it.  Hopefully this can be
6216 # fixed in future.  It's still worthwhile to use a cache file for each
6217 # directory.  I think.
6218
6219 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6220 # We need to pass --target, as newer autoconf's requires consistency
6221 # for target_alias and gcc doesn't manage it consistently.
6222 target_configargs="--cache-file=./config.cache ${target_configargs}"
6223
6224 FLAGS_FOR_TARGET=
6225 case " $target_configdirs " in
6226  *" newlib "*)
6227   case " $target_configargs " in
6228   *" --with-newlib "*)
6229    case "$target" in
6230    *-cygwin*)
6231      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' ;;
6232    esac
6233
6234    # If we're not building GCC, don't discard standard headers.
6235    if test -d ${srcdir}/gcc; then
6236      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6237
6238      if test "${build}" != "${host}"; then
6239        # On Canadian crosses, CC_FOR_TARGET will have already been set
6240        # by `configure', so we won't have an opportunity to add -Bgcc/
6241        # to it.  This is right: we don't want to search that directory
6242        # for binaries, but we want the header files in there, so add
6243        # them explicitly.
6244        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6245
6246        # Someone might think of using the pre-installed headers on
6247        # Canadian crosses, in case the installed compiler is not fully
6248        # compatible with the compiler being built.  In this case, it
6249        # would be better to flag an error than risking having
6250        # incompatible object files being constructed.  We can't
6251        # guarantee that an error will be flagged, but let's hope the
6252        # compiler will do it, when presented with incompatible header
6253        # files.
6254      fi
6255    fi
6256
6257    case "${target}-${is_cross_compiler}" in
6258    i[3456789]86-*-linux*-no)
6259       # Here host == target, so we don't need to build gcc,
6260       # so we don't want to discard standard headers.
6261       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6262       ;;
6263    *)
6264       # If we're building newlib, use its generic headers last, but search
6265       # for any libc-related directories first (so make it the last -B
6266       # switch).
6267       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6268
6269       # If we're building libgloss, find the startup file, simulator library
6270       # and linker script.
6271       case " $target_configdirs " in
6272         *" libgloss "*)
6273         # Look for startup file, simulator library and maybe linker script.
6274         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6275         # Look for libnosys.a in case the target needs it.
6276         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6277         # Most targets have the linker script in the source directory.
6278         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6279         ;;
6280       esac
6281       ;;
6282    esac
6283    ;;
6284   esac
6285   ;;
6286 esac
6287 case "$target" in
6288 *-mingw*)
6289   # Can't be handled as Cygwin above since Mingw does not use newlib.
6290   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' ;;
6291 esac
6292
6293 # Allow the user to override the flags for
6294 # our build compiler if desired.
6295 if test x"${build}" = x"${host}" ; then
6296   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6297   CPPFLAGS_FOR_BUILD=${CPPFLAGS_FOR_BUILD-${CPPFLAGS}}
6298   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6299   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6300 fi
6301
6302 # On Canadian crosses, we'll be searching the right directories for
6303 # the previously-installed cross compiler, so don't bother to add
6304 # flags for directories within the install tree of the compiler
6305 # being built; programs in there won't even run.
6306 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6307   # Search for pre-installed headers if nothing else fits.
6308   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6309 fi
6310
6311 if test "x${use_gnu_ld}" = x &&
6312    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6313   # Arrange for us to find uninstalled linker scripts.
6314   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6315 fi
6316
6317 # Search for other target-specific linker scripts and such.
6318 case "${target}" in
6319   mep*)
6320     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6321     ;;
6322 esac
6323
6324 # Makefile fragments.
6325 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6326 do
6327   eval fragval=\$$frag
6328   if test $fragval != /dev/null; then
6329     eval $frag=${srcdir}/$fragval
6330   fi
6331 done
6332
6333
6334
6335
6336
6337 # Miscellanea: directories, flags, etc.
6338
6339
6340
6341
6342
6343
6344
6345
6346 # Build module lists & subconfigure args.
6347
6348
6349
6350 # Host module lists & subconfigure args.
6351
6352
6353
6354 # Target module lists & subconfigure args.
6355
6356
6357
6358 # Build tools.
6359
6360
6361
6362
6363
6364
6365
6366
6367
6368
6369
6370
6371
6372
6373
6374
6375
6376
6377 # Generate default definitions for YACC, M4, LEX and other programs that run
6378 # on the build machine.  These are used if the Makefile can't locate these
6379 # programs in objdir.
6380 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6381
6382 for ac_prog in 'bison -y' byacc yacc
6383 do
6384   # Extract the first word of "$ac_prog", so it can be a program name with args.
6385 set dummy $ac_prog; ac_word=$2
6386 echo "$as_me:$LINENO: checking for $ac_word" >&5
6387 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6388 if test "${ac_cv_prog_YACC+set}" = set; then
6389   echo $ECHO_N "(cached) $ECHO_C" >&6
6390 else
6391   if test -n "$YACC"; then
6392   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6393 else
6394 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6395 for as_dir in $PATH
6396 do
6397   IFS=$as_save_IFS
6398   test -z "$as_dir" && as_dir=.
6399   for ac_exec_ext in '' $ac_executable_extensions; do
6400   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6401     ac_cv_prog_YACC="$ac_prog"
6402     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6403     break 2
6404   fi
6405 done
6406 done
6407
6408 fi
6409 fi
6410 YACC=$ac_cv_prog_YACC
6411 if test -n "$YACC"; then
6412   echo "$as_me:$LINENO: result: $YACC" >&5
6413 echo "${ECHO_T}$YACC" >&6
6414 else
6415   echo "$as_me:$LINENO: result: no" >&5
6416 echo "${ECHO_T}no" >&6
6417 fi
6418
6419   test -n "$YACC" && break
6420 done
6421 test -n "$YACC" || YACC="$MISSING bison -y"
6422
6423 case " $build_configdirs " in
6424   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6425   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6426 esac
6427
6428 for ac_prog in bison
6429 do
6430   # Extract the first word of "$ac_prog", so it can be a program name with args.
6431 set dummy $ac_prog; ac_word=$2
6432 echo "$as_me:$LINENO: checking for $ac_word" >&5
6433 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6434 if test "${ac_cv_prog_BISON+set}" = set; then
6435   echo $ECHO_N "(cached) $ECHO_C" >&6
6436 else
6437   if test -n "$BISON"; then
6438   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6439 else
6440 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6441 for as_dir in $PATH
6442 do
6443   IFS=$as_save_IFS
6444   test -z "$as_dir" && as_dir=.
6445   for ac_exec_ext in '' $ac_executable_extensions; do
6446   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6447     ac_cv_prog_BISON="$ac_prog"
6448     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6449     break 2
6450   fi
6451 done
6452 done
6453
6454 fi
6455 fi
6456 BISON=$ac_cv_prog_BISON
6457 if test -n "$BISON"; then
6458   echo "$as_me:$LINENO: result: $BISON" >&5
6459 echo "${ECHO_T}$BISON" >&6
6460 else
6461   echo "$as_me:$LINENO: result: no" >&5
6462 echo "${ECHO_T}no" >&6
6463 fi
6464
6465   test -n "$BISON" && break
6466 done
6467 test -n "$BISON" || BISON="$MISSING bison"
6468
6469 case " $build_configdirs " in
6470   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6471 esac
6472
6473 for ac_prog in gm4 gnum4 m4
6474 do
6475   # Extract the first word of "$ac_prog", so it can be a program name with args.
6476 set dummy $ac_prog; ac_word=$2
6477 echo "$as_me:$LINENO: checking for $ac_word" >&5
6478 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6479 if test "${ac_cv_prog_M4+set}" = set; then
6480   echo $ECHO_N "(cached) $ECHO_C" >&6
6481 else
6482   if test -n "$M4"; then
6483   ac_cv_prog_M4="$M4" # Let the user override the test.
6484 else
6485 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6486 for as_dir in $PATH
6487 do
6488   IFS=$as_save_IFS
6489   test -z "$as_dir" && as_dir=.
6490   for ac_exec_ext in '' $ac_executable_extensions; do
6491   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6492     ac_cv_prog_M4="$ac_prog"
6493     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6494     break 2
6495   fi
6496 done
6497 done
6498
6499 fi
6500 fi
6501 M4=$ac_cv_prog_M4
6502 if test -n "$M4"; then
6503   echo "$as_me:$LINENO: result: $M4" >&5
6504 echo "${ECHO_T}$M4" >&6
6505 else
6506   echo "$as_me:$LINENO: result: no" >&5
6507 echo "${ECHO_T}no" >&6
6508 fi
6509
6510   test -n "$M4" && break
6511 done
6512 test -n "$M4" || M4="$MISSING m4"
6513
6514 case " $build_configdirs " in
6515   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6516 esac
6517
6518 for ac_prog in flex lex
6519 do
6520   # Extract the first word of "$ac_prog", so it can be a program name with args.
6521 set dummy $ac_prog; ac_word=$2
6522 echo "$as_me:$LINENO: checking for $ac_word" >&5
6523 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6524 if test "${ac_cv_prog_LEX+set}" = set; then
6525   echo $ECHO_N "(cached) $ECHO_C" >&6
6526 else
6527   if test -n "$LEX"; then
6528   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6529 else
6530 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6531 for as_dir in $PATH
6532 do
6533   IFS=$as_save_IFS
6534   test -z "$as_dir" && as_dir=.
6535   for ac_exec_ext in '' $ac_executable_extensions; do
6536   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6537     ac_cv_prog_LEX="$ac_prog"
6538     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6539     break 2
6540   fi
6541 done
6542 done
6543
6544 fi
6545 fi
6546 LEX=$ac_cv_prog_LEX
6547 if test -n "$LEX"; then
6548   echo "$as_me:$LINENO: result: $LEX" >&5
6549 echo "${ECHO_T}$LEX" >&6
6550 else
6551   echo "$as_me:$LINENO: result: no" >&5
6552 echo "${ECHO_T}no" >&6
6553 fi
6554
6555   test -n "$LEX" && break
6556 done
6557 test -n "$LEX" || LEX="$MISSING flex"
6558
6559 case " $build_configdirs " in
6560   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6561   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6562 esac
6563
6564 for ac_prog in flex
6565 do
6566   # Extract the first word of "$ac_prog", so it can be a program name with args.
6567 set dummy $ac_prog; ac_word=$2
6568 echo "$as_me:$LINENO: checking for $ac_word" >&5
6569 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6570 if test "${ac_cv_prog_FLEX+set}" = set; then
6571   echo $ECHO_N "(cached) $ECHO_C" >&6
6572 else
6573   if test -n "$FLEX"; then
6574   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6575 else
6576 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6577 for as_dir in $PATH
6578 do
6579   IFS=$as_save_IFS
6580   test -z "$as_dir" && as_dir=.
6581   for ac_exec_ext in '' $ac_executable_extensions; do
6582   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6583     ac_cv_prog_FLEX="$ac_prog"
6584     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6585     break 2
6586   fi
6587 done
6588 done
6589
6590 fi
6591 fi
6592 FLEX=$ac_cv_prog_FLEX
6593 if test -n "$FLEX"; then
6594   echo "$as_me:$LINENO: result: $FLEX" >&5
6595 echo "${ECHO_T}$FLEX" >&6
6596 else
6597   echo "$as_me:$LINENO: result: no" >&5
6598 echo "${ECHO_T}no" >&6
6599 fi
6600
6601   test -n "$FLEX" && break
6602 done
6603 test -n "$FLEX" || FLEX="$MISSING flex"
6604
6605 case " $build_configdirs " in
6606   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6607 esac
6608
6609 for ac_prog in makeinfo
6610 do
6611   # Extract the first word of "$ac_prog", so it can be a program name with args.
6612 set dummy $ac_prog; ac_word=$2
6613 echo "$as_me:$LINENO: checking for $ac_word" >&5
6614 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6615 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6616   echo $ECHO_N "(cached) $ECHO_C" >&6
6617 else
6618   if test -n "$MAKEINFO"; then
6619   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6620 else
6621 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6622 for as_dir in $PATH
6623 do
6624   IFS=$as_save_IFS
6625   test -z "$as_dir" && as_dir=.
6626   for ac_exec_ext in '' $ac_executable_extensions; do
6627   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6628     ac_cv_prog_MAKEINFO="$ac_prog"
6629     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6630     break 2
6631   fi
6632 done
6633 done
6634
6635 fi
6636 fi
6637 MAKEINFO=$ac_cv_prog_MAKEINFO
6638 if test -n "$MAKEINFO"; then
6639   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6640 echo "${ECHO_T}$MAKEINFO" >&6
6641 else
6642   echo "$as_me:$LINENO: result: no" >&5
6643 echo "${ECHO_T}no" >&6
6644 fi
6645
6646   test -n "$MAKEINFO" && break
6647 done
6648 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6649
6650 case " $build_configdirs " in
6651   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6652   *)
6653
6654     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6655     # higher, else we use the "missing" dummy.
6656     if ${MAKEINFO} --version \
6657        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6658       :
6659     else
6660       MAKEINFO="$MISSING makeinfo"
6661     fi
6662     ;;
6663
6664 esac
6665
6666 # FIXME: expect and dejagnu may become build tools?
6667
6668 for ac_prog in expect
6669 do
6670   # Extract the first word of "$ac_prog", so it can be a program name with args.
6671 set dummy $ac_prog; ac_word=$2
6672 echo "$as_me:$LINENO: checking for $ac_word" >&5
6673 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6674 if test "${ac_cv_prog_EXPECT+set}" = set; then
6675   echo $ECHO_N "(cached) $ECHO_C" >&6
6676 else
6677   if test -n "$EXPECT"; then
6678   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6679 else
6680 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6681 for as_dir in $PATH
6682 do
6683   IFS=$as_save_IFS
6684   test -z "$as_dir" && as_dir=.
6685   for ac_exec_ext in '' $ac_executable_extensions; do
6686   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6687     ac_cv_prog_EXPECT="$ac_prog"
6688     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6689     break 2
6690   fi
6691 done
6692 done
6693
6694 fi
6695 fi
6696 EXPECT=$ac_cv_prog_EXPECT
6697 if test -n "$EXPECT"; then
6698   echo "$as_me:$LINENO: result: $EXPECT" >&5
6699 echo "${ECHO_T}$EXPECT" >&6
6700 else
6701   echo "$as_me:$LINENO: result: no" >&5
6702 echo "${ECHO_T}no" >&6
6703 fi
6704
6705   test -n "$EXPECT" && break
6706 done
6707 test -n "$EXPECT" || EXPECT="expect"
6708
6709 case " $configdirs " in
6710   *" expect "*)
6711     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6712     ;;
6713 esac
6714
6715 for ac_prog in runtest
6716 do
6717   # Extract the first word of "$ac_prog", so it can be a program name with args.
6718 set dummy $ac_prog; ac_word=$2
6719 echo "$as_me:$LINENO: checking for $ac_word" >&5
6720 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6721 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6722   echo $ECHO_N "(cached) $ECHO_C" >&6
6723 else
6724   if test -n "$RUNTEST"; then
6725   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6726 else
6727 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6728 for as_dir in $PATH
6729 do
6730   IFS=$as_save_IFS
6731   test -z "$as_dir" && as_dir=.
6732   for ac_exec_ext in '' $ac_executable_extensions; do
6733   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6734     ac_cv_prog_RUNTEST="$ac_prog"
6735     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6736     break 2
6737   fi
6738 done
6739 done
6740
6741 fi
6742 fi
6743 RUNTEST=$ac_cv_prog_RUNTEST
6744 if test -n "$RUNTEST"; then
6745   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6746 echo "${ECHO_T}$RUNTEST" >&6
6747 else
6748   echo "$as_me:$LINENO: result: no" >&5
6749 echo "${ECHO_T}no" >&6
6750 fi
6751
6752   test -n "$RUNTEST" && break
6753 done
6754 test -n "$RUNTEST" || RUNTEST="runtest"
6755
6756 case " $configdirs " in
6757   *" dejagnu "*)
6758     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6759     ;;
6760 esac
6761
6762
6763 # Host tools.
6764 ncn_tool_prefix=
6765 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6766 ncn_target_tool_prefix=
6767 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6768
6769
6770
6771 if test -n "$AR"; then
6772   ac_cv_prog_AR=$AR
6773 elif test -n "$ac_cv_prog_AR"; then
6774   AR=$ac_cv_prog_AR
6775 fi
6776
6777 if test -n "$ac_cv_prog_AR"; then
6778   for ncn_progname in ar; do
6779     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6780 set dummy ${ncn_progname}; ac_word=$2
6781 echo "$as_me:$LINENO: checking for $ac_word" >&5
6782 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6783 if test "${ac_cv_prog_AR+set}" = set; then
6784   echo $ECHO_N "(cached) $ECHO_C" >&6
6785 else
6786   if test -n "$AR"; then
6787   ac_cv_prog_AR="$AR" # Let the user override the test.
6788 else
6789 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6790 for as_dir in $PATH
6791 do
6792   IFS=$as_save_IFS
6793   test -z "$as_dir" && as_dir=.
6794   for ac_exec_ext in '' $ac_executable_extensions; do
6795   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6796     ac_cv_prog_AR="${ncn_progname}"
6797     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6798     break 2
6799   fi
6800 done
6801 done
6802
6803 fi
6804 fi
6805 AR=$ac_cv_prog_AR
6806 if test -n "$AR"; then
6807   echo "$as_me:$LINENO: result: $AR" >&5
6808 echo "${ECHO_T}$AR" >&6
6809 else
6810   echo "$as_me:$LINENO: result: no" >&5
6811 echo "${ECHO_T}no" >&6
6812 fi
6813
6814   done
6815 fi
6816
6817 for ncn_progname in ar; do
6818   if test -n "$ncn_tool_prefix"; then
6819     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6820 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6821 echo "$as_me:$LINENO: checking for $ac_word" >&5
6822 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6823 if test "${ac_cv_prog_AR+set}" = set; then
6824   echo $ECHO_N "(cached) $ECHO_C" >&6
6825 else
6826   if test -n "$AR"; then
6827   ac_cv_prog_AR="$AR" # Let the user override the test.
6828 else
6829 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6830 for as_dir in $PATH
6831 do
6832   IFS=$as_save_IFS
6833   test -z "$as_dir" && as_dir=.
6834   for ac_exec_ext in '' $ac_executable_extensions; do
6835   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6836     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6837     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6838     break 2
6839   fi
6840 done
6841 done
6842
6843 fi
6844 fi
6845 AR=$ac_cv_prog_AR
6846 if test -n "$AR"; then
6847   echo "$as_me:$LINENO: result: $AR" >&5
6848 echo "${ECHO_T}$AR" >&6
6849 else
6850   echo "$as_me:$LINENO: result: no" >&5
6851 echo "${ECHO_T}no" >&6
6852 fi
6853
6854   fi
6855   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6856     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6857 set dummy ${ncn_progname}; ac_word=$2
6858 echo "$as_me:$LINENO: checking for $ac_word" >&5
6859 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6860 if test "${ac_cv_prog_AR+set}" = set; then
6861   echo $ECHO_N "(cached) $ECHO_C" >&6
6862 else
6863   if test -n "$AR"; then
6864   ac_cv_prog_AR="$AR" # Let the user override the test.
6865 else
6866 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6867 for as_dir in $PATH
6868 do
6869   IFS=$as_save_IFS
6870   test -z "$as_dir" && as_dir=.
6871   for ac_exec_ext in '' $ac_executable_extensions; do
6872   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6873     ac_cv_prog_AR="${ncn_progname}"
6874     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6875     break 2
6876   fi
6877 done
6878 done
6879
6880 fi
6881 fi
6882 AR=$ac_cv_prog_AR
6883 if test -n "$AR"; then
6884   echo "$as_me:$LINENO: result: $AR" >&5
6885 echo "${ECHO_T}$AR" >&6
6886 else
6887   echo "$as_me:$LINENO: result: no" >&5
6888 echo "${ECHO_T}no" >&6
6889 fi
6890
6891   fi
6892   test -n "$ac_cv_prog_AR" && break
6893 done
6894
6895 if test -z "$ac_cv_prog_AR" ; then
6896   set dummy ar
6897   if test $build = $host ; then
6898     AR="$2"
6899   else
6900     AR="${ncn_tool_prefix}$2"
6901   fi
6902 fi
6903
6904
6905
6906 if test -n "$AS"; then
6907   ac_cv_prog_AS=$AS
6908 elif test -n "$ac_cv_prog_AS"; then
6909   AS=$ac_cv_prog_AS
6910 fi
6911
6912 if test -n "$ac_cv_prog_AS"; then
6913   for ncn_progname in as; do
6914     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6915 set dummy ${ncn_progname}; ac_word=$2
6916 echo "$as_me:$LINENO: checking for $ac_word" >&5
6917 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6918 if test "${ac_cv_prog_AS+set}" = set; then
6919   echo $ECHO_N "(cached) $ECHO_C" >&6
6920 else
6921   if test -n "$AS"; then
6922   ac_cv_prog_AS="$AS" # Let the user override the test.
6923 else
6924 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6925 for as_dir in $PATH
6926 do
6927   IFS=$as_save_IFS
6928   test -z "$as_dir" && as_dir=.
6929   for ac_exec_ext in '' $ac_executable_extensions; do
6930   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6931     ac_cv_prog_AS="${ncn_progname}"
6932     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6933     break 2
6934   fi
6935 done
6936 done
6937
6938 fi
6939 fi
6940 AS=$ac_cv_prog_AS
6941 if test -n "$AS"; then
6942   echo "$as_me:$LINENO: result: $AS" >&5
6943 echo "${ECHO_T}$AS" >&6
6944 else
6945   echo "$as_me:$LINENO: result: no" >&5
6946 echo "${ECHO_T}no" >&6
6947 fi
6948
6949   done
6950 fi
6951
6952 for ncn_progname in as; do
6953   if test -n "$ncn_tool_prefix"; then
6954     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6955 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6956 echo "$as_me:$LINENO: checking for $ac_word" >&5
6957 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6958 if test "${ac_cv_prog_AS+set}" = set; then
6959   echo $ECHO_N "(cached) $ECHO_C" >&6
6960 else
6961   if test -n "$AS"; then
6962   ac_cv_prog_AS="$AS" # Let the user override the test.
6963 else
6964 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6965 for as_dir in $PATH
6966 do
6967   IFS=$as_save_IFS
6968   test -z "$as_dir" && as_dir=.
6969   for ac_exec_ext in '' $ac_executable_extensions; do
6970   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6971     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6972     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6973     break 2
6974   fi
6975 done
6976 done
6977
6978 fi
6979 fi
6980 AS=$ac_cv_prog_AS
6981 if test -n "$AS"; then
6982   echo "$as_me:$LINENO: result: $AS" >&5
6983 echo "${ECHO_T}$AS" >&6
6984 else
6985   echo "$as_me:$LINENO: result: no" >&5
6986 echo "${ECHO_T}no" >&6
6987 fi
6988
6989   fi
6990   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6991     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6992 set dummy ${ncn_progname}; ac_word=$2
6993 echo "$as_me:$LINENO: checking for $ac_word" >&5
6994 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6995 if test "${ac_cv_prog_AS+set}" = set; then
6996   echo $ECHO_N "(cached) $ECHO_C" >&6
6997 else
6998   if test -n "$AS"; then
6999   ac_cv_prog_AS="$AS" # Let the user override the test.
7000 else
7001 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7002 for as_dir in $PATH
7003 do
7004   IFS=$as_save_IFS
7005   test -z "$as_dir" && as_dir=.
7006   for ac_exec_ext in '' $ac_executable_extensions; do
7007   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7008     ac_cv_prog_AS="${ncn_progname}"
7009     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7010     break 2
7011   fi
7012 done
7013 done
7014
7015 fi
7016 fi
7017 AS=$ac_cv_prog_AS
7018 if test -n "$AS"; then
7019   echo "$as_me:$LINENO: result: $AS" >&5
7020 echo "${ECHO_T}$AS" >&6
7021 else
7022   echo "$as_me:$LINENO: result: no" >&5
7023 echo "${ECHO_T}no" >&6
7024 fi
7025
7026   fi
7027   test -n "$ac_cv_prog_AS" && break
7028 done
7029
7030 if test -z "$ac_cv_prog_AS" ; then
7031   set dummy as
7032   if test $build = $host ; then
7033     AS="$2"
7034   else
7035     AS="${ncn_tool_prefix}$2"
7036   fi
7037 fi
7038
7039
7040
7041 if test -n "$DLLTOOL"; then
7042   ac_cv_prog_DLLTOOL=$DLLTOOL
7043 elif test -n "$ac_cv_prog_DLLTOOL"; then
7044   DLLTOOL=$ac_cv_prog_DLLTOOL
7045 fi
7046
7047 if test -n "$ac_cv_prog_DLLTOOL"; then
7048   for ncn_progname in dlltool; do
7049     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7050 set dummy ${ncn_progname}; ac_word=$2
7051 echo "$as_me:$LINENO: checking for $ac_word" >&5
7052 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7053 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7054   echo $ECHO_N "(cached) $ECHO_C" >&6
7055 else
7056   if test -n "$DLLTOOL"; then
7057   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7058 else
7059 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7060 for as_dir in $PATH
7061 do
7062   IFS=$as_save_IFS
7063   test -z "$as_dir" && as_dir=.
7064   for ac_exec_ext in '' $ac_executable_extensions; do
7065   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7066     ac_cv_prog_DLLTOOL="${ncn_progname}"
7067     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7068     break 2
7069   fi
7070 done
7071 done
7072
7073 fi
7074 fi
7075 DLLTOOL=$ac_cv_prog_DLLTOOL
7076 if test -n "$DLLTOOL"; then
7077   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7078 echo "${ECHO_T}$DLLTOOL" >&6
7079 else
7080   echo "$as_me:$LINENO: result: no" >&5
7081 echo "${ECHO_T}no" >&6
7082 fi
7083
7084   done
7085 fi
7086
7087 for ncn_progname in dlltool; do
7088   if test -n "$ncn_tool_prefix"; then
7089     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7090 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7091 echo "$as_me:$LINENO: checking for $ac_word" >&5
7092 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7093 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7094   echo $ECHO_N "(cached) $ECHO_C" >&6
7095 else
7096   if test -n "$DLLTOOL"; then
7097   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7098 else
7099 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7100 for as_dir in $PATH
7101 do
7102   IFS=$as_save_IFS
7103   test -z "$as_dir" && as_dir=.
7104   for ac_exec_ext in '' $ac_executable_extensions; do
7105   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7106     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7107     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7108     break 2
7109   fi
7110 done
7111 done
7112
7113 fi
7114 fi
7115 DLLTOOL=$ac_cv_prog_DLLTOOL
7116 if test -n "$DLLTOOL"; then
7117   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7118 echo "${ECHO_T}$DLLTOOL" >&6
7119 else
7120   echo "$as_me:$LINENO: result: no" >&5
7121 echo "${ECHO_T}no" >&6
7122 fi
7123
7124   fi
7125   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7126     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7127 set dummy ${ncn_progname}; ac_word=$2
7128 echo "$as_me:$LINENO: checking for $ac_word" >&5
7129 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7130 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7131   echo $ECHO_N "(cached) $ECHO_C" >&6
7132 else
7133   if test -n "$DLLTOOL"; then
7134   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7135 else
7136 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7137 for as_dir in $PATH
7138 do
7139   IFS=$as_save_IFS
7140   test -z "$as_dir" && as_dir=.
7141   for ac_exec_ext in '' $ac_executable_extensions; do
7142   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7143     ac_cv_prog_DLLTOOL="${ncn_progname}"
7144     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7145     break 2
7146   fi
7147 done
7148 done
7149
7150 fi
7151 fi
7152 DLLTOOL=$ac_cv_prog_DLLTOOL
7153 if test -n "$DLLTOOL"; then
7154   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7155 echo "${ECHO_T}$DLLTOOL" >&6
7156 else
7157   echo "$as_me:$LINENO: result: no" >&5
7158 echo "${ECHO_T}no" >&6
7159 fi
7160
7161   fi
7162   test -n "$ac_cv_prog_DLLTOOL" && break
7163 done
7164
7165 if test -z "$ac_cv_prog_DLLTOOL" ; then
7166   set dummy dlltool
7167   if test $build = $host ; then
7168     DLLTOOL="$2"
7169   else
7170     DLLTOOL="${ncn_tool_prefix}$2"
7171   fi
7172 fi
7173
7174
7175
7176 if test -n "$LD"; then
7177   ac_cv_prog_LD=$LD
7178 elif test -n "$ac_cv_prog_LD"; then
7179   LD=$ac_cv_prog_LD
7180 fi
7181
7182 if test -n "$ac_cv_prog_LD"; then
7183   for ncn_progname in ld; do
7184     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7185 set dummy ${ncn_progname}; ac_word=$2
7186 echo "$as_me:$LINENO: checking for $ac_word" >&5
7187 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7188 if test "${ac_cv_prog_LD+set}" = set; then
7189   echo $ECHO_N "(cached) $ECHO_C" >&6
7190 else
7191   if test -n "$LD"; then
7192   ac_cv_prog_LD="$LD" # Let the user override the test.
7193 else
7194 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7195 for as_dir in $PATH
7196 do
7197   IFS=$as_save_IFS
7198   test -z "$as_dir" && as_dir=.
7199   for ac_exec_ext in '' $ac_executable_extensions; do
7200   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7201     ac_cv_prog_LD="${ncn_progname}"
7202     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7203     break 2
7204   fi
7205 done
7206 done
7207
7208 fi
7209 fi
7210 LD=$ac_cv_prog_LD
7211 if test -n "$LD"; then
7212   echo "$as_me:$LINENO: result: $LD" >&5
7213 echo "${ECHO_T}$LD" >&6
7214 else
7215   echo "$as_me:$LINENO: result: no" >&5
7216 echo "${ECHO_T}no" >&6
7217 fi
7218
7219   done
7220 fi
7221
7222 for ncn_progname in ld; do
7223   if test -n "$ncn_tool_prefix"; then
7224     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7225 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7226 echo "$as_me:$LINENO: checking for $ac_word" >&5
7227 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7228 if test "${ac_cv_prog_LD+set}" = set; then
7229   echo $ECHO_N "(cached) $ECHO_C" >&6
7230 else
7231   if test -n "$LD"; then
7232   ac_cv_prog_LD="$LD" # Let the user override the test.
7233 else
7234 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7235 for as_dir in $PATH
7236 do
7237   IFS=$as_save_IFS
7238   test -z "$as_dir" && as_dir=.
7239   for ac_exec_ext in '' $ac_executable_extensions; do
7240   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7241     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7242     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7243     break 2
7244   fi
7245 done
7246 done
7247
7248 fi
7249 fi
7250 LD=$ac_cv_prog_LD
7251 if test -n "$LD"; then
7252   echo "$as_me:$LINENO: result: $LD" >&5
7253 echo "${ECHO_T}$LD" >&6
7254 else
7255   echo "$as_me:$LINENO: result: no" >&5
7256 echo "${ECHO_T}no" >&6
7257 fi
7258
7259   fi
7260   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7261     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7262 set dummy ${ncn_progname}; ac_word=$2
7263 echo "$as_me:$LINENO: checking for $ac_word" >&5
7264 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7265 if test "${ac_cv_prog_LD+set}" = set; then
7266   echo $ECHO_N "(cached) $ECHO_C" >&6
7267 else
7268   if test -n "$LD"; then
7269   ac_cv_prog_LD="$LD" # Let the user override the test.
7270 else
7271 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7272 for as_dir in $PATH
7273 do
7274   IFS=$as_save_IFS
7275   test -z "$as_dir" && as_dir=.
7276   for ac_exec_ext in '' $ac_executable_extensions; do
7277   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7278     ac_cv_prog_LD="${ncn_progname}"
7279     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7280     break 2
7281   fi
7282 done
7283 done
7284
7285 fi
7286 fi
7287 LD=$ac_cv_prog_LD
7288 if test -n "$LD"; then
7289   echo "$as_me:$LINENO: result: $LD" >&5
7290 echo "${ECHO_T}$LD" >&6
7291 else
7292   echo "$as_me:$LINENO: result: no" >&5
7293 echo "${ECHO_T}no" >&6
7294 fi
7295
7296   fi
7297   test -n "$ac_cv_prog_LD" && break
7298 done
7299
7300 if test -z "$ac_cv_prog_LD" ; then
7301   set dummy ld
7302   if test $build = $host ; then
7303     LD="$2"
7304   else
7305     LD="${ncn_tool_prefix}$2"
7306   fi
7307 fi
7308
7309
7310
7311 if test -n "$LIPO"; then
7312   ac_cv_prog_LIPO=$LIPO
7313 elif test -n "$ac_cv_prog_LIPO"; then
7314   LIPO=$ac_cv_prog_LIPO
7315 fi
7316
7317 if test -n "$ac_cv_prog_LIPO"; then
7318   for ncn_progname in lipo; do
7319     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7320 set dummy ${ncn_progname}; ac_word=$2
7321 echo "$as_me:$LINENO: checking for $ac_word" >&5
7322 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7323 if test "${ac_cv_prog_LIPO+set}" = set; then
7324   echo $ECHO_N "(cached) $ECHO_C" >&6
7325 else
7326   if test -n "$LIPO"; then
7327   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7328 else
7329 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7330 for as_dir in $PATH
7331 do
7332   IFS=$as_save_IFS
7333   test -z "$as_dir" && as_dir=.
7334   for ac_exec_ext in '' $ac_executable_extensions; do
7335   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7336     ac_cv_prog_LIPO="${ncn_progname}"
7337     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7338     break 2
7339   fi
7340 done
7341 done
7342
7343 fi
7344 fi
7345 LIPO=$ac_cv_prog_LIPO
7346 if test -n "$LIPO"; then
7347   echo "$as_me:$LINENO: result: $LIPO" >&5
7348 echo "${ECHO_T}$LIPO" >&6
7349 else
7350   echo "$as_me:$LINENO: result: no" >&5
7351 echo "${ECHO_T}no" >&6
7352 fi
7353
7354   done
7355 fi
7356
7357 for ncn_progname in lipo; do
7358   if test -n "$ncn_tool_prefix"; then
7359     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7360 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7361 echo "$as_me:$LINENO: checking for $ac_word" >&5
7362 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7363 if test "${ac_cv_prog_LIPO+set}" = set; then
7364   echo $ECHO_N "(cached) $ECHO_C" >&6
7365 else
7366   if test -n "$LIPO"; then
7367   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7368 else
7369 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7370 for as_dir in $PATH
7371 do
7372   IFS=$as_save_IFS
7373   test -z "$as_dir" && as_dir=.
7374   for ac_exec_ext in '' $ac_executable_extensions; do
7375   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7376     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7377     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7378     break 2
7379   fi
7380 done
7381 done
7382
7383 fi
7384 fi
7385 LIPO=$ac_cv_prog_LIPO
7386 if test -n "$LIPO"; then
7387   echo "$as_me:$LINENO: result: $LIPO" >&5
7388 echo "${ECHO_T}$LIPO" >&6
7389 else
7390   echo "$as_me:$LINENO: result: no" >&5
7391 echo "${ECHO_T}no" >&6
7392 fi
7393
7394   fi
7395   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7396     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7397 set dummy ${ncn_progname}; ac_word=$2
7398 echo "$as_me:$LINENO: checking for $ac_word" >&5
7399 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7400 if test "${ac_cv_prog_LIPO+set}" = set; then
7401   echo $ECHO_N "(cached) $ECHO_C" >&6
7402 else
7403   if test -n "$LIPO"; then
7404   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7405 else
7406 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7407 for as_dir in $PATH
7408 do
7409   IFS=$as_save_IFS
7410   test -z "$as_dir" && as_dir=.
7411   for ac_exec_ext in '' $ac_executable_extensions; do
7412   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7413     ac_cv_prog_LIPO="${ncn_progname}"
7414     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7415     break 2
7416   fi
7417 done
7418 done
7419
7420 fi
7421 fi
7422 LIPO=$ac_cv_prog_LIPO
7423 if test -n "$LIPO"; then
7424   echo "$as_me:$LINENO: result: $LIPO" >&5
7425 echo "${ECHO_T}$LIPO" >&6
7426 else
7427   echo "$as_me:$LINENO: result: no" >&5
7428 echo "${ECHO_T}no" >&6
7429 fi
7430
7431   fi
7432   test -n "$ac_cv_prog_LIPO" && break
7433 done
7434
7435 if test -z "$ac_cv_prog_LIPO" ; then
7436   set dummy lipo
7437   if test $build = $host ; then
7438     LIPO="$2"
7439   else
7440     LIPO="${ncn_tool_prefix}$2"
7441   fi
7442 fi
7443
7444
7445
7446 if test -n "$NM"; then
7447   ac_cv_prog_NM=$NM
7448 elif test -n "$ac_cv_prog_NM"; then
7449   NM=$ac_cv_prog_NM
7450 fi
7451
7452 if test -n "$ac_cv_prog_NM"; then
7453   for ncn_progname in nm; do
7454     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7455 set dummy ${ncn_progname}; ac_word=$2
7456 echo "$as_me:$LINENO: checking for $ac_word" >&5
7457 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7458 if test "${ac_cv_prog_NM+set}" = set; then
7459   echo $ECHO_N "(cached) $ECHO_C" >&6
7460 else
7461   if test -n "$NM"; then
7462   ac_cv_prog_NM="$NM" # Let the user override the test.
7463 else
7464 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7465 for as_dir in $PATH
7466 do
7467   IFS=$as_save_IFS
7468   test -z "$as_dir" && as_dir=.
7469   for ac_exec_ext in '' $ac_executable_extensions; do
7470   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7471     ac_cv_prog_NM="${ncn_progname}"
7472     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7473     break 2
7474   fi
7475 done
7476 done
7477
7478 fi
7479 fi
7480 NM=$ac_cv_prog_NM
7481 if test -n "$NM"; then
7482   echo "$as_me:$LINENO: result: $NM" >&5
7483 echo "${ECHO_T}$NM" >&6
7484 else
7485   echo "$as_me:$LINENO: result: no" >&5
7486 echo "${ECHO_T}no" >&6
7487 fi
7488
7489   done
7490 fi
7491
7492 for ncn_progname in nm; do
7493   if test -n "$ncn_tool_prefix"; then
7494     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7495 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7496 echo "$as_me:$LINENO: checking for $ac_word" >&5
7497 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7498 if test "${ac_cv_prog_NM+set}" = set; then
7499   echo $ECHO_N "(cached) $ECHO_C" >&6
7500 else
7501   if test -n "$NM"; then
7502   ac_cv_prog_NM="$NM" # Let the user override the test.
7503 else
7504 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7505 for as_dir in $PATH
7506 do
7507   IFS=$as_save_IFS
7508   test -z "$as_dir" && as_dir=.
7509   for ac_exec_ext in '' $ac_executable_extensions; do
7510   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7511     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7512     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7513     break 2
7514   fi
7515 done
7516 done
7517
7518 fi
7519 fi
7520 NM=$ac_cv_prog_NM
7521 if test -n "$NM"; then
7522   echo "$as_me:$LINENO: result: $NM" >&5
7523 echo "${ECHO_T}$NM" >&6
7524 else
7525   echo "$as_me:$LINENO: result: no" >&5
7526 echo "${ECHO_T}no" >&6
7527 fi
7528
7529   fi
7530   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7531     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7532 set dummy ${ncn_progname}; ac_word=$2
7533 echo "$as_me:$LINENO: checking for $ac_word" >&5
7534 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7535 if test "${ac_cv_prog_NM+set}" = set; then
7536   echo $ECHO_N "(cached) $ECHO_C" >&6
7537 else
7538   if test -n "$NM"; then
7539   ac_cv_prog_NM="$NM" # Let the user override the test.
7540 else
7541 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7542 for as_dir in $PATH
7543 do
7544   IFS=$as_save_IFS
7545   test -z "$as_dir" && as_dir=.
7546   for ac_exec_ext in '' $ac_executable_extensions; do
7547   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7548     ac_cv_prog_NM="${ncn_progname}"
7549     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7550     break 2
7551   fi
7552 done
7553 done
7554
7555 fi
7556 fi
7557 NM=$ac_cv_prog_NM
7558 if test -n "$NM"; then
7559   echo "$as_me:$LINENO: result: $NM" >&5
7560 echo "${ECHO_T}$NM" >&6
7561 else
7562   echo "$as_me:$LINENO: result: no" >&5
7563 echo "${ECHO_T}no" >&6
7564 fi
7565
7566   fi
7567   test -n "$ac_cv_prog_NM" && break
7568 done
7569
7570 if test -z "$ac_cv_prog_NM" ; then
7571   set dummy nm
7572   if test $build = $host ; then
7573     NM="$2"
7574   else
7575     NM="${ncn_tool_prefix}$2"
7576   fi
7577 fi
7578
7579
7580
7581 if test -n "$RANLIB"; then
7582   ac_cv_prog_RANLIB=$RANLIB
7583 elif test -n "$ac_cv_prog_RANLIB"; then
7584   RANLIB=$ac_cv_prog_RANLIB
7585 fi
7586
7587 if test -n "$ac_cv_prog_RANLIB"; then
7588   for ncn_progname in ranlib; do
7589     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7590 set dummy ${ncn_progname}; ac_word=$2
7591 echo "$as_me:$LINENO: checking for $ac_word" >&5
7592 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7593 if test "${ac_cv_prog_RANLIB+set}" = set; then
7594   echo $ECHO_N "(cached) $ECHO_C" >&6
7595 else
7596   if test -n "$RANLIB"; then
7597   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7598 else
7599 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7600 for as_dir in $PATH
7601 do
7602   IFS=$as_save_IFS
7603   test -z "$as_dir" && as_dir=.
7604   for ac_exec_ext in '' $ac_executable_extensions; do
7605   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7606     ac_cv_prog_RANLIB="${ncn_progname}"
7607     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7608     break 2
7609   fi
7610 done
7611 done
7612
7613 fi
7614 fi
7615 RANLIB=$ac_cv_prog_RANLIB
7616 if test -n "$RANLIB"; then
7617   echo "$as_me:$LINENO: result: $RANLIB" >&5
7618 echo "${ECHO_T}$RANLIB" >&6
7619 else
7620   echo "$as_me:$LINENO: result: no" >&5
7621 echo "${ECHO_T}no" >&6
7622 fi
7623
7624   done
7625 fi
7626
7627 for ncn_progname in ranlib; do
7628   if test -n "$ncn_tool_prefix"; then
7629     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7630 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7631 echo "$as_me:$LINENO: checking for $ac_word" >&5
7632 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7633 if test "${ac_cv_prog_RANLIB+set}" = set; then
7634   echo $ECHO_N "(cached) $ECHO_C" >&6
7635 else
7636   if test -n "$RANLIB"; then
7637   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7638 else
7639 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7640 for as_dir in $PATH
7641 do
7642   IFS=$as_save_IFS
7643   test -z "$as_dir" && as_dir=.
7644   for ac_exec_ext in '' $ac_executable_extensions; do
7645   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7646     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7647     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7648     break 2
7649   fi
7650 done
7651 done
7652
7653 fi
7654 fi
7655 RANLIB=$ac_cv_prog_RANLIB
7656 if test -n "$RANLIB"; then
7657   echo "$as_me:$LINENO: result: $RANLIB" >&5
7658 echo "${ECHO_T}$RANLIB" >&6
7659 else
7660   echo "$as_me:$LINENO: result: no" >&5
7661 echo "${ECHO_T}no" >&6
7662 fi
7663
7664   fi
7665   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7666     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7667 set dummy ${ncn_progname}; ac_word=$2
7668 echo "$as_me:$LINENO: checking for $ac_word" >&5
7669 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7670 if test "${ac_cv_prog_RANLIB+set}" = set; then
7671   echo $ECHO_N "(cached) $ECHO_C" >&6
7672 else
7673   if test -n "$RANLIB"; then
7674   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7675 else
7676 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7677 for as_dir in $PATH
7678 do
7679   IFS=$as_save_IFS
7680   test -z "$as_dir" && as_dir=.
7681   for ac_exec_ext in '' $ac_executable_extensions; do
7682   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7683     ac_cv_prog_RANLIB="${ncn_progname}"
7684     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7685     break 2
7686   fi
7687 done
7688 done
7689
7690 fi
7691 fi
7692 RANLIB=$ac_cv_prog_RANLIB
7693 if test -n "$RANLIB"; then
7694   echo "$as_me:$LINENO: result: $RANLIB" >&5
7695 echo "${ECHO_T}$RANLIB" >&6
7696 else
7697   echo "$as_me:$LINENO: result: no" >&5
7698 echo "${ECHO_T}no" >&6
7699 fi
7700
7701   fi
7702   test -n "$ac_cv_prog_RANLIB" && break
7703 done
7704
7705 if test -z "$ac_cv_prog_RANLIB" ; then
7706   RANLIB=":"
7707 fi
7708
7709
7710
7711 if test -n "$STRIP"; then
7712   ac_cv_prog_STRIP=$STRIP
7713 elif test -n "$ac_cv_prog_STRIP"; then
7714   STRIP=$ac_cv_prog_STRIP
7715 fi
7716
7717 if test -n "$ac_cv_prog_STRIP"; then
7718   for ncn_progname in strip; do
7719     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7720 set dummy ${ncn_progname}; ac_word=$2
7721 echo "$as_me:$LINENO: checking for $ac_word" >&5
7722 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7723 if test "${ac_cv_prog_STRIP+set}" = set; then
7724   echo $ECHO_N "(cached) $ECHO_C" >&6
7725 else
7726   if test -n "$STRIP"; then
7727   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7728 else
7729 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7730 for as_dir in $PATH
7731 do
7732   IFS=$as_save_IFS
7733   test -z "$as_dir" && as_dir=.
7734   for ac_exec_ext in '' $ac_executable_extensions; do
7735   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7736     ac_cv_prog_STRIP="${ncn_progname}"
7737     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7738     break 2
7739   fi
7740 done
7741 done
7742
7743 fi
7744 fi
7745 STRIP=$ac_cv_prog_STRIP
7746 if test -n "$STRIP"; then
7747   echo "$as_me:$LINENO: result: $STRIP" >&5
7748 echo "${ECHO_T}$STRIP" >&6
7749 else
7750   echo "$as_me:$LINENO: result: no" >&5
7751 echo "${ECHO_T}no" >&6
7752 fi
7753
7754   done
7755 fi
7756
7757 for ncn_progname in strip; do
7758   if test -n "$ncn_tool_prefix"; then
7759     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7760 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7761 echo "$as_me:$LINENO: checking for $ac_word" >&5
7762 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7763 if test "${ac_cv_prog_STRIP+set}" = set; then
7764   echo $ECHO_N "(cached) $ECHO_C" >&6
7765 else
7766   if test -n "$STRIP"; then
7767   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7768 else
7769 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7770 for as_dir in $PATH
7771 do
7772   IFS=$as_save_IFS
7773   test -z "$as_dir" && as_dir=.
7774   for ac_exec_ext in '' $ac_executable_extensions; do
7775   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7776     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7777     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7778     break 2
7779   fi
7780 done
7781 done
7782
7783 fi
7784 fi
7785 STRIP=$ac_cv_prog_STRIP
7786 if test -n "$STRIP"; then
7787   echo "$as_me:$LINENO: result: $STRIP" >&5
7788 echo "${ECHO_T}$STRIP" >&6
7789 else
7790   echo "$as_me:$LINENO: result: no" >&5
7791 echo "${ECHO_T}no" >&6
7792 fi
7793
7794   fi
7795   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7796     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7797 set dummy ${ncn_progname}; ac_word=$2
7798 echo "$as_me:$LINENO: checking for $ac_word" >&5
7799 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7800 if test "${ac_cv_prog_STRIP+set}" = set; then
7801   echo $ECHO_N "(cached) $ECHO_C" >&6
7802 else
7803   if test -n "$STRIP"; then
7804   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7805 else
7806 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7807 for as_dir in $PATH
7808 do
7809   IFS=$as_save_IFS
7810   test -z "$as_dir" && as_dir=.
7811   for ac_exec_ext in '' $ac_executable_extensions; do
7812   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7813     ac_cv_prog_STRIP="${ncn_progname}"
7814     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7815     break 2
7816   fi
7817 done
7818 done
7819
7820 fi
7821 fi
7822 STRIP=$ac_cv_prog_STRIP
7823 if test -n "$STRIP"; then
7824   echo "$as_me:$LINENO: result: $STRIP" >&5
7825 echo "${ECHO_T}$STRIP" >&6
7826 else
7827   echo "$as_me:$LINENO: result: no" >&5
7828 echo "${ECHO_T}no" >&6
7829 fi
7830
7831   fi
7832   test -n "$ac_cv_prog_STRIP" && break
7833 done
7834
7835 if test -z "$ac_cv_prog_STRIP" ; then
7836   STRIP=":"
7837 fi
7838
7839
7840
7841 if test -n "$WINDRES"; then
7842   ac_cv_prog_WINDRES=$WINDRES
7843 elif test -n "$ac_cv_prog_WINDRES"; then
7844   WINDRES=$ac_cv_prog_WINDRES
7845 fi
7846
7847 if test -n "$ac_cv_prog_WINDRES"; then
7848   for ncn_progname in windres; do
7849     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7850 set dummy ${ncn_progname}; ac_word=$2
7851 echo "$as_me:$LINENO: checking for $ac_word" >&5
7852 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7853 if test "${ac_cv_prog_WINDRES+set}" = set; then
7854   echo $ECHO_N "(cached) $ECHO_C" >&6
7855 else
7856   if test -n "$WINDRES"; then
7857   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7858 else
7859 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7860 for as_dir in $PATH
7861 do
7862   IFS=$as_save_IFS
7863   test -z "$as_dir" && as_dir=.
7864   for ac_exec_ext in '' $ac_executable_extensions; do
7865   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7866     ac_cv_prog_WINDRES="${ncn_progname}"
7867     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7868     break 2
7869   fi
7870 done
7871 done
7872
7873 fi
7874 fi
7875 WINDRES=$ac_cv_prog_WINDRES
7876 if test -n "$WINDRES"; then
7877   echo "$as_me:$LINENO: result: $WINDRES" >&5
7878 echo "${ECHO_T}$WINDRES" >&6
7879 else
7880   echo "$as_me:$LINENO: result: no" >&5
7881 echo "${ECHO_T}no" >&6
7882 fi
7883
7884   done
7885 fi
7886
7887 for ncn_progname in windres; do
7888   if test -n "$ncn_tool_prefix"; then
7889     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7890 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7891 echo "$as_me:$LINENO: checking for $ac_word" >&5
7892 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7893 if test "${ac_cv_prog_WINDRES+set}" = set; then
7894   echo $ECHO_N "(cached) $ECHO_C" >&6
7895 else
7896   if test -n "$WINDRES"; then
7897   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7898 else
7899 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7900 for as_dir in $PATH
7901 do
7902   IFS=$as_save_IFS
7903   test -z "$as_dir" && as_dir=.
7904   for ac_exec_ext in '' $ac_executable_extensions; do
7905   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7906     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7907     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7908     break 2
7909   fi
7910 done
7911 done
7912
7913 fi
7914 fi
7915 WINDRES=$ac_cv_prog_WINDRES
7916 if test -n "$WINDRES"; then
7917   echo "$as_me:$LINENO: result: $WINDRES" >&5
7918 echo "${ECHO_T}$WINDRES" >&6
7919 else
7920   echo "$as_me:$LINENO: result: no" >&5
7921 echo "${ECHO_T}no" >&6
7922 fi
7923
7924   fi
7925   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7926     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7927 set dummy ${ncn_progname}; ac_word=$2
7928 echo "$as_me:$LINENO: checking for $ac_word" >&5
7929 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7930 if test "${ac_cv_prog_WINDRES+set}" = set; then
7931   echo $ECHO_N "(cached) $ECHO_C" >&6
7932 else
7933   if test -n "$WINDRES"; then
7934   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7935 else
7936 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7937 for as_dir in $PATH
7938 do
7939   IFS=$as_save_IFS
7940   test -z "$as_dir" && as_dir=.
7941   for ac_exec_ext in '' $ac_executable_extensions; do
7942   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7943     ac_cv_prog_WINDRES="${ncn_progname}"
7944     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7945     break 2
7946   fi
7947 done
7948 done
7949
7950 fi
7951 fi
7952 WINDRES=$ac_cv_prog_WINDRES
7953 if test -n "$WINDRES"; then
7954   echo "$as_me:$LINENO: result: $WINDRES" >&5
7955 echo "${ECHO_T}$WINDRES" >&6
7956 else
7957   echo "$as_me:$LINENO: result: no" >&5
7958 echo "${ECHO_T}no" >&6
7959 fi
7960
7961   fi
7962   test -n "$ac_cv_prog_WINDRES" && break
7963 done
7964
7965 if test -z "$ac_cv_prog_WINDRES" ; then
7966   set dummy windres
7967   if test $build = $host ; then
7968     WINDRES="$2"
7969   else
7970     WINDRES="${ncn_tool_prefix}$2"
7971   fi
7972 fi
7973
7974
7975
7976 if test -n "$WINDMC"; then
7977   ac_cv_prog_WINDMC=$WINDMC
7978 elif test -n "$ac_cv_prog_WINDMC"; then
7979   WINDMC=$ac_cv_prog_WINDMC
7980 fi
7981
7982 if test -n "$ac_cv_prog_WINDMC"; then
7983   for ncn_progname in windmc; do
7984     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7985 set dummy ${ncn_progname}; ac_word=$2
7986 echo "$as_me:$LINENO: checking for $ac_word" >&5
7987 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7988 if test "${ac_cv_prog_WINDMC+set}" = set; then
7989   echo $ECHO_N "(cached) $ECHO_C" >&6
7990 else
7991   if test -n "$WINDMC"; then
7992   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7993 else
7994 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7995 for as_dir in $PATH
7996 do
7997   IFS=$as_save_IFS
7998   test -z "$as_dir" && as_dir=.
7999   for ac_exec_ext in '' $ac_executable_extensions; do
8000   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8001     ac_cv_prog_WINDMC="${ncn_progname}"
8002     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8003     break 2
8004   fi
8005 done
8006 done
8007
8008 fi
8009 fi
8010 WINDMC=$ac_cv_prog_WINDMC
8011 if test -n "$WINDMC"; then
8012   echo "$as_me:$LINENO: result: $WINDMC" >&5
8013 echo "${ECHO_T}$WINDMC" >&6
8014 else
8015   echo "$as_me:$LINENO: result: no" >&5
8016 echo "${ECHO_T}no" >&6
8017 fi
8018
8019   done
8020 fi
8021
8022 for ncn_progname in windmc; do
8023   if test -n "$ncn_tool_prefix"; then
8024     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8025 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8026 echo "$as_me:$LINENO: checking for $ac_word" >&5
8027 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8028 if test "${ac_cv_prog_WINDMC+set}" = set; then
8029   echo $ECHO_N "(cached) $ECHO_C" >&6
8030 else
8031   if test -n "$WINDMC"; then
8032   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8033 else
8034 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8035 for as_dir in $PATH
8036 do
8037   IFS=$as_save_IFS
8038   test -z "$as_dir" && as_dir=.
8039   for ac_exec_ext in '' $ac_executable_extensions; do
8040   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8041     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8042     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8043     break 2
8044   fi
8045 done
8046 done
8047
8048 fi
8049 fi
8050 WINDMC=$ac_cv_prog_WINDMC
8051 if test -n "$WINDMC"; then
8052   echo "$as_me:$LINENO: result: $WINDMC" >&5
8053 echo "${ECHO_T}$WINDMC" >&6
8054 else
8055   echo "$as_me:$LINENO: result: no" >&5
8056 echo "${ECHO_T}no" >&6
8057 fi
8058
8059   fi
8060   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8061     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8062 set dummy ${ncn_progname}; ac_word=$2
8063 echo "$as_me:$LINENO: checking for $ac_word" >&5
8064 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8065 if test "${ac_cv_prog_WINDMC+set}" = set; then
8066   echo $ECHO_N "(cached) $ECHO_C" >&6
8067 else
8068   if test -n "$WINDMC"; then
8069   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8070 else
8071 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8072 for as_dir in $PATH
8073 do
8074   IFS=$as_save_IFS
8075   test -z "$as_dir" && as_dir=.
8076   for ac_exec_ext in '' $ac_executable_extensions; do
8077   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8078     ac_cv_prog_WINDMC="${ncn_progname}"
8079     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8080     break 2
8081   fi
8082 done
8083 done
8084
8085 fi
8086 fi
8087 WINDMC=$ac_cv_prog_WINDMC
8088 if test -n "$WINDMC"; then
8089   echo "$as_me:$LINENO: result: $WINDMC" >&5
8090 echo "${ECHO_T}$WINDMC" >&6
8091 else
8092   echo "$as_me:$LINENO: result: no" >&5
8093 echo "${ECHO_T}no" >&6
8094 fi
8095
8096   fi
8097   test -n "$ac_cv_prog_WINDMC" && break
8098 done
8099
8100 if test -z "$ac_cv_prog_WINDMC" ; then
8101   set dummy windmc
8102   if test $build = $host ; then
8103     WINDMC="$2"
8104   else
8105     WINDMC="${ncn_tool_prefix}$2"
8106   fi
8107 fi
8108
8109
8110
8111 if test -n "$OBJCOPY"; then
8112   ac_cv_prog_OBJCOPY=$OBJCOPY
8113 elif test -n "$ac_cv_prog_OBJCOPY"; then
8114   OBJCOPY=$ac_cv_prog_OBJCOPY
8115 fi
8116
8117 if test -n "$ac_cv_prog_OBJCOPY"; then
8118   for ncn_progname in objcopy; do
8119     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8120 set dummy ${ncn_progname}; ac_word=$2
8121 echo "$as_me:$LINENO: checking for $ac_word" >&5
8122 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8123 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8124   echo $ECHO_N "(cached) $ECHO_C" >&6
8125 else
8126   if test -n "$OBJCOPY"; then
8127   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8128 else
8129 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8130 for as_dir in $PATH
8131 do
8132   IFS=$as_save_IFS
8133   test -z "$as_dir" && as_dir=.
8134   for ac_exec_ext in '' $ac_executable_extensions; do
8135   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8136     ac_cv_prog_OBJCOPY="${ncn_progname}"
8137     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8138     break 2
8139   fi
8140 done
8141 done
8142
8143 fi
8144 fi
8145 OBJCOPY=$ac_cv_prog_OBJCOPY
8146 if test -n "$OBJCOPY"; then
8147   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8148 echo "${ECHO_T}$OBJCOPY" >&6
8149 else
8150   echo "$as_me:$LINENO: result: no" >&5
8151 echo "${ECHO_T}no" >&6
8152 fi
8153
8154   done
8155 fi
8156
8157 for ncn_progname in objcopy; do
8158   if test -n "$ncn_tool_prefix"; then
8159     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8160 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8161 echo "$as_me:$LINENO: checking for $ac_word" >&5
8162 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8163 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8164   echo $ECHO_N "(cached) $ECHO_C" >&6
8165 else
8166   if test -n "$OBJCOPY"; then
8167   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8168 else
8169 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8170 for as_dir in $PATH
8171 do
8172   IFS=$as_save_IFS
8173   test -z "$as_dir" && as_dir=.
8174   for ac_exec_ext in '' $ac_executable_extensions; do
8175   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8176     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8177     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8178     break 2
8179   fi
8180 done
8181 done
8182
8183 fi
8184 fi
8185 OBJCOPY=$ac_cv_prog_OBJCOPY
8186 if test -n "$OBJCOPY"; then
8187   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8188 echo "${ECHO_T}$OBJCOPY" >&6
8189 else
8190   echo "$as_me:$LINENO: result: no" >&5
8191 echo "${ECHO_T}no" >&6
8192 fi
8193
8194   fi
8195   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8196     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8197 set dummy ${ncn_progname}; ac_word=$2
8198 echo "$as_me:$LINENO: checking for $ac_word" >&5
8199 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8200 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8201   echo $ECHO_N "(cached) $ECHO_C" >&6
8202 else
8203   if test -n "$OBJCOPY"; then
8204   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8205 else
8206 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8207 for as_dir in $PATH
8208 do
8209   IFS=$as_save_IFS
8210   test -z "$as_dir" && as_dir=.
8211   for ac_exec_ext in '' $ac_executable_extensions; do
8212   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8213     ac_cv_prog_OBJCOPY="${ncn_progname}"
8214     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8215     break 2
8216   fi
8217 done
8218 done
8219
8220 fi
8221 fi
8222 OBJCOPY=$ac_cv_prog_OBJCOPY
8223 if test -n "$OBJCOPY"; then
8224   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8225 echo "${ECHO_T}$OBJCOPY" >&6
8226 else
8227   echo "$as_me:$LINENO: result: no" >&5
8228 echo "${ECHO_T}no" >&6
8229 fi
8230
8231   fi
8232   test -n "$ac_cv_prog_OBJCOPY" && break
8233 done
8234
8235 if test -z "$ac_cv_prog_OBJCOPY" ; then
8236   set dummy objcopy
8237   if test $build = $host ; then
8238     OBJCOPY="$2"
8239   else
8240     OBJCOPY="${ncn_tool_prefix}$2"
8241   fi
8242 fi
8243
8244
8245
8246 if test -n "$OBJDUMP"; then
8247   ac_cv_prog_OBJDUMP=$OBJDUMP
8248 elif test -n "$ac_cv_prog_OBJDUMP"; then
8249   OBJDUMP=$ac_cv_prog_OBJDUMP
8250 fi
8251
8252 if test -n "$ac_cv_prog_OBJDUMP"; then
8253   for ncn_progname in objdump; do
8254     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8255 set dummy ${ncn_progname}; ac_word=$2
8256 echo "$as_me:$LINENO: checking for $ac_word" >&5
8257 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8258 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8259   echo $ECHO_N "(cached) $ECHO_C" >&6
8260 else
8261   if test -n "$OBJDUMP"; then
8262   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8263 else
8264 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8265 for as_dir in $PATH
8266 do
8267   IFS=$as_save_IFS
8268   test -z "$as_dir" && as_dir=.
8269   for ac_exec_ext in '' $ac_executable_extensions; do
8270   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8271     ac_cv_prog_OBJDUMP="${ncn_progname}"
8272     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8273     break 2
8274   fi
8275 done
8276 done
8277
8278 fi
8279 fi
8280 OBJDUMP=$ac_cv_prog_OBJDUMP
8281 if test -n "$OBJDUMP"; then
8282   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8283 echo "${ECHO_T}$OBJDUMP" >&6
8284 else
8285   echo "$as_me:$LINENO: result: no" >&5
8286 echo "${ECHO_T}no" >&6
8287 fi
8288
8289   done
8290 fi
8291
8292 for ncn_progname in objdump; do
8293   if test -n "$ncn_tool_prefix"; then
8294     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8295 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8296 echo "$as_me:$LINENO: checking for $ac_word" >&5
8297 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8298 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8299   echo $ECHO_N "(cached) $ECHO_C" >&6
8300 else
8301   if test -n "$OBJDUMP"; then
8302   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8303 else
8304 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8305 for as_dir in $PATH
8306 do
8307   IFS=$as_save_IFS
8308   test -z "$as_dir" && as_dir=.
8309   for ac_exec_ext in '' $ac_executable_extensions; do
8310   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8311     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8312     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8313     break 2
8314   fi
8315 done
8316 done
8317
8318 fi
8319 fi
8320 OBJDUMP=$ac_cv_prog_OBJDUMP
8321 if test -n "$OBJDUMP"; then
8322   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8323 echo "${ECHO_T}$OBJDUMP" >&6
8324 else
8325   echo "$as_me:$LINENO: result: no" >&5
8326 echo "${ECHO_T}no" >&6
8327 fi
8328
8329   fi
8330   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8331     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8332 set dummy ${ncn_progname}; ac_word=$2
8333 echo "$as_me:$LINENO: checking for $ac_word" >&5
8334 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8335 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8336   echo $ECHO_N "(cached) $ECHO_C" >&6
8337 else
8338   if test -n "$OBJDUMP"; then
8339   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8340 else
8341 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8342 for as_dir in $PATH
8343 do
8344   IFS=$as_save_IFS
8345   test -z "$as_dir" && as_dir=.
8346   for ac_exec_ext in '' $ac_executable_extensions; do
8347   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8348     ac_cv_prog_OBJDUMP="${ncn_progname}"
8349     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8350     break 2
8351   fi
8352 done
8353 done
8354
8355 fi
8356 fi
8357 OBJDUMP=$ac_cv_prog_OBJDUMP
8358 if test -n "$OBJDUMP"; then
8359   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8360 echo "${ECHO_T}$OBJDUMP" >&6
8361 else
8362   echo "$as_me:$LINENO: result: no" >&5
8363 echo "${ECHO_T}no" >&6
8364 fi
8365
8366   fi
8367   test -n "$ac_cv_prog_OBJDUMP" && break
8368 done
8369
8370 if test -z "$ac_cv_prog_OBJDUMP" ; then
8371   set dummy objdump
8372   if test $build = $host ; then
8373     OBJDUMP="$2"
8374   else
8375     OBJDUMP="${ncn_tool_prefix}$2"
8376   fi
8377 fi
8378
8379
8380
8381
8382
8383
8384 # Target tools.
8385
8386 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8387 if test "${with_build_time_tools+set}" = set; then
8388   withval="$with_build_time_tools"
8389   case x"$withval" in
8390      x/*) ;;
8391      *)
8392        with_build_time_tools=
8393        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8394 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8395        ;;
8396    esac
8397 else
8398   with_build_time_tools=
8399 fi;
8400
8401
8402
8403 if test -n "$CC_FOR_TARGET"; then
8404   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8405 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8406   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8407 fi
8408
8409 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8410   for ncn_progname in cc gcc; do
8411     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8412 set dummy ${ncn_progname}; ac_word=$2
8413 echo "$as_me:$LINENO: checking for $ac_word" >&5
8414 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8415 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8416   echo $ECHO_N "(cached) $ECHO_C" >&6
8417 else
8418   if test -n "$CC_FOR_TARGET"; then
8419   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8420 else
8421 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8422 for as_dir in $PATH
8423 do
8424   IFS=$as_save_IFS
8425   test -z "$as_dir" && as_dir=.
8426   for ac_exec_ext in '' $ac_executable_extensions; do
8427   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8428     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8429     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8430     break 2
8431   fi
8432 done
8433 done
8434
8435 fi
8436 fi
8437 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8438 if test -n "$CC_FOR_TARGET"; then
8439   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8440 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8441 else
8442   echo "$as_me:$LINENO: result: no" >&5
8443 echo "${ECHO_T}no" >&6
8444 fi
8445
8446   done
8447 fi
8448
8449 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8450   for ncn_progname in cc gcc; do
8451     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8452 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8453     if test -x $with_build_time_tools/${ncn_progname}; then
8454       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8455       echo "$as_me:$LINENO: result: yes" >&5
8456 echo "${ECHO_T}yes" >&6
8457       break
8458     else
8459       echo "$as_me:$LINENO: result: no" >&5
8460 echo "${ECHO_T}no" >&6
8461     fi
8462   done
8463 fi
8464
8465 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8466   for ncn_progname in cc gcc; do
8467     if test -n "$ncn_target_tool_prefix"; then
8468       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8469 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8470 echo "$as_me:$LINENO: checking for $ac_word" >&5
8471 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8472 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8473   echo $ECHO_N "(cached) $ECHO_C" >&6
8474 else
8475   if test -n "$CC_FOR_TARGET"; then
8476   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8477 else
8478 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8479 for as_dir in $PATH
8480 do
8481   IFS=$as_save_IFS
8482   test -z "$as_dir" && as_dir=.
8483   for ac_exec_ext in '' $ac_executable_extensions; do
8484   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8485     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8486     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8487     break 2
8488   fi
8489 done
8490 done
8491
8492 fi
8493 fi
8494 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8495 if test -n "$CC_FOR_TARGET"; then
8496   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8497 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8498 else
8499   echo "$as_me:$LINENO: result: no" >&5
8500 echo "${ECHO_T}no" >&6
8501 fi
8502
8503     fi
8504     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8505       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8506 set dummy ${ncn_progname}; ac_word=$2
8507 echo "$as_me:$LINENO: checking for $ac_word" >&5
8508 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8509 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8510   echo $ECHO_N "(cached) $ECHO_C" >&6
8511 else
8512   if test -n "$CC_FOR_TARGET"; then
8513   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8514 else
8515 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8516 for as_dir in $PATH
8517 do
8518   IFS=$as_save_IFS
8519   test -z "$as_dir" && as_dir=.
8520   for ac_exec_ext in '' $ac_executable_extensions; do
8521   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8522     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8523     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8524     break 2
8525   fi
8526 done
8527 done
8528
8529 fi
8530 fi
8531 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8532 if test -n "$CC_FOR_TARGET"; then
8533   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8534 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8535 else
8536   echo "$as_me:$LINENO: result: no" >&5
8537 echo "${ECHO_T}no" >&6
8538 fi
8539
8540     fi
8541     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8542   done
8543 fi
8544
8545 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8546   set dummy cc gcc
8547   if test $build = $target ; then
8548     CC_FOR_TARGET="$2"
8549   else
8550     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8551   fi
8552 else
8553   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8554 fi
8555
8556
8557
8558 if test -n "$CXX_FOR_TARGET"; then
8559   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8560 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8561   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8562 fi
8563
8564 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8565   for ncn_progname in c++ g++ cxx gxx; do
8566     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8567 set dummy ${ncn_progname}; ac_word=$2
8568 echo "$as_me:$LINENO: checking for $ac_word" >&5
8569 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8570 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8571   echo $ECHO_N "(cached) $ECHO_C" >&6
8572 else
8573   if test -n "$CXX_FOR_TARGET"; then
8574   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8575 else
8576 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8577 for as_dir in $PATH
8578 do
8579   IFS=$as_save_IFS
8580   test -z "$as_dir" && as_dir=.
8581   for ac_exec_ext in '' $ac_executable_extensions; do
8582   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8583     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8584     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8585     break 2
8586   fi
8587 done
8588 done
8589
8590 fi
8591 fi
8592 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8593 if test -n "$CXX_FOR_TARGET"; then
8594   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8595 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8596 else
8597   echo "$as_me:$LINENO: result: no" >&5
8598 echo "${ECHO_T}no" >&6
8599 fi
8600
8601   done
8602 fi
8603
8604 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8605   for ncn_progname in c++ g++ cxx gxx; do
8606     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8607 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8608     if test -x $with_build_time_tools/${ncn_progname}; then
8609       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8610       echo "$as_me:$LINENO: result: yes" >&5
8611 echo "${ECHO_T}yes" >&6
8612       break
8613     else
8614       echo "$as_me:$LINENO: result: no" >&5
8615 echo "${ECHO_T}no" >&6
8616     fi
8617   done
8618 fi
8619
8620 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8621   for ncn_progname in c++ g++ cxx gxx; do
8622     if test -n "$ncn_target_tool_prefix"; then
8623       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8624 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8625 echo "$as_me:$LINENO: checking for $ac_word" >&5
8626 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8627 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8628   echo $ECHO_N "(cached) $ECHO_C" >&6
8629 else
8630   if test -n "$CXX_FOR_TARGET"; then
8631   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8632 else
8633 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8634 for as_dir in $PATH
8635 do
8636   IFS=$as_save_IFS
8637   test -z "$as_dir" && as_dir=.
8638   for ac_exec_ext in '' $ac_executable_extensions; do
8639   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8640     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8641     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8642     break 2
8643   fi
8644 done
8645 done
8646
8647 fi
8648 fi
8649 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8650 if test -n "$CXX_FOR_TARGET"; then
8651   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8652 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8653 else
8654   echo "$as_me:$LINENO: result: no" >&5
8655 echo "${ECHO_T}no" >&6
8656 fi
8657
8658     fi
8659     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8660       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8661 set dummy ${ncn_progname}; ac_word=$2
8662 echo "$as_me:$LINENO: checking for $ac_word" >&5
8663 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8664 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8665   echo $ECHO_N "(cached) $ECHO_C" >&6
8666 else
8667   if test -n "$CXX_FOR_TARGET"; then
8668   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8669 else
8670 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8671 for as_dir in $PATH
8672 do
8673   IFS=$as_save_IFS
8674   test -z "$as_dir" && as_dir=.
8675   for ac_exec_ext in '' $ac_executable_extensions; do
8676   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8677     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8678     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8679     break 2
8680   fi
8681 done
8682 done
8683
8684 fi
8685 fi
8686 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8687 if test -n "$CXX_FOR_TARGET"; then
8688   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8689 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8690 else
8691   echo "$as_me:$LINENO: result: no" >&5
8692 echo "${ECHO_T}no" >&6
8693 fi
8694
8695     fi
8696     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8697   done
8698 fi
8699
8700 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8701   set dummy c++ g++ cxx gxx
8702   if test $build = $target ; then
8703     CXX_FOR_TARGET="$2"
8704   else
8705     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8706   fi
8707 else
8708   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8709 fi
8710
8711
8712
8713 if test -n "$GCC_FOR_TARGET"; then
8714   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8715 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8716   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8717 fi
8718
8719 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8720   for ncn_progname in gcc; do
8721     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8722 set dummy ${ncn_progname}; ac_word=$2
8723 echo "$as_me:$LINENO: checking for $ac_word" >&5
8724 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8725 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8726   echo $ECHO_N "(cached) $ECHO_C" >&6
8727 else
8728   if test -n "$GCC_FOR_TARGET"; then
8729   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8730 else
8731 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8732 for as_dir in $PATH
8733 do
8734   IFS=$as_save_IFS
8735   test -z "$as_dir" && as_dir=.
8736   for ac_exec_ext in '' $ac_executable_extensions; do
8737   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8738     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8739     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8740     break 2
8741   fi
8742 done
8743 done
8744
8745 fi
8746 fi
8747 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8748 if test -n "$GCC_FOR_TARGET"; then
8749   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8750 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8751 else
8752   echo "$as_me:$LINENO: result: no" >&5
8753 echo "${ECHO_T}no" >&6
8754 fi
8755
8756   done
8757 fi
8758
8759 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8760   for ncn_progname in gcc; do
8761     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8762 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8763     if test -x $with_build_time_tools/${ncn_progname}; then
8764       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8765       echo "$as_me:$LINENO: result: yes" >&5
8766 echo "${ECHO_T}yes" >&6
8767       break
8768     else
8769       echo "$as_me:$LINENO: result: no" >&5
8770 echo "${ECHO_T}no" >&6
8771     fi
8772   done
8773 fi
8774
8775 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8776   for ncn_progname in gcc; do
8777     if test -n "$ncn_target_tool_prefix"; then
8778       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8779 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8780 echo "$as_me:$LINENO: checking for $ac_word" >&5
8781 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8782 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8783   echo $ECHO_N "(cached) $ECHO_C" >&6
8784 else
8785   if test -n "$GCC_FOR_TARGET"; then
8786   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8787 else
8788 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8789 for as_dir in $PATH
8790 do
8791   IFS=$as_save_IFS
8792   test -z "$as_dir" && as_dir=.
8793   for ac_exec_ext in '' $ac_executable_extensions; do
8794   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8795     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8796     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8797     break 2
8798   fi
8799 done
8800 done
8801
8802 fi
8803 fi
8804 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8805 if test -n "$GCC_FOR_TARGET"; then
8806   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8807 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8808 else
8809   echo "$as_me:$LINENO: result: no" >&5
8810 echo "${ECHO_T}no" >&6
8811 fi
8812
8813     fi
8814     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8815       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8816 set dummy ${ncn_progname}; ac_word=$2
8817 echo "$as_me:$LINENO: checking for $ac_word" >&5
8818 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8819 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8820   echo $ECHO_N "(cached) $ECHO_C" >&6
8821 else
8822   if test -n "$GCC_FOR_TARGET"; then
8823   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8824 else
8825 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8826 for as_dir in $PATH
8827 do
8828   IFS=$as_save_IFS
8829   test -z "$as_dir" && as_dir=.
8830   for ac_exec_ext in '' $ac_executable_extensions; do
8831   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8832     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8833     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8834     break 2
8835   fi
8836 done
8837 done
8838
8839 fi
8840 fi
8841 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8842 if test -n "$GCC_FOR_TARGET"; then
8843   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8844 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8845 else
8846   echo "$as_me:$LINENO: result: no" >&5
8847 echo "${ECHO_T}no" >&6
8848 fi
8849
8850     fi
8851     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8852   done
8853 fi
8854
8855 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8856   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8857 else
8858   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8859 fi
8860
8861
8862
8863 if test -n "$GCJ_FOR_TARGET"; then
8864   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8865 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8866   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8867 fi
8868
8869 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8870   for ncn_progname in gcj; do
8871     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8872 set dummy ${ncn_progname}; ac_word=$2
8873 echo "$as_me:$LINENO: checking for $ac_word" >&5
8874 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8875 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8876   echo $ECHO_N "(cached) $ECHO_C" >&6
8877 else
8878   if test -n "$GCJ_FOR_TARGET"; then
8879   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8880 else
8881 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8882 for as_dir in $PATH
8883 do
8884   IFS=$as_save_IFS
8885   test -z "$as_dir" && as_dir=.
8886   for ac_exec_ext in '' $ac_executable_extensions; do
8887   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8888     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8889     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8890     break 2
8891   fi
8892 done
8893 done
8894
8895 fi
8896 fi
8897 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8898 if test -n "$GCJ_FOR_TARGET"; then
8899   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8900 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8901 else
8902   echo "$as_me:$LINENO: result: no" >&5
8903 echo "${ECHO_T}no" >&6
8904 fi
8905
8906   done
8907 fi
8908
8909 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8910   for ncn_progname in gcj; do
8911     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8912 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8913     if test -x $with_build_time_tools/${ncn_progname}; then
8914       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8915       echo "$as_me:$LINENO: result: yes" >&5
8916 echo "${ECHO_T}yes" >&6
8917       break
8918     else
8919       echo "$as_me:$LINENO: result: no" >&5
8920 echo "${ECHO_T}no" >&6
8921     fi
8922   done
8923 fi
8924
8925 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8926   for ncn_progname in gcj; do
8927     if test -n "$ncn_target_tool_prefix"; then
8928       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8929 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8930 echo "$as_me:$LINENO: checking for $ac_word" >&5
8931 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8932 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8933   echo $ECHO_N "(cached) $ECHO_C" >&6
8934 else
8935   if test -n "$GCJ_FOR_TARGET"; then
8936   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8937 else
8938 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8939 for as_dir in $PATH
8940 do
8941   IFS=$as_save_IFS
8942   test -z "$as_dir" && as_dir=.
8943   for ac_exec_ext in '' $ac_executable_extensions; do
8944   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8945     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8946     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8947     break 2
8948   fi
8949 done
8950 done
8951
8952 fi
8953 fi
8954 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8955 if test -n "$GCJ_FOR_TARGET"; then
8956   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8957 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8958 else
8959   echo "$as_me:$LINENO: result: no" >&5
8960 echo "${ECHO_T}no" >&6
8961 fi
8962
8963     fi
8964     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8965       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8966 set dummy ${ncn_progname}; ac_word=$2
8967 echo "$as_me:$LINENO: checking for $ac_word" >&5
8968 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8969 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8970   echo $ECHO_N "(cached) $ECHO_C" >&6
8971 else
8972   if test -n "$GCJ_FOR_TARGET"; then
8973   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8974 else
8975 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8976 for as_dir in $PATH
8977 do
8978   IFS=$as_save_IFS
8979   test -z "$as_dir" && as_dir=.
8980   for ac_exec_ext in '' $ac_executable_extensions; do
8981   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8982     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8983     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8984     break 2
8985   fi
8986 done
8987 done
8988
8989 fi
8990 fi
8991 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8992 if test -n "$GCJ_FOR_TARGET"; then
8993   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8994 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8995 else
8996   echo "$as_me:$LINENO: result: no" >&5
8997 echo "${ECHO_T}no" >&6
8998 fi
8999
9000     fi
9001     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9002   done
9003 fi
9004
9005 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9006   set dummy gcj
9007   if test $build = $target ; then
9008     GCJ_FOR_TARGET="$2"
9009   else
9010     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9011   fi
9012 else
9013   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9014 fi
9015
9016
9017
9018 if test -n "$GFORTRAN_FOR_TARGET"; then
9019   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9020 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9021   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9022 fi
9023
9024 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9025   for ncn_progname in gfortran; do
9026     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9027 set dummy ${ncn_progname}; ac_word=$2
9028 echo "$as_me:$LINENO: checking for $ac_word" >&5
9029 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9030 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9031   echo $ECHO_N "(cached) $ECHO_C" >&6
9032 else
9033   if test -n "$GFORTRAN_FOR_TARGET"; then
9034   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9035 else
9036 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9037 for as_dir in $PATH
9038 do
9039   IFS=$as_save_IFS
9040   test -z "$as_dir" && as_dir=.
9041   for ac_exec_ext in '' $ac_executable_extensions; do
9042   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9043     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9044     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9045     break 2
9046   fi
9047 done
9048 done
9049
9050 fi
9051 fi
9052 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9053 if test -n "$GFORTRAN_FOR_TARGET"; then
9054   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9055 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9056 else
9057   echo "$as_me:$LINENO: result: no" >&5
9058 echo "${ECHO_T}no" >&6
9059 fi
9060
9061   done
9062 fi
9063
9064 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9065   for ncn_progname in gfortran; do
9066     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9067 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9068     if test -x $with_build_time_tools/${ncn_progname}; then
9069       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9070       echo "$as_me:$LINENO: result: yes" >&5
9071 echo "${ECHO_T}yes" >&6
9072       break
9073     else
9074       echo "$as_me:$LINENO: result: no" >&5
9075 echo "${ECHO_T}no" >&6
9076     fi
9077   done
9078 fi
9079
9080 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9081   for ncn_progname in gfortran; do
9082     if test -n "$ncn_target_tool_prefix"; then
9083       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9084 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9085 echo "$as_me:$LINENO: checking for $ac_word" >&5
9086 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9087 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9088   echo $ECHO_N "(cached) $ECHO_C" >&6
9089 else
9090   if test -n "$GFORTRAN_FOR_TARGET"; then
9091   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9092 else
9093 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9094 for as_dir in $PATH
9095 do
9096   IFS=$as_save_IFS
9097   test -z "$as_dir" && as_dir=.
9098   for ac_exec_ext in '' $ac_executable_extensions; do
9099   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9100     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9101     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9102     break 2
9103   fi
9104 done
9105 done
9106
9107 fi
9108 fi
9109 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9110 if test -n "$GFORTRAN_FOR_TARGET"; then
9111   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9112 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9113 else
9114   echo "$as_me:$LINENO: result: no" >&5
9115 echo "${ECHO_T}no" >&6
9116 fi
9117
9118     fi
9119     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9120       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9121 set dummy ${ncn_progname}; ac_word=$2
9122 echo "$as_me:$LINENO: checking for $ac_word" >&5
9123 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9124 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9125   echo $ECHO_N "(cached) $ECHO_C" >&6
9126 else
9127   if test -n "$GFORTRAN_FOR_TARGET"; then
9128   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9129 else
9130 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9131 for as_dir in $PATH
9132 do
9133   IFS=$as_save_IFS
9134   test -z "$as_dir" && as_dir=.
9135   for ac_exec_ext in '' $ac_executable_extensions; do
9136   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9137     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9138     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9139     break 2
9140   fi
9141 done
9142 done
9143
9144 fi
9145 fi
9146 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9147 if test -n "$GFORTRAN_FOR_TARGET"; then
9148   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9149 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9150 else
9151   echo "$as_me:$LINENO: result: no" >&5
9152 echo "${ECHO_T}no" >&6
9153 fi
9154
9155     fi
9156     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9157   done
9158 fi
9159
9160 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9161   set dummy gfortran
9162   if test $build = $target ; then
9163     GFORTRAN_FOR_TARGET="$2"
9164   else
9165     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9166   fi
9167 else
9168   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9169 fi
9170
9171
9172
9173 cat > conftest.c << \EOF
9174 #ifdef __GNUC__
9175   gcc_yay;
9176 #endif
9177 EOF
9178 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9179   have_gcc_for_target=yes
9180 else
9181   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9182   have_gcc_for_target=no
9183 fi
9184 rm conftest.c
9185
9186
9187
9188
9189 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9190   if test -n "$with_build_time_tools"; then
9191     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9192 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9193     if test -x $with_build_time_tools/ar; then
9194       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9195       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9196       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9197 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9198     else
9199       echo "$as_me:$LINENO: result: no" >&5
9200 echo "${ECHO_T}no" >&6
9201     fi
9202   elif test $build != $host && test $have_gcc_for_target = yes; then
9203     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9204     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9205     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9206   fi
9207 fi
9208 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9209   # Extract the first word of "ar", so it can be a program name with args.
9210 set dummy ar; ac_word=$2
9211 echo "$as_me:$LINENO: checking for $ac_word" >&5
9212 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9213 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9214   echo $ECHO_N "(cached) $ECHO_C" >&6
9215 else
9216   case $AR_FOR_TARGET in
9217   [\\/]* | ?:[\\/]*)
9218   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9219   ;;
9220   *)
9221   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9222 for as_dir in $gcc_cv_tool_dirs
9223 do
9224   IFS=$as_save_IFS
9225   test -z "$as_dir" && as_dir=.
9226   for ac_exec_ext in '' $ac_executable_extensions; do
9227   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9228     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9229     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9230     break 2
9231   fi
9232 done
9233 done
9234
9235   ;;
9236 esac
9237 fi
9238 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9239
9240 if test -n "$AR_FOR_TARGET"; then
9241   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9242 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9243 else
9244   echo "$as_me:$LINENO: result: no" >&5
9245 echo "${ECHO_T}no" >&6
9246 fi
9247
9248 fi
9249 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9250
9251
9252 if test -n "$AR_FOR_TARGET"; then
9253   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9254 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9255   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9256 fi
9257
9258 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9259   for ncn_progname in ar; do
9260     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9261 set dummy ${ncn_progname}; ac_word=$2
9262 echo "$as_me:$LINENO: checking for $ac_word" >&5
9263 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9264 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9265   echo $ECHO_N "(cached) $ECHO_C" >&6
9266 else
9267   if test -n "$AR_FOR_TARGET"; then
9268   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9269 else
9270 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9271 for as_dir in $PATH
9272 do
9273   IFS=$as_save_IFS
9274   test -z "$as_dir" && as_dir=.
9275   for ac_exec_ext in '' $ac_executable_extensions; do
9276   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9277     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9278     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9279     break 2
9280   fi
9281 done
9282 done
9283
9284 fi
9285 fi
9286 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9287 if test -n "$AR_FOR_TARGET"; then
9288   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9289 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9290 else
9291   echo "$as_me:$LINENO: result: no" >&5
9292 echo "${ECHO_T}no" >&6
9293 fi
9294
9295   done
9296 fi
9297
9298 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9299   for ncn_progname in ar; do
9300     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9301 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9302     if test -x $with_build_time_tools/${ncn_progname}; then
9303       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9304       echo "$as_me:$LINENO: result: yes" >&5
9305 echo "${ECHO_T}yes" >&6
9306       break
9307     else
9308       echo "$as_me:$LINENO: result: no" >&5
9309 echo "${ECHO_T}no" >&6
9310     fi
9311   done
9312 fi
9313
9314 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9315   for ncn_progname in ar; do
9316     if test -n "$ncn_target_tool_prefix"; then
9317       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9318 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9319 echo "$as_me:$LINENO: checking for $ac_word" >&5
9320 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9321 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9322   echo $ECHO_N "(cached) $ECHO_C" >&6
9323 else
9324   if test -n "$AR_FOR_TARGET"; then
9325   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9326 else
9327 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9328 for as_dir in $PATH
9329 do
9330   IFS=$as_save_IFS
9331   test -z "$as_dir" && as_dir=.
9332   for ac_exec_ext in '' $ac_executable_extensions; do
9333   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9334     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9335     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9336     break 2
9337   fi
9338 done
9339 done
9340
9341 fi
9342 fi
9343 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9344 if test -n "$AR_FOR_TARGET"; then
9345   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9346 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9347 else
9348   echo "$as_me:$LINENO: result: no" >&5
9349 echo "${ECHO_T}no" >&6
9350 fi
9351
9352     fi
9353     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9354       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9355 set dummy ${ncn_progname}; ac_word=$2
9356 echo "$as_me:$LINENO: checking for $ac_word" >&5
9357 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9358 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9359   echo $ECHO_N "(cached) $ECHO_C" >&6
9360 else
9361   if test -n "$AR_FOR_TARGET"; then
9362   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9363 else
9364 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9365 for as_dir in $PATH
9366 do
9367   IFS=$as_save_IFS
9368   test -z "$as_dir" && as_dir=.
9369   for ac_exec_ext in '' $ac_executable_extensions; do
9370   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9371     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9372     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9373     break 2
9374   fi
9375 done
9376 done
9377
9378 fi
9379 fi
9380 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9381 if test -n "$AR_FOR_TARGET"; then
9382   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9383 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9384 else
9385   echo "$as_me:$LINENO: result: no" >&5
9386 echo "${ECHO_T}no" >&6
9387 fi
9388
9389     fi
9390     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9391   done
9392 fi
9393
9394 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9395   set dummy ar
9396   if test $build = $target ; then
9397     AR_FOR_TARGET="$2"
9398   else
9399     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9400   fi
9401 else
9402   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9403 fi
9404
9405 else
9406   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9407 fi
9408
9409
9410
9411
9412 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9413   if test -n "$with_build_time_tools"; then
9414     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9415 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9416     if test -x $with_build_time_tools/as; then
9417       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9418       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9419       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9420 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9421     else
9422       echo "$as_me:$LINENO: result: no" >&5
9423 echo "${ECHO_T}no" >&6
9424     fi
9425   elif test $build != $host && test $have_gcc_for_target = yes; then
9426     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9427     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9428     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9429   fi
9430 fi
9431 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9432   # Extract the first word of "as", so it can be a program name with args.
9433 set dummy as; ac_word=$2
9434 echo "$as_me:$LINENO: checking for $ac_word" >&5
9435 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9436 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9437   echo $ECHO_N "(cached) $ECHO_C" >&6
9438 else
9439   case $AS_FOR_TARGET in
9440   [\\/]* | ?:[\\/]*)
9441   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9442   ;;
9443   *)
9444   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9445 for as_dir in $gcc_cv_tool_dirs
9446 do
9447   IFS=$as_save_IFS
9448   test -z "$as_dir" && as_dir=.
9449   for ac_exec_ext in '' $ac_executable_extensions; do
9450   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9451     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9452     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9453     break 2
9454   fi
9455 done
9456 done
9457
9458   ;;
9459 esac
9460 fi
9461 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9462
9463 if test -n "$AS_FOR_TARGET"; then
9464   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9465 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9466 else
9467   echo "$as_me:$LINENO: result: no" >&5
9468 echo "${ECHO_T}no" >&6
9469 fi
9470
9471 fi
9472 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9473
9474
9475 if test -n "$AS_FOR_TARGET"; then
9476   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9477 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9478   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9479 fi
9480
9481 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9482   for ncn_progname in as; do
9483     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9484 set dummy ${ncn_progname}; ac_word=$2
9485 echo "$as_me:$LINENO: checking for $ac_word" >&5
9486 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9487 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9488   echo $ECHO_N "(cached) $ECHO_C" >&6
9489 else
9490   if test -n "$AS_FOR_TARGET"; then
9491   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9492 else
9493 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9494 for as_dir in $PATH
9495 do
9496   IFS=$as_save_IFS
9497   test -z "$as_dir" && as_dir=.
9498   for ac_exec_ext in '' $ac_executable_extensions; do
9499   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9500     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9501     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9502     break 2
9503   fi
9504 done
9505 done
9506
9507 fi
9508 fi
9509 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9510 if test -n "$AS_FOR_TARGET"; then
9511   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9512 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9513 else
9514   echo "$as_me:$LINENO: result: no" >&5
9515 echo "${ECHO_T}no" >&6
9516 fi
9517
9518   done
9519 fi
9520
9521 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9522   for ncn_progname in as; do
9523     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9524 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9525     if test -x $with_build_time_tools/${ncn_progname}; then
9526       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9527       echo "$as_me:$LINENO: result: yes" >&5
9528 echo "${ECHO_T}yes" >&6
9529       break
9530     else
9531       echo "$as_me:$LINENO: result: no" >&5
9532 echo "${ECHO_T}no" >&6
9533     fi
9534   done
9535 fi
9536
9537 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9538   for ncn_progname in as; do
9539     if test -n "$ncn_target_tool_prefix"; then
9540       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9541 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9542 echo "$as_me:$LINENO: checking for $ac_word" >&5
9543 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9544 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9545   echo $ECHO_N "(cached) $ECHO_C" >&6
9546 else
9547   if test -n "$AS_FOR_TARGET"; then
9548   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9549 else
9550 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9551 for as_dir in $PATH
9552 do
9553   IFS=$as_save_IFS
9554   test -z "$as_dir" && as_dir=.
9555   for ac_exec_ext in '' $ac_executable_extensions; do
9556   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9557     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9558     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9559     break 2
9560   fi
9561 done
9562 done
9563
9564 fi
9565 fi
9566 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9567 if test -n "$AS_FOR_TARGET"; then
9568   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9569 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9570 else
9571   echo "$as_me:$LINENO: result: no" >&5
9572 echo "${ECHO_T}no" >&6
9573 fi
9574
9575     fi
9576     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9577       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9578 set dummy ${ncn_progname}; ac_word=$2
9579 echo "$as_me:$LINENO: checking for $ac_word" >&5
9580 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9581 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9582   echo $ECHO_N "(cached) $ECHO_C" >&6
9583 else
9584   if test -n "$AS_FOR_TARGET"; then
9585   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9586 else
9587 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9588 for as_dir in $PATH
9589 do
9590   IFS=$as_save_IFS
9591   test -z "$as_dir" && as_dir=.
9592   for ac_exec_ext in '' $ac_executable_extensions; do
9593   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9594     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9595     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9596     break 2
9597   fi
9598 done
9599 done
9600
9601 fi
9602 fi
9603 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9604 if test -n "$AS_FOR_TARGET"; then
9605   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9606 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9607 else
9608   echo "$as_me:$LINENO: result: no" >&5
9609 echo "${ECHO_T}no" >&6
9610 fi
9611
9612     fi
9613     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9614   done
9615 fi
9616
9617 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9618   set dummy as
9619   if test $build = $target ; then
9620     AS_FOR_TARGET="$2"
9621   else
9622     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9623   fi
9624 else
9625   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9626 fi
9627
9628 else
9629   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9630 fi
9631
9632
9633
9634
9635 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9636   if test -n "$with_build_time_tools"; then
9637     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9638 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9639     if test -x $with_build_time_tools/dlltool; then
9640       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9641       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9642       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9643 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9644     else
9645       echo "$as_me:$LINENO: result: no" >&5
9646 echo "${ECHO_T}no" >&6
9647     fi
9648   elif test $build != $host && test $have_gcc_for_target = yes; then
9649     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9650     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9651     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9652   fi
9653 fi
9654 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9655   # Extract the first word of "dlltool", so it can be a program name with args.
9656 set dummy dlltool; ac_word=$2
9657 echo "$as_me:$LINENO: checking for $ac_word" >&5
9658 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9659 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9660   echo $ECHO_N "(cached) $ECHO_C" >&6
9661 else
9662   case $DLLTOOL_FOR_TARGET in
9663   [\\/]* | ?:[\\/]*)
9664   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9665   ;;
9666   *)
9667   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9668 for as_dir in $gcc_cv_tool_dirs
9669 do
9670   IFS=$as_save_IFS
9671   test -z "$as_dir" && as_dir=.
9672   for ac_exec_ext in '' $ac_executable_extensions; do
9673   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9674     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9675     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9676     break 2
9677   fi
9678 done
9679 done
9680
9681   ;;
9682 esac
9683 fi
9684 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9685
9686 if test -n "$DLLTOOL_FOR_TARGET"; then
9687   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9688 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9689 else
9690   echo "$as_me:$LINENO: result: no" >&5
9691 echo "${ECHO_T}no" >&6
9692 fi
9693
9694 fi
9695 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9696
9697
9698 if test -n "$DLLTOOL_FOR_TARGET"; then
9699   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9700 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9701   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9702 fi
9703
9704 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9705   for ncn_progname in dlltool; do
9706     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9707 set dummy ${ncn_progname}; ac_word=$2
9708 echo "$as_me:$LINENO: checking for $ac_word" >&5
9709 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9710 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9711   echo $ECHO_N "(cached) $ECHO_C" >&6
9712 else
9713   if test -n "$DLLTOOL_FOR_TARGET"; then
9714   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9715 else
9716 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9717 for as_dir in $PATH
9718 do
9719   IFS=$as_save_IFS
9720   test -z "$as_dir" && as_dir=.
9721   for ac_exec_ext in '' $ac_executable_extensions; do
9722   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9723     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9724     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9725     break 2
9726   fi
9727 done
9728 done
9729
9730 fi
9731 fi
9732 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9733 if test -n "$DLLTOOL_FOR_TARGET"; then
9734   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9735 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9736 else
9737   echo "$as_me:$LINENO: result: no" >&5
9738 echo "${ECHO_T}no" >&6
9739 fi
9740
9741   done
9742 fi
9743
9744 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9745   for ncn_progname in dlltool; do
9746     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9747 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9748     if test -x $with_build_time_tools/${ncn_progname}; then
9749       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9750       echo "$as_me:$LINENO: result: yes" >&5
9751 echo "${ECHO_T}yes" >&6
9752       break
9753     else
9754       echo "$as_me:$LINENO: result: no" >&5
9755 echo "${ECHO_T}no" >&6
9756     fi
9757   done
9758 fi
9759
9760 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9761   for ncn_progname in dlltool; do
9762     if test -n "$ncn_target_tool_prefix"; then
9763       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9764 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9765 echo "$as_me:$LINENO: checking for $ac_word" >&5
9766 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9767 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9768   echo $ECHO_N "(cached) $ECHO_C" >&6
9769 else
9770   if test -n "$DLLTOOL_FOR_TARGET"; then
9771   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9772 else
9773 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9774 for as_dir in $PATH
9775 do
9776   IFS=$as_save_IFS
9777   test -z "$as_dir" && as_dir=.
9778   for ac_exec_ext in '' $ac_executable_extensions; do
9779   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9780     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9781     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9782     break 2
9783   fi
9784 done
9785 done
9786
9787 fi
9788 fi
9789 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9790 if test -n "$DLLTOOL_FOR_TARGET"; then
9791   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9792 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9793 else
9794   echo "$as_me:$LINENO: result: no" >&5
9795 echo "${ECHO_T}no" >&6
9796 fi
9797
9798     fi
9799     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9800       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9801 set dummy ${ncn_progname}; ac_word=$2
9802 echo "$as_me:$LINENO: checking for $ac_word" >&5
9803 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9804 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9805   echo $ECHO_N "(cached) $ECHO_C" >&6
9806 else
9807   if test -n "$DLLTOOL_FOR_TARGET"; then
9808   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9809 else
9810 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9811 for as_dir in $PATH
9812 do
9813   IFS=$as_save_IFS
9814   test -z "$as_dir" && as_dir=.
9815   for ac_exec_ext in '' $ac_executable_extensions; do
9816   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9817     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9818     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9819     break 2
9820   fi
9821 done
9822 done
9823
9824 fi
9825 fi
9826 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9827 if test -n "$DLLTOOL_FOR_TARGET"; then
9828   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9829 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9830 else
9831   echo "$as_me:$LINENO: result: no" >&5
9832 echo "${ECHO_T}no" >&6
9833 fi
9834
9835     fi
9836     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9837   done
9838 fi
9839
9840 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9841   set dummy dlltool
9842   if test $build = $target ; then
9843     DLLTOOL_FOR_TARGET="$2"
9844   else
9845     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9846   fi
9847 else
9848   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9849 fi
9850
9851 else
9852   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9853 fi
9854
9855
9856
9857
9858 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9859   if test -n "$with_build_time_tools"; then
9860     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9861 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9862     if test -x $with_build_time_tools/ld; then
9863       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9864       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9865       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9866 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9867     else
9868       echo "$as_me:$LINENO: result: no" >&5
9869 echo "${ECHO_T}no" >&6
9870     fi
9871   elif test $build != $host && test $have_gcc_for_target = yes; then
9872     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9873     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9874     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9875   fi
9876 fi
9877 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9878   # Extract the first word of "ld", so it can be a program name with args.
9879 set dummy ld; ac_word=$2
9880 echo "$as_me:$LINENO: checking for $ac_word" >&5
9881 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9882 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9883   echo $ECHO_N "(cached) $ECHO_C" >&6
9884 else
9885   case $LD_FOR_TARGET in
9886   [\\/]* | ?:[\\/]*)
9887   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9888   ;;
9889   *)
9890   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9891 for as_dir in $gcc_cv_tool_dirs
9892 do
9893   IFS=$as_save_IFS
9894   test -z "$as_dir" && as_dir=.
9895   for ac_exec_ext in '' $ac_executable_extensions; do
9896   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9897     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9898     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9899     break 2
9900   fi
9901 done
9902 done
9903
9904   ;;
9905 esac
9906 fi
9907 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9908
9909 if test -n "$LD_FOR_TARGET"; then
9910   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9911 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9912 else
9913   echo "$as_me:$LINENO: result: no" >&5
9914 echo "${ECHO_T}no" >&6
9915 fi
9916
9917 fi
9918 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9919
9920
9921 if test -n "$LD_FOR_TARGET"; then
9922   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9923 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9924   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9925 fi
9926
9927 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9928   for ncn_progname in ld; do
9929     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9930 set dummy ${ncn_progname}; ac_word=$2
9931 echo "$as_me:$LINENO: checking for $ac_word" >&5
9932 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9933 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9934   echo $ECHO_N "(cached) $ECHO_C" >&6
9935 else
9936   if test -n "$LD_FOR_TARGET"; then
9937   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9938 else
9939 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9940 for as_dir in $PATH
9941 do
9942   IFS=$as_save_IFS
9943   test -z "$as_dir" && as_dir=.
9944   for ac_exec_ext in '' $ac_executable_extensions; do
9945   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9946     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9947     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9948     break 2
9949   fi
9950 done
9951 done
9952
9953 fi
9954 fi
9955 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9956 if test -n "$LD_FOR_TARGET"; then
9957   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9958 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9959 else
9960   echo "$as_me:$LINENO: result: no" >&5
9961 echo "${ECHO_T}no" >&6
9962 fi
9963
9964   done
9965 fi
9966
9967 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9968   for ncn_progname in ld; do
9969     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9970 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9971     if test -x $with_build_time_tools/${ncn_progname}; then
9972       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9973       echo "$as_me:$LINENO: result: yes" >&5
9974 echo "${ECHO_T}yes" >&6
9975       break
9976     else
9977       echo "$as_me:$LINENO: result: no" >&5
9978 echo "${ECHO_T}no" >&6
9979     fi
9980   done
9981 fi
9982
9983 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9984   for ncn_progname in ld; do
9985     if test -n "$ncn_target_tool_prefix"; then
9986       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9987 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9988 echo "$as_me:$LINENO: checking for $ac_word" >&5
9989 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9990 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9991   echo $ECHO_N "(cached) $ECHO_C" >&6
9992 else
9993   if test -n "$LD_FOR_TARGET"; then
9994   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9995 else
9996 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9997 for as_dir in $PATH
9998 do
9999   IFS=$as_save_IFS
10000   test -z "$as_dir" && as_dir=.
10001   for ac_exec_ext in '' $ac_executable_extensions; do
10002   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10003     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10004     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10005     break 2
10006   fi
10007 done
10008 done
10009
10010 fi
10011 fi
10012 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10013 if test -n "$LD_FOR_TARGET"; then
10014   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10015 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10016 else
10017   echo "$as_me:$LINENO: result: no" >&5
10018 echo "${ECHO_T}no" >&6
10019 fi
10020
10021     fi
10022     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10023       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10024 set dummy ${ncn_progname}; ac_word=$2
10025 echo "$as_me:$LINENO: checking for $ac_word" >&5
10026 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10027 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10028   echo $ECHO_N "(cached) $ECHO_C" >&6
10029 else
10030   if test -n "$LD_FOR_TARGET"; then
10031   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10032 else
10033 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10034 for as_dir in $PATH
10035 do
10036   IFS=$as_save_IFS
10037   test -z "$as_dir" && as_dir=.
10038   for ac_exec_ext in '' $ac_executable_extensions; do
10039   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10040     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10041     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10042     break 2
10043   fi
10044 done
10045 done
10046
10047 fi
10048 fi
10049 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10050 if test -n "$LD_FOR_TARGET"; then
10051   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10052 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10053 else
10054   echo "$as_me:$LINENO: result: no" >&5
10055 echo "${ECHO_T}no" >&6
10056 fi
10057
10058     fi
10059     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10060   done
10061 fi
10062
10063 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10064   set dummy ld
10065   if test $build = $target ; then
10066     LD_FOR_TARGET="$2"
10067   else
10068     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10069   fi
10070 else
10071   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10072 fi
10073
10074 else
10075   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10076 fi
10077
10078
10079
10080
10081 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10082   if test -n "$with_build_time_tools"; then
10083     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10084 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10085     if test -x $with_build_time_tools/lipo; then
10086       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10087       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10088       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10089 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10090     else
10091       echo "$as_me:$LINENO: result: no" >&5
10092 echo "${ECHO_T}no" >&6
10093     fi
10094   elif test $build != $host && test $have_gcc_for_target = yes; then
10095     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10096     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10097     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10098   fi
10099 fi
10100 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10101   # Extract the first word of "lipo", so it can be a program name with args.
10102 set dummy lipo; ac_word=$2
10103 echo "$as_me:$LINENO: checking for $ac_word" >&5
10104 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10105 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10106   echo $ECHO_N "(cached) $ECHO_C" >&6
10107 else
10108   case $LIPO_FOR_TARGET in
10109   [\\/]* | ?:[\\/]*)
10110   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10111   ;;
10112   *)
10113   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10114 for as_dir in $gcc_cv_tool_dirs
10115 do
10116   IFS=$as_save_IFS
10117   test -z "$as_dir" && as_dir=.
10118   for ac_exec_ext in '' $ac_executable_extensions; do
10119   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10120     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10121     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10122     break 2
10123   fi
10124 done
10125 done
10126
10127   ;;
10128 esac
10129 fi
10130 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10131
10132 if test -n "$LIPO_FOR_TARGET"; then
10133   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10134 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10135 else
10136   echo "$as_me:$LINENO: result: no" >&5
10137 echo "${ECHO_T}no" >&6
10138 fi
10139
10140 fi
10141 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10142
10143
10144 if test -n "$LIPO_FOR_TARGET"; then
10145   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10146 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10147   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10148 fi
10149
10150 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10151   for ncn_progname in lipo; do
10152     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10153 set dummy ${ncn_progname}; ac_word=$2
10154 echo "$as_me:$LINENO: checking for $ac_word" >&5
10155 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10156 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10157   echo $ECHO_N "(cached) $ECHO_C" >&6
10158 else
10159   if test -n "$LIPO_FOR_TARGET"; then
10160   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10161 else
10162 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10163 for as_dir in $PATH
10164 do
10165   IFS=$as_save_IFS
10166   test -z "$as_dir" && as_dir=.
10167   for ac_exec_ext in '' $ac_executable_extensions; do
10168   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10169     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10170     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10171     break 2
10172   fi
10173 done
10174 done
10175
10176 fi
10177 fi
10178 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10179 if test -n "$LIPO_FOR_TARGET"; then
10180   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10181 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10182 else
10183   echo "$as_me:$LINENO: result: no" >&5
10184 echo "${ECHO_T}no" >&6
10185 fi
10186
10187   done
10188 fi
10189
10190 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10191   for ncn_progname in lipo; do
10192     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10193 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10194     if test -x $with_build_time_tools/${ncn_progname}; then
10195       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10196       echo "$as_me:$LINENO: result: yes" >&5
10197 echo "${ECHO_T}yes" >&6
10198       break
10199     else
10200       echo "$as_me:$LINENO: result: no" >&5
10201 echo "${ECHO_T}no" >&6
10202     fi
10203   done
10204 fi
10205
10206 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10207   for ncn_progname in lipo; do
10208     if test -n "$ncn_target_tool_prefix"; then
10209       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10210 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10211 echo "$as_me:$LINENO: checking for $ac_word" >&5
10212 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10213 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10214   echo $ECHO_N "(cached) $ECHO_C" >&6
10215 else
10216   if test -n "$LIPO_FOR_TARGET"; then
10217   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10218 else
10219 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10220 for as_dir in $PATH
10221 do
10222   IFS=$as_save_IFS
10223   test -z "$as_dir" && as_dir=.
10224   for ac_exec_ext in '' $ac_executable_extensions; do
10225   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10226     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10227     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10228     break 2
10229   fi
10230 done
10231 done
10232
10233 fi
10234 fi
10235 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10236 if test -n "$LIPO_FOR_TARGET"; then
10237   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10238 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10239 else
10240   echo "$as_me:$LINENO: result: no" >&5
10241 echo "${ECHO_T}no" >&6
10242 fi
10243
10244     fi
10245     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10246       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10247 set dummy ${ncn_progname}; ac_word=$2
10248 echo "$as_me:$LINENO: checking for $ac_word" >&5
10249 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10250 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10251   echo $ECHO_N "(cached) $ECHO_C" >&6
10252 else
10253   if test -n "$LIPO_FOR_TARGET"; then
10254   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10255 else
10256 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10257 for as_dir in $PATH
10258 do
10259   IFS=$as_save_IFS
10260   test -z "$as_dir" && as_dir=.
10261   for ac_exec_ext in '' $ac_executable_extensions; do
10262   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10263     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10264     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10265     break 2
10266   fi
10267 done
10268 done
10269
10270 fi
10271 fi
10272 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10273 if test -n "$LIPO_FOR_TARGET"; then
10274   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10275 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10276 else
10277   echo "$as_me:$LINENO: result: no" >&5
10278 echo "${ECHO_T}no" >&6
10279 fi
10280
10281     fi
10282     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10283   done
10284 fi
10285
10286 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10287   set dummy lipo
10288   if test $build = $target ; then
10289     LIPO_FOR_TARGET="$2"
10290   else
10291     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10292   fi
10293 else
10294   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10295 fi
10296
10297 else
10298   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10299 fi
10300
10301
10302
10303
10304 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10305   if test -n "$with_build_time_tools"; then
10306     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10307 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10308     if test -x $with_build_time_tools/nm; then
10309       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10310       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10311       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10312 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10313     else
10314       echo "$as_me:$LINENO: result: no" >&5
10315 echo "${ECHO_T}no" >&6
10316     fi
10317   elif test $build != $host && test $have_gcc_for_target = yes; then
10318     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10319     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10320     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10321   fi
10322 fi
10323 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10324   # Extract the first word of "nm", so it can be a program name with args.
10325 set dummy nm; ac_word=$2
10326 echo "$as_me:$LINENO: checking for $ac_word" >&5
10327 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10328 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10329   echo $ECHO_N "(cached) $ECHO_C" >&6
10330 else
10331   case $NM_FOR_TARGET in
10332   [\\/]* | ?:[\\/]*)
10333   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10334   ;;
10335   *)
10336   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10337 for as_dir in $gcc_cv_tool_dirs
10338 do
10339   IFS=$as_save_IFS
10340   test -z "$as_dir" && as_dir=.
10341   for ac_exec_ext in '' $ac_executable_extensions; do
10342   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10343     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10344     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10345     break 2
10346   fi
10347 done
10348 done
10349
10350   ;;
10351 esac
10352 fi
10353 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10354
10355 if test -n "$NM_FOR_TARGET"; then
10356   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10357 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10358 else
10359   echo "$as_me:$LINENO: result: no" >&5
10360 echo "${ECHO_T}no" >&6
10361 fi
10362
10363 fi
10364 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10365
10366
10367 if test -n "$NM_FOR_TARGET"; then
10368   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10369 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10370   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10371 fi
10372
10373 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10374   for ncn_progname in nm; do
10375     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10376 set dummy ${ncn_progname}; ac_word=$2
10377 echo "$as_me:$LINENO: checking for $ac_word" >&5
10378 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10379 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10380   echo $ECHO_N "(cached) $ECHO_C" >&6
10381 else
10382   if test -n "$NM_FOR_TARGET"; then
10383   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10384 else
10385 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10386 for as_dir in $PATH
10387 do
10388   IFS=$as_save_IFS
10389   test -z "$as_dir" && as_dir=.
10390   for ac_exec_ext in '' $ac_executable_extensions; do
10391   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10392     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10393     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10394     break 2
10395   fi
10396 done
10397 done
10398
10399 fi
10400 fi
10401 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10402 if test -n "$NM_FOR_TARGET"; then
10403   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10404 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10405 else
10406   echo "$as_me:$LINENO: result: no" >&5
10407 echo "${ECHO_T}no" >&6
10408 fi
10409
10410   done
10411 fi
10412
10413 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10414   for ncn_progname in nm; do
10415     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10416 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10417     if test -x $with_build_time_tools/${ncn_progname}; then
10418       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10419       echo "$as_me:$LINENO: result: yes" >&5
10420 echo "${ECHO_T}yes" >&6
10421       break
10422     else
10423       echo "$as_me:$LINENO: result: no" >&5
10424 echo "${ECHO_T}no" >&6
10425     fi
10426   done
10427 fi
10428
10429 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10430   for ncn_progname in nm; do
10431     if test -n "$ncn_target_tool_prefix"; then
10432       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10433 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10434 echo "$as_me:$LINENO: checking for $ac_word" >&5
10435 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10436 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10437   echo $ECHO_N "(cached) $ECHO_C" >&6
10438 else
10439   if test -n "$NM_FOR_TARGET"; then
10440   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10441 else
10442 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10443 for as_dir in $PATH
10444 do
10445   IFS=$as_save_IFS
10446   test -z "$as_dir" && as_dir=.
10447   for ac_exec_ext in '' $ac_executable_extensions; do
10448   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10449     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10450     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10451     break 2
10452   fi
10453 done
10454 done
10455
10456 fi
10457 fi
10458 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10459 if test -n "$NM_FOR_TARGET"; then
10460   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10461 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10462 else
10463   echo "$as_me:$LINENO: result: no" >&5
10464 echo "${ECHO_T}no" >&6
10465 fi
10466
10467     fi
10468     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10469       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10470 set dummy ${ncn_progname}; ac_word=$2
10471 echo "$as_me:$LINENO: checking for $ac_word" >&5
10472 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10473 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10474   echo $ECHO_N "(cached) $ECHO_C" >&6
10475 else
10476   if test -n "$NM_FOR_TARGET"; then
10477   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10478 else
10479 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10480 for as_dir in $PATH
10481 do
10482   IFS=$as_save_IFS
10483   test -z "$as_dir" && as_dir=.
10484   for ac_exec_ext in '' $ac_executable_extensions; do
10485   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10486     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10487     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10488     break 2
10489   fi
10490 done
10491 done
10492
10493 fi
10494 fi
10495 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10496 if test -n "$NM_FOR_TARGET"; then
10497   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10498 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10499 else
10500   echo "$as_me:$LINENO: result: no" >&5
10501 echo "${ECHO_T}no" >&6
10502 fi
10503
10504     fi
10505     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10506   done
10507 fi
10508
10509 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10510   set dummy nm
10511   if test $build = $target ; then
10512     NM_FOR_TARGET="$2"
10513   else
10514     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10515   fi
10516 else
10517   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10518 fi
10519
10520 else
10521   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10522 fi
10523
10524
10525
10526
10527 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10528   if test -n "$with_build_time_tools"; then
10529     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10530 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10531     if test -x $with_build_time_tools/objdump; then
10532       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10533       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10534       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10535 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10536     else
10537       echo "$as_me:$LINENO: result: no" >&5
10538 echo "${ECHO_T}no" >&6
10539     fi
10540   elif test $build != $host && test $have_gcc_for_target = yes; then
10541     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10542     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10543     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10544   fi
10545 fi
10546 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10547   # Extract the first word of "objdump", so it can be a program name with args.
10548 set dummy objdump; ac_word=$2
10549 echo "$as_me:$LINENO: checking for $ac_word" >&5
10550 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10551 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10552   echo $ECHO_N "(cached) $ECHO_C" >&6
10553 else
10554   case $OBJDUMP_FOR_TARGET in
10555   [\\/]* | ?:[\\/]*)
10556   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10557   ;;
10558   *)
10559   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10560 for as_dir in $gcc_cv_tool_dirs
10561 do
10562   IFS=$as_save_IFS
10563   test -z "$as_dir" && as_dir=.
10564   for ac_exec_ext in '' $ac_executable_extensions; do
10565   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10566     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10567     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10568     break 2
10569   fi
10570 done
10571 done
10572
10573   ;;
10574 esac
10575 fi
10576 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10577
10578 if test -n "$OBJDUMP_FOR_TARGET"; then
10579   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10580 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10581 else
10582   echo "$as_me:$LINENO: result: no" >&5
10583 echo "${ECHO_T}no" >&6
10584 fi
10585
10586 fi
10587 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10588
10589
10590 if test -n "$OBJDUMP_FOR_TARGET"; then
10591   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10592 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10593   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10594 fi
10595
10596 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10597   for ncn_progname in objdump; do
10598     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10599 set dummy ${ncn_progname}; ac_word=$2
10600 echo "$as_me:$LINENO: checking for $ac_word" >&5
10601 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10602 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10603   echo $ECHO_N "(cached) $ECHO_C" >&6
10604 else
10605   if test -n "$OBJDUMP_FOR_TARGET"; then
10606   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10607 else
10608 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10609 for as_dir in $PATH
10610 do
10611   IFS=$as_save_IFS
10612   test -z "$as_dir" && as_dir=.
10613   for ac_exec_ext in '' $ac_executable_extensions; do
10614   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10615     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10616     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10617     break 2
10618   fi
10619 done
10620 done
10621
10622 fi
10623 fi
10624 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10625 if test -n "$OBJDUMP_FOR_TARGET"; then
10626   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10627 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10628 else
10629   echo "$as_me:$LINENO: result: no" >&5
10630 echo "${ECHO_T}no" >&6
10631 fi
10632
10633   done
10634 fi
10635
10636 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10637   for ncn_progname in objdump; do
10638     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10639 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10640     if test -x $with_build_time_tools/${ncn_progname}; then
10641       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10642       echo "$as_me:$LINENO: result: yes" >&5
10643 echo "${ECHO_T}yes" >&6
10644       break
10645     else
10646       echo "$as_me:$LINENO: result: no" >&5
10647 echo "${ECHO_T}no" >&6
10648     fi
10649   done
10650 fi
10651
10652 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10653   for ncn_progname in objdump; do
10654     if test -n "$ncn_target_tool_prefix"; then
10655       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10656 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10657 echo "$as_me:$LINENO: checking for $ac_word" >&5
10658 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10659 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10660   echo $ECHO_N "(cached) $ECHO_C" >&6
10661 else
10662   if test -n "$OBJDUMP_FOR_TARGET"; then
10663   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10664 else
10665 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10666 for as_dir in $PATH
10667 do
10668   IFS=$as_save_IFS
10669   test -z "$as_dir" && as_dir=.
10670   for ac_exec_ext in '' $ac_executable_extensions; do
10671   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10672     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10673     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10674     break 2
10675   fi
10676 done
10677 done
10678
10679 fi
10680 fi
10681 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10682 if test -n "$OBJDUMP_FOR_TARGET"; then
10683   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10684 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10685 else
10686   echo "$as_me:$LINENO: result: no" >&5
10687 echo "${ECHO_T}no" >&6
10688 fi
10689
10690     fi
10691     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10692       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10693 set dummy ${ncn_progname}; ac_word=$2
10694 echo "$as_me:$LINENO: checking for $ac_word" >&5
10695 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10696 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10697   echo $ECHO_N "(cached) $ECHO_C" >&6
10698 else
10699   if test -n "$OBJDUMP_FOR_TARGET"; then
10700   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10701 else
10702 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10703 for as_dir in $PATH
10704 do
10705   IFS=$as_save_IFS
10706   test -z "$as_dir" && as_dir=.
10707   for ac_exec_ext in '' $ac_executable_extensions; do
10708   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10709     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10710     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10711     break 2
10712   fi
10713 done
10714 done
10715
10716 fi
10717 fi
10718 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10719 if test -n "$OBJDUMP_FOR_TARGET"; then
10720   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10721 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10722 else
10723   echo "$as_me:$LINENO: result: no" >&5
10724 echo "${ECHO_T}no" >&6
10725 fi
10726
10727     fi
10728     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10729   done
10730 fi
10731
10732 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10733   set dummy objdump
10734   if test $build = $target ; then
10735     OBJDUMP_FOR_TARGET="$2"
10736   else
10737     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10738   fi
10739 else
10740   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10741 fi
10742
10743 else
10744   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10745 fi
10746
10747
10748
10749
10750 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10751   if test -n "$with_build_time_tools"; then
10752     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10753 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10754     if test -x $with_build_time_tools/ranlib; then
10755       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10756       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10757       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10758 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10759     else
10760       echo "$as_me:$LINENO: result: no" >&5
10761 echo "${ECHO_T}no" >&6
10762     fi
10763   elif test $build != $host && test $have_gcc_for_target = yes; then
10764     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10765     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10766     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10767   fi
10768 fi
10769 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10770   # Extract the first word of "ranlib", so it can be a program name with args.
10771 set dummy ranlib; ac_word=$2
10772 echo "$as_me:$LINENO: checking for $ac_word" >&5
10773 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10774 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10775   echo $ECHO_N "(cached) $ECHO_C" >&6
10776 else
10777   case $RANLIB_FOR_TARGET in
10778   [\\/]* | ?:[\\/]*)
10779   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10780   ;;
10781   *)
10782   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10783 for as_dir in $gcc_cv_tool_dirs
10784 do
10785   IFS=$as_save_IFS
10786   test -z "$as_dir" && as_dir=.
10787   for ac_exec_ext in '' $ac_executable_extensions; do
10788   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10789     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10790     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10791     break 2
10792   fi
10793 done
10794 done
10795
10796   ;;
10797 esac
10798 fi
10799 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10800
10801 if test -n "$RANLIB_FOR_TARGET"; then
10802   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10803 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10804 else
10805   echo "$as_me:$LINENO: result: no" >&5
10806 echo "${ECHO_T}no" >&6
10807 fi
10808
10809 fi
10810 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10811
10812
10813 if test -n "$RANLIB_FOR_TARGET"; then
10814   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10815 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10816   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10817 fi
10818
10819 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10820   for ncn_progname in ranlib; do
10821     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10822 set dummy ${ncn_progname}; ac_word=$2
10823 echo "$as_me:$LINENO: checking for $ac_word" >&5
10824 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10825 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10826   echo $ECHO_N "(cached) $ECHO_C" >&6
10827 else
10828   if test -n "$RANLIB_FOR_TARGET"; then
10829   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10830 else
10831 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10832 for as_dir in $PATH
10833 do
10834   IFS=$as_save_IFS
10835   test -z "$as_dir" && as_dir=.
10836   for ac_exec_ext in '' $ac_executable_extensions; do
10837   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10838     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10839     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10840     break 2
10841   fi
10842 done
10843 done
10844
10845 fi
10846 fi
10847 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10848 if test -n "$RANLIB_FOR_TARGET"; then
10849   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10850 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10851 else
10852   echo "$as_me:$LINENO: result: no" >&5
10853 echo "${ECHO_T}no" >&6
10854 fi
10855
10856   done
10857 fi
10858
10859 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10860   for ncn_progname in ranlib; do
10861     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10862 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10863     if test -x $with_build_time_tools/${ncn_progname}; then
10864       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10865       echo "$as_me:$LINENO: result: yes" >&5
10866 echo "${ECHO_T}yes" >&6
10867       break
10868     else
10869       echo "$as_me:$LINENO: result: no" >&5
10870 echo "${ECHO_T}no" >&6
10871     fi
10872   done
10873 fi
10874
10875 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10876   for ncn_progname in ranlib; do
10877     if test -n "$ncn_target_tool_prefix"; then
10878       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10879 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10880 echo "$as_me:$LINENO: checking for $ac_word" >&5
10881 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10882 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10883   echo $ECHO_N "(cached) $ECHO_C" >&6
10884 else
10885   if test -n "$RANLIB_FOR_TARGET"; then
10886   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10887 else
10888 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10889 for as_dir in $PATH
10890 do
10891   IFS=$as_save_IFS
10892   test -z "$as_dir" && as_dir=.
10893   for ac_exec_ext in '' $ac_executable_extensions; do
10894   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10895     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10896     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10897     break 2
10898   fi
10899 done
10900 done
10901
10902 fi
10903 fi
10904 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10905 if test -n "$RANLIB_FOR_TARGET"; then
10906   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10907 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10908 else
10909   echo "$as_me:$LINENO: result: no" >&5
10910 echo "${ECHO_T}no" >&6
10911 fi
10912
10913     fi
10914     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10915       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10916 set dummy ${ncn_progname}; ac_word=$2
10917 echo "$as_me:$LINENO: checking for $ac_word" >&5
10918 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10919 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10920   echo $ECHO_N "(cached) $ECHO_C" >&6
10921 else
10922   if test -n "$RANLIB_FOR_TARGET"; then
10923   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10924 else
10925 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10926 for as_dir in $PATH
10927 do
10928   IFS=$as_save_IFS
10929   test -z "$as_dir" && as_dir=.
10930   for ac_exec_ext in '' $ac_executable_extensions; do
10931   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10932     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10933     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10934     break 2
10935   fi
10936 done
10937 done
10938
10939 fi
10940 fi
10941 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10942 if test -n "$RANLIB_FOR_TARGET"; then
10943   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10944 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10945 else
10946   echo "$as_me:$LINENO: result: no" >&5
10947 echo "${ECHO_T}no" >&6
10948 fi
10949
10950     fi
10951     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10952   done
10953 fi
10954
10955 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10956   set dummy ranlib
10957   if test $build = $target ; then
10958     RANLIB_FOR_TARGET="$2"
10959   else
10960     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10961   fi
10962 else
10963   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10964 fi
10965
10966 else
10967   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10968 fi
10969
10970
10971
10972
10973 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10974   if test -n "$with_build_time_tools"; then
10975     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10976 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10977     if test -x $with_build_time_tools/strip; then
10978       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10979       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10980       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10981 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10982     else
10983       echo "$as_me:$LINENO: result: no" >&5
10984 echo "${ECHO_T}no" >&6
10985     fi
10986   elif test $build != $host && test $have_gcc_for_target = yes; then
10987     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10988     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10989     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10990   fi
10991 fi
10992 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10993   # Extract the first word of "strip", so it can be a program name with args.
10994 set dummy strip; ac_word=$2
10995 echo "$as_me:$LINENO: checking for $ac_word" >&5
10996 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10997 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10998   echo $ECHO_N "(cached) $ECHO_C" >&6
10999 else
11000   case $STRIP_FOR_TARGET in
11001   [\\/]* | ?:[\\/]*)
11002   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11003   ;;
11004   *)
11005   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11006 for as_dir in $gcc_cv_tool_dirs
11007 do
11008   IFS=$as_save_IFS
11009   test -z "$as_dir" && as_dir=.
11010   for ac_exec_ext in '' $ac_executable_extensions; do
11011   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11012     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11013     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11014     break 2
11015   fi
11016 done
11017 done
11018
11019   ;;
11020 esac
11021 fi
11022 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11023
11024 if test -n "$STRIP_FOR_TARGET"; then
11025   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11026 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11027 else
11028   echo "$as_me:$LINENO: result: no" >&5
11029 echo "${ECHO_T}no" >&6
11030 fi
11031
11032 fi
11033 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11034
11035
11036 if test -n "$STRIP_FOR_TARGET"; then
11037   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11038 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11039   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11040 fi
11041
11042 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11043   for ncn_progname in strip; do
11044     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11045 set dummy ${ncn_progname}; ac_word=$2
11046 echo "$as_me:$LINENO: checking for $ac_word" >&5
11047 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11048 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11049   echo $ECHO_N "(cached) $ECHO_C" >&6
11050 else
11051   if test -n "$STRIP_FOR_TARGET"; then
11052   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11053 else
11054 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11055 for as_dir in $PATH
11056 do
11057   IFS=$as_save_IFS
11058   test -z "$as_dir" && as_dir=.
11059   for ac_exec_ext in '' $ac_executable_extensions; do
11060   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11061     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11062     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11063     break 2
11064   fi
11065 done
11066 done
11067
11068 fi
11069 fi
11070 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11071 if test -n "$STRIP_FOR_TARGET"; then
11072   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11073 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11074 else
11075   echo "$as_me:$LINENO: result: no" >&5
11076 echo "${ECHO_T}no" >&6
11077 fi
11078
11079   done
11080 fi
11081
11082 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11083   for ncn_progname in strip; do
11084     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11085 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11086     if test -x $with_build_time_tools/${ncn_progname}; then
11087       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11088       echo "$as_me:$LINENO: result: yes" >&5
11089 echo "${ECHO_T}yes" >&6
11090       break
11091     else
11092       echo "$as_me:$LINENO: result: no" >&5
11093 echo "${ECHO_T}no" >&6
11094     fi
11095   done
11096 fi
11097
11098 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11099   for ncn_progname in strip; do
11100     if test -n "$ncn_target_tool_prefix"; then
11101       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11102 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11103 echo "$as_me:$LINENO: checking for $ac_word" >&5
11104 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11105 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11106   echo $ECHO_N "(cached) $ECHO_C" >&6
11107 else
11108   if test -n "$STRIP_FOR_TARGET"; then
11109   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11110 else
11111 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11112 for as_dir in $PATH
11113 do
11114   IFS=$as_save_IFS
11115   test -z "$as_dir" && as_dir=.
11116   for ac_exec_ext in '' $ac_executable_extensions; do
11117   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11118     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11119     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11120     break 2
11121   fi
11122 done
11123 done
11124
11125 fi
11126 fi
11127 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11128 if test -n "$STRIP_FOR_TARGET"; then
11129   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11130 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11131 else
11132   echo "$as_me:$LINENO: result: no" >&5
11133 echo "${ECHO_T}no" >&6
11134 fi
11135
11136     fi
11137     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11138       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11139 set dummy ${ncn_progname}; ac_word=$2
11140 echo "$as_me:$LINENO: checking for $ac_word" >&5
11141 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11142 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11143   echo $ECHO_N "(cached) $ECHO_C" >&6
11144 else
11145   if test -n "$STRIP_FOR_TARGET"; then
11146   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11147 else
11148 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11149 for as_dir in $PATH
11150 do
11151   IFS=$as_save_IFS
11152   test -z "$as_dir" && as_dir=.
11153   for ac_exec_ext in '' $ac_executable_extensions; do
11154   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11155     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11156     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11157     break 2
11158   fi
11159 done
11160 done
11161
11162 fi
11163 fi
11164 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11165 if test -n "$STRIP_FOR_TARGET"; then
11166   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11167 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11168 else
11169   echo "$as_me:$LINENO: result: no" >&5
11170 echo "${ECHO_T}no" >&6
11171 fi
11172
11173     fi
11174     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11175   done
11176 fi
11177
11178 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11179   set dummy strip
11180   if test $build = $target ; then
11181     STRIP_FOR_TARGET="$2"
11182   else
11183     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11184   fi
11185 else
11186   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11187 fi
11188
11189 else
11190   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11191 fi
11192
11193
11194
11195
11196 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11197   if test -n "$with_build_time_tools"; then
11198     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11199 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11200     if test -x $with_build_time_tools/windres; then
11201       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11202       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11203       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11204 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11205     else
11206       echo "$as_me:$LINENO: result: no" >&5
11207 echo "${ECHO_T}no" >&6
11208     fi
11209   elif test $build != $host && test $have_gcc_for_target = yes; then
11210     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11211     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11212     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11213   fi
11214 fi
11215 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11216   # Extract the first word of "windres", so it can be a program name with args.
11217 set dummy windres; ac_word=$2
11218 echo "$as_me:$LINENO: checking for $ac_word" >&5
11219 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11220 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11221   echo $ECHO_N "(cached) $ECHO_C" >&6
11222 else
11223   case $WINDRES_FOR_TARGET in
11224   [\\/]* | ?:[\\/]*)
11225   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11226   ;;
11227   *)
11228   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11229 for as_dir in $gcc_cv_tool_dirs
11230 do
11231   IFS=$as_save_IFS
11232   test -z "$as_dir" && as_dir=.
11233   for ac_exec_ext in '' $ac_executable_extensions; do
11234   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11235     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11236     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11237     break 2
11238   fi
11239 done
11240 done
11241
11242   ;;
11243 esac
11244 fi
11245 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11246
11247 if test -n "$WINDRES_FOR_TARGET"; then
11248   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11249 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11250 else
11251   echo "$as_me:$LINENO: result: no" >&5
11252 echo "${ECHO_T}no" >&6
11253 fi
11254
11255 fi
11256 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11257
11258
11259 if test -n "$WINDRES_FOR_TARGET"; then
11260   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11261 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11262   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11263 fi
11264
11265 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11266   for ncn_progname in windres; do
11267     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11268 set dummy ${ncn_progname}; ac_word=$2
11269 echo "$as_me:$LINENO: checking for $ac_word" >&5
11270 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11271 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11272   echo $ECHO_N "(cached) $ECHO_C" >&6
11273 else
11274   if test -n "$WINDRES_FOR_TARGET"; then
11275   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11276 else
11277 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11278 for as_dir in $PATH
11279 do
11280   IFS=$as_save_IFS
11281   test -z "$as_dir" && as_dir=.
11282   for ac_exec_ext in '' $ac_executable_extensions; do
11283   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11284     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11285     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11286     break 2
11287   fi
11288 done
11289 done
11290
11291 fi
11292 fi
11293 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11294 if test -n "$WINDRES_FOR_TARGET"; then
11295   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11296 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11297 else
11298   echo "$as_me:$LINENO: result: no" >&5
11299 echo "${ECHO_T}no" >&6
11300 fi
11301
11302   done
11303 fi
11304
11305 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11306   for ncn_progname in windres; do
11307     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11308 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11309     if test -x $with_build_time_tools/${ncn_progname}; then
11310       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11311       echo "$as_me:$LINENO: result: yes" >&5
11312 echo "${ECHO_T}yes" >&6
11313       break
11314     else
11315       echo "$as_me:$LINENO: result: no" >&5
11316 echo "${ECHO_T}no" >&6
11317     fi
11318   done
11319 fi
11320
11321 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11322   for ncn_progname in windres; do
11323     if test -n "$ncn_target_tool_prefix"; then
11324       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11325 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11326 echo "$as_me:$LINENO: checking for $ac_word" >&5
11327 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11328 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11329   echo $ECHO_N "(cached) $ECHO_C" >&6
11330 else
11331   if test -n "$WINDRES_FOR_TARGET"; then
11332   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11333 else
11334 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11335 for as_dir in $PATH
11336 do
11337   IFS=$as_save_IFS
11338   test -z "$as_dir" && as_dir=.
11339   for ac_exec_ext in '' $ac_executable_extensions; do
11340   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11341     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11342     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11343     break 2
11344   fi
11345 done
11346 done
11347
11348 fi
11349 fi
11350 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11351 if test -n "$WINDRES_FOR_TARGET"; then
11352   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11353 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11354 else
11355   echo "$as_me:$LINENO: result: no" >&5
11356 echo "${ECHO_T}no" >&6
11357 fi
11358
11359     fi
11360     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11361       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11362 set dummy ${ncn_progname}; ac_word=$2
11363 echo "$as_me:$LINENO: checking for $ac_word" >&5
11364 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11365 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11366   echo $ECHO_N "(cached) $ECHO_C" >&6
11367 else
11368   if test -n "$WINDRES_FOR_TARGET"; then
11369   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11370 else
11371 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11372 for as_dir in $PATH
11373 do
11374   IFS=$as_save_IFS
11375   test -z "$as_dir" && as_dir=.
11376   for ac_exec_ext in '' $ac_executable_extensions; do
11377   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11378     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11379     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11380     break 2
11381   fi
11382 done
11383 done
11384
11385 fi
11386 fi
11387 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11388 if test -n "$WINDRES_FOR_TARGET"; then
11389   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11390 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11391 else
11392   echo "$as_me:$LINENO: result: no" >&5
11393 echo "${ECHO_T}no" >&6
11394 fi
11395
11396     fi
11397     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11398   done
11399 fi
11400
11401 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11402   set dummy windres
11403   if test $build = $target ; then
11404     WINDRES_FOR_TARGET="$2"
11405   else
11406     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11407   fi
11408 else
11409   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11410 fi
11411
11412 else
11413   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11414 fi
11415
11416
11417
11418
11419 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11420   if test -n "$with_build_time_tools"; then
11421     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11422 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11423     if test -x $with_build_time_tools/windmc; then
11424       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11425       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11426       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11427 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11428     else
11429       echo "$as_me:$LINENO: result: no" >&5
11430 echo "${ECHO_T}no" >&6
11431     fi
11432   elif test $build != $host && test $have_gcc_for_target = yes; then
11433     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11434     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11435     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11436   fi
11437 fi
11438 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11439   # Extract the first word of "windmc", so it can be a program name with args.
11440 set dummy windmc; ac_word=$2
11441 echo "$as_me:$LINENO: checking for $ac_word" >&5
11442 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11443 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11444   echo $ECHO_N "(cached) $ECHO_C" >&6
11445 else
11446   case $WINDMC_FOR_TARGET in
11447   [\\/]* | ?:[\\/]*)
11448   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11449   ;;
11450   *)
11451   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11452 for as_dir in $gcc_cv_tool_dirs
11453 do
11454   IFS=$as_save_IFS
11455   test -z "$as_dir" && as_dir=.
11456   for ac_exec_ext in '' $ac_executable_extensions; do
11457   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11458     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11459     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11460     break 2
11461   fi
11462 done
11463 done
11464
11465   ;;
11466 esac
11467 fi
11468 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11469
11470 if test -n "$WINDMC_FOR_TARGET"; then
11471   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11472 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11473 else
11474   echo "$as_me:$LINENO: result: no" >&5
11475 echo "${ECHO_T}no" >&6
11476 fi
11477
11478 fi
11479 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11480
11481
11482 if test -n "$WINDMC_FOR_TARGET"; then
11483   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11484 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11485   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11486 fi
11487
11488 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11489   for ncn_progname in windmc; do
11490     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11491 set dummy ${ncn_progname}; ac_word=$2
11492 echo "$as_me:$LINENO: checking for $ac_word" >&5
11493 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11494 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11495   echo $ECHO_N "(cached) $ECHO_C" >&6
11496 else
11497   if test -n "$WINDMC_FOR_TARGET"; then
11498   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11499 else
11500 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11501 for as_dir in $PATH
11502 do
11503   IFS=$as_save_IFS
11504   test -z "$as_dir" && as_dir=.
11505   for ac_exec_ext in '' $ac_executable_extensions; do
11506   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11507     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11508     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11509     break 2
11510   fi
11511 done
11512 done
11513
11514 fi
11515 fi
11516 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11517 if test -n "$WINDMC_FOR_TARGET"; then
11518   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11519 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11520 else
11521   echo "$as_me:$LINENO: result: no" >&5
11522 echo "${ECHO_T}no" >&6
11523 fi
11524
11525   done
11526 fi
11527
11528 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11529   for ncn_progname in windmc; do
11530     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11531 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11532     if test -x $with_build_time_tools/${ncn_progname}; then
11533       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11534       echo "$as_me:$LINENO: result: yes" >&5
11535 echo "${ECHO_T}yes" >&6
11536       break
11537     else
11538       echo "$as_me:$LINENO: result: no" >&5
11539 echo "${ECHO_T}no" >&6
11540     fi
11541   done
11542 fi
11543
11544 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11545   for ncn_progname in windmc; do
11546     if test -n "$ncn_target_tool_prefix"; then
11547       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11548 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11549 echo "$as_me:$LINENO: checking for $ac_word" >&5
11550 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11551 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11552   echo $ECHO_N "(cached) $ECHO_C" >&6
11553 else
11554   if test -n "$WINDMC_FOR_TARGET"; then
11555   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11556 else
11557 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11558 for as_dir in $PATH
11559 do
11560   IFS=$as_save_IFS
11561   test -z "$as_dir" && as_dir=.
11562   for ac_exec_ext in '' $ac_executable_extensions; do
11563   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11564     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11565     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11566     break 2
11567   fi
11568 done
11569 done
11570
11571 fi
11572 fi
11573 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11574 if test -n "$WINDMC_FOR_TARGET"; then
11575   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11576 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11577 else
11578   echo "$as_me:$LINENO: result: no" >&5
11579 echo "${ECHO_T}no" >&6
11580 fi
11581
11582     fi
11583     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11584       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11585 set dummy ${ncn_progname}; ac_word=$2
11586 echo "$as_me:$LINENO: checking for $ac_word" >&5
11587 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11588 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11589   echo $ECHO_N "(cached) $ECHO_C" >&6
11590 else
11591   if test -n "$WINDMC_FOR_TARGET"; then
11592   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11593 else
11594 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11595 for as_dir in $PATH
11596 do
11597   IFS=$as_save_IFS
11598   test -z "$as_dir" && as_dir=.
11599   for ac_exec_ext in '' $ac_executable_extensions; do
11600   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11601     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11602     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11603     break 2
11604   fi
11605 done
11606 done
11607
11608 fi
11609 fi
11610 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11611 if test -n "$WINDMC_FOR_TARGET"; then
11612   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11613 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11614 else
11615   echo "$as_me:$LINENO: result: no" >&5
11616 echo "${ECHO_T}no" >&6
11617 fi
11618
11619     fi
11620     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11621   done
11622 fi
11623
11624 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11625   set dummy windmc
11626   if test $build = $target ; then
11627     WINDMC_FOR_TARGET="$2"
11628   else
11629     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11630   fi
11631 else
11632   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11633 fi
11634
11635 else
11636   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11637 fi
11638
11639
11640 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11641
11642 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11643 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11644 if test "x${build}" != "x${host}" ; then
11645   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11646     # We already found the complete path
11647     ac_dir=`dirname $AR_FOR_TARGET`
11648     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11649 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11650   else
11651     # Canadian cross, just use what we found
11652     echo "$as_me:$LINENO: result: pre-installed" >&5
11653 echo "${ECHO_T}pre-installed" >&6
11654   fi
11655 else
11656   ok=yes
11657   case " ${configdirs} " in
11658     *" binutils "*) ;;
11659     *) ok=no ;;
11660   esac
11661
11662   if test $ok = yes; then
11663     # An in-tree tool is available and we can use it
11664     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11665     echo "$as_me:$LINENO: result: just compiled" >&5
11666 echo "${ECHO_T}just compiled" >&6
11667   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11668     # We already found the complete path
11669     ac_dir=`dirname $AR_FOR_TARGET`
11670     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11671 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11672   elif test "x$target" = "x$host"; then
11673     # We can use an host tool
11674     AR_FOR_TARGET='$(AR)'
11675     echo "$as_me:$LINENO: result: host tool" >&5
11676 echo "${ECHO_T}host tool" >&6
11677   else
11678     # We need a cross tool
11679     echo "$as_me:$LINENO: result: pre-installed" >&5
11680 echo "${ECHO_T}pre-installed" >&6
11681   fi
11682 fi
11683
11684 echo "$as_me:$LINENO: checking where to find the target as" >&5
11685 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11686 if test "x${build}" != "x${host}" ; then
11687   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11688     # We already found the complete path
11689     ac_dir=`dirname $AS_FOR_TARGET`
11690     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11691 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11692   else
11693     # Canadian cross, just use what we found
11694     echo "$as_me:$LINENO: result: pre-installed" >&5
11695 echo "${ECHO_T}pre-installed" >&6
11696   fi
11697 else
11698   ok=yes
11699   case " ${configdirs} " in
11700     *" gas "*) ;;
11701     *) ok=no ;;
11702   esac
11703
11704   if test $ok = yes; then
11705     # An in-tree tool is available and we can use it
11706     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11707     echo "$as_me:$LINENO: result: just compiled" >&5
11708 echo "${ECHO_T}just compiled" >&6
11709   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11710     # We already found the complete path
11711     ac_dir=`dirname $AS_FOR_TARGET`
11712     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11713 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11714   elif test "x$target" = "x$host"; then
11715     # We can use an host tool
11716     AS_FOR_TARGET='$(AS)'
11717     echo "$as_me:$LINENO: result: host tool" >&5
11718 echo "${ECHO_T}host tool" >&6
11719   else
11720     # We need a cross tool
11721     echo "$as_me:$LINENO: result: pre-installed" >&5
11722 echo "${ECHO_T}pre-installed" >&6
11723   fi
11724 fi
11725
11726 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11727 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11728 if test "x${build}" != "x${host}" ; then
11729   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11730     # We already found the complete path
11731     ac_dir=`dirname $CC_FOR_TARGET`
11732     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11733 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11734   else
11735     # Canadian cross, just use what we found
11736     echo "$as_me:$LINENO: result: pre-installed" >&5
11737 echo "${ECHO_T}pre-installed" >&6
11738   fi
11739 else
11740   ok=yes
11741   case " ${configdirs} " in
11742     *" gcc "*) ;;
11743     *) ok=no ;;
11744   esac
11745
11746   if test $ok = yes; then
11747     # An in-tree tool is available and we can use it
11748     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11749     echo "$as_me:$LINENO: result: just compiled" >&5
11750 echo "${ECHO_T}just compiled" >&6
11751   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11752     # We already found the complete path
11753     ac_dir=`dirname $CC_FOR_TARGET`
11754     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11755 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11756   elif test "x$target" = "x$host"; then
11757     # We can use an host tool
11758     CC_FOR_TARGET='$(CC)'
11759     echo "$as_me:$LINENO: result: host tool" >&5
11760 echo "${ECHO_T}host tool" >&6
11761   else
11762     # We need a cross tool
11763     echo "$as_me:$LINENO: result: pre-installed" >&5
11764 echo "${ECHO_T}pre-installed" >&6
11765   fi
11766 fi
11767
11768 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11769 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11770 if test "x${build}" != "x${host}" ; then
11771   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11772     # We already found the complete path
11773     ac_dir=`dirname $CXX_FOR_TARGET`
11774     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11775 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11776   else
11777     # Canadian cross, just use what we found
11778     echo "$as_me:$LINENO: result: pre-installed" >&5
11779 echo "${ECHO_T}pre-installed" >&6
11780   fi
11781 else
11782   ok=yes
11783   case " ${configdirs} " in
11784     *" gcc "*) ;;
11785     *) ok=no ;;
11786   esac
11787   case ,${enable_languages}, in
11788     *,c++,*) ;;
11789     *) ok=no ;;
11790   esac
11791   if test $ok = yes; then
11792     # An in-tree tool is available and we can use it
11793     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'
11794     echo "$as_me:$LINENO: result: just compiled" >&5
11795 echo "${ECHO_T}just compiled" >&6
11796   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11797     # We already found the complete path
11798     ac_dir=`dirname $CXX_FOR_TARGET`
11799     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11800 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11801   elif test "x$target" = "x$host"; then
11802     # We can use an host tool
11803     CXX_FOR_TARGET='$(CXX)'
11804     echo "$as_me:$LINENO: result: host tool" >&5
11805 echo "${ECHO_T}host tool" >&6
11806   else
11807     # We need a cross tool
11808     echo "$as_me:$LINENO: result: pre-installed" >&5
11809 echo "${ECHO_T}pre-installed" >&6
11810   fi
11811 fi
11812
11813 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11814 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11815 if test "x${build}" != "x${host}" ; then
11816   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11817     # We already found the complete path
11818     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11819     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11820 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11821   else
11822     # Canadian cross, just use what we found
11823     echo "$as_me:$LINENO: result: pre-installed" >&5
11824 echo "${ECHO_T}pre-installed" >&6
11825   fi
11826 else
11827   ok=yes
11828   case " ${configdirs} " in
11829     *" gcc "*) ;;
11830     *) ok=no ;;
11831   esac
11832   case ,${enable_languages}, in
11833     *,c++,*) ;;
11834     *) ok=no ;;
11835   esac
11836   if test $ok = yes; then
11837     # An in-tree tool is available and we can use it
11838     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'
11839     echo "$as_me:$LINENO: result: just compiled" >&5
11840 echo "${ECHO_T}just compiled" >&6
11841   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11842     # We already found the complete path
11843     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11844     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11845 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11846   elif test "x$target" = "x$host"; then
11847     # We can use an host tool
11848     RAW_CXX_FOR_TARGET='$(CXX)'
11849     echo "$as_me:$LINENO: result: host tool" >&5
11850 echo "${ECHO_T}host tool" >&6
11851   else
11852     # We need a cross tool
11853     echo "$as_me:$LINENO: result: pre-installed" >&5
11854 echo "${ECHO_T}pre-installed" >&6
11855   fi
11856 fi
11857
11858 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11859 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11860 if test "x${build}" != "x${host}" ; then
11861   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11862     # We already found the complete path
11863     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11864     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11865 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11866   else
11867     # Canadian cross, just use what we found
11868     echo "$as_me:$LINENO: result: pre-installed" >&5
11869 echo "${ECHO_T}pre-installed" >&6
11870   fi
11871 else
11872   ok=yes
11873   case " ${configdirs} " in
11874     *" binutils "*) ;;
11875     *) ok=no ;;
11876   esac
11877
11878   if test $ok = yes; then
11879     # An in-tree tool is available and we can use it
11880     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11881     echo "$as_me:$LINENO: result: just compiled" >&5
11882 echo "${ECHO_T}just compiled" >&6
11883   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11884     # We already found the complete path
11885     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11886     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11887 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11888   elif test "x$target" = "x$host"; then
11889     # We can use an host tool
11890     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11891     echo "$as_me:$LINENO: result: host tool" >&5
11892 echo "${ECHO_T}host tool" >&6
11893   else
11894     # We need a cross tool
11895     echo "$as_me:$LINENO: result: pre-installed" >&5
11896 echo "${ECHO_T}pre-installed" >&6
11897   fi
11898 fi
11899
11900 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11901 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11902 if test "x${build}" != "x${host}" ; then
11903   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11904     # We already found the complete path
11905     ac_dir=`dirname $GCC_FOR_TARGET`
11906     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11907 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11908   else
11909     # Canadian cross, just use what we found
11910     echo "$as_me:$LINENO: result: pre-installed" >&5
11911 echo "${ECHO_T}pre-installed" >&6
11912   fi
11913 else
11914   ok=yes
11915   case " ${configdirs} " in
11916     *" gcc "*) ;;
11917     *) ok=no ;;
11918   esac
11919
11920   if test $ok = yes; then
11921     # An in-tree tool is available and we can use it
11922     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11923     echo "$as_me:$LINENO: result: just compiled" >&5
11924 echo "${ECHO_T}just compiled" >&6
11925   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11926     # We already found the complete path
11927     ac_dir=`dirname $GCC_FOR_TARGET`
11928     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11929 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11930   elif test "x$target" = "x$host"; then
11931     # We can use an host tool
11932     GCC_FOR_TARGET='$()'
11933     echo "$as_me:$LINENO: result: host tool" >&5
11934 echo "${ECHO_T}host tool" >&6
11935   else
11936     # We need a cross tool
11937     echo "$as_me:$LINENO: result: pre-installed" >&5
11938 echo "${ECHO_T}pre-installed" >&6
11939   fi
11940 fi
11941
11942 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11943 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11944 if test "x${build}" != "x${host}" ; then
11945   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11946     # We already found the complete path
11947     ac_dir=`dirname $GCJ_FOR_TARGET`
11948     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11949 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11950   else
11951     # Canadian cross, just use what we found
11952     echo "$as_me:$LINENO: result: pre-installed" >&5
11953 echo "${ECHO_T}pre-installed" >&6
11954   fi
11955 else
11956   ok=yes
11957   case " ${configdirs} " in
11958     *" gcc "*) ;;
11959     *) ok=no ;;
11960   esac
11961   case ,${enable_languages}, in
11962     *,java,*) ;;
11963     *) ok=no ;;
11964   esac
11965   if test $ok = yes; then
11966     # An in-tree tool is available and we can use it
11967     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11968     echo "$as_me:$LINENO: result: just compiled" >&5
11969 echo "${ECHO_T}just compiled" >&6
11970   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11971     # We already found the complete path
11972     ac_dir=`dirname $GCJ_FOR_TARGET`
11973     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11974 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11975   elif test "x$target" = "x$host"; then
11976     # We can use an host tool
11977     GCJ_FOR_TARGET='$(GCJ)'
11978     echo "$as_me:$LINENO: result: host tool" >&5
11979 echo "${ECHO_T}host tool" >&6
11980   else
11981     # We need a cross tool
11982     echo "$as_me:$LINENO: result: pre-installed" >&5
11983 echo "${ECHO_T}pre-installed" >&6
11984   fi
11985 fi
11986
11987 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11988 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11989 if test "x${build}" != "x${host}" ; then
11990   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11991     # We already found the complete path
11992     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11993     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11994 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11995   else
11996     # Canadian cross, just use what we found
11997     echo "$as_me:$LINENO: result: pre-installed" >&5
11998 echo "${ECHO_T}pre-installed" >&6
11999   fi
12000 else
12001   ok=yes
12002   case " ${configdirs} " in
12003     *" gcc "*) ;;
12004     *) ok=no ;;
12005   esac
12006   case ,${enable_languages}, in
12007     *,fortran,*) ;;
12008     *) ok=no ;;
12009   esac
12010   if test $ok = yes; then
12011     # An in-tree tool is available and we can use it
12012     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12013     echo "$as_me:$LINENO: result: just compiled" >&5
12014 echo "${ECHO_T}just compiled" >&6
12015   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12016     # We already found the complete path
12017     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12018     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12019 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12020   elif test "x$target" = "x$host"; then
12021     # We can use an host tool
12022     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12023     echo "$as_me:$LINENO: result: host tool" >&5
12024 echo "${ECHO_T}host tool" >&6
12025   else
12026     # We need a cross tool
12027     echo "$as_me:$LINENO: result: pre-installed" >&5
12028 echo "${ECHO_T}pre-installed" >&6
12029   fi
12030 fi
12031
12032 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12033 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12034 if test "x${build}" != "x${host}" ; then
12035   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12036     # We already found the complete path
12037     ac_dir=`dirname $LD_FOR_TARGET`
12038     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12039 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12040   else
12041     # Canadian cross, just use what we found
12042     echo "$as_me:$LINENO: result: pre-installed" >&5
12043 echo "${ECHO_T}pre-installed" >&6
12044   fi
12045 else
12046   ok=yes
12047   case " ${configdirs} " in
12048     *" ld "*) ;;
12049     *) ok=no ;;
12050   esac
12051
12052   if test $ok = yes; then
12053     # An in-tree tool is available and we can use it
12054     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12055     echo "$as_me:$LINENO: result: just compiled" >&5
12056 echo "${ECHO_T}just compiled" >&6
12057   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12058     # We already found the complete path
12059     ac_dir=`dirname $LD_FOR_TARGET`
12060     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12061 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12062   elif test "x$target" = "x$host"; then
12063     # We can use an host tool
12064     LD_FOR_TARGET='$(LD)'
12065     echo "$as_me:$LINENO: result: host tool" >&5
12066 echo "${ECHO_T}host tool" >&6
12067   else
12068     # We need a cross tool
12069     echo "$as_me:$LINENO: result: pre-installed" >&5
12070 echo "${ECHO_T}pre-installed" >&6
12071   fi
12072 fi
12073
12074 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12075 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12076 if test "x${build}" != "x${host}" ; then
12077   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12078     # We already found the complete path
12079     ac_dir=`dirname $LIPO_FOR_TARGET`
12080     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12081 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12082   else
12083     # Canadian cross, just use what we found
12084     echo "$as_me:$LINENO: result: pre-installed" >&5
12085 echo "${ECHO_T}pre-installed" >&6
12086   fi
12087 else
12088   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12089     # We already found the complete path
12090     ac_dir=`dirname $LIPO_FOR_TARGET`
12091     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12092 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12093   elif test "x$target" = "x$host"; then
12094     # We can use an host tool
12095     LIPO_FOR_TARGET='$(LIPO)'
12096     echo "$as_me:$LINENO: result: host tool" >&5
12097 echo "${ECHO_T}host tool" >&6
12098   else
12099     # We need a cross tool
12100     echo "$as_me:$LINENO: result: pre-installed" >&5
12101 echo "${ECHO_T}pre-installed" >&6
12102   fi
12103 fi
12104
12105 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12106 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12107 if test "x${build}" != "x${host}" ; then
12108   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12109     # We already found the complete path
12110     ac_dir=`dirname $NM_FOR_TARGET`
12111     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12112 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12113   else
12114     # Canadian cross, just use what we found
12115     echo "$as_me:$LINENO: result: pre-installed" >&5
12116 echo "${ECHO_T}pre-installed" >&6
12117   fi
12118 else
12119   ok=yes
12120   case " ${configdirs} " in
12121     *" binutils "*) ;;
12122     *) ok=no ;;
12123   esac
12124
12125   if test $ok = yes; then
12126     # An in-tree tool is available and we can use it
12127     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12128     echo "$as_me:$LINENO: result: just compiled" >&5
12129 echo "${ECHO_T}just compiled" >&6
12130   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12131     # We already found the complete path
12132     ac_dir=`dirname $NM_FOR_TARGET`
12133     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12134 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12135   elif test "x$target" = "x$host"; then
12136     # We can use an host tool
12137     NM_FOR_TARGET='$(NM)'
12138     echo "$as_me:$LINENO: result: host tool" >&5
12139 echo "${ECHO_T}host tool" >&6
12140   else
12141     # We need a cross tool
12142     echo "$as_me:$LINENO: result: pre-installed" >&5
12143 echo "${ECHO_T}pre-installed" >&6
12144   fi
12145 fi
12146
12147 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12148 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12149 if test "x${build}" != "x${host}" ; then
12150   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12151     # We already found the complete path
12152     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12153     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12154 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12155   else
12156     # Canadian cross, just use what we found
12157     echo "$as_me:$LINENO: result: pre-installed" >&5
12158 echo "${ECHO_T}pre-installed" >&6
12159   fi
12160 else
12161   ok=yes
12162   case " ${configdirs} " in
12163     *" binutils "*) ;;
12164     *) ok=no ;;
12165   esac
12166
12167   if test $ok = yes; then
12168     # An in-tree tool is available and we can use it
12169     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12170     echo "$as_me:$LINENO: result: just compiled" >&5
12171 echo "${ECHO_T}just compiled" >&6
12172   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12173     # We already found the complete path
12174     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12175     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12176 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12177   elif test "x$target" = "x$host"; then
12178     # We can use an host tool
12179     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12180     echo "$as_me:$LINENO: result: host tool" >&5
12181 echo "${ECHO_T}host tool" >&6
12182   else
12183     # We need a cross tool
12184     echo "$as_me:$LINENO: result: pre-installed" >&5
12185 echo "${ECHO_T}pre-installed" >&6
12186   fi
12187 fi
12188
12189 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12190 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12191 if test "x${build}" != "x${host}" ; then
12192   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12193     # We already found the complete path
12194     ac_dir=`dirname $RANLIB_FOR_TARGET`
12195     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12196 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12197   else
12198     # Canadian cross, just use what we found
12199     echo "$as_me:$LINENO: result: pre-installed" >&5
12200 echo "${ECHO_T}pre-installed" >&6
12201   fi
12202 else
12203   ok=yes
12204   case " ${configdirs} " in
12205     *" binutils "*) ;;
12206     *) ok=no ;;
12207   esac
12208
12209   if test $ok = yes; then
12210     # An in-tree tool is available and we can use it
12211     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12212     echo "$as_me:$LINENO: result: just compiled" >&5
12213 echo "${ECHO_T}just compiled" >&6
12214   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12215     # We already found the complete path
12216     ac_dir=`dirname $RANLIB_FOR_TARGET`
12217     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12218 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12219   elif test "x$target" = "x$host"; then
12220     # We can use an host tool
12221     RANLIB_FOR_TARGET='$(RANLIB)'
12222     echo "$as_me:$LINENO: result: host tool" >&5
12223 echo "${ECHO_T}host tool" >&6
12224   else
12225     # We need a cross tool
12226     echo "$as_me:$LINENO: result: pre-installed" >&5
12227 echo "${ECHO_T}pre-installed" >&6
12228   fi
12229 fi
12230
12231 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12232 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12233 if test "x${build}" != "x${host}" ; then
12234   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12235     # We already found the complete path
12236     ac_dir=`dirname $STRIP_FOR_TARGET`
12237     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12238 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12239   else
12240     # Canadian cross, just use what we found
12241     echo "$as_me:$LINENO: result: pre-installed" >&5
12242 echo "${ECHO_T}pre-installed" >&6
12243   fi
12244 else
12245   ok=yes
12246   case " ${configdirs} " in
12247     *" binutils "*) ;;
12248     *) ok=no ;;
12249   esac
12250
12251   if test $ok = yes; then
12252     # An in-tree tool is available and we can use it
12253     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12254     echo "$as_me:$LINENO: result: just compiled" >&5
12255 echo "${ECHO_T}just compiled" >&6
12256   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12257     # We already found the complete path
12258     ac_dir=`dirname $STRIP_FOR_TARGET`
12259     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12260 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12261   elif test "x$target" = "x$host"; then
12262     # We can use an host tool
12263     STRIP_FOR_TARGET='$(STRIP)'
12264     echo "$as_me:$LINENO: result: host tool" >&5
12265 echo "${ECHO_T}host tool" >&6
12266   else
12267     # We need a cross tool
12268     echo "$as_me:$LINENO: result: pre-installed" >&5
12269 echo "${ECHO_T}pre-installed" >&6
12270   fi
12271 fi
12272
12273 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12274 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12275 if test "x${build}" != "x${host}" ; then
12276   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12277     # We already found the complete path
12278     ac_dir=`dirname $WINDRES_FOR_TARGET`
12279     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12280 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12281   else
12282     # Canadian cross, just use what we found
12283     echo "$as_me:$LINENO: result: pre-installed" >&5
12284 echo "${ECHO_T}pre-installed" >&6
12285   fi
12286 else
12287   ok=yes
12288   case " ${configdirs} " in
12289     *" binutils "*) ;;
12290     *) ok=no ;;
12291   esac
12292
12293   if test $ok = yes; then
12294     # An in-tree tool is available and we can use it
12295     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12296     echo "$as_me:$LINENO: result: just compiled" >&5
12297 echo "${ECHO_T}just compiled" >&6
12298   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12299     # We already found the complete path
12300     ac_dir=`dirname $WINDRES_FOR_TARGET`
12301     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12302 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12303   elif test "x$target" = "x$host"; then
12304     # We can use an host tool
12305     WINDRES_FOR_TARGET='$(WINDRES)'
12306     echo "$as_me:$LINENO: result: host tool" >&5
12307 echo "${ECHO_T}host tool" >&6
12308   else
12309     # We need a cross tool
12310     echo "$as_me:$LINENO: result: pre-installed" >&5
12311 echo "${ECHO_T}pre-installed" >&6
12312   fi
12313 fi
12314
12315 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12316 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12317 if test "x${build}" != "x${host}" ; then
12318   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12319     # We already found the complete path
12320     ac_dir=`dirname $WINDMC_FOR_TARGET`
12321     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12322 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12323   else
12324     # Canadian cross, just use what we found
12325     echo "$as_me:$LINENO: result: pre-installed" >&5
12326 echo "${ECHO_T}pre-installed" >&6
12327   fi
12328 else
12329   ok=yes
12330   case " ${configdirs} " in
12331     *" binutils "*) ;;
12332     *) ok=no ;;
12333   esac
12334
12335   if test $ok = yes; then
12336     # An in-tree tool is available and we can use it
12337     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12338     echo "$as_me:$LINENO: result: just compiled" >&5
12339 echo "${ECHO_T}just compiled" >&6
12340   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12341     # We already found the complete path
12342     ac_dir=`dirname $WINDMC_FOR_TARGET`
12343     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12344 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12345   elif test "x$target" = "x$host"; then
12346     # We can use an host tool
12347     WINDMC_FOR_TARGET='$(WINDMC)'
12348     echo "$as_me:$LINENO: result: host tool" >&5
12349 echo "${ECHO_T}host tool" >&6
12350   else
12351     # We need a cross tool
12352     echo "$as_me:$LINENO: result: pre-installed" >&5
12353 echo "${ECHO_T}pre-installed" >&6
12354   fi
12355 fi
12356
12357
12358
12359
12360
12361 # Certain tools may need extra flags.
12362 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12363 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12364 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12365
12366 # When building target libraries, except in a Canadian cross, we use
12367 # the same toolchain as the compiler we just built.
12368 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12369 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12370 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12371 if test $host = $build; then
12372   case " $configdirs " in
12373     *" gcc "*)
12374       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12375       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12376       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12377       ;;
12378   esac
12379 fi
12380
12381
12382
12383
12384
12385 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12386 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12387 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12388 if test "${enable_maintainer_mode+set}" = set; then
12389   enableval="$enable_maintainer_mode"
12390   USE_MAINTAINER_MODE=$enableval
12391 else
12392   USE_MAINTAINER_MODE=no
12393 fi;
12394 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12395 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12396
12397
12398 if test "$USE_MAINTAINER_MODE" = yes; then
12399   MAINTAINER_MODE_TRUE=
12400   MAINTAINER_MODE_FALSE='#'
12401 else
12402   MAINTAINER_MODE_TRUE='#'
12403   MAINTAINER_MODE_FALSE=
12404 fi
12405 MAINT=$MAINTAINER_MODE_TRUE
12406
12407 # ---------------------
12408 # GCC bootstrap support
12409 # ---------------------
12410
12411 # Stage specific cflags for build.
12412 stage1_cflags="-g"
12413 case $build in
12414   vax-*-*)
12415     case ${GCC} in
12416       yes) stage1_cflags="-g -Wa,-J" ;;
12417       *) stage1_cflags="-g -J" ;;
12418     esac ;;
12419 esac
12420
12421 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12422 if test "$GCC" = yes; then
12423   saved_CFLAGS="$CFLAGS"
12424
12425   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12426   CFLAGS="$CFLAGS -fkeep-inline-functions"
12427   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12428 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12429   cat >conftest.$ac_ext <<_ACEOF
12430 /* confdefs.h.  */
12431 _ACEOF
12432 cat confdefs.h >>conftest.$ac_ext
12433 cat >>conftest.$ac_ext <<_ACEOF
12434 /* end confdefs.h.  */
12435
12436 #if (__GNUC__ < 3) \
12437     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12438                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12439 #error http://gcc.gnu.org/PR29382
12440 #endif
12441
12442 int
12443 main ()
12444 {
12445
12446   ;
12447   return 0;
12448 }
12449 _ACEOF
12450 rm -f conftest.$ac_objext
12451 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12452   (eval $ac_compile) 2>conftest.er1
12453   ac_status=$?
12454   grep -v '^ *+' conftest.er1 >conftest.err
12455   rm -f conftest.er1
12456   cat conftest.err >&5
12457   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12458   (exit $ac_status); } &&
12459          { ac_try='test -z "$ac_c_werror_flag"
12460                          || test ! -s conftest.err'
12461   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12462   (eval $ac_try) 2>&5
12463   ac_status=$?
12464   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12465   (exit $ac_status); }; } &&
12466          { ac_try='test -s conftest.$ac_objext'
12467   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12468   (eval $ac_try) 2>&5
12469   ac_status=$?
12470   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12471   (exit $ac_status); }; }; then
12472   echo "$as_me:$LINENO: result: yes" >&5
12473 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12474 else
12475   echo "$as_me: failed program was:" >&5
12476 sed 's/^/| /' conftest.$ac_ext >&5
12477
12478 echo "$as_me:$LINENO: result: no" >&5
12479 echo "${ECHO_T}no" >&6
12480 fi
12481 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12482
12483   CFLAGS="$saved_CFLAGS"
12484 fi
12485
12486
12487
12488 # Enable --enable-checking in stage1 of the compiler.
12489 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12490 if test "${enable_stage1_checking+set}" = set; then
12491   enableval="$enable_stage1_checking"
12492   stage1_checking=--enable-checking=${enable_stage1_checking}
12493 else
12494   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12495   stage1_checking=--enable-checking=yes,types
12496 else
12497   stage1_checking=--enable-checking=$enable_checking,types
12498 fi
12499 fi;
12500
12501
12502 # Enable -Werror in bootstrap stage2 and later.
12503 # Check whether --enable-werror or --disable-werror was given.
12504 if test "${enable_werror+set}" = set; then
12505   enableval="$enable_werror"
12506
12507 else
12508   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12509   enable_werror=yes
12510 else
12511   enable_werror=no
12512 fi
12513 fi;
12514 case ${enable_werror} in
12515   yes) stage2_werror_flag="--enable-werror-always" ;;
12516   *) stage2_werror_flag="" ;;
12517 esac
12518
12519
12520 # Flags needed to enable html installing and building
12521
12522 # Check whether --with-datarootdir or --without-datarootdir was given.
12523 if test "${with_datarootdir+set}" = set; then
12524   withval="$with_datarootdir"
12525   datarootdir="\${prefix}/${withval}"
12526 else
12527   datarootdir="\${prefix}/share"
12528 fi;
12529
12530
12531 # Check whether --with-docdir or --without-docdir was given.
12532 if test "${with_docdir+set}" = set; then
12533   withval="$with_docdir"
12534   docdir="\${prefix}/${withval}"
12535 else
12536   docdir="\${datarootdir}/doc"
12537 fi;
12538
12539
12540 # Check whether --with-pdfdir or --without-pdfdir was given.
12541 if test "${with_pdfdir+set}" = set; then
12542   withval="$with_pdfdir"
12543   pdfdir="\${prefix}/${withval}"
12544 else
12545   pdfdir="\${docdir}"
12546 fi;
12547
12548
12549 # Check whether --with-htmldir or --without-htmldir was given.
12550 if test "${with_htmldir+set}" = set; then
12551   withval="$with_htmldir"
12552   htmldir="\${prefix}/${withval}"
12553 else
12554   htmldir="\${docdir}"
12555 fi;
12556
12557
12558
12559
12560
12561
12562           ac_config_files="$ac_config_files Makefile"
12563 cat >confcache <<\_ACEOF
12564 # This file is a shell script that caches the results of configure
12565 # tests run on this system so they can be shared between configure
12566 # scripts and configure runs, see configure's option --config-cache.
12567 # It is not useful on other systems.  If it contains results you don't
12568 # want to keep, you may remove or edit it.
12569 #
12570 # config.status only pays attention to the cache file if you give it
12571 # the --recheck option to rerun configure.
12572 #
12573 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12574 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12575 # following values.
12576
12577 _ACEOF
12578
12579 # The following way of writing the cache mishandles newlines in values,
12580 # but we know of no workaround that is simple, portable, and efficient.
12581 # So, don't put newlines in cache variables' values.
12582 # Ultrix sh set writes to stderr and can't be redirected directly,
12583 # and sets the high bit in the cache file unless we assign to the vars.
12584 {
12585   (set) 2>&1 |
12586     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12587     *ac_space=\ *)
12588       # `set' does not quote correctly, so add quotes (double-quote
12589       # substitution turns \\\\ into \\, and sed turns \\ into \).
12590       sed -n \
12591         "s/'/'\\\\''/g;
12592           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12593       ;;
12594     *)
12595       # `set' quotes correctly as required by POSIX, so do not add quotes.
12596       sed -n \
12597         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12598       ;;
12599     esac;
12600 } |
12601   sed '
12602      t clear
12603      : clear
12604      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12605      t end
12606      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12607      : end' >>confcache
12608 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12609   if test -w $cache_file; then
12610     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12611     cat confcache >$cache_file
12612   else
12613     echo "not updating unwritable cache $cache_file"
12614   fi
12615 fi
12616 rm -f confcache
12617
12618 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12619 # Let make expand exec_prefix.
12620 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12621
12622 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12623 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12624 # trailing colons and then remove the whole line if VPATH becomes empty
12625 # (actually we leave an empty line to preserve line numbers).
12626 if test "x$srcdir" = x.; then
12627   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12628 s/:*\$(srcdir):*/:/;
12629 s/:*\${srcdir}:*/:/;
12630 s/:*@srcdir@:*/:/;
12631 s/^\([^=]*=[     ]*\):*/\1/;
12632 s/:*$//;
12633 s/^[^=]*=[       ]*$//;
12634 }'
12635 fi
12636
12637 # Transform confdefs.h into DEFS.
12638 # Protect against shell expansion while executing Makefile rules.
12639 # Protect against Makefile macro expansion.
12640 #
12641 # If the first sed substitution is executed (which looks for macros that
12642 # take arguments), then we branch to the quote section.  Otherwise,
12643 # look for a macro that doesn't take arguments.
12644 cat >confdef2opt.sed <<\_ACEOF
12645 t clear
12646 : clear
12647 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12648 t quote
12649 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12650 t quote
12651 d
12652 : quote
12653 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12654 s,\[,\\&,g
12655 s,\],\\&,g
12656 s,\$,$$,g
12657 p
12658 _ACEOF
12659 # We use echo to avoid assuming a particular line-breaking character.
12660 # The extra dot is to prevent the shell from consuming trailing
12661 # line-breaks from the sub-command output.  A line-break within
12662 # single-quotes doesn't work because, if this script is created in a
12663 # platform that uses two characters for line-breaks (e.g., DOS), tr
12664 # would break.
12665 ac_LF_and_DOT=`echo; echo .`
12666 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12667 rm -f confdef2opt.sed
12668
12669
12670 ac_libobjs=
12671 ac_ltlibobjs=
12672 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12673   # 1. Remove the extension, and $U if already installed.
12674   ac_i=`echo "$ac_i" |
12675          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12676   # 2. Add them.
12677   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12678   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12679 done
12680 LIBOBJS=$ac_libobjs
12681
12682 LTLIBOBJS=$ac_ltlibobjs
12683
12684
12685
12686 : ${CONFIG_STATUS=./config.status}
12687 ac_clean_files_save=$ac_clean_files
12688 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12689 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12690 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12691 cat >$CONFIG_STATUS <<_ACEOF
12692 #! $SHELL
12693 # Generated by $as_me.
12694 # Run this file to recreate the current configuration.
12695 # Compiler output produced by configure, useful for debugging
12696 # configure, is in config.log if it exists.
12697
12698 debug=false
12699 ac_cs_recheck=false
12700 ac_cs_silent=false
12701 SHELL=\${CONFIG_SHELL-$SHELL}
12702 _ACEOF
12703
12704 cat >>$CONFIG_STATUS <<\_ACEOF
12705 ## --------------------- ##
12706 ## M4sh Initialization.  ##
12707 ## --------------------- ##
12708
12709 # Be Bourne compatible
12710 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12711   emulate sh
12712   NULLCMD=:
12713   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12714   # is contrary to our usage.  Disable this feature.
12715   alias -g '${1+"$@"}'='"$@"'
12716 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12717   set -o posix
12718 fi
12719 DUALCASE=1; export DUALCASE # for MKS sh
12720
12721 # Support unset when possible.
12722 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12723   as_unset=unset
12724 else
12725   as_unset=false
12726 fi
12727
12728
12729 # Work around bugs in pre-3.0 UWIN ksh.
12730 $as_unset ENV MAIL MAILPATH
12731 PS1='$ '
12732 PS2='> '
12733 PS4='+ '
12734
12735 # NLS nuisances.
12736 for as_var in \
12737   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12738   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12739   LC_TELEPHONE LC_TIME
12740 do
12741   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12742     eval $as_var=C; export $as_var
12743   else
12744     $as_unset $as_var
12745   fi
12746 done
12747
12748 # Required to use basename.
12749 if expr a : '\(a\)' >/dev/null 2>&1; then
12750   as_expr=expr
12751 else
12752   as_expr=false
12753 fi
12754
12755 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12756   as_basename=basename
12757 else
12758   as_basename=false
12759 fi
12760
12761
12762 # Name of the executable.
12763 as_me=`$as_basename "$0" ||
12764 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12765          X"$0" : 'X\(//\)$' \| \
12766          X"$0" : 'X\(/\)$' \| \
12767          .     : '\(.\)' 2>/dev/null ||
12768 echo X/"$0" |
12769     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12770           /^X\/\(\/\/\)$/{ s//\1/; q; }
12771           /^X\/\(\/\).*/{ s//\1/; q; }
12772           s/.*/./; q'`
12773
12774
12775 # PATH needs CR, and LINENO needs CR and PATH.
12776 # Avoid depending upon Character Ranges.
12777 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12778 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12779 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12780 as_cr_digits='0123456789'
12781 as_cr_alnum=$as_cr_Letters$as_cr_digits
12782
12783 # The user is always right.
12784 if test "${PATH_SEPARATOR+set}" != set; then
12785   echo "#! /bin/sh" >conf$$.sh
12786   echo  "exit 0"   >>conf$$.sh
12787   chmod +x conf$$.sh
12788   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12789     PATH_SEPARATOR=';'
12790   else
12791     PATH_SEPARATOR=:
12792   fi
12793   rm -f conf$$.sh
12794 fi
12795
12796
12797   as_lineno_1=$LINENO
12798   as_lineno_2=$LINENO
12799   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12800   test "x$as_lineno_1" != "x$as_lineno_2" &&
12801   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12802   # Find who we are.  Look in the path if we contain no path at all
12803   # relative or not.
12804   case $0 in
12805     *[\\/]* ) as_myself=$0 ;;
12806     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12807 for as_dir in $PATH
12808 do
12809   IFS=$as_save_IFS
12810   test -z "$as_dir" && as_dir=.
12811   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12812 done
12813
12814        ;;
12815   esac
12816   # We did not find ourselves, most probably we were run as `sh COMMAND'
12817   # in which case we are not to be found in the path.
12818   if test "x$as_myself" = x; then
12819     as_myself=$0
12820   fi
12821   if test ! -f "$as_myself"; then
12822     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12823 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12824    { (exit 1); exit 1; }; }
12825   fi
12826   case $CONFIG_SHELL in
12827   '')
12828     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12829 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12830 do
12831   IFS=$as_save_IFS
12832   test -z "$as_dir" && as_dir=.
12833   for as_base in sh bash ksh sh5; do
12834          case $as_dir in
12835          /*)
12836            if ("$as_dir/$as_base" -c '
12837   as_lineno_1=$LINENO
12838   as_lineno_2=$LINENO
12839   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12840   test "x$as_lineno_1" != "x$as_lineno_2" &&
12841   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12842              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12843              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12844              CONFIG_SHELL=$as_dir/$as_base
12845              export CONFIG_SHELL
12846              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12847            fi;;
12848          esac
12849        done
12850 done
12851 ;;
12852   esac
12853
12854   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12855   # uniformly replaced by the line number.  The first 'sed' inserts a
12856   # line-number line before each line; the second 'sed' does the real
12857   # work.  The second script uses 'N' to pair each line-number line
12858   # with the numbered line, and appends trailing '-' during
12859   # substitution so that $LINENO is not a special case at line end.
12860   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12861   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12862   sed '=' <$as_myself |
12863     sed '
12864       N
12865       s,$,-,
12866       : loop
12867       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12868       t loop
12869       s,-$,,
12870       s,^['$as_cr_digits']*\n,,
12871     ' >$as_me.lineno &&
12872   chmod +x $as_me.lineno ||
12873     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12874 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12875    { (exit 1); exit 1; }; }
12876
12877   # Don't try to exec as it changes $[0], causing all sort of problems
12878   # (the dirname of $[0] is not the place where we might find the
12879   # original and so on.  Autoconf is especially sensible to this).
12880   . ./$as_me.lineno
12881   # Exit status is that of the last command.
12882   exit
12883 }
12884
12885
12886 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12887   *c*,-n*) ECHO_N= ECHO_C='
12888 ' ECHO_T='      ' ;;
12889   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12890   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12891 esac
12892
12893 if expr a : '\(a\)' >/dev/null 2>&1; then
12894   as_expr=expr
12895 else
12896   as_expr=false
12897 fi
12898
12899 rm -f conf$$ conf$$.exe conf$$.file
12900 echo >conf$$.file
12901 if ln -s conf$$.file conf$$ 2>/dev/null; then
12902   # We could just check for DJGPP; but this test a) works b) is more generic
12903   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12904   if test -f conf$$.exe; then
12905     # Don't use ln at all; we don't have any links
12906     as_ln_s='cp -p'
12907   else
12908     as_ln_s='ln -s'
12909   fi
12910 elif ln conf$$.file conf$$ 2>/dev/null; then
12911   as_ln_s=ln
12912 else
12913   as_ln_s='cp -p'
12914 fi
12915 rm -f conf$$ conf$$.exe conf$$.file
12916
12917 if mkdir -p . 2>/dev/null; then
12918   as_mkdir_p=:
12919 else
12920   test -d ./-p && rmdir ./-p
12921   as_mkdir_p=false
12922 fi
12923
12924 as_executable_p="test -f"
12925
12926 # Sed expression to map a string onto a valid CPP name.
12927 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12928
12929 # Sed expression to map a string onto a valid variable name.
12930 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12931
12932
12933 # IFS
12934 # We need space, tab and new line, in precisely that order.
12935 as_nl='
12936 '
12937 IFS="   $as_nl"
12938
12939 # CDPATH.
12940 $as_unset CDPATH
12941
12942 exec 6>&1
12943
12944 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12945 # report actual input values of CONFIG_FILES etc. instead of their
12946 # values after options handling.  Logging --version etc. is OK.
12947 exec 5>>config.log
12948 {
12949   echo
12950   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12951 ## Running $as_me. ##
12952 _ASBOX
12953 } >&5
12954 cat >&5 <<_CSEOF
12955
12956 This file was extended by $as_me, which was
12957 generated by GNU Autoconf 2.59.  Invocation command line was
12958
12959   CONFIG_FILES    = $CONFIG_FILES
12960   CONFIG_HEADERS  = $CONFIG_HEADERS
12961   CONFIG_LINKS    = $CONFIG_LINKS
12962   CONFIG_COMMANDS = $CONFIG_COMMANDS
12963   $ $0 $@
12964
12965 _CSEOF
12966 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12967 echo >&5
12968 _ACEOF
12969
12970 # Files that config.status was made for.
12971 if test -n "$ac_config_files"; then
12972   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12973 fi
12974
12975 if test -n "$ac_config_headers"; then
12976   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12977 fi
12978
12979 if test -n "$ac_config_links"; then
12980   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12981 fi
12982
12983 if test -n "$ac_config_commands"; then
12984   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12985 fi
12986
12987 cat >>$CONFIG_STATUS <<\_ACEOF
12988
12989 ac_cs_usage="\
12990 \`$as_me' instantiates files from templates according to the
12991 current configuration.
12992
12993 Usage: $0 [OPTIONS] [FILE]...
12994
12995   -h, --help       print this help, then exit
12996   -V, --version    print version number, then exit
12997   -q, --quiet      do not print progress messages
12998   -d, --debug      don't remove temporary files
12999       --recheck    update $as_me by reconfiguring in the same conditions
13000   --file=FILE[:TEMPLATE]
13001                    instantiate the configuration file FILE
13002
13003 Configuration files:
13004 $config_files
13005
13006 Report bugs to <bug-autoconf@gnu.org>."
13007 _ACEOF
13008
13009 cat >>$CONFIG_STATUS <<_ACEOF
13010 ac_cs_version="\\
13011 config.status
13012 configured by $0, generated by GNU Autoconf 2.59,
13013   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13014
13015 Copyright (C) 2003 Free Software Foundation, Inc.
13016 This config.status script is free software; the Free Software Foundation
13017 gives unlimited permission to copy, distribute and modify it."
13018 srcdir=$srcdir
13019 INSTALL="$INSTALL"
13020 _ACEOF
13021
13022 cat >>$CONFIG_STATUS <<\_ACEOF
13023 # If no file are specified by the user, then we need to provide default
13024 # value.  By we need to know if files were specified by the user.
13025 ac_need_defaults=:
13026 while test $# != 0
13027 do
13028   case $1 in
13029   --*=*)
13030     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13031     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13032     ac_shift=:
13033     ;;
13034   -*)
13035     ac_option=$1
13036     ac_optarg=$2
13037     ac_shift=shift
13038     ;;
13039   *) # This is not an option, so the user has probably given explicit
13040      # arguments.
13041      ac_option=$1
13042      ac_need_defaults=false;;
13043   esac
13044
13045   case $ac_option in
13046   # Handling of the options.
13047 _ACEOF
13048 cat >>$CONFIG_STATUS <<\_ACEOF
13049   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13050     ac_cs_recheck=: ;;
13051   --version | --vers* | -V )
13052     echo "$ac_cs_version"; exit 0 ;;
13053   --he | --h)
13054     # Conflict between --help and --header
13055     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13056 Try \`$0 --help' for more information." >&5
13057 echo "$as_me: error: ambiguous option: $1
13058 Try \`$0 --help' for more information." >&2;}
13059    { (exit 1); exit 1; }; };;
13060   --help | --hel | -h )
13061     echo "$ac_cs_usage"; exit 0 ;;
13062   --debug | --d* | -d )
13063     debug=: ;;
13064   --file | --fil | --fi | --f )
13065     $ac_shift
13066     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13067     ac_need_defaults=false;;
13068   --header | --heade | --head | --hea )
13069     $ac_shift
13070     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13071     ac_need_defaults=false;;
13072   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13073   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13074     ac_cs_silent=: ;;
13075
13076   # This is an error.
13077   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13078 Try \`$0 --help' for more information." >&5
13079 echo "$as_me: error: unrecognized option: $1
13080 Try \`$0 --help' for more information." >&2;}
13081    { (exit 1); exit 1; }; } ;;
13082
13083   *) ac_config_targets="$ac_config_targets $1" ;;
13084
13085   esac
13086   shift
13087 done
13088
13089 ac_configure_extra_args=
13090
13091 if $ac_cs_silent; then
13092   exec 6>/dev/null
13093   ac_configure_extra_args="$ac_configure_extra_args --silent"
13094 fi
13095
13096 _ACEOF
13097 cat >>$CONFIG_STATUS <<_ACEOF
13098 if \$ac_cs_recheck; then
13099   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13100   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13101 fi
13102
13103 _ACEOF
13104
13105
13106
13107
13108
13109 cat >>$CONFIG_STATUS <<\_ACEOF
13110 for ac_config_target in $ac_config_targets
13111 do
13112   case "$ac_config_target" in
13113   # Handling of arguments.
13114   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13115   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13116 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13117    { (exit 1); exit 1; }; };;
13118   esac
13119 done
13120
13121 # If the user did not use the arguments to specify the items to instantiate,
13122 # then the envvar interface is used.  Set only those that are not.
13123 # We use the long form for the default assignment because of an extremely
13124 # bizarre bug on SunOS 4.1.3.
13125 if $ac_need_defaults; then
13126   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13127 fi
13128
13129 # Have a temporary directory for convenience.  Make it in the build tree
13130 # simply because there is no reason to put it here, and in addition,
13131 # creating and moving files from /tmp can sometimes cause problems.
13132 # Create a temporary directory, and hook for its removal unless debugging.
13133 $debug ||
13134 {
13135   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13136   trap '{ (exit 1); exit 1; }' 1 2 13 15
13137 }
13138
13139 # Create a (secure) tmp directory for tmp files.
13140
13141 {
13142   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13143   test -n "$tmp" && test -d "$tmp"
13144 }  ||
13145 {
13146   tmp=./confstat$$-$RANDOM
13147   (umask 077 && mkdir $tmp)
13148 } ||
13149 {
13150    echo "$me: cannot create a temporary directory in ." >&2
13151    { (exit 1); exit 1; }
13152 }
13153
13154 _ACEOF
13155
13156 cat >>$CONFIG_STATUS <<_ACEOF
13157
13158 #
13159 # CONFIG_FILES section.
13160 #
13161
13162 # No need to generate the scripts if there are no CONFIG_FILES.
13163 # This happens for instance when ./config.status config.h
13164 if test -n "\$CONFIG_FILES"; then
13165   # Protect against being on the right side of a sed subst in config.status.
13166   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13167    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13168 s,@SHELL@,$SHELL,;t t
13169 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13170 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13171 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13172 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13173 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13174 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13175 s,@exec_prefix@,$exec_prefix,;t t
13176 s,@prefix@,$prefix,;t t
13177 s,@program_transform_name@,$program_transform_name,;t t
13178 s,@bindir@,$bindir,;t t
13179 s,@sbindir@,$sbindir,;t t
13180 s,@libexecdir@,$libexecdir,;t t
13181 s,@datadir@,$datadir,;t t
13182 s,@sysconfdir@,$sysconfdir,;t t
13183 s,@sharedstatedir@,$sharedstatedir,;t t
13184 s,@localstatedir@,$localstatedir,;t t
13185 s,@libdir@,$libdir,;t t
13186 s,@includedir@,$includedir,;t t
13187 s,@oldincludedir@,$oldincludedir,;t t
13188 s,@infodir@,$infodir,;t t
13189 s,@mandir@,$mandir,;t t
13190 s,@build_alias@,$build_alias,;t t
13191 s,@host_alias@,$host_alias,;t t
13192 s,@target_alias@,$target_alias,;t t
13193 s,@DEFS@,$DEFS,;t t
13194 s,@ECHO_C@,$ECHO_C,;t t
13195 s,@ECHO_N@,$ECHO_N,;t t
13196 s,@ECHO_T@,$ECHO_T,;t t
13197 s,@LIBS@,$LIBS,;t t
13198 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13199 s,@build@,$build,;t t
13200 s,@build_cpu@,$build_cpu,;t t
13201 s,@build_vendor@,$build_vendor,;t t
13202 s,@build_os@,$build_os,;t t
13203 s,@build_noncanonical@,$build_noncanonical,;t t
13204 s,@host_noncanonical@,$host_noncanonical,;t t
13205 s,@target_noncanonical@,$target_noncanonical,;t t
13206 s,@host@,$host,;t t
13207 s,@host_cpu@,$host_cpu,;t t
13208 s,@host_vendor@,$host_vendor,;t t
13209 s,@host_os@,$host_os,;t t
13210 s,@target@,$target,;t t
13211 s,@target_cpu@,$target_cpu,;t t
13212 s,@target_vendor@,$target_vendor,;t t
13213 s,@target_os@,$target_os,;t t
13214 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13215 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13216 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13217 s,@LN@,$LN,;t t
13218 s,@LN_S@,$LN_S,;t t
13219 s,@build_libsubdir@,$build_libsubdir,;t t
13220 s,@build_subdir@,$build_subdir,;t t
13221 s,@host_subdir@,$host_subdir,;t t
13222 s,@target_subdir@,$target_subdir,;t t
13223 s,@CC@,$CC,;t t
13224 s,@CFLAGS@,$CFLAGS,;t t
13225 s,@LDFLAGS@,$LDFLAGS,;t t
13226 s,@CPPFLAGS@,$CPPFLAGS,;t t
13227 s,@ac_ct_CC@,$ac_ct_CC,;t t
13228 s,@EXEEXT@,$EXEEXT,;t t
13229 s,@OBJEXT@,$OBJEXT,;t t
13230 s,@CXX@,$CXX,;t t
13231 s,@CXXFLAGS@,$CXXFLAGS,;t t
13232 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13233 s,@GNATBIND@,$GNATBIND,;t t
13234 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13235 s,@GNATMAKE@,$GNATMAKE,;t t
13236 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13237 s,@do_compare@,$do_compare,;t t
13238 s,@gmplibs@,$gmplibs,;t t
13239 s,@gmpinc@,$gmpinc,;t t
13240 s,@ppllibs@,$ppllibs,;t t
13241 s,@pplinc@,$pplinc,;t t
13242 s,@clooglibs@,$clooglibs,;t t
13243 s,@clooginc@,$clooginc,;t t
13244 s,@stage1_languages@,$stage1_languages,;t t
13245 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13246 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13247 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13248 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13249 s,@CPPFLAGS_FOR_TARGET@,$CPPFLAGS_FOR_TARGET,;t t
13250 s,@LDFLAGS_FOR_TARGET@,$LDFLAGS_FOR_TARGET,;t t
13251 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13252 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13253 s,@tooldir@,$tooldir,;t t
13254 s,@build_tooldir@,$build_tooldir,;t t
13255 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13256 s,@GDB_TK@,$GDB_TK,;t t
13257 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13258 s,@build_configargs@,$build_configargs,;t t
13259 s,@build_configdirs@,$build_configdirs,;t t
13260 s,@host_configargs@,$host_configargs,;t t
13261 s,@configdirs@,$configdirs,;t t
13262 s,@target_configargs@,$target_configargs,;t t
13263 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13264 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13265 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13266 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13267 s,@CPPFLAGS_FOR_BUILD@,$CPPFLAGS_FOR_BUILD,;t t
13268 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13269 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13270 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13271 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13272 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13273 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13274 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13275 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13276 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13277 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13278 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13279 s,@config_shell@,$config_shell,;t t
13280 s,@YACC@,$YACC,;t t
13281 s,@BISON@,$BISON,;t t
13282 s,@M4@,$M4,;t t
13283 s,@LEX@,$LEX,;t t
13284 s,@FLEX@,$FLEX,;t t
13285 s,@MAKEINFO@,$MAKEINFO,;t t
13286 s,@EXPECT@,$EXPECT,;t t
13287 s,@RUNTEST@,$RUNTEST,;t t
13288 s,@AR@,$AR,;t t
13289 s,@AS@,$AS,;t t
13290 s,@DLLTOOL@,$DLLTOOL,;t t
13291 s,@LD@,$LD,;t t
13292 s,@LIPO@,$LIPO,;t t
13293 s,@NM@,$NM,;t t
13294 s,@RANLIB@,$RANLIB,;t t
13295 s,@STRIP@,$STRIP,;t t
13296 s,@WINDRES@,$WINDRES,;t t
13297 s,@WINDMC@,$WINDMC,;t t
13298 s,@OBJCOPY@,$OBJCOPY,;t t
13299 s,@OBJDUMP@,$OBJDUMP,;t t
13300 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13301 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13302 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13303 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13304 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13305 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13306 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13307 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13308 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13309 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13310 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13311 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13312 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13313 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13314 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13315 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13316 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13317 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13318 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13319 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13320 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13321 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13322 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13323 s,@MAINT@,$MAINT,;t t
13324 s,@stage1_cflags@,$stage1_cflags,;t t
13325 s,@stage1_checking@,$stage1_checking,;t t
13326 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13327 s,@datarootdir@,$datarootdir,;t t
13328 s,@docdir@,$docdir,;t t
13329 s,@pdfdir@,$pdfdir,;t t
13330 s,@htmldir@,$htmldir,;t t
13331 s,@LIBOBJS@,$LIBOBJS,;t t
13332 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13333 /@serialization_dependencies@/r $serialization_dependencies
13334 s,@serialization_dependencies@,,;t t
13335 /@host_makefile_frag@/r $host_makefile_frag
13336 s,@host_makefile_frag@,,;t t
13337 /@target_makefile_frag@/r $target_makefile_frag
13338 s,@target_makefile_frag@,,;t t
13339 /@alphaieee_frag@/r $alphaieee_frag
13340 s,@alphaieee_frag@,,;t t
13341 /@ospace_frag@/r $ospace_frag
13342 s,@ospace_frag@,,;t t
13343 CEOF
13344
13345 _ACEOF
13346
13347   cat >>$CONFIG_STATUS <<\_ACEOF
13348   # Split the substitutions into bite-sized pieces for seds with
13349   # small command number limits, like on Digital OSF/1 and HP-UX.
13350   ac_max_sed_lines=48
13351   ac_sed_frag=1 # Number of current file.
13352   ac_beg=1 # First line for current file.
13353   ac_end=$ac_max_sed_lines # Line after last line for current file.
13354   ac_more_lines=:
13355   ac_sed_cmds=
13356   while $ac_more_lines; do
13357     if test $ac_beg -gt 1; then
13358       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13359     else
13360       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13361     fi
13362     if test ! -s $tmp/subs.frag; then
13363       ac_more_lines=false
13364     else
13365       # The purpose of the label and of the branching condition is to
13366       # speed up the sed processing (if there are no `@' at all, there
13367       # is no need to browse any of the substitutions).
13368       # These are the two extra sed commands mentioned above.
13369       (echo ':t
13370   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13371       if test -z "$ac_sed_cmds"; then
13372         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13373       else
13374         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13375       fi
13376       ac_sed_frag=`expr $ac_sed_frag + 1`
13377       ac_beg=$ac_end
13378       ac_end=`expr $ac_end + $ac_max_sed_lines`
13379     fi
13380   done
13381   if test -z "$ac_sed_cmds"; then
13382     ac_sed_cmds=cat
13383   fi
13384 fi # test -n "$CONFIG_FILES"
13385
13386 _ACEOF
13387 cat >>$CONFIG_STATUS <<\_ACEOF
13388 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13389   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13390   case $ac_file in
13391   - | *:- | *:-:* ) # input from stdin
13392         cat >$tmp/stdin
13393         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13394         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13395   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13396         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13397   * )   ac_file_in=$ac_file.in ;;
13398   esac
13399
13400   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13401   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13402 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13403          X"$ac_file" : 'X\(//\)[^/]' \| \
13404          X"$ac_file" : 'X\(//\)$' \| \
13405          X"$ac_file" : 'X\(/\)' \| \
13406          .     : '\(.\)' 2>/dev/null ||
13407 echo X"$ac_file" |
13408     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13409           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13410           /^X\(\/\/\)$/{ s//\1/; q; }
13411           /^X\(\/\).*/{ s//\1/; q; }
13412           s/.*/./; q'`
13413   { if $as_mkdir_p; then
13414     mkdir -p "$ac_dir"
13415   else
13416     as_dir="$ac_dir"
13417     as_dirs=
13418     while test ! -d "$as_dir"; do
13419       as_dirs="$as_dir $as_dirs"
13420       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13421 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13422          X"$as_dir" : 'X\(//\)[^/]' \| \
13423          X"$as_dir" : 'X\(//\)$' \| \
13424          X"$as_dir" : 'X\(/\)' \| \
13425          .     : '\(.\)' 2>/dev/null ||
13426 echo X"$as_dir" |
13427     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13428           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13429           /^X\(\/\/\)$/{ s//\1/; q; }
13430           /^X\(\/\).*/{ s//\1/; q; }
13431           s/.*/./; q'`
13432     done
13433     test ! -n "$as_dirs" || mkdir $as_dirs
13434   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13435 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13436    { (exit 1); exit 1; }; }; }
13437
13438   ac_builddir=.
13439
13440 if test "$ac_dir" != .; then
13441   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13442   # A "../" for each directory in $ac_dir_suffix.
13443   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13444 else
13445   ac_dir_suffix= ac_top_builddir=
13446 fi
13447
13448 case $srcdir in
13449   .)  # No --srcdir option.  We are building in place.
13450     ac_srcdir=.
13451     if test -z "$ac_top_builddir"; then
13452        ac_top_srcdir=.
13453     else
13454        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13455     fi ;;
13456   [\\/]* | ?:[\\/]* )  # Absolute path.
13457     ac_srcdir=$srcdir$ac_dir_suffix;
13458     ac_top_srcdir=$srcdir ;;
13459   *) # Relative path.
13460     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13461     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13462 esac
13463
13464 # Do not use `cd foo && pwd` to compute absolute paths, because
13465 # the directories may not exist.
13466 case `pwd` in
13467 .) ac_abs_builddir="$ac_dir";;
13468 *)
13469   case "$ac_dir" in
13470   .) ac_abs_builddir=`pwd`;;
13471   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13472   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13473   esac;;
13474 esac
13475 case $ac_abs_builddir in
13476 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13477 *)
13478   case ${ac_top_builddir}. in
13479   .) ac_abs_top_builddir=$ac_abs_builddir;;
13480   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13481   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13482   esac;;
13483 esac
13484 case $ac_abs_builddir in
13485 .) ac_abs_srcdir=$ac_srcdir;;
13486 *)
13487   case $ac_srcdir in
13488   .) ac_abs_srcdir=$ac_abs_builddir;;
13489   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13490   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13491   esac;;
13492 esac
13493 case $ac_abs_builddir in
13494 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13495 *)
13496   case $ac_top_srcdir in
13497   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13498   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13499   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13500   esac;;
13501 esac
13502
13503
13504   case $INSTALL in
13505   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13506   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13507   esac
13508
13509   if test x"$ac_file" != x-; then
13510     { echo "$as_me:$LINENO: creating $ac_file" >&5
13511 echo "$as_me: creating $ac_file" >&6;}
13512     rm -f "$ac_file"
13513   fi
13514   # Let's still pretend it is `configure' which instantiates (i.e., don't
13515   # use $as_me), people would be surprised to read:
13516   #    /* config.h.  Generated by config.status.  */
13517   if test x"$ac_file" = x-; then
13518     configure_input=
13519   else
13520     configure_input="$ac_file.  "
13521   fi
13522   configure_input=$configure_input"Generated from `echo $ac_file_in |
13523                                      sed 's,.*/,,'` by configure."
13524
13525   # First look for the input files in the build tree, otherwise in the
13526   # src tree.
13527   ac_file_inputs=`IFS=:
13528     for f in $ac_file_in; do
13529       case $f in
13530       -) echo $tmp/stdin ;;
13531       [\\/$]*)
13532          # Absolute (can't be DOS-style, as IFS=:)
13533          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13534 echo "$as_me: error: cannot find input file: $f" >&2;}
13535    { (exit 1); exit 1; }; }
13536          echo "$f";;
13537       *) # Relative
13538          if test -f "$f"; then
13539            # Build tree
13540            echo "$f"
13541          elif test -f "$srcdir/$f"; then
13542            # Source tree
13543            echo "$srcdir/$f"
13544          else
13545            # /dev/null tree
13546            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13547 echo "$as_me: error: cannot find input file: $f" >&2;}
13548    { (exit 1); exit 1; }; }
13549          fi;;
13550       esac
13551     done` || { (exit 1); exit 1; }
13552 _ACEOF
13553 cat >>$CONFIG_STATUS <<_ACEOF
13554   sed "$ac_vpsub
13555 $extrasub
13556 _ACEOF
13557 cat >>$CONFIG_STATUS <<\_ACEOF
13558 :t
13559 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13560 s,@configure_input@,$configure_input,;t t
13561 s,@srcdir@,$ac_srcdir,;t t
13562 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13563 s,@top_srcdir@,$ac_top_srcdir,;t t
13564 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13565 s,@builddir@,$ac_builddir,;t t
13566 s,@abs_builddir@,$ac_abs_builddir,;t t
13567 s,@top_builddir@,$ac_top_builddir,;t t
13568 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13569 s,@INSTALL@,$ac_INSTALL,;t t
13570 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13571   rm -f $tmp/stdin
13572   if test x"$ac_file" != x-; then
13573     mv $tmp/out $ac_file
13574   else
13575     cat $tmp/out
13576     rm -f $tmp/out
13577   fi
13578
13579 done
13580 _ACEOF
13581
13582 cat >>$CONFIG_STATUS <<\_ACEOF
13583
13584 { (exit 0); exit 0; }
13585 _ACEOF
13586 chmod +x $CONFIG_STATUS
13587 ac_clean_files=$ac_clean_files_save
13588
13589
13590 # configure is writing to config.log, and then calls config.status.
13591 # config.status does its own redirection, appending to config.log.
13592 # Unfortunately, on DOS this fails, as config.log is still kept open
13593 # by configure, so config.status won't be able to write to it; its
13594 # output is simply discarded.  So we exec the FD to /dev/null,
13595 # effectively closing config.log, so it can be properly (re)opened and
13596 # appended to by config.status.  When coming back to configure, we
13597 # need to make the FD available again.
13598 if test "$no_create" != yes; then
13599   ac_cs_success=:
13600   ac_config_status_args=
13601   test "$silent" = yes &&
13602     ac_config_status_args="$ac_config_status_args --quiet"
13603   exec 5>/dev/null
13604   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13605   exec 5>>config.log
13606   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13607   # would make configure fail if this is the last instruction.
13608   $ac_cs_success || { (exit 1); exit 1; }
13609 fi
13610