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     skipdirs="target-libssp"
2660     ;;
2661   v810-*-*)
2662     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2663     ;;
2664   v850-*-*)
2665     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2666     ;;
2667   v850e-*-*)
2668     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2669     ;;
2670   v850ea-*-*)
2671     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2672     ;;
2673   vax-*-vms)
2674     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2675     ;;
2676   vax-*-*)
2677     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2678     ;;
2679   xtensa*-*-*)
2680     noconfigdirs="$noconfigdirs ${libgcj}"
2681     ;;
2682   ip2k-*-*)
2683     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2684     ;;
2685   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2686     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2687     ;;
2688   *-*-lynxos*)
2689     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2690     ;;
2691   *-*-*)
2692     noconfigdirs="$noconfigdirs ${libgcj}"
2693     ;;
2694 esac
2695
2696 # If we aren't building newlib, then don't build libgloss, since libgloss
2697 # depends upon some newlib header files.
2698 case "${noconfigdirs}" in
2699   *target-libgloss*) ;;
2700   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2701 esac
2702
2703 # Work in distributions that contain no compiler tools, like Autoconf.
2704 tentative_cc=""
2705 host_makefile_frag=/dev/null
2706 if test -d ${srcdir}/config ; then
2707 case "${host}" in
2708   m68k-hp-hpux*)
2709     # Avoid "too much defining" errors from HPUX compiler.
2710     tentative_cc="cc -Wp,-H256000"
2711     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2712     # If it's HP/UX ar, this should be harmless.
2713     RANLIB="ar ts"
2714     ;;
2715   m68k-apollo-sysv*)
2716     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2717     ;;
2718   m68k-apollo-bsd*)
2719     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2720     # chokes on bfd, the compiler won't let you assign integers to enums, and
2721     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2722     # the apollo compiler" (the preferred version of GCC could be called cc,
2723     # or whatever), but I'm not sure leaving CC as cc is any better...
2724     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2725     # Used to have BISON=yacc.
2726     tentative_cc=gcc
2727     ;;
2728   m88k-dg-dgux*)
2729     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2730     ;;
2731   m88k-harris-cxux*)
2732     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2733     tentative_cc="cc -Xa"
2734     host_makefile_frag="config/mh-cxux"
2735     ;;
2736   m88k-motorola-sysv*)
2737     ;;
2738   mips*-dec-ultrix*)
2739     tentative_cc="cc -Wf,-XNg1000"
2740     host_makefile_frag="config/mh-decstation"
2741     ;;
2742   mips*-nec-sysv4*)
2743     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2744     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2745     host_makefile_frag="config/mh-necv4"
2746     ;;
2747   mips*-sgi-irix4*)
2748     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2749     # environment.  Also bump switch table size so that cp-parse will
2750     # compile.  Bump string length limit so linker builds.
2751     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2752     ;;
2753   mips*-*-sysv4*)
2754     host_makefile_frag="config/mh-sysv4"
2755     ;;
2756   mips*-*-sysv*)
2757     # This is for a MIPS running RISC/os 4.52C.
2758
2759     # This is needed for GDB, but needs to be in the top-level make because
2760     # if a library is compiled with the bsd headers and gets linked with the
2761     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2762     # a different size).
2763     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2764     # known except to select the sysv environment.  Could we use /proc instead?
2765     # These "sysv environments" and "bsd environments" often end up being a pain.
2766     #
2767     # This is not part of CFLAGS because perhaps not all C compilers have this
2768     # option.
2769     tentative_cc="cc -systype sysv"
2770     ;;
2771   i370-ibm-opened*)
2772     tentative_cc="c89"
2773     ;;
2774   i[3456789]86-*-sysv5*)
2775     host_makefile_frag="config/mh-sysv5"
2776     ;;
2777   i[3456789]86-*-dgux*)
2778     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2779     host_makefile_frag="config/mh-dgux386"
2780     ;;
2781   i[3456789]86-ncr-sysv4.3*)
2782     # The MetaWare compiler will generate a copyright message unless you
2783     # turn it off by adding the -Hnocopyr flag.
2784     tentative_cc="cc -Hnocopyr"
2785     ;;
2786   i[3456789]86-ncr-sysv4*)
2787     # for an NCR 3000 (i486/SVR4) system.
2788     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2789     # This compiler not only emits obnoxious copyright messages every time
2790     # you run it, but it chokes and dies on a whole bunch of GNU source
2791     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2792     tentative_cc="/usr/ccs/ATT/cc"
2793     host_makefile_frag="config/mh-ncr3000"
2794     ;;
2795   i[3456789]86-*-sco3.2v5*)
2796     ;;
2797   i[3456789]86-*-sco*)
2798     # The native C compiler botches some simple uses of const.  Unfortunately,
2799     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2800     tentative_cc="cc -Dconst="
2801     host_makefile_frag="config/mh-sco"
2802     ;;
2803   i[3456789]86-*-udk*)
2804     host_makefile_frag="config/mh-sysv5"
2805     ;;
2806   i[3456789]86-*-solaris2*)
2807     host_makefile_frag="config/mh-sysv4"
2808     ;;
2809   i[3456789]86-*-msdosdjgpp*)
2810     host_makefile_frag="config/mh-djgpp"
2811     ;;
2812   *-cygwin*)
2813
2814 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2815 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2816 echo a >cygwin-cat-check
2817 if test `cat cygwin-cat-check` == a ; then
2818   rm cygwin-cat-check
2819   echo "$as_me:$LINENO: result: yes" >&5
2820 echo "${ECHO_T}yes" >&6
2821 else
2822   rm cygwin-cat-check
2823   echo "$as_me:$LINENO: result: no" >&5
2824 echo "${ECHO_T}no" >&6
2825   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2826   Please either mount the build directory in binary mode or run the following
2827   commands before running any configure script:
2828 set -o igncr
2829 export SHELLOPTS
2830   " >&5
2831 echo "$as_me: error: The cat command does not ignore carriage return characters.
2832   Please either mount the build directory in binary mode or run the following
2833   commands before running any configure script:
2834 set -o igncr
2835 export SHELLOPTS
2836   " >&2;}
2837    { (exit 1); exit 1; }; }
2838 fi
2839
2840     host_makefile_frag="config/mh-cygwin"
2841     ;;
2842   *-mingw*)
2843     host_makefile_frag="config/mh-mingw"
2844     ;;
2845   *-interix*)
2846     host_makefile_frag="config/mh-interix"
2847     ;;
2848   vax-*-ultrix2*)
2849     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2850     tentative_cc=gcc
2851     ;;
2852   *-*-solaris2*)
2853     host_makefile_frag="config/mh-solaris"
2854     ;;
2855   m68k-sun-sunos*)
2856     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2857     # without overflowing the jump tables (-J says to use a 32 bit table)
2858     tentative_cc="cc -J"
2859     ;;
2860   hppa*-hp-hpux10*)
2861     tentative_cc="cc -Wp,-H256000"
2862     host_makefile_frag="config/mh-pa-hpux10"
2863     ;;
2864   hppa*-hp-hpux* | hppa*-*-hiux*)
2865     tentative_cc="cc -Wp,-H256000"
2866     host_makefile_frag="config/mh-pa"
2867     ;;
2868   hppa*-*)
2869     host_makefile_frag="config/mh-pa"
2870     ;;
2871   *-hp-hpux* | *-*-hiux*)
2872     tentative_cc="cc -Wp,-H256000"
2873     ;;
2874   rs6000-*-lynxos*)
2875     # /bin/cc is less than useful for our purposes.  Always use GCC
2876     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2877     host_makefile_frag="config/mh-lynxrs6k"
2878     ;;
2879   powerpc-*-darwin*)
2880     host_makefile_frag="config/mh-ppc-darwin"
2881     ;;
2882   powerpc-*-aix*)
2883     host_makefile_frag="config/mh-ppc-aix"
2884     ;;
2885   rs6000-*-aix*)
2886     host_makefile_frag="config/mh-ppc-aix"
2887     ;;
2888   *-*-lynxos*)
2889     # /bin/cc is less than useful for our purposes.  Always use GCC
2890     tentative_cc="/bin/gcc"
2891     ;;
2892   *-*-sysv4*)
2893     host_makefile_frag="config/mh-sysv4"
2894     ;;
2895   # This is placed last to prevent interfering with the cases above.
2896   i[3456789]86-*-*)
2897     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2898     host_makefile_frag="config/mh-x86omitfp"
2899     ;;
2900 esac
2901 fi
2902
2903 # If we aren't going to be using gcc, see if we can extract a definition
2904 # of CC from the fragment.
2905 # Actually, use the 'pre-extracted' version above.
2906 if test -z "${CC}" && test "${build}" = "${host}" ; then
2907   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2908   found=
2909   for dir in $PATH; do
2910     test -z "$dir" && dir=.
2911     if test -f $dir/gcc; then
2912       found=yes
2913       break
2914     fi
2915   done
2916   IFS="$save_ifs"
2917   if test -z "${found}" && test -n "${tentative_cc}" ; then
2918     CC=$tentative_cc
2919   fi
2920 fi
2921
2922 if test "${build}" != "${host}" ; then
2923   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2924   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2925   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2926   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2927   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2928   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2929   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2930   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2931   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2932   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2933   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2934   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2935 else
2936   AR_FOR_BUILD="\$(AR)"
2937   AS_FOR_BUILD="\$(AS)"
2938   CC_FOR_BUILD="\$(CC)"
2939   CXX_FOR_BUILD="\$(CXX)"
2940   GCJ_FOR_BUILD="\$(GCJ)"
2941   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2942   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2943   LD_FOR_BUILD="\$(LD)"
2944   NM_FOR_BUILD="\$(NM)"
2945   RANLIB_FOR_BUILD="\$(RANLIB)"
2946   WINDRES_FOR_BUILD="\$(WINDRES)"
2947   WINDMC_FOR_BUILD="\$(WINDMC)"
2948 fi
2949
2950 ac_ext=c
2951 ac_cpp='$CPP $CPPFLAGS'
2952 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2953 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2954 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2955 if test -n "$ac_tool_prefix"; then
2956   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2957 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2958 echo "$as_me:$LINENO: checking for $ac_word" >&5
2959 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2960 if test "${ac_cv_prog_CC+set}" = set; then
2961   echo $ECHO_N "(cached) $ECHO_C" >&6
2962 else
2963   if test -n "$CC"; then
2964   ac_cv_prog_CC="$CC" # Let the user override the test.
2965 else
2966 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2967 for as_dir in $PATH
2968 do
2969   IFS=$as_save_IFS
2970   test -z "$as_dir" && as_dir=.
2971   for ac_exec_ext in '' $ac_executable_extensions; do
2972   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2973     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2974     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2975     break 2
2976   fi
2977 done
2978 done
2979
2980 fi
2981 fi
2982 CC=$ac_cv_prog_CC
2983 if test -n "$CC"; then
2984   echo "$as_me:$LINENO: result: $CC" >&5
2985 echo "${ECHO_T}$CC" >&6
2986 else
2987   echo "$as_me:$LINENO: result: no" >&5
2988 echo "${ECHO_T}no" >&6
2989 fi
2990
2991 fi
2992 if test -z "$ac_cv_prog_CC"; then
2993   ac_ct_CC=$CC
2994   # Extract the first word of "gcc", so it can be a program name with args.
2995 set dummy gcc; ac_word=$2
2996 echo "$as_me:$LINENO: checking for $ac_word" >&5
2997 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2998 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2999   echo $ECHO_N "(cached) $ECHO_C" >&6
3000 else
3001   if test -n "$ac_ct_CC"; then
3002   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3003 else
3004 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3005 for as_dir in $PATH
3006 do
3007   IFS=$as_save_IFS
3008   test -z "$as_dir" && as_dir=.
3009   for ac_exec_ext in '' $ac_executable_extensions; do
3010   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3011     ac_cv_prog_ac_ct_CC="gcc"
3012     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3013     break 2
3014   fi
3015 done
3016 done
3017
3018 fi
3019 fi
3020 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3021 if test -n "$ac_ct_CC"; then
3022   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3023 echo "${ECHO_T}$ac_ct_CC" >&6
3024 else
3025   echo "$as_me:$LINENO: result: no" >&5
3026 echo "${ECHO_T}no" >&6
3027 fi
3028
3029   CC=$ac_ct_CC
3030 else
3031   CC="$ac_cv_prog_CC"
3032 fi
3033
3034 if test -z "$CC"; then
3035   if test -n "$ac_tool_prefix"; then
3036   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3037 set dummy ${ac_tool_prefix}cc; ac_word=$2
3038 echo "$as_me:$LINENO: checking for $ac_word" >&5
3039 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3040 if test "${ac_cv_prog_CC+set}" = set; then
3041   echo $ECHO_N "(cached) $ECHO_C" >&6
3042 else
3043   if test -n "$CC"; then
3044   ac_cv_prog_CC="$CC" # Let the user override the test.
3045 else
3046 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3047 for as_dir in $PATH
3048 do
3049   IFS=$as_save_IFS
3050   test -z "$as_dir" && as_dir=.
3051   for ac_exec_ext in '' $ac_executable_extensions; do
3052   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3053     ac_cv_prog_CC="${ac_tool_prefix}cc"
3054     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3055     break 2
3056   fi
3057 done
3058 done
3059
3060 fi
3061 fi
3062 CC=$ac_cv_prog_CC
3063 if test -n "$CC"; then
3064   echo "$as_me:$LINENO: result: $CC" >&5
3065 echo "${ECHO_T}$CC" >&6
3066 else
3067   echo "$as_me:$LINENO: result: no" >&5
3068 echo "${ECHO_T}no" >&6
3069 fi
3070
3071 fi
3072 if test -z "$ac_cv_prog_CC"; then
3073   ac_ct_CC=$CC
3074   # Extract the first word of "cc", so it can be a program name with args.
3075 set dummy cc; ac_word=$2
3076 echo "$as_me:$LINENO: checking for $ac_word" >&5
3077 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3078 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3079   echo $ECHO_N "(cached) $ECHO_C" >&6
3080 else
3081   if test -n "$ac_ct_CC"; then
3082   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3083 else
3084 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3085 for as_dir in $PATH
3086 do
3087   IFS=$as_save_IFS
3088   test -z "$as_dir" && as_dir=.
3089   for ac_exec_ext in '' $ac_executable_extensions; do
3090   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3091     ac_cv_prog_ac_ct_CC="cc"
3092     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3093     break 2
3094   fi
3095 done
3096 done
3097
3098 fi
3099 fi
3100 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3101 if test -n "$ac_ct_CC"; then
3102   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3103 echo "${ECHO_T}$ac_ct_CC" >&6
3104 else
3105   echo "$as_me:$LINENO: result: no" >&5
3106 echo "${ECHO_T}no" >&6
3107 fi
3108
3109   CC=$ac_ct_CC
3110 else
3111   CC="$ac_cv_prog_CC"
3112 fi
3113
3114 fi
3115 if test -z "$CC"; then
3116   # Extract the first word of "cc", so it can be a program name with args.
3117 set dummy cc; ac_word=$2
3118 echo "$as_me:$LINENO: checking for $ac_word" >&5
3119 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3120 if test "${ac_cv_prog_CC+set}" = set; then
3121   echo $ECHO_N "(cached) $ECHO_C" >&6
3122 else
3123   if test -n "$CC"; then
3124   ac_cv_prog_CC="$CC" # Let the user override the test.
3125 else
3126   ac_prog_rejected=no
3127 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3128 for as_dir in $PATH
3129 do
3130   IFS=$as_save_IFS
3131   test -z "$as_dir" && as_dir=.
3132   for ac_exec_ext in '' $ac_executable_extensions; do
3133   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3134     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3135        ac_prog_rejected=yes
3136        continue
3137      fi
3138     ac_cv_prog_CC="cc"
3139     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3140     break 2
3141   fi
3142 done
3143 done
3144
3145 if test $ac_prog_rejected = yes; then
3146   # We found a bogon in the path, so make sure we never use it.
3147   set dummy $ac_cv_prog_CC
3148   shift
3149   if test $# != 0; then
3150     # We chose a different compiler from the bogus one.
3151     # However, it has the same basename, so the bogon will be chosen
3152     # first if we set CC to just the basename; use the full file name.
3153     shift
3154     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3155   fi
3156 fi
3157 fi
3158 fi
3159 CC=$ac_cv_prog_CC
3160 if test -n "$CC"; then
3161   echo "$as_me:$LINENO: result: $CC" >&5
3162 echo "${ECHO_T}$CC" >&6
3163 else
3164   echo "$as_me:$LINENO: result: no" >&5
3165 echo "${ECHO_T}no" >&6
3166 fi
3167
3168 fi
3169 if test -z "$CC"; then
3170   if test -n "$ac_tool_prefix"; then
3171   for ac_prog in cl
3172   do
3173     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3174 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3175 echo "$as_me:$LINENO: checking for $ac_word" >&5
3176 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3177 if test "${ac_cv_prog_CC+set}" = set; then
3178   echo $ECHO_N "(cached) $ECHO_C" >&6
3179 else
3180   if test -n "$CC"; then
3181   ac_cv_prog_CC="$CC" # Let the user override the test.
3182 else
3183 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3184 for as_dir in $PATH
3185 do
3186   IFS=$as_save_IFS
3187   test -z "$as_dir" && as_dir=.
3188   for ac_exec_ext in '' $ac_executable_extensions; do
3189   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3190     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3191     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3192     break 2
3193   fi
3194 done
3195 done
3196
3197 fi
3198 fi
3199 CC=$ac_cv_prog_CC
3200 if test -n "$CC"; then
3201   echo "$as_me:$LINENO: result: $CC" >&5
3202 echo "${ECHO_T}$CC" >&6
3203 else
3204   echo "$as_me:$LINENO: result: no" >&5
3205 echo "${ECHO_T}no" >&6
3206 fi
3207
3208     test -n "$CC" && break
3209   done
3210 fi
3211 if test -z "$CC"; then
3212   ac_ct_CC=$CC
3213   for ac_prog in cl
3214 do
3215   # Extract the first word of "$ac_prog", so it can be a program name with args.
3216 set dummy $ac_prog; ac_word=$2
3217 echo "$as_me:$LINENO: checking for $ac_word" >&5
3218 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3219 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3220   echo $ECHO_N "(cached) $ECHO_C" >&6
3221 else
3222   if test -n "$ac_ct_CC"; then
3223   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3224 else
3225 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3226 for as_dir in $PATH
3227 do
3228   IFS=$as_save_IFS
3229   test -z "$as_dir" && as_dir=.
3230   for ac_exec_ext in '' $ac_executable_extensions; do
3231   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3232     ac_cv_prog_ac_ct_CC="$ac_prog"
3233     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3234     break 2
3235   fi
3236 done
3237 done
3238
3239 fi
3240 fi
3241 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3242 if test -n "$ac_ct_CC"; then
3243   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3244 echo "${ECHO_T}$ac_ct_CC" >&6
3245 else
3246   echo "$as_me:$LINENO: result: no" >&5
3247 echo "${ECHO_T}no" >&6
3248 fi
3249
3250   test -n "$ac_ct_CC" && break
3251 done
3252
3253   CC=$ac_ct_CC
3254 fi
3255
3256 fi
3257
3258
3259 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3260 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3261 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3262 See \`config.log' for more details." >&5
3263 echo "$as_me: error: no acceptable C compiler found in \$PATH
3264 See \`config.log' for more details." >&2;}
3265    { (exit 1); exit 1; }; }; }
3266
3267 # Provide some information about the compiler.
3268 echo "$as_me:$LINENO:" \
3269      "checking for C compiler version" >&5
3270 ac_compiler=`set X $ac_compile; echo $2`
3271 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3272   (eval $ac_compiler --version </dev/null >&5) 2>&5
3273   ac_status=$?
3274   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3275   (exit $ac_status); }
3276 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3277   (eval $ac_compiler -v </dev/null >&5) 2>&5
3278   ac_status=$?
3279   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3280   (exit $ac_status); }
3281 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3282   (eval $ac_compiler -V </dev/null >&5) 2>&5
3283   ac_status=$?
3284   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3285   (exit $ac_status); }
3286
3287 cat >conftest.$ac_ext <<_ACEOF
3288 /* confdefs.h.  */
3289 _ACEOF
3290 cat confdefs.h >>conftest.$ac_ext
3291 cat >>conftest.$ac_ext <<_ACEOF
3292 /* end confdefs.h.  */
3293
3294 int
3295 main ()
3296 {
3297
3298   ;
3299   return 0;
3300 }
3301 _ACEOF
3302 ac_clean_files_save=$ac_clean_files
3303 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3304 # Try to create an executable without -o first, disregard a.out.
3305 # It will help us diagnose broken compilers, and finding out an intuition
3306 # of exeext.
3307 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3308 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3309 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3310 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3311   (eval $ac_link_default) 2>&5
3312   ac_status=$?
3313   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3314   (exit $ac_status); }; then
3315   # Find the output, starting from the most likely.  This scheme is
3316 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3317 # resort.
3318
3319 # Be careful to initialize this variable, since it used to be cached.
3320 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3321 ac_cv_exeext=
3322 # b.out is created by i960 compilers.
3323 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3324 do
3325   test -f "$ac_file" || continue
3326   case $ac_file in
3327     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3328         ;;
3329     conftest.$ac_ext )
3330         # This is the source file.
3331         ;;
3332     [ab].out )
3333         # We found the default executable, but exeext='' is most
3334         # certainly right.
3335         break;;
3336     *.* )
3337         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3338         # FIXME: I believe we export ac_cv_exeext for Libtool,
3339         # but it would be cool to find out if it's true.  Does anybody
3340         # maintain Libtool? --akim.
3341         export ac_cv_exeext
3342         break;;
3343     * )
3344         break;;
3345   esac
3346 done
3347 else
3348   echo "$as_me: failed program was:" >&5
3349 sed 's/^/| /' conftest.$ac_ext >&5
3350
3351 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3352 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3353 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3354 See \`config.log' for more details." >&5
3355 echo "$as_me: error: C compiler cannot create executables
3356 See \`config.log' for more details." >&2;}
3357    { (exit 77); exit 77; }; }; }
3358 fi
3359
3360 ac_exeext=$ac_cv_exeext
3361 echo "$as_me:$LINENO: result: $ac_file" >&5
3362 echo "${ECHO_T}$ac_file" >&6
3363
3364 # Check the compiler produces executables we can run.  If not, either
3365 # the compiler is broken, or we cross compile.
3366 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3367 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3368 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3369 # If not cross compiling, check that we can run a simple program.
3370 if test "$cross_compiling" != yes; then
3371   if { ac_try='./$ac_file'
3372   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3373   (eval $ac_try) 2>&5
3374   ac_status=$?
3375   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3376   (exit $ac_status); }; }; then
3377     cross_compiling=no
3378   else
3379     if test "$cross_compiling" = maybe; then
3380         cross_compiling=yes
3381     else
3382         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3383 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3384 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3385 If you meant to cross compile, use \`--host'.
3386 See \`config.log' for more details." >&5
3387 echo "$as_me: error: cannot run C compiled programs.
3388 If you meant to cross compile, use \`--host'.
3389 See \`config.log' for more details." >&2;}
3390    { (exit 1); exit 1; }; }; }
3391     fi
3392   fi
3393 fi
3394 echo "$as_me:$LINENO: result: yes" >&5
3395 echo "${ECHO_T}yes" >&6
3396
3397 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3398 ac_clean_files=$ac_clean_files_save
3399 # Check the compiler produces executables we can run.  If not, either
3400 # the compiler is broken, or we cross compile.
3401 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3402 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3403 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3404 echo "${ECHO_T}$cross_compiling" >&6
3405
3406 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3407 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3408 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3409   (eval $ac_link) 2>&5
3410   ac_status=$?
3411   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3412   (exit $ac_status); }; then
3413   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3414 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3415 # work properly (i.e., refer to `conftest.exe'), while it won't with
3416 # `rm'.
3417 for ac_file in conftest.exe conftest conftest.*; do
3418   test -f "$ac_file" || continue
3419   case $ac_file in
3420     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3421     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3422           export ac_cv_exeext
3423           break;;
3424     * ) break;;
3425   esac
3426 done
3427 else
3428   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3429 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3430 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3431 See \`config.log' for more details." >&5
3432 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3433 See \`config.log' for more details." >&2;}
3434    { (exit 1); exit 1; }; }; }
3435 fi
3436
3437 rm -f conftest$ac_cv_exeext
3438 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3439 echo "${ECHO_T}$ac_cv_exeext" >&6
3440
3441 rm -f conftest.$ac_ext
3442 EXEEXT=$ac_cv_exeext
3443 ac_exeext=$EXEEXT
3444 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3445 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3446 if test "${ac_cv_objext+set}" = set; then
3447   echo $ECHO_N "(cached) $ECHO_C" >&6
3448 else
3449   cat >conftest.$ac_ext <<_ACEOF
3450 /* confdefs.h.  */
3451 _ACEOF
3452 cat confdefs.h >>conftest.$ac_ext
3453 cat >>conftest.$ac_ext <<_ACEOF
3454 /* end confdefs.h.  */
3455
3456 int
3457 main ()
3458 {
3459
3460   ;
3461   return 0;
3462 }
3463 _ACEOF
3464 rm -f conftest.o conftest.obj
3465 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3466   (eval $ac_compile) 2>&5
3467   ac_status=$?
3468   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3469   (exit $ac_status); }; then
3470   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3471   case $ac_file in
3472     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3473     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3474        break;;
3475   esac
3476 done
3477 else
3478   echo "$as_me: failed program was:" >&5
3479 sed 's/^/| /' conftest.$ac_ext >&5
3480
3481 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3482 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3483 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3484 See \`config.log' for more details." >&5
3485 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3486 See \`config.log' for more details." >&2;}
3487    { (exit 1); exit 1; }; }; }
3488 fi
3489
3490 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3491 fi
3492 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3493 echo "${ECHO_T}$ac_cv_objext" >&6
3494 OBJEXT=$ac_cv_objext
3495 ac_objext=$OBJEXT
3496 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3497 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3498 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3499   echo $ECHO_N "(cached) $ECHO_C" >&6
3500 else
3501   cat >conftest.$ac_ext <<_ACEOF
3502 /* confdefs.h.  */
3503 _ACEOF
3504 cat confdefs.h >>conftest.$ac_ext
3505 cat >>conftest.$ac_ext <<_ACEOF
3506 /* end confdefs.h.  */
3507
3508 int
3509 main ()
3510 {
3511 #ifndef __GNUC__
3512        choke me
3513 #endif
3514
3515   ;
3516   return 0;
3517 }
3518 _ACEOF
3519 rm -f conftest.$ac_objext
3520 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3521   (eval $ac_compile) 2>conftest.er1
3522   ac_status=$?
3523   grep -v '^ *+' conftest.er1 >conftest.err
3524   rm -f conftest.er1
3525   cat conftest.err >&5
3526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3527   (exit $ac_status); } &&
3528          { ac_try='test -z "$ac_c_werror_flag"
3529                          || test ! -s conftest.err'
3530   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3531   (eval $ac_try) 2>&5
3532   ac_status=$?
3533   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3534   (exit $ac_status); }; } &&
3535          { ac_try='test -s conftest.$ac_objext'
3536   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3537   (eval $ac_try) 2>&5
3538   ac_status=$?
3539   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3540   (exit $ac_status); }; }; then
3541   ac_compiler_gnu=yes
3542 else
3543   echo "$as_me: failed program was:" >&5
3544 sed 's/^/| /' conftest.$ac_ext >&5
3545
3546 ac_compiler_gnu=no
3547 fi
3548 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3549 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3550
3551 fi
3552 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3553 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3554 GCC=`test $ac_compiler_gnu = yes && echo yes`
3555 ac_test_CFLAGS=${CFLAGS+set}
3556 ac_save_CFLAGS=$CFLAGS
3557 CFLAGS="-g"
3558 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3559 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3560 if test "${ac_cv_prog_cc_g+set}" = set; then
3561   echo $ECHO_N "(cached) $ECHO_C" >&6
3562 else
3563   cat >conftest.$ac_ext <<_ACEOF
3564 /* confdefs.h.  */
3565 _ACEOF
3566 cat confdefs.h >>conftest.$ac_ext
3567 cat >>conftest.$ac_ext <<_ACEOF
3568 /* end confdefs.h.  */
3569
3570 int
3571 main ()
3572 {
3573
3574   ;
3575   return 0;
3576 }
3577 _ACEOF
3578 rm -f conftest.$ac_objext
3579 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3580   (eval $ac_compile) 2>conftest.er1
3581   ac_status=$?
3582   grep -v '^ *+' conftest.er1 >conftest.err
3583   rm -f conftest.er1
3584   cat conftest.err >&5
3585   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3586   (exit $ac_status); } &&
3587          { ac_try='test -z "$ac_c_werror_flag"
3588                          || test ! -s conftest.err'
3589   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3590   (eval $ac_try) 2>&5
3591   ac_status=$?
3592   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3593   (exit $ac_status); }; } &&
3594          { ac_try='test -s conftest.$ac_objext'
3595   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3596   (eval $ac_try) 2>&5
3597   ac_status=$?
3598   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3599   (exit $ac_status); }; }; then
3600   ac_cv_prog_cc_g=yes
3601 else
3602   echo "$as_me: failed program was:" >&5
3603 sed 's/^/| /' conftest.$ac_ext >&5
3604
3605 ac_cv_prog_cc_g=no
3606 fi
3607 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3608 fi
3609 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3610 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3611 if test "$ac_test_CFLAGS" = set; then
3612   CFLAGS=$ac_save_CFLAGS
3613 elif test $ac_cv_prog_cc_g = yes; then
3614   if test "$GCC" = yes; then
3615     CFLAGS="-g -O2"
3616   else
3617     CFLAGS="-g"
3618   fi
3619 else
3620   if test "$GCC" = yes; then
3621     CFLAGS="-O2"
3622   else
3623     CFLAGS=
3624   fi
3625 fi
3626 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3627 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3628 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3629   echo $ECHO_N "(cached) $ECHO_C" >&6
3630 else
3631   ac_cv_prog_cc_stdc=no
3632 ac_save_CC=$CC
3633 cat >conftest.$ac_ext <<_ACEOF
3634 /* confdefs.h.  */
3635 _ACEOF
3636 cat confdefs.h >>conftest.$ac_ext
3637 cat >>conftest.$ac_ext <<_ACEOF
3638 /* end confdefs.h.  */
3639 #include <stdarg.h>
3640 #include <stdio.h>
3641 #include <sys/types.h>
3642 #include <sys/stat.h>
3643 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3644 struct buf { int x; };
3645 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3646 static char *e (p, i)
3647      char **p;
3648      int i;
3649 {
3650   return p[i];
3651 }
3652 static char *f (char * (*g) (char **, int), char **p, ...)
3653 {
3654   char *s;
3655   va_list v;
3656   va_start (v,p);
3657   s = g (p, va_arg (v,int));
3658   va_end (v);
3659   return s;
3660 }
3661
3662 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3663    function prototypes and stuff, but not '\xHH' hex character constants.
3664    These don't provoke an error unfortunately, instead are silently treated
3665    as 'x'.  The following induces an error, until -std1 is added to get
3666    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3667    array size at least.  It's necessary to write '\x00'==0 to get something
3668    that's true only with -std1.  */
3669 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3670
3671 int test (int i, double x);
3672 struct s1 {int (*f) (int a);};
3673 struct s2 {int (*f) (double a);};
3674 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3675 int argc;
3676 char **argv;
3677 int
3678 main ()
3679 {
3680 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3681   ;
3682   return 0;
3683 }
3684 _ACEOF
3685 # Don't try gcc -ansi; that turns off useful extensions and
3686 # breaks some systems' header files.
3687 # AIX                   -qlanglvl=ansi
3688 # Ultrix and OSF/1      -std1
3689 # HP-UX 10.20 and later -Ae
3690 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3691 # SVR4                  -Xc -D__EXTENSIONS__
3692 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3693 do
3694   CC="$ac_save_CC $ac_arg"
3695   rm -f conftest.$ac_objext
3696 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3697   (eval $ac_compile) 2>conftest.er1
3698   ac_status=$?
3699   grep -v '^ *+' conftest.er1 >conftest.err
3700   rm -f conftest.er1
3701   cat conftest.err >&5
3702   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3703   (exit $ac_status); } &&
3704          { ac_try='test -z "$ac_c_werror_flag"
3705                          || test ! -s conftest.err'
3706   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3707   (eval $ac_try) 2>&5
3708   ac_status=$?
3709   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3710   (exit $ac_status); }; } &&
3711          { ac_try='test -s conftest.$ac_objext'
3712   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3713   (eval $ac_try) 2>&5
3714   ac_status=$?
3715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3716   (exit $ac_status); }; }; then
3717   ac_cv_prog_cc_stdc=$ac_arg
3718 break
3719 else
3720   echo "$as_me: failed program was:" >&5
3721 sed 's/^/| /' conftest.$ac_ext >&5
3722
3723 fi
3724 rm -f conftest.err conftest.$ac_objext
3725 done
3726 rm -f conftest.$ac_ext conftest.$ac_objext
3727 CC=$ac_save_CC
3728
3729 fi
3730
3731 case "x$ac_cv_prog_cc_stdc" in
3732   x|xno)
3733     echo "$as_me:$LINENO: result: none needed" >&5
3734 echo "${ECHO_T}none needed" >&6 ;;
3735   *)
3736     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3737 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3738     CC="$CC $ac_cv_prog_cc_stdc" ;;
3739 esac
3740
3741 # Some people use a C++ compiler to compile C.  Since we use `exit',
3742 # in C++ we need to declare it.  In case someone uses the same compiler
3743 # for both compiling C and C++ we need to have the C++ compiler decide
3744 # the declaration of exit, since it's the most demanding environment.
3745 cat >conftest.$ac_ext <<_ACEOF
3746 #ifndef __cplusplus
3747   choke me
3748 #endif
3749 _ACEOF
3750 rm -f conftest.$ac_objext
3751 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3752   (eval $ac_compile) 2>conftest.er1
3753   ac_status=$?
3754   grep -v '^ *+' conftest.er1 >conftest.err
3755   rm -f conftest.er1
3756   cat conftest.err >&5
3757   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3758   (exit $ac_status); } &&
3759          { ac_try='test -z "$ac_c_werror_flag"
3760                          || test ! -s conftest.err'
3761   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3762   (eval $ac_try) 2>&5
3763   ac_status=$?
3764   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3765   (exit $ac_status); }; } &&
3766          { ac_try='test -s conftest.$ac_objext'
3767   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3768   (eval $ac_try) 2>&5
3769   ac_status=$?
3770   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3771   (exit $ac_status); }; }; then
3772   for ac_declaration in \
3773    '' \
3774    'extern "C" void std::exit (int) throw (); using std::exit;' \
3775    'extern "C" void std::exit (int); using std::exit;' \
3776    'extern "C" void exit (int) throw ();' \
3777    'extern "C" void exit (int);' \
3778    'void exit (int);'
3779 do
3780   cat >conftest.$ac_ext <<_ACEOF
3781 /* confdefs.h.  */
3782 _ACEOF
3783 cat confdefs.h >>conftest.$ac_ext
3784 cat >>conftest.$ac_ext <<_ACEOF
3785 /* end confdefs.h.  */
3786 $ac_declaration
3787 #include <stdlib.h>
3788 int
3789 main ()
3790 {
3791 exit (42);
3792   ;
3793   return 0;
3794 }
3795 _ACEOF
3796 rm -f conftest.$ac_objext
3797 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3798   (eval $ac_compile) 2>conftest.er1
3799   ac_status=$?
3800   grep -v '^ *+' conftest.er1 >conftest.err
3801   rm -f conftest.er1
3802   cat conftest.err >&5
3803   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3804   (exit $ac_status); } &&
3805          { ac_try='test -z "$ac_c_werror_flag"
3806                          || test ! -s conftest.err'
3807   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3808   (eval $ac_try) 2>&5
3809   ac_status=$?
3810   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3811   (exit $ac_status); }; } &&
3812          { ac_try='test -s conftest.$ac_objext'
3813   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3814   (eval $ac_try) 2>&5
3815   ac_status=$?
3816   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3817   (exit $ac_status); }; }; then
3818   :
3819 else
3820   echo "$as_me: failed program was:" >&5
3821 sed 's/^/| /' conftest.$ac_ext >&5
3822
3823 continue
3824 fi
3825 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3826   cat >conftest.$ac_ext <<_ACEOF
3827 /* confdefs.h.  */
3828 _ACEOF
3829 cat confdefs.h >>conftest.$ac_ext
3830 cat >>conftest.$ac_ext <<_ACEOF
3831 /* end confdefs.h.  */
3832 $ac_declaration
3833 int
3834 main ()
3835 {
3836 exit (42);
3837   ;
3838   return 0;
3839 }
3840 _ACEOF
3841 rm -f conftest.$ac_objext
3842 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3843   (eval $ac_compile) 2>conftest.er1
3844   ac_status=$?
3845   grep -v '^ *+' conftest.er1 >conftest.err
3846   rm -f conftest.er1
3847   cat conftest.err >&5
3848   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3849   (exit $ac_status); } &&
3850          { ac_try='test -z "$ac_c_werror_flag"
3851                          || test ! -s conftest.err'
3852   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3853   (eval $ac_try) 2>&5
3854   ac_status=$?
3855   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3856   (exit $ac_status); }; } &&
3857          { ac_try='test -s conftest.$ac_objext'
3858   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3859   (eval $ac_try) 2>&5
3860   ac_status=$?
3861   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3862   (exit $ac_status); }; }; then
3863   break
3864 else
3865   echo "$as_me: failed program was:" >&5
3866 sed 's/^/| /' conftest.$ac_ext >&5
3867
3868 fi
3869 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3870 done
3871 rm -f conftest*
3872 if test -n "$ac_declaration"; then
3873   echo '#ifdef __cplusplus' >>confdefs.h
3874   echo $ac_declaration      >>confdefs.h
3875   echo '#endif'             >>confdefs.h
3876 fi
3877
3878 else
3879   echo "$as_me: failed program was:" >&5
3880 sed 's/^/| /' conftest.$ac_ext >&5
3881
3882 fi
3883 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3884 ac_ext=c
3885 ac_cpp='$CPP $CPPFLAGS'
3886 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3887 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3888 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3889
3890 ac_ext=cc
3891 ac_cpp='$CXXCPP $CPPFLAGS'
3892 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3893 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3894 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3895 if test -n "$ac_tool_prefix"; then
3896   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3897   do
3898     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3899 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3900 echo "$as_me:$LINENO: checking for $ac_word" >&5
3901 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3902 if test "${ac_cv_prog_CXX+set}" = set; then
3903   echo $ECHO_N "(cached) $ECHO_C" >&6
3904 else
3905   if test -n "$CXX"; then
3906   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3907 else
3908 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3909 for as_dir in $PATH
3910 do
3911   IFS=$as_save_IFS
3912   test -z "$as_dir" && as_dir=.
3913   for ac_exec_ext in '' $ac_executable_extensions; do
3914   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3915     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3916     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3917     break 2
3918   fi
3919 done
3920 done
3921
3922 fi
3923 fi
3924 CXX=$ac_cv_prog_CXX
3925 if test -n "$CXX"; then
3926   echo "$as_me:$LINENO: result: $CXX" >&5
3927 echo "${ECHO_T}$CXX" >&6
3928 else
3929   echo "$as_me:$LINENO: result: no" >&5
3930 echo "${ECHO_T}no" >&6
3931 fi
3932
3933     test -n "$CXX" && break
3934   done
3935 fi
3936 if test -z "$CXX"; then
3937   ac_ct_CXX=$CXX
3938   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3939 do
3940   # Extract the first word of "$ac_prog", so it can be a program name with args.
3941 set dummy $ac_prog; ac_word=$2
3942 echo "$as_me:$LINENO: checking for $ac_word" >&5
3943 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3944 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3945   echo $ECHO_N "(cached) $ECHO_C" >&6
3946 else
3947   if test -n "$ac_ct_CXX"; then
3948   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3949 else
3950 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3951 for as_dir in $PATH
3952 do
3953   IFS=$as_save_IFS
3954   test -z "$as_dir" && as_dir=.
3955   for ac_exec_ext in '' $ac_executable_extensions; do
3956   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3957     ac_cv_prog_ac_ct_CXX="$ac_prog"
3958     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3959     break 2
3960   fi
3961 done
3962 done
3963
3964 fi
3965 fi
3966 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3967 if test -n "$ac_ct_CXX"; then
3968   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3969 echo "${ECHO_T}$ac_ct_CXX" >&6
3970 else
3971   echo "$as_me:$LINENO: result: no" >&5
3972 echo "${ECHO_T}no" >&6
3973 fi
3974
3975   test -n "$ac_ct_CXX" && break
3976 done
3977 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3978
3979   CXX=$ac_ct_CXX
3980 fi
3981
3982
3983 # Provide some information about the compiler.
3984 echo "$as_me:$LINENO:" \
3985      "checking for C++ compiler version" >&5
3986 ac_compiler=`set X $ac_compile; echo $2`
3987 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3988   (eval $ac_compiler --version </dev/null >&5) 2>&5
3989   ac_status=$?
3990   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3991   (exit $ac_status); }
3992 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3993   (eval $ac_compiler -v </dev/null >&5) 2>&5
3994   ac_status=$?
3995   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3996   (exit $ac_status); }
3997 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3998   (eval $ac_compiler -V </dev/null >&5) 2>&5
3999   ac_status=$?
4000   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4001   (exit $ac_status); }
4002
4003 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4004 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4005 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4006   echo $ECHO_N "(cached) $ECHO_C" >&6
4007 else
4008   cat >conftest.$ac_ext <<_ACEOF
4009 /* confdefs.h.  */
4010 _ACEOF
4011 cat confdefs.h >>conftest.$ac_ext
4012 cat >>conftest.$ac_ext <<_ACEOF
4013 /* end confdefs.h.  */
4014
4015 int
4016 main ()
4017 {
4018 #ifndef __GNUC__
4019        choke me
4020 #endif
4021
4022   ;
4023   return 0;
4024 }
4025 _ACEOF
4026 rm -f conftest.$ac_objext
4027 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4028   (eval $ac_compile) 2>conftest.er1
4029   ac_status=$?
4030   grep -v '^ *+' conftest.er1 >conftest.err
4031   rm -f conftest.er1
4032   cat conftest.err >&5
4033   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4034   (exit $ac_status); } &&
4035          { ac_try='test -z "$ac_cxx_werror_flag"
4036                          || test ! -s conftest.err'
4037   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4038   (eval $ac_try) 2>&5
4039   ac_status=$?
4040   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4041   (exit $ac_status); }; } &&
4042          { ac_try='test -s conftest.$ac_objext'
4043   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4044   (eval $ac_try) 2>&5
4045   ac_status=$?
4046   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4047   (exit $ac_status); }; }; then
4048   ac_compiler_gnu=yes
4049 else
4050   echo "$as_me: failed program was:" >&5
4051 sed 's/^/| /' conftest.$ac_ext >&5
4052
4053 ac_compiler_gnu=no
4054 fi
4055 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4056 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4057
4058 fi
4059 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4060 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4061 GXX=`test $ac_compiler_gnu = yes && echo yes`
4062 ac_test_CXXFLAGS=${CXXFLAGS+set}
4063 ac_save_CXXFLAGS=$CXXFLAGS
4064 CXXFLAGS="-g"
4065 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4066 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4067 if test "${ac_cv_prog_cxx_g+set}" = set; then
4068   echo $ECHO_N "(cached) $ECHO_C" >&6
4069 else
4070   cat >conftest.$ac_ext <<_ACEOF
4071 /* confdefs.h.  */
4072 _ACEOF
4073 cat confdefs.h >>conftest.$ac_ext
4074 cat >>conftest.$ac_ext <<_ACEOF
4075 /* end confdefs.h.  */
4076
4077 int
4078 main ()
4079 {
4080
4081   ;
4082   return 0;
4083 }
4084 _ACEOF
4085 rm -f conftest.$ac_objext
4086 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4087   (eval $ac_compile) 2>conftest.er1
4088   ac_status=$?
4089   grep -v '^ *+' conftest.er1 >conftest.err
4090   rm -f conftest.er1
4091   cat conftest.err >&5
4092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4093   (exit $ac_status); } &&
4094          { ac_try='test -z "$ac_cxx_werror_flag"
4095                          || test ! -s conftest.err'
4096   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4097   (eval $ac_try) 2>&5
4098   ac_status=$?
4099   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4100   (exit $ac_status); }; } &&
4101          { ac_try='test -s conftest.$ac_objext'
4102   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4103   (eval $ac_try) 2>&5
4104   ac_status=$?
4105   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4106   (exit $ac_status); }; }; then
4107   ac_cv_prog_cxx_g=yes
4108 else
4109   echo "$as_me: failed program was:" >&5
4110 sed 's/^/| /' conftest.$ac_ext >&5
4111
4112 ac_cv_prog_cxx_g=no
4113 fi
4114 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4115 fi
4116 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4117 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4118 if test "$ac_test_CXXFLAGS" = set; then
4119   CXXFLAGS=$ac_save_CXXFLAGS
4120 elif test $ac_cv_prog_cxx_g = yes; then
4121   if test "$GXX" = yes; then
4122     CXXFLAGS="-g -O2"
4123   else
4124     CXXFLAGS="-g"
4125   fi
4126 else
4127   if test "$GXX" = yes; then
4128     CXXFLAGS="-O2"
4129   else
4130     CXXFLAGS=
4131   fi
4132 fi
4133 for ac_declaration in \
4134    '' \
4135    'extern "C" void std::exit (int) throw (); using std::exit;' \
4136    'extern "C" void std::exit (int); using std::exit;' \
4137    'extern "C" void exit (int) throw ();' \
4138    'extern "C" void exit (int);' \
4139    'void exit (int);'
4140 do
4141   cat >conftest.$ac_ext <<_ACEOF
4142 /* confdefs.h.  */
4143 _ACEOF
4144 cat confdefs.h >>conftest.$ac_ext
4145 cat >>conftest.$ac_ext <<_ACEOF
4146 /* end confdefs.h.  */
4147 $ac_declaration
4148 #include <stdlib.h>
4149 int
4150 main ()
4151 {
4152 exit (42);
4153   ;
4154   return 0;
4155 }
4156 _ACEOF
4157 rm -f conftest.$ac_objext
4158 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4159   (eval $ac_compile) 2>conftest.er1
4160   ac_status=$?
4161   grep -v '^ *+' conftest.er1 >conftest.err
4162   rm -f conftest.er1
4163   cat conftest.err >&5
4164   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4165   (exit $ac_status); } &&
4166          { ac_try='test -z "$ac_cxx_werror_flag"
4167                          || test ! -s conftest.err'
4168   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4169   (eval $ac_try) 2>&5
4170   ac_status=$?
4171   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4172   (exit $ac_status); }; } &&
4173          { ac_try='test -s conftest.$ac_objext'
4174   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4175   (eval $ac_try) 2>&5
4176   ac_status=$?
4177   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4178   (exit $ac_status); }; }; then
4179   :
4180 else
4181   echo "$as_me: failed program was:" >&5
4182 sed 's/^/| /' conftest.$ac_ext >&5
4183
4184 continue
4185 fi
4186 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4187   cat >conftest.$ac_ext <<_ACEOF
4188 /* confdefs.h.  */
4189 _ACEOF
4190 cat confdefs.h >>conftest.$ac_ext
4191 cat >>conftest.$ac_ext <<_ACEOF
4192 /* end confdefs.h.  */
4193 $ac_declaration
4194 int
4195 main ()
4196 {
4197 exit (42);
4198   ;
4199   return 0;
4200 }
4201 _ACEOF
4202 rm -f conftest.$ac_objext
4203 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4204   (eval $ac_compile) 2>conftest.er1
4205   ac_status=$?
4206   grep -v '^ *+' conftest.er1 >conftest.err
4207   rm -f conftest.er1
4208   cat conftest.err >&5
4209   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4210   (exit $ac_status); } &&
4211          { ac_try='test -z "$ac_cxx_werror_flag"
4212                          || test ! -s conftest.err'
4213   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4214   (eval $ac_try) 2>&5
4215   ac_status=$?
4216   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4217   (exit $ac_status); }; } &&
4218          { ac_try='test -s conftest.$ac_objext'
4219   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4220   (eval $ac_try) 2>&5
4221   ac_status=$?
4222   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4223   (exit $ac_status); }; }; then
4224   break
4225 else
4226   echo "$as_me: failed program was:" >&5
4227 sed 's/^/| /' conftest.$ac_ext >&5
4228
4229 fi
4230 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4231 done
4232 rm -f conftest*
4233 if test -n "$ac_declaration"; then
4234   echo '#ifdef __cplusplus' >>confdefs.h
4235   echo $ac_declaration      >>confdefs.h
4236   echo '#endif'             >>confdefs.h
4237 fi
4238
4239 ac_ext=c
4240 ac_cpp='$CPP $CPPFLAGS'
4241 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4242 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4243 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4244
4245
4246 # We must set the default linker to the linker used by gcc for the correct
4247 # operation of libtool.  If LD is not defined and we are using gcc, try to
4248 # set the LD default to the ld used by gcc.
4249 if test -z "$LD"; then
4250   if test "$GCC" = yes; then
4251     case $build in
4252     *-*-mingw*)
4253       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4254     *)
4255       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4256     esac
4257     case $gcc_prog_ld in
4258     # Accept absolute paths.
4259     [\\/]* | [A-Za-z]:[\\/]*)
4260       LD="$gcc_prog_ld" ;;
4261     esac
4262   fi
4263 fi
4264
4265
4266
4267
4268 if test -n "$ac_tool_prefix"; then
4269   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4270 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4271 echo "$as_me:$LINENO: checking for $ac_word" >&5
4272 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4273 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4274   echo $ECHO_N "(cached) $ECHO_C" >&6
4275 else
4276   if test -n "$GNATBIND"; then
4277   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4278 else
4279 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4280 for as_dir in $PATH
4281 do
4282   IFS=$as_save_IFS
4283   test -z "$as_dir" && as_dir=.
4284   for ac_exec_ext in '' $ac_executable_extensions; do
4285   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4286     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4287     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4288     break 2
4289   fi
4290 done
4291 done
4292
4293 fi
4294 fi
4295 GNATBIND=$ac_cv_prog_GNATBIND
4296 if test -n "$GNATBIND"; then
4297   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4298 echo "${ECHO_T}$GNATBIND" >&6
4299 else
4300   echo "$as_me:$LINENO: result: no" >&5
4301 echo "${ECHO_T}no" >&6
4302 fi
4303
4304 fi
4305 if test -z "$ac_cv_prog_GNATBIND"; then
4306   ac_ct_GNATBIND=$GNATBIND
4307   # Extract the first word of "gnatbind", so it can be a program name with args.
4308 set dummy gnatbind; ac_word=$2
4309 echo "$as_me:$LINENO: checking for $ac_word" >&5
4310 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4311 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4312   echo $ECHO_N "(cached) $ECHO_C" >&6
4313 else
4314   if test -n "$ac_ct_GNATBIND"; then
4315   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4316 else
4317 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4318 for as_dir in $PATH
4319 do
4320   IFS=$as_save_IFS
4321   test -z "$as_dir" && as_dir=.
4322   for ac_exec_ext in '' $ac_executable_extensions; do
4323   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4324     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4325     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4326     break 2
4327   fi
4328 done
4329 done
4330
4331   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4332 fi
4333 fi
4334 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4335 if test -n "$ac_ct_GNATBIND"; then
4336   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4337 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4338 else
4339   echo "$as_me:$LINENO: result: no" >&5
4340 echo "${ECHO_T}no" >&6
4341 fi
4342
4343   GNATBIND=$ac_ct_GNATBIND
4344 else
4345   GNATBIND="$ac_cv_prog_GNATBIND"
4346 fi
4347
4348 if test -n "$ac_tool_prefix"; then
4349   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4350 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4351 echo "$as_me:$LINENO: checking for $ac_word" >&5
4352 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4353 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4354   echo $ECHO_N "(cached) $ECHO_C" >&6
4355 else
4356   if test -n "$GNATMAKE"; then
4357   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4358 else
4359 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4360 for as_dir in $PATH
4361 do
4362   IFS=$as_save_IFS
4363   test -z "$as_dir" && as_dir=.
4364   for ac_exec_ext in '' $ac_executable_extensions; do
4365   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4366     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4367     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4368     break 2
4369   fi
4370 done
4371 done
4372
4373 fi
4374 fi
4375 GNATMAKE=$ac_cv_prog_GNATMAKE
4376 if test -n "$GNATMAKE"; then
4377   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4378 echo "${ECHO_T}$GNATMAKE" >&6
4379 else
4380   echo "$as_me:$LINENO: result: no" >&5
4381 echo "${ECHO_T}no" >&6
4382 fi
4383
4384 fi
4385 if test -z "$ac_cv_prog_GNATMAKE"; then
4386   ac_ct_GNATMAKE=$GNATMAKE
4387   # Extract the first word of "gnatmake", so it can be a program name with args.
4388 set dummy gnatmake; ac_word=$2
4389 echo "$as_me:$LINENO: checking for $ac_word" >&5
4390 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4391 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4392   echo $ECHO_N "(cached) $ECHO_C" >&6
4393 else
4394   if test -n "$ac_ct_GNATMAKE"; then
4395   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4396 else
4397 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4398 for as_dir in $PATH
4399 do
4400   IFS=$as_save_IFS
4401   test -z "$as_dir" && as_dir=.
4402   for ac_exec_ext in '' $ac_executable_extensions; do
4403   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4404     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4405     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4406     break 2
4407   fi
4408 done
4409 done
4410
4411   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4412 fi
4413 fi
4414 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4415 if test -n "$ac_ct_GNATMAKE"; then
4416   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4417 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4418 else
4419   echo "$as_me:$LINENO: result: no" >&5
4420 echo "${ECHO_T}no" >&6
4421 fi
4422
4423   GNATMAKE=$ac_ct_GNATMAKE
4424 else
4425   GNATMAKE="$ac_cv_prog_GNATMAKE"
4426 fi
4427
4428 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4429 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4430 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4431   echo $ECHO_N "(cached) $ECHO_C" >&6
4432 else
4433   cat >conftest.adb <<EOF
4434 procedure conftest is begin null; end conftest;
4435 EOF
4436 acx_cv_cc_gcc_supports_ada=no
4437 # There is a bug in old released versions of GCC which causes the
4438 # driver to exit successfully when the appropriate language module
4439 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4440 # Therefore we must check for the error message as well as an
4441 # unsuccessful exit.
4442 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4443 # given a .adb file, but produce no object file.  So we must check
4444 # if an object file was really produced to guard against this.
4445 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4446 if test x"$errors" = x && test -f conftest.$ac_objext; then
4447   acx_cv_cc_gcc_supports_ada=yes
4448 fi
4449 rm -f conftest.*
4450 fi
4451 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4452 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4453
4454 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4455   have_gnat=yes
4456 else
4457   have_gnat=no
4458 fi
4459
4460 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4461 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4462 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4463   echo $ECHO_N "(cached) $ECHO_C" >&6
4464 else
4465    echo abfoo >t1
4466   echo cdfoo >t2
4467   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4468   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4469     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4470       :
4471     else
4472       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4473     fi
4474   fi
4475   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4476     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4477       :
4478     else
4479       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4480     fi
4481   fi
4482   rm t1 t2
4483
4484 fi
4485 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4486 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4487 do_compare="$gcc_cv_prog_cmp_skip"
4488
4489
4490
4491 # Check for GMP and MPFR
4492 gmplibs="-lmpfr -lgmp"
4493 gmpinc=
4494 have_gmp=no
4495
4496 # Specify a location for mpfr
4497 # check for this first so it ends up on the link line before gmp.
4498
4499 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4500 if test "${with_mpfr_dir+set}" = set; then
4501   withval="$with_mpfr_dir"
4502   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4503 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4504 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4505 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4506    { (exit 1); exit 1; }; }
4507 fi;
4508
4509
4510 # Check whether --with-mpfr or --without-mpfr was given.
4511 if test "${with_mpfr+set}" = set; then
4512   withval="$with_mpfr"
4513
4514 fi;
4515
4516 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4517 if test "${with_mpfr_include+set}" = set; then
4518   withval="$with_mpfr_include"
4519
4520 fi;
4521
4522 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4523 if test "${with_mpfr_lib+set}" = set; then
4524   withval="$with_mpfr_lib"
4525
4526 fi;
4527
4528 if test "x$with_mpfr" != x; then
4529   gmplibs="-L$with_mpfr/lib $gmplibs"
4530   gmpinc="-I$with_mpfr/include"
4531 fi
4532 if test "x$with_mpfr_include" != x; then
4533   gmpinc="-I$with_mpfr_include"
4534 fi
4535 if test "x$with_mpfr_lib" != x; then
4536   gmplibs="-L$with_mpfr_lib $gmplibs"
4537 fi
4538 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4539   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4540   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4541   # Do not test the mpfr version.  Assume that it is sufficient, since
4542   # it is in the source tree, and the library has not been built yet
4543   # but it would be included on the link line in the version check below
4544   # hence making the test fail.
4545   have_gmp=yes
4546 fi
4547
4548 # Specify a location for gmp
4549
4550 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4551 if test "${with_gmp_dir+set}" = set; then
4552   withval="$with_gmp_dir"
4553   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4554 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4555 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4556 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4557    { (exit 1); exit 1; }; }
4558 fi;
4559
4560
4561 # Check whether --with-gmp or --without-gmp was given.
4562 if test "${with_gmp+set}" = set; then
4563   withval="$with_gmp"
4564
4565 fi;
4566
4567 # Check whether --with-gmp_include or --without-gmp_include was given.
4568 if test "${with_gmp_include+set}" = set; then
4569   withval="$with_gmp_include"
4570
4571 fi;
4572
4573 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4574 if test "${with_gmp_lib+set}" = set; then
4575   withval="$with_gmp_lib"
4576
4577 fi;
4578
4579
4580 if test "x$with_gmp" != x; then
4581   gmplibs="-L$with_gmp/lib $gmplibs"
4582   gmpinc="-I$with_gmp/include $gmpinc"
4583 fi
4584 if test "x$with_gmp_include" != x; then
4585   gmpinc="-I$with_gmp_include $gmpinc"
4586 fi
4587 if test "x$with_gmp_lib" != x; then
4588   gmplibs="-L$with_gmp_lib $gmplibs"
4589 fi
4590 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4591   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4592   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4593   # Do not test the gmp version.  Assume that it is sufficient, since
4594   # it is in the source tree, and the library has not been built yet
4595   # but it would be included on the link line in the version check below
4596   # hence making the test fail.
4597   have_gmp=yes
4598 fi
4599
4600 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4601   have_gmp=yes
4602   saved_CFLAGS="$CFLAGS"
4603   CFLAGS="$CFLAGS $gmpinc"
4604   # Check GMP actually works
4605   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4606 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4607
4608 cat >conftest.$ac_ext <<_ACEOF
4609 /* confdefs.h.  */
4610 _ACEOF
4611 cat confdefs.h >>conftest.$ac_ext
4612 cat >>conftest.$ac_ext <<_ACEOF
4613 /* end confdefs.h.  */
4614 #include "gmp.h"
4615 int
4616 main ()
4617 {
4618
4619   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4620   choke me
4621   #endif
4622
4623   ;
4624   return 0;
4625 }
4626 _ACEOF
4627 rm -f conftest.$ac_objext
4628 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4629   (eval $ac_compile) 2>conftest.er1
4630   ac_status=$?
4631   grep -v '^ *+' conftest.er1 >conftest.err
4632   rm -f conftest.er1
4633   cat conftest.err >&5
4634   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4635   (exit $ac_status); } &&
4636          { ac_try='test -z "$ac_c_werror_flag"
4637                          || test ! -s conftest.err'
4638   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4639   (eval $ac_try) 2>&5
4640   ac_status=$?
4641   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4642   (exit $ac_status); }; } &&
4643          { ac_try='test -s conftest.$ac_objext'
4644   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4645   (eval $ac_try) 2>&5
4646   ac_status=$?
4647   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4648   (exit $ac_status); }; }; then
4649   echo "$as_me:$LINENO: result: yes" >&5
4650 echo "${ECHO_T}yes" >&6
4651 else
4652   echo "$as_me: failed program was:" >&5
4653 sed 's/^/| /' conftest.$ac_ext >&5
4654
4655 echo "$as_me:$LINENO: result: no" >&5
4656 echo "${ECHO_T}no" >&6; have_gmp=no
4657 fi
4658 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4659
4660   if test x"$have_gmp" = xyes; then
4661     saved_LIBS="$LIBS"
4662     LIBS="$LIBS $gmplibs"
4663         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4664 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4665     cat >conftest.$ac_ext <<_ACEOF
4666 /* confdefs.h.  */
4667 _ACEOF
4668 cat confdefs.h >>conftest.$ac_ext
4669 cat >>conftest.$ac_ext <<_ACEOF
4670 /* end confdefs.h.  */
4671 #include <gmp.h>
4672     #include <mpfr.h>
4673 int
4674 main ()
4675 {
4676
4677     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4678     choke me
4679     #endif
4680     mpfr_t n;
4681     mpfr_t x;
4682     int t;
4683     mpfr_init (n);
4684     mpfr_init (x);
4685     mpfr_atan2 (n, n, x, GMP_RNDN);
4686     mpfr_erfc (n, x, GMP_RNDN);
4687     mpfr_subnormalize (x, t, GMP_RNDN);
4688
4689   ;
4690   return 0;
4691 }
4692 _ACEOF
4693 rm -f conftest.$ac_objext conftest$ac_exeext
4694 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4695   (eval $ac_link) 2>conftest.er1
4696   ac_status=$?
4697   grep -v '^ *+' conftest.er1 >conftest.err
4698   rm -f conftest.er1
4699   cat conftest.err >&5
4700   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4701   (exit $ac_status); } &&
4702          { ac_try='test -z "$ac_c_werror_flag"
4703                          || test ! -s conftest.err'
4704   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4705   (eval $ac_try) 2>&5
4706   ac_status=$?
4707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4708   (exit $ac_status); }; } &&
4709          { ac_try='test -s conftest$ac_exeext'
4710   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4711   (eval $ac_try) 2>&5
4712   ac_status=$?
4713   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4714   (exit $ac_status); }; }; then
4715   cat >conftest.$ac_ext <<_ACEOF
4716 /* confdefs.h.  */
4717 _ACEOF
4718 cat confdefs.h >>conftest.$ac_ext
4719 cat >>conftest.$ac_ext <<_ACEOF
4720 /* end confdefs.h.  */
4721 #include <gmp.h>
4722     #include <mpfr.h>
4723 int
4724 main ()
4725 {
4726
4727     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4728     choke me
4729     #endif
4730     mpfr_t n; mpfr_init(n);
4731
4732   ;
4733   return 0;
4734 }
4735 _ACEOF
4736 rm -f conftest.$ac_objext conftest$ac_exeext
4737 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4738   (eval $ac_link) 2>conftest.er1
4739   ac_status=$?
4740   grep -v '^ *+' conftest.er1 >conftest.err
4741   rm -f conftest.er1
4742   cat conftest.err >&5
4743   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4744   (exit $ac_status); } &&
4745          { ac_try='test -z "$ac_c_werror_flag"
4746                          || test ! -s conftest.err'
4747   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4748   (eval $ac_try) 2>&5
4749   ac_status=$?
4750   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4751   (exit $ac_status); }; } &&
4752          { ac_try='test -s conftest$ac_exeext'
4753   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4754   (eval $ac_try) 2>&5
4755   ac_status=$?
4756   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4757   (exit $ac_status); }; }; then
4758   echo "$as_me:$LINENO: result: yes" >&5
4759 echo "${ECHO_T}yes" >&6
4760 else
4761   echo "$as_me: failed program was:" >&5
4762 sed 's/^/| /' conftest.$ac_ext >&5
4763
4764 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4765 echo "${ECHO_T}buggy but acceptable" >&6
4766 fi
4767 rm -f conftest.err conftest.$ac_objext \
4768       conftest$ac_exeext conftest.$ac_ext
4769 else
4770   echo "$as_me: failed program was:" >&5
4771 sed 's/^/| /' conftest.$ac_ext >&5
4772
4773 echo "$as_me:$LINENO: result: no" >&5
4774 echo "${ECHO_T}no" >&6; have_gmp=no
4775 fi
4776 rm -f conftest.err conftest.$ac_objext \
4777       conftest$ac_exeext conftest.$ac_ext
4778       LIBS="$saved_LIBS"
4779   fi
4780   CFLAGS="$saved_CFLAGS"
4781
4782   if test x$have_gmp != xyes; then
4783     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.2+.
4784 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4785 Copies of these libraries' source code can be found at their respective
4786 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4787 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4788 If you obtained GMP and/or MPFR from a vendor distribution package, make
4789 sure that you have installed both the libraries and the header files.
4790 They may be located in separate packages." >&5
4791 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.2+.
4792 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4793 Copies of these libraries' source code can be found at their respective
4794 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4795 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4796 If you obtained GMP and/or MPFR from a vendor distribution package, make
4797 sure that you have installed both the libraries and the header files.
4798 They may be located in separate packages." >&2;}
4799    { (exit 1); exit 1; }; }
4800   fi
4801 fi
4802
4803 # Flags needed for both GMP and/or MPFR
4804
4805
4806
4807
4808 # Check for PPL
4809 ppl_major_version=0
4810 ppl_minor_version=10
4811 ppllibs=
4812 pplinc=
4813
4814
4815 # Check whether --with-ppl or --without-ppl was given.
4816 if test "${with_ppl+set}" = set; then
4817   withval="$with_ppl"
4818
4819 fi;
4820
4821 # Check whether --with-ppl_include or --without-ppl_include was given.
4822 if test "${with_ppl_include+set}" = set; then
4823   withval="$with_ppl_include"
4824
4825 fi;
4826
4827 # Check whether --with-ppl_lib or --without-ppl_lib was given.
4828 if test "${with_ppl_lib+set}" = set; then
4829   withval="$with_ppl_lib"
4830
4831 fi;
4832
4833 if test "x$with_ppl" != x; then
4834   ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx"
4835   pplinc="-I$with_ppl/include $pplinc"
4836   LIBS="$ppllibs $LIBS"
4837 fi
4838 if test "x$with_ppl_include" != x; then
4839   pplinc="-I$with_ppl_include $pplinc"
4840 fi
4841 if test "x$with_ppl_lib" != x; then
4842   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx"
4843   LIBS="$ppllibs $LIBS"
4844 fi
4845 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
4846   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '
4847   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
4848   LIBS="$ppllibs $LIBS"
4849 fi
4850
4851 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
4852 if test "${enable_ppl_version_check+set}" = set; then
4853   enableval="$enable_ppl_version_check"
4854   ENABLE_PPL_CHECK=$enableval
4855 else
4856   ENABLE_PPL_CHECK=yes
4857 fi;
4858
4859 if test "${ENABLE_PPL_CHECK}" = "yes"; then
4860   saved_CFLAGS="$CFLAGS"
4861   CFLAGS="$CFLAGS $pplinc $gmpinc"
4862   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
4863 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
4864   cat >conftest.$ac_ext <<_ACEOF
4865 /* confdefs.h.  */
4866 _ACEOF
4867 cat confdefs.h >>conftest.$ac_ext
4868 cat >>conftest.$ac_ext <<_ACEOF
4869 /* end confdefs.h.  */
4870 #include "ppl_c.h"
4871 int
4872 main ()
4873 {
4874
4875   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
4876   choke me
4877   #endif
4878
4879   ;
4880   return 0;
4881 }
4882 _ACEOF
4883 rm -f conftest.$ac_objext
4884 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4885   (eval $ac_compile) 2>conftest.er1
4886   ac_status=$?
4887   grep -v '^ *+' conftest.er1 >conftest.err
4888   rm -f conftest.er1
4889   cat conftest.err >&5
4890   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4891   (exit $ac_status); } &&
4892          { ac_try='test -z "$ac_c_werror_flag"
4893                          || test ! -s conftest.err'
4894   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4895   (eval $ac_try) 2>&5
4896   ac_status=$?
4897   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4898   (exit $ac_status); }; } &&
4899          { ac_try='test -s conftest.$ac_objext'
4900   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4901   (eval $ac_try) 2>&5
4902   ac_status=$?
4903   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4904   (exit $ac_status); }; }; then
4905   echo "$as_me:$LINENO: result: yes" >&5
4906 echo "${ECHO_T}yes" >&6
4907 else
4908   echo "$as_me: failed program was:" >&5
4909 sed 's/^/| /' conftest.$ac_ext >&5
4910
4911 echo "$as_me:$LINENO: result: no" >&5
4912 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
4913 fi
4914 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4915   CFLAGS="$saved_CFLAGS"
4916 fi
4917
4918 # Flags needed for PPL
4919
4920
4921
4922
4923 # Check for CLOOG
4924 clooglibs=" -lcloog "
4925 clooginc=" -DCLOOG_PPL_BACKEND "
4926
4927
4928 # Check whether --with-cloog or --without-cloog was given.
4929 if test "${with_cloog+set}" = set; then
4930   withval="$with_cloog"
4931
4932 fi;
4933
4934 # Check whether --with-cloog_include or --without-cloog_include was given.
4935 if test "${with_cloog_include+set}" = set; then
4936   withval="$with_cloog_include"
4937
4938 fi;
4939
4940 # Check whether --with-cloog_lib or --without-cloog_lib was given.
4941 if test "${with_cloog_lib+set}" = set; then
4942   withval="$with_cloog_lib"
4943
4944 fi;
4945
4946 # Check whether --with-cloog-polylib or --without-cloog-polylib was given.
4947 if test "${with_cloog_polylib+set}" = set; then
4948   withval="$with_cloog_polylib"
4949
4950 fi;
4951
4952 if test "x$with_cloog" != x; then
4953   clooglibs="-L$with_cloog/lib -lcloog"
4954   clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
4955   LIBS="$clooglibs $LIBS"
4956 fi
4957 if test "x$with_cloog_polylib" != x; then
4958   clooglibs="-L$with_cloog/lib -lcloog"
4959   clooginc="-I$with_cloog/include "
4960   LIBS="$clooglibs $LIBS"
4961 fi
4962 if test "x$with_cloog_include" != x; then
4963   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
4964 fi
4965 if test "x$with_cloog_lib" != x; then
4966   clooglibs="-L$with_cloog_lib -lcloog"
4967   LIBS="$clooglibs $LIBS"
4968 fi
4969 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
4970   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
4971   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
4972   LIBS="$clooglibs $LIBS"
4973 fi
4974
4975 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
4976 if test "${enable_cloog_version_check+set}" = set; then
4977   enableval="$enable_cloog_version_check"
4978   ENABLE_CLOOG_CHECK=$enableval
4979 else
4980   ENABLE_CLOOG_CHECK=yes
4981 fi;
4982
4983 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
4984   saved_CFLAGS="$CFLAGS"
4985   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
4986   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
4987 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
4988   cat >conftest.$ac_ext <<_ACEOF
4989 /* confdefs.h.  */
4990 _ACEOF
4991 cat confdefs.h >>conftest.$ac_ext
4992 cat >>conftest.$ac_ext <<_ACEOF
4993 /* end confdefs.h.  */
4994 #include "cloog/cloog.h"
4995 int
4996 main ()
4997 {
4998
4999   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5000   choke me
5001   #endif
5002
5003   ;
5004   return 0;
5005 }
5006 _ACEOF
5007 rm -f conftest.$ac_objext
5008 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5009   (eval $ac_compile) 2>conftest.er1
5010   ac_status=$?
5011   grep -v '^ *+' conftest.er1 >conftest.err
5012   rm -f conftest.er1
5013   cat conftest.err >&5
5014   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5015   (exit $ac_status); } &&
5016          { ac_try='test -z "$ac_c_werror_flag"
5017                          || test ! -s conftest.err'
5018   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5019   (eval $ac_try) 2>&5
5020   ac_status=$?
5021   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5022   (exit $ac_status); }; } &&
5023          { ac_try='test -s conftest.$ac_objext'
5024   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5025   (eval $ac_try) 2>&5
5026   ac_status=$?
5027   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5028   (exit $ac_status); }; }; then
5029   echo "$as_me:$LINENO: result: yes" >&5
5030 echo "${ECHO_T}yes" >&6
5031 else
5032   echo "$as_me: failed program was:" >&5
5033 sed 's/^/| /' conftest.$ac_ext >&5
5034
5035 echo "$as_me:$LINENO: result: no" >&5
5036 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5037 fi
5038 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5039   CFLAGS="$saved_CFLAGS"
5040 fi
5041
5042 # Flags needed for CLOOG
5043
5044
5045
5046
5047 # By default, C is the only stage 1 language.
5048 stage1_languages=,c,
5049
5050 # Figure out what language subdirectories are present.
5051 # Look if the user specified --enable-languages="..."; if not, use
5052 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5053 # go away some day.
5054 # NB:  embedded tabs in this IF block -- do not untabify
5055 if test -d ${srcdir}/gcc; then
5056   if test x"${enable_languages+set}" != xset; then
5057     if test x"${LANGUAGES+set}" = xset; then
5058       enable_languages="${LANGUAGES}"
5059         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5060     else
5061       enable_languages=all
5062     fi
5063   else
5064     if test x"${enable_languages}" = x ||
5065        test x"${enable_languages}" = xyes;
5066        then
5067       echo configure.in: --enable-languages needs at least one language argument 1>&2
5068       exit 1
5069     fi
5070   fi
5071   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5072
5073   # 'f95' is the old name for the 'fortran' language. We issue a warning
5074   # and make the substitution.
5075   case ,${enable_languages}, in
5076     *,f95,*)
5077       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5078       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5079       ;;
5080   esac
5081
5082   # First scan to see if an enabled language requires some other language.
5083   # We assume that a given config-lang.in will list all the language
5084   # front ends it requires, even if some are required indirectly.
5085   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5086     case ${lang_frag} in
5087       ..) ;;
5088       # The odd quoting in the next line works around
5089       # an apparent bug in bash 1.12 on linux.
5090       ${srcdir}/gcc/[*]/config-lang.in) ;;
5091       *)
5092         # From the config-lang.in, get $language, $lang_requires
5093         language=
5094         lang_requires=
5095         . ${lang_frag}
5096         for other in ${lang_requires} ; do
5097           case ,${enable_languages}, in
5098             *,$other,*) ;;
5099             *,all,*) ;;
5100             *,$language,*)
5101               echo " \`$other' language required by \`$language'; enabling" 1>&2
5102               enable_languages="${enable_languages},${other}"
5103               ;;
5104           esac
5105         done
5106         ;;
5107     esac
5108   done
5109
5110   new_enable_languages=,c,
5111   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5112   potential_languages=,c,
5113
5114   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5115     case ${lang_frag} in
5116       ..) ;;
5117       # The odd quoting in the next line works around
5118       # an apparent bug in bash 1.12 on linux.
5119       ${srcdir}/gcc/[*]/config-lang.in) ;;
5120       *)
5121         # From the config-lang.in, get $language, $target_libs,
5122         # $lang_dirs, $boot_language, and $build_by_default
5123         language=
5124         target_libs=
5125         lang_dirs=
5126         subdir_requires=
5127         boot_language=no
5128         build_by_default=yes
5129         . ${lang_frag}
5130         if test x${language} = x; then
5131           echo "${lang_frag} doesn't set \$language." 1>&2
5132           exit 1
5133         fi
5134
5135         case ,${enable_languages}, in
5136           *,${language},*)
5137             # Language was explicitly selected; include it.
5138             add_this_lang=yes
5139             ;;
5140           *,all,*)
5141             # 'all' was selected, select it if it is a default language
5142             add_this_lang=${build_by_default}
5143             ;;
5144           *)
5145             add_this_lang=no
5146             ;;
5147         esac
5148
5149         # Disable languages that need other directories if these aren't available.
5150         for i in $subdir_requires; do
5151           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5152           case ,${enable_languages}, in
5153             *,${language},*)
5154               # Specifically requested language; tell them.
5155               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5156 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5157    { (exit 1); exit 1; }; }
5158               ;;
5159             *)
5160               # Silently disable.
5161               add_this_lang=unsupported
5162               ;;
5163           esac
5164         done
5165
5166         # Disable Ada if no preexisting GNAT is available.
5167         case ,${enable_languages},:${language}:${have_gnat} in
5168           *,${language},*:ada:no)
5169             # Specifically requested language; tell them.
5170             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5171 echo "$as_me: error: GNAT is required to build $language" >&2;}
5172    { (exit 1); exit 1; }; }
5173             ;;
5174           *:ada:no)
5175             # Silently disable.
5176             add_this_lang=unsupported
5177             ;;
5178         esac
5179
5180         # Disable a language that is unsupported by the target.
5181         case " $unsupported_languages " in
5182           *" $language "*)
5183             add_this_lang=unsupported
5184             ;;
5185         esac
5186
5187         case $add_this_lang in
5188           unsupported)
5189             # Remove language-dependent dirs.
5190             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5191             ;;
5192           no)
5193             # Remove language-dependent dirs; still show language as supported.
5194             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5195             potential_languages="${potential_languages}${language},"
5196             ;;
5197           yes)
5198             new_enable_languages="${new_enable_languages}${language},"
5199             potential_languages="${potential_languages}${language},"
5200             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5201             case ${boot_language} in
5202               yes)
5203                 # Add to (comma-separated) list of stage 1 languages.
5204                 stage1_languages="${stage1_languages}${language},"
5205                 ;;
5206             esac
5207             ;;
5208         esac
5209         ;;
5210     esac
5211   done
5212
5213   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5214 if test "${enable_stage1_languages+set}" = set; then
5215   enableval="$enable_stage1_languages"
5216   case ,${enable_stage1_languages}, in
5217     ,no,|,,)
5218       # Set it to something that will have no effect in the loop below
5219       enable_stage1_languages=c ;;
5220     ,yes,)
5221       enable_stage1_languages=`echo $new_enable_languages | \
5222         sed -e "s/^,//" -e "s/,$//" ` ;;
5223     *,all,*)
5224       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5225         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5226   esac
5227
5228   # Add "good" languages from enable_stage1_languages to stage1_languages,
5229   # while "bad" languages go in missing_languages.  Leave no duplicates.
5230   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5231     case $potential_languages in
5232       *,$i,*)
5233         case $stage1_languages in
5234           *,$i,*) ;;
5235           *) stage1_languages="$stage1_languages$i," ;;
5236         esac ;;
5237       *)
5238         case $missing_languages in
5239           *,$i,*) ;;
5240           *) missing_languages="$missing_languages$i," ;;
5241         esac ;;
5242      esac
5243   done
5244 fi;
5245
5246   # Remove leading/trailing commas that were added for simplicity
5247   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5248   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5249   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5250   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5251
5252   if test "x$missing_languages" != x; then
5253     { { echo "$as_me:$LINENO: error:
5254 The following requested languages could not be built: ${missing_languages}
5255 Supported languages are: ${potential_languages}" >&5
5256 echo "$as_me: error:
5257 The following requested languages could not be built: ${missing_languages}
5258 Supported languages are: ${potential_languages}" >&2;}
5259    { (exit 1); exit 1; }; }
5260   fi
5261   if test "x$new_enable_languages" != "x$enable_languages"; then
5262     echo The following languages will be built: ${new_enable_languages}
5263     enable_languages="$new_enable_languages"
5264   fi
5265
5266
5267   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5268 fi
5269
5270 # Handle --disable-<component> generically.
5271 for dir in $configdirs $build_configdirs $target_configdirs ; do
5272   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5273   varname=`echo $dirname | sed -e s/+/_/g`
5274   if eval test x\${enable_${varname}} "=" xno ; then
5275     noconfigdirs="$noconfigdirs $dir"
5276   fi
5277 done
5278
5279 # Check for Boehm's garbage collector
5280 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5281 if test "${enable_objc_gc+set}" = set; then
5282   enableval="$enable_objc_gc"
5283   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5284   *,objc,*:*:yes:*target-boehm-gc*)
5285     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5286 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5287    { (exit 1); exit 1; }; }
5288     ;;
5289 esac
5290 fi;
5291
5292 # Make sure we only build Boehm's garbage collector if required.
5293 case ,${enable_languages},:${enable_objc_gc} in
5294   *,objc,*:yes)
5295     # Keep target-boehm-gc if requested for Objective-C.
5296     ;;
5297   *)
5298     # Otherwise remove target-boehm-gc depending on target-libjava.
5299     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5300       noconfigdirs="$noconfigdirs target-boehm-gc"
5301     fi
5302     ;;
5303 esac
5304
5305 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5306 # $build_configdirs and $target_configdirs.
5307 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5308
5309 notsupp=""
5310 for dir in . $skipdirs $noconfigdirs ; do
5311   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5312   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5313     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5314     if test -r $srcdir/$dirname/configure ; then
5315       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5316         true
5317       else
5318         notsupp="$notsupp $dir"
5319       fi
5320     fi
5321   fi
5322   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5323     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5324     if test -r $srcdir/$dirname/configure ; then
5325       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5326         true
5327       else
5328         notsupp="$notsupp $dir"
5329       fi
5330     fi
5331   fi
5332   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5333     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5334     if test -r $srcdir/$dirname/configure ; then
5335       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5336         true
5337       else
5338         notsupp="$notsupp $dir"
5339       fi
5340     fi
5341   fi
5342 done
5343
5344 # Sometimes the tools are distributed with libiberty but with no other
5345 # libraries.  In that case, we don't want to build target-libiberty.
5346 # Don't let libgcc imply libiberty either.
5347 if test -n "${target_configdirs}" ; then
5348   libgcc=
5349   others=
5350   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5351     if test "$i" = "libgcc"; then
5352       libgcc=target-libgcc
5353     elif test "$i" != "libiberty" ; then
5354       if test -r $srcdir/$i/configure ; then
5355         others=yes;
5356         break;
5357       fi
5358     fi
5359   done
5360   if test -z "${others}" ; then
5361     target_configdirs=$libgcc
5362   fi
5363 fi
5364
5365 # Quietly strip out all directories which aren't configurable in this tree.
5366 # This relies on all configurable subdirectories being autoconfiscated, which
5367 # is now the case.
5368 build_configdirs_all="$build_configdirs"
5369 build_configdirs=
5370 for i in ${build_configdirs_all} ; do
5371   j=`echo $i | sed -e s/build-//g`
5372   if test -f ${srcdir}/$j/configure ; then
5373     build_configdirs="${build_configdirs} $i"
5374   fi
5375 done
5376
5377 configdirs_all="$configdirs"
5378 configdirs=
5379 for i in ${configdirs_all} ; do
5380   if test -f ${srcdir}/$i/configure ; then
5381     configdirs="${configdirs} $i"
5382   fi
5383 done
5384
5385 target_configdirs_all="$target_configdirs"
5386 target_configdirs=
5387 for i in ${target_configdirs_all} ; do
5388   j=`echo $i | sed -e s/target-//g`
5389   if test -f ${srcdir}/$j/configure ; then
5390     target_configdirs="${target_configdirs} $i"
5391   fi
5392 done
5393
5394 # Produce a warning message for the subdirs we can't configure.
5395 # This isn't especially interesting in the Cygnus tree, but in the individual
5396 # FSF releases, it's important to let people know when their machine isn't
5397 # supported by the one or two programs in a package.
5398
5399 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5400   # If $appdirs is non-empty, at least one of those directories must still
5401   # be configured, or we error out.  (E.g., if the gas release supports a
5402   # specified target in some subdirs but not the gas subdir, we shouldn't
5403   # pretend that all is well.)
5404   if test -n "$appdirs" ; then
5405     for dir in $appdirs ; do
5406       if test -r $dir/Makefile.in ; then
5407         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5408           appdirs=""
5409           break
5410         fi
5411         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5412           appdirs=""
5413           break
5414         fi
5415       fi
5416     done
5417     if test -n "$appdirs" ; then
5418       echo "*** This configuration is not supported by this package." 1>&2
5419       exit 1
5420     fi
5421   fi
5422   # Okay, some application will build, or we don't care to check.  Still
5423   # notify of subdirs not getting built.
5424   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5425   echo "    ${notsupp}" 1>&2
5426   echo "    (Any other directories should still work fine.)" 1>&2
5427 fi
5428
5429 case "$host" in
5430   *msdosdjgpp*)
5431     enable_gdbtk=no ;;
5432 esac
5433
5434 # To find our prefix, in gcc_cv_tool_prefix.
5435
5436 # The user is always right.
5437 if test "${PATH_SEPARATOR+set}" != set; then
5438   echo "#! /bin/sh" >conf$$.sh
5439   echo  "exit 0"   >>conf$$.sh
5440   chmod +x conf$$.sh
5441   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5442     PATH_SEPARATOR=';'
5443   else
5444     PATH_SEPARATOR=:
5445   fi
5446   rm -f conf$$.sh
5447 fi
5448
5449
5450
5451 if test "x$exec_prefix" = xNONE; then
5452         if test "x$prefix" = xNONE; then
5453                 gcc_cv_tool_prefix=$ac_default_prefix
5454         else
5455                 gcc_cv_tool_prefix=$prefix
5456         fi
5457 else
5458         gcc_cv_tool_prefix=$exec_prefix
5459 fi
5460
5461 # If there is no compiler in the tree, use the PATH only.  In any
5462 # case, if there is no compiler in the tree nobody should use
5463 # AS_FOR_TARGET and LD_FOR_TARGET.
5464 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5465     gcc_version=`cat $srcdir/gcc/BASE-VER`
5466     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5467     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5468     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5469     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5470     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5471     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5472 else
5473     gcc_cv_tool_dirs=
5474 fi
5475
5476 if test x$build = x$target && test -n "$md_exec_prefix"; then
5477         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5478 fi
5479
5480
5481
5482 copy_dirs=
5483
5484
5485 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5486 if test "${with_build_sysroot+set}" = set; then
5487   withval="$with_build_sysroot"
5488   if test x"$withval" != x ; then
5489      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5490    fi
5491 else
5492   SYSROOT_CFLAGS_FOR_TARGET=
5493 fi;
5494
5495
5496
5497 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5498 if test "${with_debug_prefix_map+set}" = set; then
5499   withval="$with_debug_prefix_map"
5500   if test x"$withval" != x; then
5501      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5502      for debug_map in $withval; do
5503        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5504      done
5505    fi
5506 else
5507   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5508 fi;
5509
5510
5511 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5512 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5513 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5514 # We want to ensure that TARGET libraries (which we know are built with
5515 # gcc) are built with "-O2 -g", so include those options when setting
5516 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5517 if test "x$CFLAGS_FOR_TARGET" = x; then
5518   CFLAGS_FOR_TARGET=$CFLAGS
5519   case " $CFLAGS " in
5520     *" -O2 "*) ;;
5521     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5522   esac
5523   case " $CFLAGS " in
5524     *" -g "* | *" -g3 "*) ;;
5525     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5526   esac
5527 fi
5528
5529
5530 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5531   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5532   case " $CXXFLAGS " in
5533     *" -O2 "*) ;;
5534     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5535   esac
5536   case " $CXXFLAGS " in
5537     *" -g "* | *" -g3 "*) ;;
5538     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5539   esac
5540 fi
5541
5542
5543 # Other target tools.
5544 CPPFLAGS_FOR_TARGET=${CPPFLAGS_FOR_TARGET-${CPPFLAGS}}
5545
5546 LDFLAGS_FOR_TARGET=${LDFLAGS_FOR_TARGET-${LDFLAGS}}
5547
5548
5549 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5550 # the named directory are copied to $(tooldir)/sys-include.
5551 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5552   if test x${is_cross_compiler} = xno ; then
5553     echo 1>&2 '***' --with-headers is only supported when cross compiling
5554     exit 1
5555   fi
5556   if test x"${with_headers}" != xyes ; then
5557     x=${gcc_cv_tool_prefix}
5558     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5559   fi
5560 fi
5561
5562 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5563 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5564 # are permitted.
5565 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5566   if test x${is_cross_compiler} = xno ; then
5567     echo 1>&2 '***' --with-libs is only supported when cross compiling
5568     exit 1
5569   fi
5570   if test x"${with_libs}" != xyes ; then
5571     # Copy the libraries in reverse order, so that files in the first named
5572     # library override files in subsequent libraries.
5573     x=${gcc_cv_tool_prefix}
5574     for l in ${with_libs}; do
5575       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5576     done
5577   fi
5578 fi
5579
5580 # Set with_gnu_as and with_gnu_ld as appropriate.
5581 #
5582 # This is done by determining whether or not the appropriate directory
5583 # is available, and by checking whether or not specific configurations
5584 # have requested that this magic not happen.
5585 #
5586 # The command line options always override the explicit settings in
5587 # configure.in, and the settings in configure.in override this magic.
5588 #
5589 # If the default for a toolchain is to use GNU as and ld, and you don't
5590 # want to do that, then you should use the --without-gnu-as and
5591 # --without-gnu-ld options for the configure script.
5592
5593 if test x${use_gnu_as} = x &&
5594    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5595   with_gnu_as=yes
5596   extra_host_args="$extra_host_args --with-gnu-as"
5597 fi
5598
5599 if test x${use_gnu_ld} = x &&
5600    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5601   with_gnu_ld=yes
5602   extra_host_args="$extra_host_args --with-gnu-ld"
5603 fi
5604
5605 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5606 # can detect this case.
5607
5608 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5609   with_newlib=yes
5610   extra_host_args="$extra_host_args --with-newlib"
5611 fi
5612
5613 # Handle ${copy_dirs}
5614 set fnord ${copy_dirs}
5615 shift
5616 while test $# != 0 ; do
5617   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5618     :
5619   else
5620     echo Copying $1 to $2
5621
5622     # Use the install script to create the directory and all required
5623     # parent directories.
5624     if test -d $2 ; then
5625       :
5626     else
5627       echo >config.temp
5628       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5629     fi
5630
5631     # Copy the directory, assuming we have tar.
5632     # FIXME: Should we use B in the second tar?  Not all systems support it.
5633     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5634
5635     # It is the responsibility of the user to correctly adjust all
5636     # symlinks.  If somebody can figure out how to handle them correctly
5637     # here, feel free to add the code.
5638
5639     echo $1 > $2/COPIED
5640   fi
5641   shift; shift
5642 done
5643
5644 # Determine a target-dependent exec_prefix that the installed
5645 # gcc will search in.  Keep this list sorted by triplet, with
5646 # the *-*-osname triplets last.
5647 md_exec_prefix=
5648 case "${target}" in
5649   alpha*-*-*vms*)
5650     md_exec_prefix=/gnu/lib/gcc-lib
5651     ;;
5652   i[34567]86-pc-msdosdjgpp*)
5653     md_exec_prefix=/dev/env/DJDIR/bin
5654     ;;
5655   i[34567]86-*-sco3.2v5*)
5656     if test $with_gnu_as = yes; then
5657       md_exec_prefix=/usr/gnu/bin
5658     else
5659       md_exec_prefix=/usr/ccs/bin/elf
5660     fi
5661     ;;
5662
5663   mn10300-*-* | \
5664   powerpc-*-chorusos* | \
5665   powerpc*-*-eabi* | \
5666   powerpc*-*-sysv* | \
5667   powerpc*-*-kaos* | \
5668   s390x-ibm-tpf*)
5669     md_exec_prefix=/usr/ccs/bin
5670     ;;
5671   sparc64-*-elf*)
5672     ;;
5673   v850*-*-*)
5674     md_exec_prefix=/usr/ccs/bin
5675     ;;
5676   xtensa*-*-elf*)
5677     ;;
5678
5679   *-*-beos* | \
5680   *-*-elf* | \
5681   *-*-hpux* | \
5682   *-*-netware* | \
5683   *-*-nto-qnx* | \
5684   *-*-rtems* | \
5685   *-*-solaris2* | \
5686   *-*-sysv[45]* | \
5687   *-*-vxworks* | \
5688   *-wrs-windiss)
5689     md_exec_prefix=/usr/ccs/bin
5690     ;;
5691 esac
5692
5693 extra_arflags_for_target=
5694 extra_nmflags_for_target=
5695 extra_ranlibflags_for_target=
5696 target_makefile_frag=/dev/null
5697 case "${target}" in
5698   mep*-*-*)
5699     target_makefile_frag="config/mt-mep"
5700     ;;
5701   spu-*-*)
5702     target_makefile_frag="config/mt-spu"
5703     ;;
5704   mips*-sde-elf*)
5705     target_makefile_frag="config/mt-sde"
5706     ;;
5707   mipsisa*-*-elfoabi*)
5708     target_makefile_frag="config/mt-mips-elfoabi"
5709     ;;
5710   mips*-*-*linux* | mips*-*-gnu*)
5711     target_makefile_frag="config/mt-mips-gnu"
5712     ;;
5713   *-*-netware*)
5714     target_makefile_frag="config/mt-netware"
5715     ;;
5716   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5717     target_makefile_frag="config/mt-gnu"
5718     ;;
5719   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5720     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5721     # commands to handle both 32-bit and 64-bit objects.  These flags are
5722     # harmless if we're using GNU nm or ar.
5723     extra_arflags_for_target=" -X32_64"
5724     extra_nmflags_for_target=" -B -X32_64"
5725     ;;
5726   *-*-darwin*)
5727     # ranlib from Darwin requires the -c flag to look at common symbols.
5728     extra_ranlibflags_for_target=" -c"
5729     ;;
5730   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5731     target_makefile_frag="config/mt-wince"
5732     ;;
5733 esac
5734
5735 alphaieee_frag=/dev/null
5736 case $target in
5737   alpha*-*-*)
5738     # This just makes sure to use the -mieee option to build target libs.
5739     # This should probably be set individually by each library.
5740     alphaieee_frag="config/mt-alphaieee"
5741     ;;
5742 esac
5743
5744 # If --enable-target-optspace always use -Os instead of -O2 to build
5745 # the target libraries, similarly if it is not specified, use -Os
5746 # on selected platforms.
5747 ospace_frag=/dev/null
5748 case "${enable_target_optspace}:${target}" in
5749   yes:*)
5750     ospace_frag="config/mt-ospace"
5751     ;;
5752   :d30v-*)
5753     ospace_frag="config/mt-d30v"
5754     ;;
5755   :m32r-* | :d10v-* | :fr30-*)
5756     ospace_frag="config/mt-ospace"
5757     ;;
5758   no:* | :*)
5759     ;;
5760   *)
5761     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5762     ;;
5763 esac
5764
5765 # Default to using --with-stabs for certain targets.
5766 if test x${with_stabs} = x ; then
5767   case "${target}" in
5768   mips*-*-irix[56]*)
5769     ;;
5770   mips*-*-* | alpha*-*-osf*)
5771     with_stabs=yes;
5772     extra_host_args="${extra_host_args} --with-stabs"
5773     ;;
5774   esac
5775 fi
5776
5777 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5778 # them automatically.
5779 case "${host}" in
5780   hppa*64*-*-hpux11*)
5781     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5782     ;;
5783 esac
5784
5785 # Some systems (e.g., one of the i386-aix systems the gas testers are
5786 # using) don't handle "\$" correctly, so don't use it here.
5787 tooldir='${exec_prefix}'/${target_noncanonical}
5788 build_tooldir=${tooldir}
5789
5790 # Create a .gdbinit file which runs the one in srcdir
5791 # and tells GDB to look there for source files.
5792
5793 if test -r ${srcdir}/.gdbinit ; then
5794   case ${srcdir} in
5795     .) ;;
5796     *) cat > ./.gdbinit <<EOF
5797 # ${NO_EDIT}
5798 dir ${srcdir}
5799 dir .
5800 source ${srcdir}/.gdbinit
5801 EOF
5802     ;;
5803   esac
5804 fi
5805
5806 # Make sure that the compiler is able to generate an executable.  If it
5807 # can't, we are probably in trouble.  We don't care whether we can run the
5808 # executable--we might be using a cross compiler--we only care whether it
5809 # can be created.  At this point the main configure script has set CC.
5810 we_are_ok=no
5811 echo "int main () { return 0; }" > conftest.c
5812 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5813 if test $? = 0 ; then
5814   if test -s conftest || test -s conftest.exe ; then
5815     we_are_ok=yes
5816   fi
5817 fi
5818 case $we_are_ok in
5819   no)
5820     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5821     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5822     rm -f conftest*
5823     exit 1
5824     ;;
5825 esac
5826 rm -f conftest*
5827
5828 # The Solaris /usr/ucb/cc compiler does not appear to work.
5829 case "${host}" in
5830   sparc-sun-solaris2*)
5831       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5832       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5833           could_use=
5834           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5835           if test -d /opt/cygnus/bin ; then
5836               if test "$could_use" = "" ; then
5837                   could_use="/opt/cygnus/bin"
5838               else
5839                   could_use="$could_use or /opt/cygnus/bin"
5840               fi
5841           fi
5842         if test "$could_use" = "" ; then
5843             echo "Warning: compilation may fail because you're using"
5844             echo "/usr/ucb/cc.  You should change your PATH or CC "
5845             echo "variable and rerun configure."
5846         else
5847             echo "Warning: compilation may fail because you're using"
5848             echo "/usr/ucb/cc, when you should use the C compiler from"
5849             echo "$could_use.  You should change your"
5850             echo "PATH or CC variable and rerun configure."
5851         fi
5852       fi
5853   ;;
5854 esac
5855
5856 # Decide which environment variable is used to find dynamic libraries.
5857 case "${host}" in
5858   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5859   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5860   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5861   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5862 esac
5863
5864 # On systems where the dynamic library environment variable is PATH,
5865 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
5866 # built executables to PATH.
5867 if test "$RPATH_ENVVAR" = PATH; then
5868   GCC_SHLIB_SUBDIR=/shlib
5869 else
5870   GCC_SHLIB_SUBDIR=
5871 fi
5872
5873 # Record target_configdirs and the configure arguments for target and
5874 # build configuration in Makefile.
5875 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5876 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5877
5878 # Determine whether gdb needs tk/tcl or not.
5879 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5880 # and in that case we want gdb to be built without tk.  Ugh!
5881 # In fact I believe gdb is the *only* package directly dependent on tk,
5882 # so we should be able to put the 'maybe's in unconditionally and
5883 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5884 # 100% sure that that's safe though.
5885
5886 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5887 case "$enable_gdbtk" in
5888   no)
5889     GDB_TK="" ;;
5890   yes)
5891     GDB_TK="${gdb_tk}" ;;
5892   *)
5893     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5894     # distro.  Eventually someone will fix this and move Insight, nee
5895     # gdbtk to a separate directory.
5896     if test -d ${srcdir}/gdb/gdbtk ; then
5897       GDB_TK="${gdb_tk}"
5898     else
5899       GDB_TK=""
5900     fi
5901     ;;
5902 esac
5903 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5904 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5905
5906 # Strip out unwanted targets.
5907
5908 # While at that, we remove Makefiles if we were started for recursive
5909 # configuration, so that the top-level Makefile reconfigures them,
5910 # like we used to do when configure itself was recursive.
5911
5912 # Loop over modules.  $extrasub must be used with care, limiting as
5913 # much as possible the usage of range addresses.  That's because autoconf
5914 # splits the sed script to overcome limits in the number of commands,
5915 # and relying on carefully-timed sed passes may turn out to be very hard
5916 # to maintain later.  In this particular case, you just have to be careful
5917 # not to nest @if/@endif pairs, because configure will not warn you at all.
5918
5919 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5920 if test "${enable_bootstrap+set}" = set; then
5921   enableval="$enable_bootstrap"
5922
5923 else
5924   enable_bootstrap=default
5925 fi;
5926
5927 # Issue errors and warnings for invalid/strange bootstrap combinations.
5928 case "$configdirs" in
5929   *gcc*) have_compiler=yes ;;
5930   *) have_compiler=no ;;
5931 esac
5932
5933 case "$have_compiler:$host:$target:$enable_bootstrap" in
5934   *:*:*:no) ;;
5935
5936   # Default behavior.  Enable bootstrap if we have a compiler
5937   # and we are in a native configuration.
5938   yes:$build:$build:default)
5939     enable_bootstrap=yes ;;
5940
5941   *:*:*:default)
5942     enable_bootstrap=no ;;
5943
5944   # We have a compiler and we are in a native configuration, bootstrap is ok
5945   yes:$build:$build:yes)
5946     ;;
5947
5948   # Other configurations, but we have a compiler.  Assume the user knows
5949   # what he's doing.
5950   yes:*:*:yes)
5951     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5952 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5953     ;;
5954
5955   # No compiler: if they passed --enable-bootstrap explicitly, fail
5956   no:*:*:yes)
5957     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5958 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5959    { (exit 1); exit 1; }; } ;;
5960
5961   # Fail if wrong command line
5962   *)
5963     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5964 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5965    { (exit 1); exit 1; }; }
5966     ;;
5967 esac
5968
5969 # Adjust the toplevel makefile according to whether bootstrap was selected.
5970 case "$enable_bootstrap" in
5971   yes)
5972     bootstrap_suffix=bootstrap ;;
5973   no)
5974     bootstrap_suffix=no-bootstrap ;;
5975 esac
5976
5977 for module in ${build_configdirs} ; do
5978   if test -z "${no_recursion}" \
5979      && test -f ${build_subdir}/${module}/Makefile; then
5980     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5981     rm -f ${build_subdir}/${module}/Makefile
5982   fi
5983   extrasub="$extrasub
5984 /^@if build-$module\$/d
5985 /^@endif build-$module\$/d
5986 /^@if build-$module-$bootstrap_suffix\$/d
5987 /^@endif build-$module-$bootstrap_suffix\$/d"
5988 done
5989 for module in ${configdirs} ; do
5990   if test -z "${no_recursion}"; then
5991     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5992       if test -f ${file}; then
5993         echo 1>&2 "*** removing ${file} to force reconfigure"
5994         rm -f ${file}
5995       fi
5996     done
5997   fi
5998   extrasub="$extrasub
5999 /^@if $module\$/d
6000 /^@endif $module\$/d
6001 /^@if $module-$bootstrap_suffix\$/d
6002 /^@endif $module-$bootstrap_suffix\$/d"
6003 done
6004 for module in ${target_configdirs} ; do
6005   if test -z "${no_recursion}" \
6006      && test -f ${target_subdir}/${module}/Makefile; then
6007     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6008     rm -f ${target_subdir}/${module}/Makefile
6009   fi
6010   extrasub="$extrasub
6011 /^@if target-$module\$/d
6012 /^@endif target-$module\$/d
6013 /^@if target-$module-$bootstrap_suffix\$/d
6014 /^@endif target-$module-$bootstrap_suffix\$/d"
6015 done
6016
6017 extrasub="$extrasub
6018 /^@if /,/^@endif /d"
6019
6020 # Create the serialization dependencies.  This uses a temporary file.
6021
6022 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6023 if test "${enable_serial_configure+set}" = set; then
6024   enableval="$enable_serial_configure"
6025
6026 fi;
6027
6028 case ${enable_serial_configure} in
6029   yes)
6030     enable_serial_build_configure=yes
6031     enable_serial_host_configure=yes
6032     enable_serial_target_configure=yes
6033     ;;
6034 esac
6035
6036 # These force 'configure's to be done one at a time, to avoid problems
6037 # with contention over a shared config.cache.
6038 rm -f serdep.tmp
6039 echo '# serdep.tmp' > serdep.tmp
6040 olditem=
6041 test "x${enable_serial_build_configure}" = xyes &&
6042 for item in ${build_configdirs} ; do
6043   case ${olditem} in
6044     "") ;;
6045     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6046   esac
6047   olditem=${item}
6048 done
6049 olditem=
6050 test "x${enable_serial_host_configure}" = xyes &&
6051 for item in ${configdirs} ; do
6052   case ${olditem} in
6053     "") ;;
6054     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6055   esac
6056   olditem=${item}
6057 done
6058 olditem=
6059 test "x${enable_serial_target_configure}" = xyes &&
6060 for item in ${target_configdirs} ; do
6061   case ${olditem} in
6062     "") ;;
6063     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6064   esac
6065   olditem=${item}
6066 done
6067 serialization_dependencies=serdep.tmp
6068
6069
6070 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6071 # target, nonopt, and variable assignments.  These are the ones we
6072 # might not want to pass down to subconfigures.  Also strip
6073 # program-prefix, program-suffix, and program-transform-name, so that
6074 # we can pass down a consistent program-transform-name.
6075 baseargs=
6076 keep_next=no
6077 skip_next=no
6078 eval "set -- $ac_configure_args"
6079 for ac_arg
6080 do
6081   if test X"$skip_next" = X"yes"; then
6082     skip_next=no
6083     continue
6084   fi
6085   if test X"$keep_next" = X"yes"; then
6086     case $ac_arg in
6087       *\'*)
6088         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6089     esac
6090     baseargs="$baseargs '$ac_arg'"
6091     keep_next=no
6092     continue
6093   fi
6094
6095   # Handle separated arguments.  Based on the logic generated by
6096   # autoconf 2.59.
6097   case $ac_arg in
6098     *=* | --config-cache | -C | -disable-* | --disable-* \
6099       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6100       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6101       | -with-* | --with-* | -without-* | --without-* | --x)
6102       separate_arg=no
6103       ;;
6104     -*)
6105       separate_arg=yes
6106       ;;
6107     *)
6108       separate_arg=no
6109       ;;
6110   esac
6111
6112   case "$ac_arg" in
6113     --no*)
6114       continue
6115       ;;
6116     --c* | \
6117     --sr* | \
6118     --ho* | \
6119     --bu* | \
6120     --t* | \
6121     --program-* | \
6122     -cache_file* | \
6123     -srcdir* | \
6124     -host* | \
6125     -build* | \
6126     -target* | \
6127     -program-prefix* | \
6128     -program-suffix* | \
6129     -program-transform-name* )
6130       skip_next=$separate_arg
6131       continue
6132       ;;
6133     -*)
6134       # An option.  Add it.
6135       case $ac_arg in
6136         *\'*)
6137           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6138       esac
6139       baseargs="$baseargs '$ac_arg'"
6140       keep_next=$separate_arg
6141       ;;
6142     *)
6143       # Either a variable assignment, or a nonopt (triplet).  Don't
6144       # pass it down; let the Makefile handle this.
6145       continue
6146       ;;
6147   esac
6148 done
6149 # Remove the initial space we just introduced and, as these will be
6150 # expanded by make, quote '$'.
6151 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6152
6153 # Add in --program-transform-name, after --program-prefix and
6154 # --program-suffix have been applied to it.  Autoconf has already
6155 # doubled dollar signs and backslashes in program_transform_name; we want
6156 # the backslashes un-doubled, and then the entire thing wrapped in single
6157 # quotes, because this will be expanded first by make and then by the shell.
6158 # Also, because we want to override the logic in subdir configure scripts to
6159 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6160 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6161 ${program_transform_name}
6162 EOF_SED
6163 gcc_transform_name=`cat conftestsed.out`
6164 rm -f conftestsed.out
6165 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6166 if test "$silent" = yes; then
6167   baseargs="$baseargs --silent"
6168 fi
6169
6170 # For the build-side libraries, we just need to pretend we're native,
6171 # and not use the same cache file.  Multilibs are neither needed nor
6172 # desired.
6173 build_configargs="--cache-file=../config.cache ${baseargs}"
6174
6175 # For host modules, accept cache file option, or specification as blank.
6176 case "${cache_file}" in
6177 "") # empty
6178   cache_file_option="" ;;
6179 /* | [A-Za-z]:[\\/]* ) # absolute path
6180   cache_file_option="--cache-file=${cache_file}" ;;
6181 *) # relative path
6182   cache_file_option="--cache-file=../${cache_file}" ;;
6183 esac
6184
6185 # Host dirs don't like to share a cache file either, horribly enough.
6186 # This seems to be due to autoconf 2.5x stupidity.
6187 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6188
6189 target_configargs=${baseargs}
6190
6191 # Passing a --with-cross-host argument lets the target libraries know
6192 # whether they are being built with a cross-compiler or being built
6193 # native.  However, it would be better to use other mechanisms to make the
6194 # sorts of decisions they want to make on this basis.  Please consider
6195 # this option to be deprecated.  FIXME.
6196 if test x${is_cross_compiler} = xyes ; then
6197   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6198 fi
6199
6200 # Default to --enable-multilib.
6201 if test x${enable_multilib} = x ; then
6202   target_configargs="--enable-multilib ${target_configargs}"
6203 fi
6204
6205 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6206 # changed from the earlier setting of with_newlib.
6207 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6208   target_configargs="--with-newlib ${target_configargs}"
6209 fi
6210
6211 # Different target subdirs use different values of certain variables
6212 # (notably CXX).  Worse, multilibs use *lots* of different values.
6213 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6214 # it doesn't automatically accept command-line overrides of them.
6215 # This means it's not safe for target subdirs to share a cache file,
6216 # which is disgusting, but there you have it.  Hopefully this can be
6217 # fixed in future.  It's still worthwhile to use a cache file for each
6218 # directory.  I think.
6219
6220 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6221 # We need to pass --target, as newer autoconf's requires consistency
6222 # for target_alias and gcc doesn't manage it consistently.
6223 target_configargs="--cache-file=./config.cache ${target_configargs}"
6224
6225 FLAGS_FOR_TARGET=
6226 case " $target_configdirs " in
6227  *" newlib "*)
6228   case " $target_configargs " in
6229   *" --with-newlib "*)
6230    case "$target" in
6231    *-cygwin*)
6232      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' ;;
6233    esac
6234
6235    # If we're not building GCC, don't discard standard headers.
6236    if test -d ${srcdir}/gcc; then
6237      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6238
6239      if test "${build}" != "${host}"; then
6240        # On Canadian crosses, CC_FOR_TARGET will have already been set
6241        # by `configure', so we won't have an opportunity to add -Bgcc/
6242        # to it.  This is right: we don't want to search that directory
6243        # for binaries, but we want the header files in there, so add
6244        # them explicitly.
6245        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6246
6247        # Someone might think of using the pre-installed headers on
6248        # Canadian crosses, in case the installed compiler is not fully
6249        # compatible with the compiler being built.  In this case, it
6250        # would be better to flag an error than risking having
6251        # incompatible object files being constructed.  We can't
6252        # guarantee that an error will be flagged, but let's hope the
6253        # compiler will do it, when presented with incompatible header
6254        # files.
6255      fi
6256    fi
6257
6258    case "${target}-${is_cross_compiler}" in
6259    i[3456789]86-*-linux*-no)
6260       # Here host == target, so we don't need to build gcc,
6261       # so we don't want to discard standard headers.
6262       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6263       ;;
6264    *)
6265       # If we're building newlib, use its generic headers last, but search
6266       # for any libc-related directories first (so make it the last -B
6267       # switch).
6268       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6269
6270       # If we're building libgloss, find the startup file, simulator library
6271       # and linker script.
6272       case " $target_configdirs " in
6273         *" libgloss "*)
6274         # Look for startup file, simulator library and maybe linker script.
6275         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6276         # Look for libnosys.a in case the target needs it.
6277         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6278         # Most targets have the linker script in the source directory.
6279         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6280         ;;
6281       esac
6282       ;;
6283    esac
6284    ;;
6285   esac
6286   ;;
6287 esac
6288 case "$target" in
6289 *-mingw*)
6290   # Can't be handled as Cygwin above since Mingw does not use newlib.
6291   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' ;;
6292 esac
6293
6294 # Allow the user to override the flags for
6295 # our build compiler if desired.
6296 if test x"${build}" = x"${host}" ; then
6297   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6298   CPPFLAGS_FOR_BUILD=${CPPFLAGS_FOR_BUILD-${CPPFLAGS}}
6299   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6300   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6301 fi
6302
6303 # On Canadian crosses, we'll be searching the right directories for
6304 # the previously-installed cross compiler, so don't bother to add
6305 # flags for directories within the install tree of the compiler
6306 # being built; programs in there won't even run.
6307 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6308   # Search for pre-installed headers if nothing else fits.
6309   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6310 fi
6311
6312 if test "x${use_gnu_ld}" = x &&
6313    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6314   # Arrange for us to find uninstalled linker scripts.
6315   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6316 fi
6317
6318 # Search for other target-specific linker scripts and such.
6319 case "${target}" in
6320   mep*)
6321     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6322     ;;
6323 esac
6324
6325 # Makefile fragments.
6326 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6327 do
6328   eval fragval=\$$frag
6329   if test $fragval != /dev/null; then
6330     eval $frag=${srcdir}/$fragval
6331   fi
6332 done
6333
6334
6335
6336
6337
6338 # Miscellanea: directories, flags, etc.
6339
6340
6341
6342
6343
6344
6345
6346
6347 # Build module lists & subconfigure args.
6348
6349
6350
6351 # Host module lists & subconfigure args.
6352
6353
6354
6355 # Target module lists & subconfigure args.
6356
6357
6358
6359 # Build tools.
6360
6361
6362
6363
6364
6365
6366
6367
6368
6369
6370
6371
6372
6373
6374
6375
6376
6377
6378 # Generate default definitions for YACC, M4, LEX and other programs that run
6379 # on the build machine.  These are used if the Makefile can't locate these
6380 # programs in objdir.
6381 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6382
6383 for ac_prog in 'bison -y' byacc yacc
6384 do
6385   # Extract the first word of "$ac_prog", so it can be a program name with args.
6386 set dummy $ac_prog; ac_word=$2
6387 echo "$as_me:$LINENO: checking for $ac_word" >&5
6388 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6389 if test "${ac_cv_prog_YACC+set}" = set; then
6390   echo $ECHO_N "(cached) $ECHO_C" >&6
6391 else
6392   if test -n "$YACC"; then
6393   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6394 else
6395 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6396 for as_dir in $PATH
6397 do
6398   IFS=$as_save_IFS
6399   test -z "$as_dir" && as_dir=.
6400   for ac_exec_ext in '' $ac_executable_extensions; do
6401   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6402     ac_cv_prog_YACC="$ac_prog"
6403     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6404     break 2
6405   fi
6406 done
6407 done
6408
6409 fi
6410 fi
6411 YACC=$ac_cv_prog_YACC
6412 if test -n "$YACC"; then
6413   echo "$as_me:$LINENO: result: $YACC" >&5
6414 echo "${ECHO_T}$YACC" >&6
6415 else
6416   echo "$as_me:$LINENO: result: no" >&5
6417 echo "${ECHO_T}no" >&6
6418 fi
6419
6420   test -n "$YACC" && break
6421 done
6422 test -n "$YACC" || YACC="$MISSING bison -y"
6423
6424 case " $build_configdirs " in
6425   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6426   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6427 esac
6428
6429 for ac_prog in bison
6430 do
6431   # Extract the first word of "$ac_prog", so it can be a program name with args.
6432 set dummy $ac_prog; ac_word=$2
6433 echo "$as_me:$LINENO: checking for $ac_word" >&5
6434 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6435 if test "${ac_cv_prog_BISON+set}" = set; then
6436   echo $ECHO_N "(cached) $ECHO_C" >&6
6437 else
6438   if test -n "$BISON"; then
6439   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6440 else
6441 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6442 for as_dir in $PATH
6443 do
6444   IFS=$as_save_IFS
6445   test -z "$as_dir" && as_dir=.
6446   for ac_exec_ext in '' $ac_executable_extensions; do
6447   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6448     ac_cv_prog_BISON="$ac_prog"
6449     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6450     break 2
6451   fi
6452 done
6453 done
6454
6455 fi
6456 fi
6457 BISON=$ac_cv_prog_BISON
6458 if test -n "$BISON"; then
6459   echo "$as_me:$LINENO: result: $BISON" >&5
6460 echo "${ECHO_T}$BISON" >&6
6461 else
6462   echo "$as_me:$LINENO: result: no" >&5
6463 echo "${ECHO_T}no" >&6
6464 fi
6465
6466   test -n "$BISON" && break
6467 done
6468 test -n "$BISON" || BISON="$MISSING bison"
6469
6470 case " $build_configdirs " in
6471   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6472 esac
6473
6474 for ac_prog in gm4 gnum4 m4
6475 do
6476   # Extract the first word of "$ac_prog", so it can be a program name with args.
6477 set dummy $ac_prog; ac_word=$2
6478 echo "$as_me:$LINENO: checking for $ac_word" >&5
6479 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6480 if test "${ac_cv_prog_M4+set}" = set; then
6481   echo $ECHO_N "(cached) $ECHO_C" >&6
6482 else
6483   if test -n "$M4"; then
6484   ac_cv_prog_M4="$M4" # Let the user override the test.
6485 else
6486 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6487 for as_dir in $PATH
6488 do
6489   IFS=$as_save_IFS
6490   test -z "$as_dir" && as_dir=.
6491   for ac_exec_ext in '' $ac_executable_extensions; do
6492   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6493     ac_cv_prog_M4="$ac_prog"
6494     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6495     break 2
6496   fi
6497 done
6498 done
6499
6500 fi
6501 fi
6502 M4=$ac_cv_prog_M4
6503 if test -n "$M4"; then
6504   echo "$as_me:$LINENO: result: $M4" >&5
6505 echo "${ECHO_T}$M4" >&6
6506 else
6507   echo "$as_me:$LINENO: result: no" >&5
6508 echo "${ECHO_T}no" >&6
6509 fi
6510
6511   test -n "$M4" && break
6512 done
6513 test -n "$M4" || M4="$MISSING m4"
6514
6515 case " $build_configdirs " in
6516   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6517 esac
6518
6519 for ac_prog in flex lex
6520 do
6521   # Extract the first word of "$ac_prog", so it can be a program name with args.
6522 set dummy $ac_prog; ac_word=$2
6523 echo "$as_me:$LINENO: checking for $ac_word" >&5
6524 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6525 if test "${ac_cv_prog_LEX+set}" = set; then
6526   echo $ECHO_N "(cached) $ECHO_C" >&6
6527 else
6528   if test -n "$LEX"; then
6529   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6530 else
6531 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6532 for as_dir in $PATH
6533 do
6534   IFS=$as_save_IFS
6535   test -z "$as_dir" && as_dir=.
6536   for ac_exec_ext in '' $ac_executable_extensions; do
6537   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6538     ac_cv_prog_LEX="$ac_prog"
6539     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6540     break 2
6541   fi
6542 done
6543 done
6544
6545 fi
6546 fi
6547 LEX=$ac_cv_prog_LEX
6548 if test -n "$LEX"; then
6549   echo "$as_me:$LINENO: result: $LEX" >&5
6550 echo "${ECHO_T}$LEX" >&6
6551 else
6552   echo "$as_me:$LINENO: result: no" >&5
6553 echo "${ECHO_T}no" >&6
6554 fi
6555
6556   test -n "$LEX" && break
6557 done
6558 test -n "$LEX" || LEX="$MISSING flex"
6559
6560 case " $build_configdirs " in
6561   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6562   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6563 esac
6564
6565 for ac_prog in flex
6566 do
6567   # Extract the first word of "$ac_prog", so it can be a program name with args.
6568 set dummy $ac_prog; ac_word=$2
6569 echo "$as_me:$LINENO: checking for $ac_word" >&5
6570 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6571 if test "${ac_cv_prog_FLEX+set}" = set; then
6572   echo $ECHO_N "(cached) $ECHO_C" >&6
6573 else
6574   if test -n "$FLEX"; then
6575   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6576 else
6577 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6578 for as_dir in $PATH
6579 do
6580   IFS=$as_save_IFS
6581   test -z "$as_dir" && as_dir=.
6582   for ac_exec_ext in '' $ac_executable_extensions; do
6583   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6584     ac_cv_prog_FLEX="$ac_prog"
6585     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6586     break 2
6587   fi
6588 done
6589 done
6590
6591 fi
6592 fi
6593 FLEX=$ac_cv_prog_FLEX
6594 if test -n "$FLEX"; then
6595   echo "$as_me:$LINENO: result: $FLEX" >&5
6596 echo "${ECHO_T}$FLEX" >&6
6597 else
6598   echo "$as_me:$LINENO: result: no" >&5
6599 echo "${ECHO_T}no" >&6
6600 fi
6601
6602   test -n "$FLEX" && break
6603 done
6604 test -n "$FLEX" || FLEX="$MISSING flex"
6605
6606 case " $build_configdirs " in
6607   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6608 esac
6609
6610 for ac_prog in makeinfo
6611 do
6612   # Extract the first word of "$ac_prog", so it can be a program name with args.
6613 set dummy $ac_prog; ac_word=$2
6614 echo "$as_me:$LINENO: checking for $ac_word" >&5
6615 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6616 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6617   echo $ECHO_N "(cached) $ECHO_C" >&6
6618 else
6619   if test -n "$MAKEINFO"; then
6620   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6621 else
6622 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6623 for as_dir in $PATH
6624 do
6625   IFS=$as_save_IFS
6626   test -z "$as_dir" && as_dir=.
6627   for ac_exec_ext in '' $ac_executable_extensions; do
6628   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6629     ac_cv_prog_MAKEINFO="$ac_prog"
6630     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6631     break 2
6632   fi
6633 done
6634 done
6635
6636 fi
6637 fi
6638 MAKEINFO=$ac_cv_prog_MAKEINFO
6639 if test -n "$MAKEINFO"; then
6640   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6641 echo "${ECHO_T}$MAKEINFO" >&6
6642 else
6643   echo "$as_me:$LINENO: result: no" >&5
6644 echo "${ECHO_T}no" >&6
6645 fi
6646
6647   test -n "$MAKEINFO" && break
6648 done
6649 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6650
6651 case " $build_configdirs " in
6652   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6653   *)
6654
6655     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6656     # higher, else we use the "missing" dummy.
6657     if ${MAKEINFO} --version \
6658        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6659       :
6660     else
6661       MAKEINFO="$MISSING makeinfo"
6662     fi
6663     ;;
6664
6665 esac
6666
6667 # FIXME: expect and dejagnu may become build tools?
6668
6669 for ac_prog in expect
6670 do
6671   # Extract the first word of "$ac_prog", so it can be a program name with args.
6672 set dummy $ac_prog; ac_word=$2
6673 echo "$as_me:$LINENO: checking for $ac_word" >&5
6674 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6675 if test "${ac_cv_prog_EXPECT+set}" = set; then
6676   echo $ECHO_N "(cached) $ECHO_C" >&6
6677 else
6678   if test -n "$EXPECT"; then
6679   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6680 else
6681 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6682 for as_dir in $PATH
6683 do
6684   IFS=$as_save_IFS
6685   test -z "$as_dir" && as_dir=.
6686   for ac_exec_ext in '' $ac_executable_extensions; do
6687   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6688     ac_cv_prog_EXPECT="$ac_prog"
6689     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6690     break 2
6691   fi
6692 done
6693 done
6694
6695 fi
6696 fi
6697 EXPECT=$ac_cv_prog_EXPECT
6698 if test -n "$EXPECT"; then
6699   echo "$as_me:$LINENO: result: $EXPECT" >&5
6700 echo "${ECHO_T}$EXPECT" >&6
6701 else
6702   echo "$as_me:$LINENO: result: no" >&5
6703 echo "${ECHO_T}no" >&6
6704 fi
6705
6706   test -n "$EXPECT" && break
6707 done
6708 test -n "$EXPECT" || EXPECT="expect"
6709
6710 case " $configdirs " in
6711   *" expect "*)
6712     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6713     ;;
6714 esac
6715
6716 for ac_prog in runtest
6717 do
6718   # Extract the first word of "$ac_prog", so it can be a program name with args.
6719 set dummy $ac_prog; ac_word=$2
6720 echo "$as_me:$LINENO: checking for $ac_word" >&5
6721 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6722 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6723   echo $ECHO_N "(cached) $ECHO_C" >&6
6724 else
6725   if test -n "$RUNTEST"; then
6726   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6727 else
6728 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6729 for as_dir in $PATH
6730 do
6731   IFS=$as_save_IFS
6732   test -z "$as_dir" && as_dir=.
6733   for ac_exec_ext in '' $ac_executable_extensions; do
6734   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6735     ac_cv_prog_RUNTEST="$ac_prog"
6736     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6737     break 2
6738   fi
6739 done
6740 done
6741
6742 fi
6743 fi
6744 RUNTEST=$ac_cv_prog_RUNTEST
6745 if test -n "$RUNTEST"; then
6746   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6747 echo "${ECHO_T}$RUNTEST" >&6
6748 else
6749   echo "$as_me:$LINENO: result: no" >&5
6750 echo "${ECHO_T}no" >&6
6751 fi
6752
6753   test -n "$RUNTEST" && break
6754 done
6755 test -n "$RUNTEST" || RUNTEST="runtest"
6756
6757 case " $configdirs " in
6758   *" dejagnu "*)
6759     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6760     ;;
6761 esac
6762
6763
6764 # Host tools.
6765 ncn_tool_prefix=
6766 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6767 ncn_target_tool_prefix=
6768 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6769
6770
6771
6772 if test -n "$AR"; then
6773   ac_cv_prog_AR=$AR
6774 elif test -n "$ac_cv_prog_AR"; then
6775   AR=$ac_cv_prog_AR
6776 fi
6777
6778 if test -n "$ac_cv_prog_AR"; then
6779   for ncn_progname in ar; do
6780     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6781 set dummy ${ncn_progname}; ac_word=$2
6782 echo "$as_me:$LINENO: checking for $ac_word" >&5
6783 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6784 if test "${ac_cv_prog_AR+set}" = set; then
6785   echo $ECHO_N "(cached) $ECHO_C" >&6
6786 else
6787   if test -n "$AR"; then
6788   ac_cv_prog_AR="$AR" # Let the user override the test.
6789 else
6790 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6791 for as_dir in $PATH
6792 do
6793   IFS=$as_save_IFS
6794   test -z "$as_dir" && as_dir=.
6795   for ac_exec_ext in '' $ac_executable_extensions; do
6796   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6797     ac_cv_prog_AR="${ncn_progname}"
6798     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6799     break 2
6800   fi
6801 done
6802 done
6803
6804 fi
6805 fi
6806 AR=$ac_cv_prog_AR
6807 if test -n "$AR"; then
6808   echo "$as_me:$LINENO: result: $AR" >&5
6809 echo "${ECHO_T}$AR" >&6
6810 else
6811   echo "$as_me:$LINENO: result: no" >&5
6812 echo "${ECHO_T}no" >&6
6813 fi
6814
6815   done
6816 fi
6817
6818 for ncn_progname in ar; do
6819   if test -n "$ncn_tool_prefix"; then
6820     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6821 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6822 echo "$as_me:$LINENO: checking for $ac_word" >&5
6823 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6824 if test "${ac_cv_prog_AR+set}" = set; then
6825   echo $ECHO_N "(cached) $ECHO_C" >&6
6826 else
6827   if test -n "$AR"; then
6828   ac_cv_prog_AR="$AR" # Let the user override the test.
6829 else
6830 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6831 for as_dir in $PATH
6832 do
6833   IFS=$as_save_IFS
6834   test -z "$as_dir" && as_dir=.
6835   for ac_exec_ext in '' $ac_executable_extensions; do
6836   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6837     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6838     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6839     break 2
6840   fi
6841 done
6842 done
6843
6844 fi
6845 fi
6846 AR=$ac_cv_prog_AR
6847 if test -n "$AR"; then
6848   echo "$as_me:$LINENO: result: $AR" >&5
6849 echo "${ECHO_T}$AR" >&6
6850 else
6851   echo "$as_me:$LINENO: result: no" >&5
6852 echo "${ECHO_T}no" >&6
6853 fi
6854
6855   fi
6856   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6857     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6858 set dummy ${ncn_progname}; ac_word=$2
6859 echo "$as_me:$LINENO: checking for $ac_word" >&5
6860 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6861 if test "${ac_cv_prog_AR+set}" = set; then
6862   echo $ECHO_N "(cached) $ECHO_C" >&6
6863 else
6864   if test -n "$AR"; then
6865   ac_cv_prog_AR="$AR" # Let the user override the test.
6866 else
6867 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6868 for as_dir in $PATH
6869 do
6870   IFS=$as_save_IFS
6871   test -z "$as_dir" && as_dir=.
6872   for ac_exec_ext in '' $ac_executable_extensions; do
6873   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6874     ac_cv_prog_AR="${ncn_progname}"
6875     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6876     break 2
6877   fi
6878 done
6879 done
6880
6881 fi
6882 fi
6883 AR=$ac_cv_prog_AR
6884 if test -n "$AR"; then
6885   echo "$as_me:$LINENO: result: $AR" >&5
6886 echo "${ECHO_T}$AR" >&6
6887 else
6888   echo "$as_me:$LINENO: result: no" >&5
6889 echo "${ECHO_T}no" >&6
6890 fi
6891
6892   fi
6893   test -n "$ac_cv_prog_AR" && break
6894 done
6895
6896 if test -z "$ac_cv_prog_AR" ; then
6897   set dummy ar
6898   if test $build = $host ; then
6899     AR="$2"
6900   else
6901     AR="${ncn_tool_prefix}$2"
6902   fi
6903 fi
6904
6905
6906
6907 if test -n "$AS"; then
6908   ac_cv_prog_AS=$AS
6909 elif test -n "$ac_cv_prog_AS"; then
6910   AS=$ac_cv_prog_AS
6911 fi
6912
6913 if test -n "$ac_cv_prog_AS"; then
6914   for ncn_progname in as; do
6915     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6916 set dummy ${ncn_progname}; ac_word=$2
6917 echo "$as_me:$LINENO: checking for $ac_word" >&5
6918 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6919 if test "${ac_cv_prog_AS+set}" = set; then
6920   echo $ECHO_N "(cached) $ECHO_C" >&6
6921 else
6922   if test -n "$AS"; then
6923   ac_cv_prog_AS="$AS" # Let the user override the test.
6924 else
6925 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6926 for as_dir in $PATH
6927 do
6928   IFS=$as_save_IFS
6929   test -z "$as_dir" && as_dir=.
6930   for ac_exec_ext in '' $ac_executable_extensions; do
6931   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6932     ac_cv_prog_AS="${ncn_progname}"
6933     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6934     break 2
6935   fi
6936 done
6937 done
6938
6939 fi
6940 fi
6941 AS=$ac_cv_prog_AS
6942 if test -n "$AS"; then
6943   echo "$as_me:$LINENO: result: $AS" >&5
6944 echo "${ECHO_T}$AS" >&6
6945 else
6946   echo "$as_me:$LINENO: result: no" >&5
6947 echo "${ECHO_T}no" >&6
6948 fi
6949
6950   done
6951 fi
6952
6953 for ncn_progname in as; do
6954   if test -n "$ncn_tool_prefix"; then
6955     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6956 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6957 echo "$as_me:$LINENO: checking for $ac_word" >&5
6958 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6959 if test "${ac_cv_prog_AS+set}" = set; then
6960   echo $ECHO_N "(cached) $ECHO_C" >&6
6961 else
6962   if test -n "$AS"; then
6963   ac_cv_prog_AS="$AS" # Let the user override the test.
6964 else
6965 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6966 for as_dir in $PATH
6967 do
6968   IFS=$as_save_IFS
6969   test -z "$as_dir" && as_dir=.
6970   for ac_exec_ext in '' $ac_executable_extensions; do
6971   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6972     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6973     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6974     break 2
6975   fi
6976 done
6977 done
6978
6979 fi
6980 fi
6981 AS=$ac_cv_prog_AS
6982 if test -n "$AS"; then
6983   echo "$as_me:$LINENO: result: $AS" >&5
6984 echo "${ECHO_T}$AS" >&6
6985 else
6986   echo "$as_me:$LINENO: result: no" >&5
6987 echo "${ECHO_T}no" >&6
6988 fi
6989
6990   fi
6991   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6992     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6993 set dummy ${ncn_progname}; ac_word=$2
6994 echo "$as_me:$LINENO: checking for $ac_word" >&5
6995 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6996 if test "${ac_cv_prog_AS+set}" = set; then
6997   echo $ECHO_N "(cached) $ECHO_C" >&6
6998 else
6999   if test -n "$AS"; then
7000   ac_cv_prog_AS="$AS" # Let the user override the test.
7001 else
7002 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7003 for as_dir in $PATH
7004 do
7005   IFS=$as_save_IFS
7006   test -z "$as_dir" && as_dir=.
7007   for ac_exec_ext in '' $ac_executable_extensions; do
7008   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7009     ac_cv_prog_AS="${ncn_progname}"
7010     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7011     break 2
7012   fi
7013 done
7014 done
7015
7016 fi
7017 fi
7018 AS=$ac_cv_prog_AS
7019 if test -n "$AS"; then
7020   echo "$as_me:$LINENO: result: $AS" >&5
7021 echo "${ECHO_T}$AS" >&6
7022 else
7023   echo "$as_me:$LINENO: result: no" >&5
7024 echo "${ECHO_T}no" >&6
7025 fi
7026
7027   fi
7028   test -n "$ac_cv_prog_AS" && break
7029 done
7030
7031 if test -z "$ac_cv_prog_AS" ; then
7032   set dummy as
7033   if test $build = $host ; then
7034     AS="$2"
7035   else
7036     AS="${ncn_tool_prefix}$2"
7037   fi
7038 fi
7039
7040
7041
7042 if test -n "$DLLTOOL"; then
7043   ac_cv_prog_DLLTOOL=$DLLTOOL
7044 elif test -n "$ac_cv_prog_DLLTOOL"; then
7045   DLLTOOL=$ac_cv_prog_DLLTOOL
7046 fi
7047
7048 if test -n "$ac_cv_prog_DLLTOOL"; then
7049   for ncn_progname in dlltool; do
7050     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7051 set dummy ${ncn_progname}; ac_word=$2
7052 echo "$as_me:$LINENO: checking for $ac_word" >&5
7053 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7054 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7055   echo $ECHO_N "(cached) $ECHO_C" >&6
7056 else
7057   if test -n "$DLLTOOL"; then
7058   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7059 else
7060 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7061 for as_dir in $PATH
7062 do
7063   IFS=$as_save_IFS
7064   test -z "$as_dir" && as_dir=.
7065   for ac_exec_ext in '' $ac_executable_extensions; do
7066   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7067     ac_cv_prog_DLLTOOL="${ncn_progname}"
7068     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7069     break 2
7070   fi
7071 done
7072 done
7073
7074 fi
7075 fi
7076 DLLTOOL=$ac_cv_prog_DLLTOOL
7077 if test -n "$DLLTOOL"; then
7078   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7079 echo "${ECHO_T}$DLLTOOL" >&6
7080 else
7081   echo "$as_me:$LINENO: result: no" >&5
7082 echo "${ECHO_T}no" >&6
7083 fi
7084
7085   done
7086 fi
7087
7088 for ncn_progname in dlltool; do
7089   if test -n "$ncn_tool_prefix"; then
7090     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7091 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7092 echo "$as_me:$LINENO: checking for $ac_word" >&5
7093 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7094 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7095   echo $ECHO_N "(cached) $ECHO_C" >&6
7096 else
7097   if test -n "$DLLTOOL"; then
7098   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7099 else
7100 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7101 for as_dir in $PATH
7102 do
7103   IFS=$as_save_IFS
7104   test -z "$as_dir" && as_dir=.
7105   for ac_exec_ext in '' $ac_executable_extensions; do
7106   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7107     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7108     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7109     break 2
7110   fi
7111 done
7112 done
7113
7114 fi
7115 fi
7116 DLLTOOL=$ac_cv_prog_DLLTOOL
7117 if test -n "$DLLTOOL"; then
7118   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7119 echo "${ECHO_T}$DLLTOOL" >&6
7120 else
7121   echo "$as_me:$LINENO: result: no" >&5
7122 echo "${ECHO_T}no" >&6
7123 fi
7124
7125   fi
7126   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7127     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7128 set dummy ${ncn_progname}; ac_word=$2
7129 echo "$as_me:$LINENO: checking for $ac_word" >&5
7130 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7131 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7132   echo $ECHO_N "(cached) $ECHO_C" >&6
7133 else
7134   if test -n "$DLLTOOL"; then
7135   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7136 else
7137 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7138 for as_dir in $PATH
7139 do
7140   IFS=$as_save_IFS
7141   test -z "$as_dir" && as_dir=.
7142   for ac_exec_ext in '' $ac_executable_extensions; do
7143   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7144     ac_cv_prog_DLLTOOL="${ncn_progname}"
7145     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7146     break 2
7147   fi
7148 done
7149 done
7150
7151 fi
7152 fi
7153 DLLTOOL=$ac_cv_prog_DLLTOOL
7154 if test -n "$DLLTOOL"; then
7155   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7156 echo "${ECHO_T}$DLLTOOL" >&6
7157 else
7158   echo "$as_me:$LINENO: result: no" >&5
7159 echo "${ECHO_T}no" >&6
7160 fi
7161
7162   fi
7163   test -n "$ac_cv_prog_DLLTOOL" && break
7164 done
7165
7166 if test -z "$ac_cv_prog_DLLTOOL" ; then
7167   set dummy dlltool
7168   if test $build = $host ; then
7169     DLLTOOL="$2"
7170   else
7171     DLLTOOL="${ncn_tool_prefix}$2"
7172   fi
7173 fi
7174
7175
7176
7177 if test -n "$LD"; then
7178   ac_cv_prog_LD=$LD
7179 elif test -n "$ac_cv_prog_LD"; then
7180   LD=$ac_cv_prog_LD
7181 fi
7182
7183 if test -n "$ac_cv_prog_LD"; then
7184   for ncn_progname in ld; do
7185     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7186 set dummy ${ncn_progname}; ac_word=$2
7187 echo "$as_me:$LINENO: checking for $ac_word" >&5
7188 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7189 if test "${ac_cv_prog_LD+set}" = set; then
7190   echo $ECHO_N "(cached) $ECHO_C" >&6
7191 else
7192   if test -n "$LD"; then
7193   ac_cv_prog_LD="$LD" # Let the user override the test.
7194 else
7195 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7196 for as_dir in $PATH
7197 do
7198   IFS=$as_save_IFS
7199   test -z "$as_dir" && as_dir=.
7200   for ac_exec_ext in '' $ac_executable_extensions; do
7201   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7202     ac_cv_prog_LD="${ncn_progname}"
7203     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7204     break 2
7205   fi
7206 done
7207 done
7208
7209 fi
7210 fi
7211 LD=$ac_cv_prog_LD
7212 if test -n "$LD"; then
7213   echo "$as_me:$LINENO: result: $LD" >&5
7214 echo "${ECHO_T}$LD" >&6
7215 else
7216   echo "$as_me:$LINENO: result: no" >&5
7217 echo "${ECHO_T}no" >&6
7218 fi
7219
7220   done
7221 fi
7222
7223 for ncn_progname in ld; do
7224   if test -n "$ncn_tool_prefix"; then
7225     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7226 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7227 echo "$as_me:$LINENO: checking for $ac_word" >&5
7228 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7229 if test "${ac_cv_prog_LD+set}" = set; then
7230   echo $ECHO_N "(cached) $ECHO_C" >&6
7231 else
7232   if test -n "$LD"; then
7233   ac_cv_prog_LD="$LD" # Let the user override the test.
7234 else
7235 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7236 for as_dir in $PATH
7237 do
7238   IFS=$as_save_IFS
7239   test -z "$as_dir" && as_dir=.
7240   for ac_exec_ext in '' $ac_executable_extensions; do
7241   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7242     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7243     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7244     break 2
7245   fi
7246 done
7247 done
7248
7249 fi
7250 fi
7251 LD=$ac_cv_prog_LD
7252 if test -n "$LD"; then
7253   echo "$as_me:$LINENO: result: $LD" >&5
7254 echo "${ECHO_T}$LD" >&6
7255 else
7256   echo "$as_me:$LINENO: result: no" >&5
7257 echo "${ECHO_T}no" >&6
7258 fi
7259
7260   fi
7261   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7262     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7263 set dummy ${ncn_progname}; ac_word=$2
7264 echo "$as_me:$LINENO: checking for $ac_word" >&5
7265 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7266 if test "${ac_cv_prog_LD+set}" = set; then
7267   echo $ECHO_N "(cached) $ECHO_C" >&6
7268 else
7269   if test -n "$LD"; then
7270   ac_cv_prog_LD="$LD" # Let the user override the test.
7271 else
7272 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7273 for as_dir in $PATH
7274 do
7275   IFS=$as_save_IFS
7276   test -z "$as_dir" && as_dir=.
7277   for ac_exec_ext in '' $ac_executable_extensions; do
7278   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7279     ac_cv_prog_LD="${ncn_progname}"
7280     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7281     break 2
7282   fi
7283 done
7284 done
7285
7286 fi
7287 fi
7288 LD=$ac_cv_prog_LD
7289 if test -n "$LD"; then
7290   echo "$as_me:$LINENO: result: $LD" >&5
7291 echo "${ECHO_T}$LD" >&6
7292 else
7293   echo "$as_me:$LINENO: result: no" >&5
7294 echo "${ECHO_T}no" >&6
7295 fi
7296
7297   fi
7298   test -n "$ac_cv_prog_LD" && break
7299 done
7300
7301 if test -z "$ac_cv_prog_LD" ; then
7302   set dummy ld
7303   if test $build = $host ; then
7304     LD="$2"
7305   else
7306     LD="${ncn_tool_prefix}$2"
7307   fi
7308 fi
7309
7310
7311
7312 if test -n "$LIPO"; then
7313   ac_cv_prog_LIPO=$LIPO
7314 elif test -n "$ac_cv_prog_LIPO"; then
7315   LIPO=$ac_cv_prog_LIPO
7316 fi
7317
7318 if test -n "$ac_cv_prog_LIPO"; then
7319   for ncn_progname in lipo; do
7320     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7321 set dummy ${ncn_progname}; ac_word=$2
7322 echo "$as_me:$LINENO: checking for $ac_word" >&5
7323 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7324 if test "${ac_cv_prog_LIPO+set}" = set; then
7325   echo $ECHO_N "(cached) $ECHO_C" >&6
7326 else
7327   if test -n "$LIPO"; then
7328   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7329 else
7330 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7331 for as_dir in $PATH
7332 do
7333   IFS=$as_save_IFS
7334   test -z "$as_dir" && as_dir=.
7335   for ac_exec_ext in '' $ac_executable_extensions; do
7336   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7337     ac_cv_prog_LIPO="${ncn_progname}"
7338     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7339     break 2
7340   fi
7341 done
7342 done
7343
7344 fi
7345 fi
7346 LIPO=$ac_cv_prog_LIPO
7347 if test -n "$LIPO"; then
7348   echo "$as_me:$LINENO: result: $LIPO" >&5
7349 echo "${ECHO_T}$LIPO" >&6
7350 else
7351   echo "$as_me:$LINENO: result: no" >&5
7352 echo "${ECHO_T}no" >&6
7353 fi
7354
7355   done
7356 fi
7357
7358 for ncn_progname in lipo; do
7359   if test -n "$ncn_tool_prefix"; then
7360     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7361 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7362 echo "$as_me:$LINENO: checking for $ac_word" >&5
7363 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7364 if test "${ac_cv_prog_LIPO+set}" = set; then
7365   echo $ECHO_N "(cached) $ECHO_C" >&6
7366 else
7367   if test -n "$LIPO"; then
7368   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7369 else
7370 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7371 for as_dir in $PATH
7372 do
7373   IFS=$as_save_IFS
7374   test -z "$as_dir" && as_dir=.
7375   for ac_exec_ext in '' $ac_executable_extensions; do
7376   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7377     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7378     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7379     break 2
7380   fi
7381 done
7382 done
7383
7384 fi
7385 fi
7386 LIPO=$ac_cv_prog_LIPO
7387 if test -n "$LIPO"; then
7388   echo "$as_me:$LINENO: result: $LIPO" >&5
7389 echo "${ECHO_T}$LIPO" >&6
7390 else
7391   echo "$as_me:$LINENO: result: no" >&5
7392 echo "${ECHO_T}no" >&6
7393 fi
7394
7395   fi
7396   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7397     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7398 set dummy ${ncn_progname}; ac_word=$2
7399 echo "$as_me:$LINENO: checking for $ac_word" >&5
7400 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7401 if test "${ac_cv_prog_LIPO+set}" = set; then
7402   echo $ECHO_N "(cached) $ECHO_C" >&6
7403 else
7404   if test -n "$LIPO"; then
7405   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7406 else
7407 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7408 for as_dir in $PATH
7409 do
7410   IFS=$as_save_IFS
7411   test -z "$as_dir" && as_dir=.
7412   for ac_exec_ext in '' $ac_executable_extensions; do
7413   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7414     ac_cv_prog_LIPO="${ncn_progname}"
7415     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7416     break 2
7417   fi
7418 done
7419 done
7420
7421 fi
7422 fi
7423 LIPO=$ac_cv_prog_LIPO
7424 if test -n "$LIPO"; then
7425   echo "$as_me:$LINENO: result: $LIPO" >&5
7426 echo "${ECHO_T}$LIPO" >&6
7427 else
7428   echo "$as_me:$LINENO: result: no" >&5
7429 echo "${ECHO_T}no" >&6
7430 fi
7431
7432   fi
7433   test -n "$ac_cv_prog_LIPO" && break
7434 done
7435
7436 if test -z "$ac_cv_prog_LIPO" ; then
7437   set dummy lipo
7438   if test $build = $host ; then
7439     LIPO="$2"
7440   else
7441     LIPO="${ncn_tool_prefix}$2"
7442   fi
7443 fi
7444
7445
7446
7447 if test -n "$NM"; then
7448   ac_cv_prog_NM=$NM
7449 elif test -n "$ac_cv_prog_NM"; then
7450   NM=$ac_cv_prog_NM
7451 fi
7452
7453 if test -n "$ac_cv_prog_NM"; then
7454   for ncn_progname in nm; do
7455     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7456 set dummy ${ncn_progname}; ac_word=$2
7457 echo "$as_me:$LINENO: checking for $ac_word" >&5
7458 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7459 if test "${ac_cv_prog_NM+set}" = set; then
7460   echo $ECHO_N "(cached) $ECHO_C" >&6
7461 else
7462   if test -n "$NM"; then
7463   ac_cv_prog_NM="$NM" # Let the user override the test.
7464 else
7465 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7466 for as_dir in $PATH
7467 do
7468   IFS=$as_save_IFS
7469   test -z "$as_dir" && as_dir=.
7470   for ac_exec_ext in '' $ac_executable_extensions; do
7471   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7472     ac_cv_prog_NM="${ncn_progname}"
7473     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7474     break 2
7475   fi
7476 done
7477 done
7478
7479 fi
7480 fi
7481 NM=$ac_cv_prog_NM
7482 if test -n "$NM"; then
7483   echo "$as_me:$LINENO: result: $NM" >&5
7484 echo "${ECHO_T}$NM" >&6
7485 else
7486   echo "$as_me:$LINENO: result: no" >&5
7487 echo "${ECHO_T}no" >&6
7488 fi
7489
7490   done
7491 fi
7492
7493 for ncn_progname in nm; do
7494   if test -n "$ncn_tool_prefix"; then
7495     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7496 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7497 echo "$as_me:$LINENO: checking for $ac_word" >&5
7498 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7499 if test "${ac_cv_prog_NM+set}" = set; then
7500   echo $ECHO_N "(cached) $ECHO_C" >&6
7501 else
7502   if test -n "$NM"; then
7503   ac_cv_prog_NM="$NM" # Let the user override the test.
7504 else
7505 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7506 for as_dir in $PATH
7507 do
7508   IFS=$as_save_IFS
7509   test -z "$as_dir" && as_dir=.
7510   for ac_exec_ext in '' $ac_executable_extensions; do
7511   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7512     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7513     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7514     break 2
7515   fi
7516 done
7517 done
7518
7519 fi
7520 fi
7521 NM=$ac_cv_prog_NM
7522 if test -n "$NM"; then
7523   echo "$as_me:$LINENO: result: $NM" >&5
7524 echo "${ECHO_T}$NM" >&6
7525 else
7526   echo "$as_me:$LINENO: result: no" >&5
7527 echo "${ECHO_T}no" >&6
7528 fi
7529
7530   fi
7531   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7532     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7533 set dummy ${ncn_progname}; ac_word=$2
7534 echo "$as_me:$LINENO: checking for $ac_word" >&5
7535 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7536 if test "${ac_cv_prog_NM+set}" = set; then
7537   echo $ECHO_N "(cached) $ECHO_C" >&6
7538 else
7539   if test -n "$NM"; then
7540   ac_cv_prog_NM="$NM" # Let the user override the test.
7541 else
7542 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7543 for as_dir in $PATH
7544 do
7545   IFS=$as_save_IFS
7546   test -z "$as_dir" && as_dir=.
7547   for ac_exec_ext in '' $ac_executable_extensions; do
7548   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7549     ac_cv_prog_NM="${ncn_progname}"
7550     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7551     break 2
7552   fi
7553 done
7554 done
7555
7556 fi
7557 fi
7558 NM=$ac_cv_prog_NM
7559 if test -n "$NM"; then
7560   echo "$as_me:$LINENO: result: $NM" >&5
7561 echo "${ECHO_T}$NM" >&6
7562 else
7563   echo "$as_me:$LINENO: result: no" >&5
7564 echo "${ECHO_T}no" >&6
7565 fi
7566
7567   fi
7568   test -n "$ac_cv_prog_NM" && break
7569 done
7570
7571 if test -z "$ac_cv_prog_NM" ; then
7572   set dummy nm
7573   if test $build = $host ; then
7574     NM="$2"
7575   else
7576     NM="${ncn_tool_prefix}$2"
7577   fi
7578 fi
7579
7580
7581
7582 if test -n "$RANLIB"; then
7583   ac_cv_prog_RANLIB=$RANLIB
7584 elif test -n "$ac_cv_prog_RANLIB"; then
7585   RANLIB=$ac_cv_prog_RANLIB
7586 fi
7587
7588 if test -n "$ac_cv_prog_RANLIB"; then
7589   for ncn_progname in ranlib; do
7590     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7591 set dummy ${ncn_progname}; ac_word=$2
7592 echo "$as_me:$LINENO: checking for $ac_word" >&5
7593 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7594 if test "${ac_cv_prog_RANLIB+set}" = set; then
7595   echo $ECHO_N "(cached) $ECHO_C" >&6
7596 else
7597   if test -n "$RANLIB"; then
7598   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7599 else
7600 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7601 for as_dir in $PATH
7602 do
7603   IFS=$as_save_IFS
7604   test -z "$as_dir" && as_dir=.
7605   for ac_exec_ext in '' $ac_executable_extensions; do
7606   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7607     ac_cv_prog_RANLIB="${ncn_progname}"
7608     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7609     break 2
7610   fi
7611 done
7612 done
7613
7614 fi
7615 fi
7616 RANLIB=$ac_cv_prog_RANLIB
7617 if test -n "$RANLIB"; then
7618   echo "$as_me:$LINENO: result: $RANLIB" >&5
7619 echo "${ECHO_T}$RANLIB" >&6
7620 else
7621   echo "$as_me:$LINENO: result: no" >&5
7622 echo "${ECHO_T}no" >&6
7623 fi
7624
7625   done
7626 fi
7627
7628 for ncn_progname in ranlib; do
7629   if test -n "$ncn_tool_prefix"; then
7630     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7631 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7632 echo "$as_me:$LINENO: checking for $ac_word" >&5
7633 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7634 if test "${ac_cv_prog_RANLIB+set}" = set; then
7635   echo $ECHO_N "(cached) $ECHO_C" >&6
7636 else
7637   if test -n "$RANLIB"; then
7638   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7639 else
7640 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7641 for as_dir in $PATH
7642 do
7643   IFS=$as_save_IFS
7644   test -z "$as_dir" && as_dir=.
7645   for ac_exec_ext in '' $ac_executable_extensions; do
7646   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7647     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7648     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7649     break 2
7650   fi
7651 done
7652 done
7653
7654 fi
7655 fi
7656 RANLIB=$ac_cv_prog_RANLIB
7657 if test -n "$RANLIB"; then
7658   echo "$as_me:$LINENO: result: $RANLIB" >&5
7659 echo "${ECHO_T}$RANLIB" >&6
7660 else
7661   echo "$as_me:$LINENO: result: no" >&5
7662 echo "${ECHO_T}no" >&6
7663 fi
7664
7665   fi
7666   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7667     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7668 set dummy ${ncn_progname}; ac_word=$2
7669 echo "$as_me:$LINENO: checking for $ac_word" >&5
7670 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7671 if test "${ac_cv_prog_RANLIB+set}" = set; then
7672   echo $ECHO_N "(cached) $ECHO_C" >&6
7673 else
7674   if test -n "$RANLIB"; then
7675   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7676 else
7677 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7678 for as_dir in $PATH
7679 do
7680   IFS=$as_save_IFS
7681   test -z "$as_dir" && as_dir=.
7682   for ac_exec_ext in '' $ac_executable_extensions; do
7683   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7684     ac_cv_prog_RANLIB="${ncn_progname}"
7685     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7686     break 2
7687   fi
7688 done
7689 done
7690
7691 fi
7692 fi
7693 RANLIB=$ac_cv_prog_RANLIB
7694 if test -n "$RANLIB"; then
7695   echo "$as_me:$LINENO: result: $RANLIB" >&5
7696 echo "${ECHO_T}$RANLIB" >&6
7697 else
7698   echo "$as_me:$LINENO: result: no" >&5
7699 echo "${ECHO_T}no" >&6
7700 fi
7701
7702   fi
7703   test -n "$ac_cv_prog_RANLIB" && break
7704 done
7705
7706 if test -z "$ac_cv_prog_RANLIB" ; then
7707   RANLIB=":"
7708 fi
7709
7710
7711
7712 if test -n "$STRIP"; then
7713   ac_cv_prog_STRIP=$STRIP
7714 elif test -n "$ac_cv_prog_STRIP"; then
7715   STRIP=$ac_cv_prog_STRIP
7716 fi
7717
7718 if test -n "$ac_cv_prog_STRIP"; then
7719   for ncn_progname in strip; do
7720     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7721 set dummy ${ncn_progname}; ac_word=$2
7722 echo "$as_me:$LINENO: checking for $ac_word" >&5
7723 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7724 if test "${ac_cv_prog_STRIP+set}" = set; then
7725   echo $ECHO_N "(cached) $ECHO_C" >&6
7726 else
7727   if test -n "$STRIP"; then
7728   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7729 else
7730 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7731 for as_dir in $PATH
7732 do
7733   IFS=$as_save_IFS
7734   test -z "$as_dir" && as_dir=.
7735   for ac_exec_ext in '' $ac_executable_extensions; do
7736   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7737     ac_cv_prog_STRIP="${ncn_progname}"
7738     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7739     break 2
7740   fi
7741 done
7742 done
7743
7744 fi
7745 fi
7746 STRIP=$ac_cv_prog_STRIP
7747 if test -n "$STRIP"; then
7748   echo "$as_me:$LINENO: result: $STRIP" >&5
7749 echo "${ECHO_T}$STRIP" >&6
7750 else
7751   echo "$as_me:$LINENO: result: no" >&5
7752 echo "${ECHO_T}no" >&6
7753 fi
7754
7755   done
7756 fi
7757
7758 for ncn_progname in strip; do
7759   if test -n "$ncn_tool_prefix"; then
7760     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7761 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7762 echo "$as_me:$LINENO: checking for $ac_word" >&5
7763 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7764 if test "${ac_cv_prog_STRIP+set}" = set; then
7765   echo $ECHO_N "(cached) $ECHO_C" >&6
7766 else
7767   if test -n "$STRIP"; then
7768   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7769 else
7770 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7771 for as_dir in $PATH
7772 do
7773   IFS=$as_save_IFS
7774   test -z "$as_dir" && as_dir=.
7775   for ac_exec_ext in '' $ac_executable_extensions; do
7776   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7777     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7778     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7779     break 2
7780   fi
7781 done
7782 done
7783
7784 fi
7785 fi
7786 STRIP=$ac_cv_prog_STRIP
7787 if test -n "$STRIP"; then
7788   echo "$as_me:$LINENO: result: $STRIP" >&5
7789 echo "${ECHO_T}$STRIP" >&6
7790 else
7791   echo "$as_me:$LINENO: result: no" >&5
7792 echo "${ECHO_T}no" >&6
7793 fi
7794
7795   fi
7796   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7797     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7798 set dummy ${ncn_progname}; ac_word=$2
7799 echo "$as_me:$LINENO: checking for $ac_word" >&5
7800 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7801 if test "${ac_cv_prog_STRIP+set}" = set; then
7802   echo $ECHO_N "(cached) $ECHO_C" >&6
7803 else
7804   if test -n "$STRIP"; then
7805   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7806 else
7807 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7808 for as_dir in $PATH
7809 do
7810   IFS=$as_save_IFS
7811   test -z "$as_dir" && as_dir=.
7812   for ac_exec_ext in '' $ac_executable_extensions; do
7813   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7814     ac_cv_prog_STRIP="${ncn_progname}"
7815     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7816     break 2
7817   fi
7818 done
7819 done
7820
7821 fi
7822 fi
7823 STRIP=$ac_cv_prog_STRIP
7824 if test -n "$STRIP"; then
7825   echo "$as_me:$LINENO: result: $STRIP" >&5
7826 echo "${ECHO_T}$STRIP" >&6
7827 else
7828   echo "$as_me:$LINENO: result: no" >&5
7829 echo "${ECHO_T}no" >&6
7830 fi
7831
7832   fi
7833   test -n "$ac_cv_prog_STRIP" && break
7834 done
7835
7836 if test -z "$ac_cv_prog_STRIP" ; then
7837   STRIP=":"
7838 fi
7839
7840
7841
7842 if test -n "$WINDRES"; then
7843   ac_cv_prog_WINDRES=$WINDRES
7844 elif test -n "$ac_cv_prog_WINDRES"; then
7845   WINDRES=$ac_cv_prog_WINDRES
7846 fi
7847
7848 if test -n "$ac_cv_prog_WINDRES"; then
7849   for ncn_progname in windres; do
7850     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7851 set dummy ${ncn_progname}; ac_word=$2
7852 echo "$as_me:$LINENO: checking for $ac_word" >&5
7853 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7854 if test "${ac_cv_prog_WINDRES+set}" = set; then
7855   echo $ECHO_N "(cached) $ECHO_C" >&6
7856 else
7857   if test -n "$WINDRES"; then
7858   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7859 else
7860 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7861 for as_dir in $PATH
7862 do
7863   IFS=$as_save_IFS
7864   test -z "$as_dir" && as_dir=.
7865   for ac_exec_ext in '' $ac_executable_extensions; do
7866   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7867     ac_cv_prog_WINDRES="${ncn_progname}"
7868     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7869     break 2
7870   fi
7871 done
7872 done
7873
7874 fi
7875 fi
7876 WINDRES=$ac_cv_prog_WINDRES
7877 if test -n "$WINDRES"; then
7878   echo "$as_me:$LINENO: result: $WINDRES" >&5
7879 echo "${ECHO_T}$WINDRES" >&6
7880 else
7881   echo "$as_me:$LINENO: result: no" >&5
7882 echo "${ECHO_T}no" >&6
7883 fi
7884
7885   done
7886 fi
7887
7888 for ncn_progname in windres; do
7889   if test -n "$ncn_tool_prefix"; then
7890     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7891 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7892 echo "$as_me:$LINENO: checking for $ac_word" >&5
7893 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7894 if test "${ac_cv_prog_WINDRES+set}" = set; then
7895   echo $ECHO_N "(cached) $ECHO_C" >&6
7896 else
7897   if test -n "$WINDRES"; then
7898   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7899 else
7900 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7901 for as_dir in $PATH
7902 do
7903   IFS=$as_save_IFS
7904   test -z "$as_dir" && as_dir=.
7905   for ac_exec_ext in '' $ac_executable_extensions; do
7906   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7907     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7908     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7909     break 2
7910   fi
7911 done
7912 done
7913
7914 fi
7915 fi
7916 WINDRES=$ac_cv_prog_WINDRES
7917 if test -n "$WINDRES"; then
7918   echo "$as_me:$LINENO: result: $WINDRES" >&5
7919 echo "${ECHO_T}$WINDRES" >&6
7920 else
7921   echo "$as_me:$LINENO: result: no" >&5
7922 echo "${ECHO_T}no" >&6
7923 fi
7924
7925   fi
7926   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7927     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7928 set dummy ${ncn_progname}; ac_word=$2
7929 echo "$as_me:$LINENO: checking for $ac_word" >&5
7930 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7931 if test "${ac_cv_prog_WINDRES+set}" = set; then
7932   echo $ECHO_N "(cached) $ECHO_C" >&6
7933 else
7934   if test -n "$WINDRES"; then
7935   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7936 else
7937 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7938 for as_dir in $PATH
7939 do
7940   IFS=$as_save_IFS
7941   test -z "$as_dir" && as_dir=.
7942   for ac_exec_ext in '' $ac_executable_extensions; do
7943   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7944     ac_cv_prog_WINDRES="${ncn_progname}"
7945     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7946     break 2
7947   fi
7948 done
7949 done
7950
7951 fi
7952 fi
7953 WINDRES=$ac_cv_prog_WINDRES
7954 if test -n "$WINDRES"; then
7955   echo "$as_me:$LINENO: result: $WINDRES" >&5
7956 echo "${ECHO_T}$WINDRES" >&6
7957 else
7958   echo "$as_me:$LINENO: result: no" >&5
7959 echo "${ECHO_T}no" >&6
7960 fi
7961
7962   fi
7963   test -n "$ac_cv_prog_WINDRES" && break
7964 done
7965
7966 if test -z "$ac_cv_prog_WINDRES" ; then
7967   set dummy windres
7968   if test $build = $host ; then
7969     WINDRES="$2"
7970   else
7971     WINDRES="${ncn_tool_prefix}$2"
7972   fi
7973 fi
7974
7975
7976
7977 if test -n "$WINDMC"; then
7978   ac_cv_prog_WINDMC=$WINDMC
7979 elif test -n "$ac_cv_prog_WINDMC"; then
7980   WINDMC=$ac_cv_prog_WINDMC
7981 fi
7982
7983 if test -n "$ac_cv_prog_WINDMC"; then
7984   for ncn_progname in windmc; do
7985     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7986 set dummy ${ncn_progname}; ac_word=$2
7987 echo "$as_me:$LINENO: checking for $ac_word" >&5
7988 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7989 if test "${ac_cv_prog_WINDMC+set}" = set; then
7990   echo $ECHO_N "(cached) $ECHO_C" >&6
7991 else
7992   if test -n "$WINDMC"; then
7993   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7994 else
7995 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7996 for as_dir in $PATH
7997 do
7998   IFS=$as_save_IFS
7999   test -z "$as_dir" && as_dir=.
8000   for ac_exec_ext in '' $ac_executable_extensions; do
8001   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8002     ac_cv_prog_WINDMC="${ncn_progname}"
8003     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8004     break 2
8005   fi
8006 done
8007 done
8008
8009 fi
8010 fi
8011 WINDMC=$ac_cv_prog_WINDMC
8012 if test -n "$WINDMC"; then
8013   echo "$as_me:$LINENO: result: $WINDMC" >&5
8014 echo "${ECHO_T}$WINDMC" >&6
8015 else
8016   echo "$as_me:$LINENO: result: no" >&5
8017 echo "${ECHO_T}no" >&6
8018 fi
8019
8020   done
8021 fi
8022
8023 for ncn_progname in windmc; do
8024   if test -n "$ncn_tool_prefix"; then
8025     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8026 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8027 echo "$as_me:$LINENO: checking for $ac_word" >&5
8028 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8029 if test "${ac_cv_prog_WINDMC+set}" = set; then
8030   echo $ECHO_N "(cached) $ECHO_C" >&6
8031 else
8032   if test -n "$WINDMC"; then
8033   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8034 else
8035 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8036 for as_dir in $PATH
8037 do
8038   IFS=$as_save_IFS
8039   test -z "$as_dir" && as_dir=.
8040   for ac_exec_ext in '' $ac_executable_extensions; do
8041   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8042     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8043     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8044     break 2
8045   fi
8046 done
8047 done
8048
8049 fi
8050 fi
8051 WINDMC=$ac_cv_prog_WINDMC
8052 if test -n "$WINDMC"; then
8053   echo "$as_me:$LINENO: result: $WINDMC" >&5
8054 echo "${ECHO_T}$WINDMC" >&6
8055 else
8056   echo "$as_me:$LINENO: result: no" >&5
8057 echo "${ECHO_T}no" >&6
8058 fi
8059
8060   fi
8061   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8062     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8063 set dummy ${ncn_progname}; ac_word=$2
8064 echo "$as_me:$LINENO: checking for $ac_word" >&5
8065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8066 if test "${ac_cv_prog_WINDMC+set}" = set; then
8067   echo $ECHO_N "(cached) $ECHO_C" >&6
8068 else
8069   if test -n "$WINDMC"; then
8070   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8071 else
8072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8073 for as_dir in $PATH
8074 do
8075   IFS=$as_save_IFS
8076   test -z "$as_dir" && as_dir=.
8077   for ac_exec_ext in '' $ac_executable_extensions; do
8078   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8079     ac_cv_prog_WINDMC="${ncn_progname}"
8080     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8081     break 2
8082   fi
8083 done
8084 done
8085
8086 fi
8087 fi
8088 WINDMC=$ac_cv_prog_WINDMC
8089 if test -n "$WINDMC"; then
8090   echo "$as_me:$LINENO: result: $WINDMC" >&5
8091 echo "${ECHO_T}$WINDMC" >&6
8092 else
8093   echo "$as_me:$LINENO: result: no" >&5
8094 echo "${ECHO_T}no" >&6
8095 fi
8096
8097   fi
8098   test -n "$ac_cv_prog_WINDMC" && break
8099 done
8100
8101 if test -z "$ac_cv_prog_WINDMC" ; then
8102   set dummy windmc
8103   if test $build = $host ; then
8104     WINDMC="$2"
8105   else
8106     WINDMC="${ncn_tool_prefix}$2"
8107   fi
8108 fi
8109
8110
8111
8112 if test -n "$OBJCOPY"; then
8113   ac_cv_prog_OBJCOPY=$OBJCOPY
8114 elif test -n "$ac_cv_prog_OBJCOPY"; then
8115   OBJCOPY=$ac_cv_prog_OBJCOPY
8116 fi
8117
8118 if test -n "$ac_cv_prog_OBJCOPY"; then
8119   for ncn_progname in objcopy; do
8120     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8121 set dummy ${ncn_progname}; ac_word=$2
8122 echo "$as_me:$LINENO: checking for $ac_word" >&5
8123 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8124 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8125   echo $ECHO_N "(cached) $ECHO_C" >&6
8126 else
8127   if test -n "$OBJCOPY"; then
8128   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8129 else
8130 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8131 for as_dir in $PATH
8132 do
8133   IFS=$as_save_IFS
8134   test -z "$as_dir" && as_dir=.
8135   for ac_exec_ext in '' $ac_executable_extensions; do
8136   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8137     ac_cv_prog_OBJCOPY="${ncn_progname}"
8138     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8139     break 2
8140   fi
8141 done
8142 done
8143
8144 fi
8145 fi
8146 OBJCOPY=$ac_cv_prog_OBJCOPY
8147 if test -n "$OBJCOPY"; then
8148   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8149 echo "${ECHO_T}$OBJCOPY" >&6
8150 else
8151   echo "$as_me:$LINENO: result: no" >&5
8152 echo "${ECHO_T}no" >&6
8153 fi
8154
8155   done
8156 fi
8157
8158 for ncn_progname in objcopy; do
8159   if test -n "$ncn_tool_prefix"; then
8160     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8161 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8162 echo "$as_me:$LINENO: checking for $ac_word" >&5
8163 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8164 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8165   echo $ECHO_N "(cached) $ECHO_C" >&6
8166 else
8167   if test -n "$OBJCOPY"; then
8168   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8169 else
8170 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8171 for as_dir in $PATH
8172 do
8173   IFS=$as_save_IFS
8174   test -z "$as_dir" && as_dir=.
8175   for ac_exec_ext in '' $ac_executable_extensions; do
8176   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8177     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8178     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8179     break 2
8180   fi
8181 done
8182 done
8183
8184 fi
8185 fi
8186 OBJCOPY=$ac_cv_prog_OBJCOPY
8187 if test -n "$OBJCOPY"; then
8188   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8189 echo "${ECHO_T}$OBJCOPY" >&6
8190 else
8191   echo "$as_me:$LINENO: result: no" >&5
8192 echo "${ECHO_T}no" >&6
8193 fi
8194
8195   fi
8196   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8197     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8198 set dummy ${ncn_progname}; ac_word=$2
8199 echo "$as_me:$LINENO: checking for $ac_word" >&5
8200 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8201 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8202   echo $ECHO_N "(cached) $ECHO_C" >&6
8203 else
8204   if test -n "$OBJCOPY"; then
8205   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8206 else
8207 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8208 for as_dir in $PATH
8209 do
8210   IFS=$as_save_IFS
8211   test -z "$as_dir" && as_dir=.
8212   for ac_exec_ext in '' $ac_executable_extensions; do
8213   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8214     ac_cv_prog_OBJCOPY="${ncn_progname}"
8215     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8216     break 2
8217   fi
8218 done
8219 done
8220
8221 fi
8222 fi
8223 OBJCOPY=$ac_cv_prog_OBJCOPY
8224 if test -n "$OBJCOPY"; then
8225   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8226 echo "${ECHO_T}$OBJCOPY" >&6
8227 else
8228   echo "$as_me:$LINENO: result: no" >&5
8229 echo "${ECHO_T}no" >&6
8230 fi
8231
8232   fi
8233   test -n "$ac_cv_prog_OBJCOPY" && break
8234 done
8235
8236 if test -z "$ac_cv_prog_OBJCOPY" ; then
8237   set dummy objcopy
8238   if test $build = $host ; then
8239     OBJCOPY="$2"
8240   else
8241     OBJCOPY="${ncn_tool_prefix}$2"
8242   fi
8243 fi
8244
8245
8246
8247 if test -n "$OBJDUMP"; then
8248   ac_cv_prog_OBJDUMP=$OBJDUMP
8249 elif test -n "$ac_cv_prog_OBJDUMP"; then
8250   OBJDUMP=$ac_cv_prog_OBJDUMP
8251 fi
8252
8253 if test -n "$ac_cv_prog_OBJDUMP"; then
8254   for ncn_progname in objdump; do
8255     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8256 set dummy ${ncn_progname}; ac_word=$2
8257 echo "$as_me:$LINENO: checking for $ac_word" >&5
8258 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8259 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8260   echo $ECHO_N "(cached) $ECHO_C" >&6
8261 else
8262   if test -n "$OBJDUMP"; then
8263   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8264 else
8265 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8266 for as_dir in $PATH
8267 do
8268   IFS=$as_save_IFS
8269   test -z "$as_dir" && as_dir=.
8270   for ac_exec_ext in '' $ac_executable_extensions; do
8271   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8272     ac_cv_prog_OBJDUMP="${ncn_progname}"
8273     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8274     break 2
8275   fi
8276 done
8277 done
8278
8279 fi
8280 fi
8281 OBJDUMP=$ac_cv_prog_OBJDUMP
8282 if test -n "$OBJDUMP"; then
8283   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8284 echo "${ECHO_T}$OBJDUMP" >&6
8285 else
8286   echo "$as_me:$LINENO: result: no" >&5
8287 echo "${ECHO_T}no" >&6
8288 fi
8289
8290   done
8291 fi
8292
8293 for ncn_progname in objdump; do
8294   if test -n "$ncn_tool_prefix"; then
8295     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8296 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8297 echo "$as_me:$LINENO: checking for $ac_word" >&5
8298 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8299 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8300   echo $ECHO_N "(cached) $ECHO_C" >&6
8301 else
8302   if test -n "$OBJDUMP"; then
8303   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8304 else
8305 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8306 for as_dir in $PATH
8307 do
8308   IFS=$as_save_IFS
8309   test -z "$as_dir" && as_dir=.
8310   for ac_exec_ext in '' $ac_executable_extensions; do
8311   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8312     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8313     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8314     break 2
8315   fi
8316 done
8317 done
8318
8319 fi
8320 fi
8321 OBJDUMP=$ac_cv_prog_OBJDUMP
8322 if test -n "$OBJDUMP"; then
8323   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8324 echo "${ECHO_T}$OBJDUMP" >&6
8325 else
8326   echo "$as_me:$LINENO: result: no" >&5
8327 echo "${ECHO_T}no" >&6
8328 fi
8329
8330   fi
8331   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8332     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8333 set dummy ${ncn_progname}; ac_word=$2
8334 echo "$as_me:$LINENO: checking for $ac_word" >&5
8335 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8336 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8337   echo $ECHO_N "(cached) $ECHO_C" >&6
8338 else
8339   if test -n "$OBJDUMP"; then
8340   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8341 else
8342 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8343 for as_dir in $PATH
8344 do
8345   IFS=$as_save_IFS
8346   test -z "$as_dir" && as_dir=.
8347   for ac_exec_ext in '' $ac_executable_extensions; do
8348   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8349     ac_cv_prog_OBJDUMP="${ncn_progname}"
8350     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8351     break 2
8352   fi
8353 done
8354 done
8355
8356 fi
8357 fi
8358 OBJDUMP=$ac_cv_prog_OBJDUMP
8359 if test -n "$OBJDUMP"; then
8360   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8361 echo "${ECHO_T}$OBJDUMP" >&6
8362 else
8363   echo "$as_me:$LINENO: result: no" >&5
8364 echo "${ECHO_T}no" >&6
8365 fi
8366
8367   fi
8368   test -n "$ac_cv_prog_OBJDUMP" && break
8369 done
8370
8371 if test -z "$ac_cv_prog_OBJDUMP" ; then
8372   set dummy objdump
8373   if test $build = $host ; then
8374     OBJDUMP="$2"
8375   else
8376     OBJDUMP="${ncn_tool_prefix}$2"
8377   fi
8378 fi
8379
8380
8381
8382
8383
8384
8385 # Target tools.
8386
8387 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8388 if test "${with_build_time_tools+set}" = set; then
8389   withval="$with_build_time_tools"
8390   case x"$withval" in
8391      x/*) ;;
8392      *)
8393        with_build_time_tools=
8394        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8395 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8396        ;;
8397    esac
8398 else
8399   with_build_time_tools=
8400 fi;
8401
8402
8403
8404 if test -n "$CC_FOR_TARGET"; then
8405   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8406 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8407   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8408 fi
8409
8410 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8411   for ncn_progname in cc gcc; do
8412     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8413 set dummy ${ncn_progname}; ac_word=$2
8414 echo "$as_me:$LINENO: checking for $ac_word" >&5
8415 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8416 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8417   echo $ECHO_N "(cached) $ECHO_C" >&6
8418 else
8419   if test -n "$CC_FOR_TARGET"; then
8420   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8421 else
8422 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8423 for as_dir in $PATH
8424 do
8425   IFS=$as_save_IFS
8426   test -z "$as_dir" && as_dir=.
8427   for ac_exec_ext in '' $ac_executable_extensions; do
8428   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8429     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8430     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8431     break 2
8432   fi
8433 done
8434 done
8435
8436 fi
8437 fi
8438 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8439 if test -n "$CC_FOR_TARGET"; then
8440   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8441 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8442 else
8443   echo "$as_me:$LINENO: result: no" >&5
8444 echo "${ECHO_T}no" >&6
8445 fi
8446
8447   done
8448 fi
8449
8450 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8451   for ncn_progname in cc gcc; do
8452     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8453 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8454     if test -x $with_build_time_tools/${ncn_progname}; then
8455       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8456       echo "$as_me:$LINENO: result: yes" >&5
8457 echo "${ECHO_T}yes" >&6
8458       break
8459     else
8460       echo "$as_me:$LINENO: result: no" >&5
8461 echo "${ECHO_T}no" >&6
8462     fi
8463   done
8464 fi
8465
8466 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8467   for ncn_progname in cc gcc; do
8468     if test -n "$ncn_target_tool_prefix"; then
8469       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8470 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8471 echo "$as_me:$LINENO: checking for $ac_word" >&5
8472 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8473 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8474   echo $ECHO_N "(cached) $ECHO_C" >&6
8475 else
8476   if test -n "$CC_FOR_TARGET"; then
8477   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8478 else
8479 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8480 for as_dir in $PATH
8481 do
8482   IFS=$as_save_IFS
8483   test -z "$as_dir" && as_dir=.
8484   for ac_exec_ext in '' $ac_executable_extensions; do
8485   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8486     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8487     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8488     break 2
8489   fi
8490 done
8491 done
8492
8493 fi
8494 fi
8495 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8496 if test -n "$CC_FOR_TARGET"; then
8497   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8498 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8499 else
8500   echo "$as_me:$LINENO: result: no" >&5
8501 echo "${ECHO_T}no" >&6
8502 fi
8503
8504     fi
8505     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8506       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8507 set dummy ${ncn_progname}; ac_word=$2
8508 echo "$as_me:$LINENO: checking for $ac_word" >&5
8509 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8510 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8511   echo $ECHO_N "(cached) $ECHO_C" >&6
8512 else
8513   if test -n "$CC_FOR_TARGET"; then
8514   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8515 else
8516 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8517 for as_dir in $PATH
8518 do
8519   IFS=$as_save_IFS
8520   test -z "$as_dir" && as_dir=.
8521   for ac_exec_ext in '' $ac_executable_extensions; do
8522   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8523     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8524     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8525     break 2
8526   fi
8527 done
8528 done
8529
8530 fi
8531 fi
8532 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8533 if test -n "$CC_FOR_TARGET"; then
8534   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8535 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8536 else
8537   echo "$as_me:$LINENO: result: no" >&5
8538 echo "${ECHO_T}no" >&6
8539 fi
8540
8541     fi
8542     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8543   done
8544 fi
8545
8546 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8547   set dummy cc gcc
8548   if test $build = $target ; then
8549     CC_FOR_TARGET="$2"
8550   else
8551     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8552   fi
8553 else
8554   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8555 fi
8556
8557
8558
8559 if test -n "$CXX_FOR_TARGET"; then
8560   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8561 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8562   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8563 fi
8564
8565 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8566   for ncn_progname in c++ g++ cxx gxx; do
8567     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8568 set dummy ${ncn_progname}; ac_word=$2
8569 echo "$as_me:$LINENO: checking for $ac_word" >&5
8570 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8571 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8572   echo $ECHO_N "(cached) $ECHO_C" >&6
8573 else
8574   if test -n "$CXX_FOR_TARGET"; then
8575   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8576 else
8577 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8578 for as_dir in $PATH
8579 do
8580   IFS=$as_save_IFS
8581   test -z "$as_dir" && as_dir=.
8582   for ac_exec_ext in '' $ac_executable_extensions; do
8583   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8584     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8585     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8586     break 2
8587   fi
8588 done
8589 done
8590
8591 fi
8592 fi
8593 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8594 if test -n "$CXX_FOR_TARGET"; then
8595   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8596 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8597 else
8598   echo "$as_me:$LINENO: result: no" >&5
8599 echo "${ECHO_T}no" >&6
8600 fi
8601
8602   done
8603 fi
8604
8605 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8606   for ncn_progname in c++ g++ cxx gxx; do
8607     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8608 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8609     if test -x $with_build_time_tools/${ncn_progname}; then
8610       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8611       echo "$as_me:$LINENO: result: yes" >&5
8612 echo "${ECHO_T}yes" >&6
8613       break
8614     else
8615       echo "$as_me:$LINENO: result: no" >&5
8616 echo "${ECHO_T}no" >&6
8617     fi
8618   done
8619 fi
8620
8621 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8622   for ncn_progname in c++ g++ cxx gxx; do
8623     if test -n "$ncn_target_tool_prefix"; then
8624       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8625 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8626 echo "$as_me:$LINENO: checking for $ac_word" >&5
8627 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8628 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8629   echo $ECHO_N "(cached) $ECHO_C" >&6
8630 else
8631   if test -n "$CXX_FOR_TARGET"; then
8632   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8633 else
8634 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8635 for as_dir in $PATH
8636 do
8637   IFS=$as_save_IFS
8638   test -z "$as_dir" && as_dir=.
8639   for ac_exec_ext in '' $ac_executable_extensions; do
8640   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8641     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8642     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8643     break 2
8644   fi
8645 done
8646 done
8647
8648 fi
8649 fi
8650 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8651 if test -n "$CXX_FOR_TARGET"; then
8652   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8653 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8654 else
8655   echo "$as_me:$LINENO: result: no" >&5
8656 echo "${ECHO_T}no" >&6
8657 fi
8658
8659     fi
8660     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8661       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8662 set dummy ${ncn_progname}; ac_word=$2
8663 echo "$as_me:$LINENO: checking for $ac_word" >&5
8664 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8665 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8666   echo $ECHO_N "(cached) $ECHO_C" >&6
8667 else
8668   if test -n "$CXX_FOR_TARGET"; then
8669   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8670 else
8671 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8672 for as_dir in $PATH
8673 do
8674   IFS=$as_save_IFS
8675   test -z "$as_dir" && as_dir=.
8676   for ac_exec_ext in '' $ac_executable_extensions; do
8677   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8678     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8679     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8680     break 2
8681   fi
8682 done
8683 done
8684
8685 fi
8686 fi
8687 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8688 if test -n "$CXX_FOR_TARGET"; then
8689   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8690 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8691 else
8692   echo "$as_me:$LINENO: result: no" >&5
8693 echo "${ECHO_T}no" >&6
8694 fi
8695
8696     fi
8697     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8698   done
8699 fi
8700
8701 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8702   set dummy c++ g++ cxx gxx
8703   if test $build = $target ; then
8704     CXX_FOR_TARGET="$2"
8705   else
8706     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8707   fi
8708 else
8709   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8710 fi
8711
8712
8713
8714 if test -n "$GCC_FOR_TARGET"; then
8715   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8716 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8717   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8718 fi
8719
8720 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8721   for ncn_progname in gcc; do
8722     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8723 set dummy ${ncn_progname}; ac_word=$2
8724 echo "$as_me:$LINENO: checking for $ac_word" >&5
8725 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8726 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8727   echo $ECHO_N "(cached) $ECHO_C" >&6
8728 else
8729   if test -n "$GCC_FOR_TARGET"; then
8730   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8731 else
8732 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8733 for as_dir in $PATH
8734 do
8735   IFS=$as_save_IFS
8736   test -z "$as_dir" && as_dir=.
8737   for ac_exec_ext in '' $ac_executable_extensions; do
8738   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8739     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8740     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8741     break 2
8742   fi
8743 done
8744 done
8745
8746 fi
8747 fi
8748 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8749 if test -n "$GCC_FOR_TARGET"; then
8750   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8751 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8752 else
8753   echo "$as_me:$LINENO: result: no" >&5
8754 echo "${ECHO_T}no" >&6
8755 fi
8756
8757   done
8758 fi
8759
8760 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8761   for ncn_progname in gcc; do
8762     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8763 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8764     if test -x $with_build_time_tools/${ncn_progname}; then
8765       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8766       echo "$as_me:$LINENO: result: yes" >&5
8767 echo "${ECHO_T}yes" >&6
8768       break
8769     else
8770       echo "$as_me:$LINENO: result: no" >&5
8771 echo "${ECHO_T}no" >&6
8772     fi
8773   done
8774 fi
8775
8776 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8777   for ncn_progname in gcc; do
8778     if test -n "$ncn_target_tool_prefix"; then
8779       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8780 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8781 echo "$as_me:$LINENO: checking for $ac_word" >&5
8782 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8783 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8784   echo $ECHO_N "(cached) $ECHO_C" >&6
8785 else
8786   if test -n "$GCC_FOR_TARGET"; then
8787   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8788 else
8789 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8790 for as_dir in $PATH
8791 do
8792   IFS=$as_save_IFS
8793   test -z "$as_dir" && as_dir=.
8794   for ac_exec_ext in '' $ac_executable_extensions; do
8795   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8796     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8797     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8798     break 2
8799   fi
8800 done
8801 done
8802
8803 fi
8804 fi
8805 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8806 if test -n "$GCC_FOR_TARGET"; then
8807   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8808 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8809 else
8810   echo "$as_me:$LINENO: result: no" >&5
8811 echo "${ECHO_T}no" >&6
8812 fi
8813
8814     fi
8815     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8816       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8817 set dummy ${ncn_progname}; ac_word=$2
8818 echo "$as_me:$LINENO: checking for $ac_word" >&5
8819 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8820 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8821   echo $ECHO_N "(cached) $ECHO_C" >&6
8822 else
8823   if test -n "$GCC_FOR_TARGET"; then
8824   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8825 else
8826 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8827 for as_dir in $PATH
8828 do
8829   IFS=$as_save_IFS
8830   test -z "$as_dir" && as_dir=.
8831   for ac_exec_ext in '' $ac_executable_extensions; do
8832   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8833     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8834     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8835     break 2
8836   fi
8837 done
8838 done
8839
8840 fi
8841 fi
8842 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8843 if test -n "$GCC_FOR_TARGET"; then
8844   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8845 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8846 else
8847   echo "$as_me:$LINENO: result: no" >&5
8848 echo "${ECHO_T}no" >&6
8849 fi
8850
8851     fi
8852     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8853   done
8854 fi
8855
8856 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8857   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8858 else
8859   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8860 fi
8861
8862
8863
8864 if test -n "$GCJ_FOR_TARGET"; then
8865   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8866 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8867   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8868 fi
8869
8870 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8871   for ncn_progname in gcj; do
8872     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8873 set dummy ${ncn_progname}; ac_word=$2
8874 echo "$as_me:$LINENO: checking for $ac_word" >&5
8875 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8876 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8877   echo $ECHO_N "(cached) $ECHO_C" >&6
8878 else
8879   if test -n "$GCJ_FOR_TARGET"; then
8880   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8881 else
8882 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8883 for as_dir in $PATH
8884 do
8885   IFS=$as_save_IFS
8886   test -z "$as_dir" && as_dir=.
8887   for ac_exec_ext in '' $ac_executable_extensions; do
8888   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8889     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8890     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8891     break 2
8892   fi
8893 done
8894 done
8895
8896 fi
8897 fi
8898 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8899 if test -n "$GCJ_FOR_TARGET"; then
8900   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8901 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8902 else
8903   echo "$as_me:$LINENO: result: no" >&5
8904 echo "${ECHO_T}no" >&6
8905 fi
8906
8907   done
8908 fi
8909
8910 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8911   for ncn_progname in gcj; do
8912     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8913 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8914     if test -x $with_build_time_tools/${ncn_progname}; then
8915       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8916       echo "$as_me:$LINENO: result: yes" >&5
8917 echo "${ECHO_T}yes" >&6
8918       break
8919     else
8920       echo "$as_me:$LINENO: result: no" >&5
8921 echo "${ECHO_T}no" >&6
8922     fi
8923   done
8924 fi
8925
8926 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8927   for ncn_progname in gcj; do
8928     if test -n "$ncn_target_tool_prefix"; then
8929       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8930 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8931 echo "$as_me:$LINENO: checking for $ac_word" >&5
8932 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8933 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8934   echo $ECHO_N "(cached) $ECHO_C" >&6
8935 else
8936   if test -n "$GCJ_FOR_TARGET"; then
8937   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8938 else
8939 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8940 for as_dir in $PATH
8941 do
8942   IFS=$as_save_IFS
8943   test -z "$as_dir" && as_dir=.
8944   for ac_exec_ext in '' $ac_executable_extensions; do
8945   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8946     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8947     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8948     break 2
8949   fi
8950 done
8951 done
8952
8953 fi
8954 fi
8955 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8956 if test -n "$GCJ_FOR_TARGET"; then
8957   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8958 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8959 else
8960   echo "$as_me:$LINENO: result: no" >&5
8961 echo "${ECHO_T}no" >&6
8962 fi
8963
8964     fi
8965     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8966       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8967 set dummy ${ncn_progname}; ac_word=$2
8968 echo "$as_me:$LINENO: checking for $ac_word" >&5
8969 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8970 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8971   echo $ECHO_N "(cached) $ECHO_C" >&6
8972 else
8973   if test -n "$GCJ_FOR_TARGET"; then
8974   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8975 else
8976 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8977 for as_dir in $PATH
8978 do
8979   IFS=$as_save_IFS
8980   test -z "$as_dir" && as_dir=.
8981   for ac_exec_ext in '' $ac_executable_extensions; do
8982   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8983     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8984     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8985     break 2
8986   fi
8987 done
8988 done
8989
8990 fi
8991 fi
8992 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8993 if test -n "$GCJ_FOR_TARGET"; then
8994   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8995 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8996 else
8997   echo "$as_me:$LINENO: result: no" >&5
8998 echo "${ECHO_T}no" >&6
8999 fi
9000
9001     fi
9002     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9003   done
9004 fi
9005
9006 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9007   set dummy gcj
9008   if test $build = $target ; then
9009     GCJ_FOR_TARGET="$2"
9010   else
9011     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9012   fi
9013 else
9014   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9015 fi
9016
9017
9018
9019 if test -n "$GFORTRAN_FOR_TARGET"; then
9020   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9021 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9022   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9023 fi
9024
9025 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9026   for ncn_progname in gfortran; do
9027     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9028 set dummy ${ncn_progname}; ac_word=$2
9029 echo "$as_me:$LINENO: checking for $ac_word" >&5
9030 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9031 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9032   echo $ECHO_N "(cached) $ECHO_C" >&6
9033 else
9034   if test -n "$GFORTRAN_FOR_TARGET"; then
9035   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9036 else
9037 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9038 for as_dir in $PATH
9039 do
9040   IFS=$as_save_IFS
9041   test -z "$as_dir" && as_dir=.
9042   for ac_exec_ext in '' $ac_executable_extensions; do
9043   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9044     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9045     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9046     break 2
9047   fi
9048 done
9049 done
9050
9051 fi
9052 fi
9053 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9054 if test -n "$GFORTRAN_FOR_TARGET"; then
9055   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9056 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9057 else
9058   echo "$as_me:$LINENO: result: no" >&5
9059 echo "${ECHO_T}no" >&6
9060 fi
9061
9062   done
9063 fi
9064
9065 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9066   for ncn_progname in gfortran; do
9067     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9068 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9069     if test -x $with_build_time_tools/${ncn_progname}; then
9070       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9071       echo "$as_me:$LINENO: result: yes" >&5
9072 echo "${ECHO_T}yes" >&6
9073       break
9074     else
9075       echo "$as_me:$LINENO: result: no" >&5
9076 echo "${ECHO_T}no" >&6
9077     fi
9078   done
9079 fi
9080
9081 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9082   for ncn_progname in gfortran; do
9083     if test -n "$ncn_target_tool_prefix"; then
9084       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9085 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9086 echo "$as_me:$LINENO: checking for $ac_word" >&5
9087 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9088 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9089   echo $ECHO_N "(cached) $ECHO_C" >&6
9090 else
9091   if test -n "$GFORTRAN_FOR_TARGET"; then
9092   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9093 else
9094 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9095 for as_dir in $PATH
9096 do
9097   IFS=$as_save_IFS
9098   test -z "$as_dir" && as_dir=.
9099   for ac_exec_ext in '' $ac_executable_extensions; do
9100   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9101     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9102     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9103     break 2
9104   fi
9105 done
9106 done
9107
9108 fi
9109 fi
9110 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9111 if test -n "$GFORTRAN_FOR_TARGET"; then
9112   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9113 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9114 else
9115   echo "$as_me:$LINENO: result: no" >&5
9116 echo "${ECHO_T}no" >&6
9117 fi
9118
9119     fi
9120     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9121       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9122 set dummy ${ncn_progname}; ac_word=$2
9123 echo "$as_me:$LINENO: checking for $ac_word" >&5
9124 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9125 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9126   echo $ECHO_N "(cached) $ECHO_C" >&6
9127 else
9128   if test -n "$GFORTRAN_FOR_TARGET"; then
9129   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9130 else
9131 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9132 for as_dir in $PATH
9133 do
9134   IFS=$as_save_IFS
9135   test -z "$as_dir" && as_dir=.
9136   for ac_exec_ext in '' $ac_executable_extensions; do
9137   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9138     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9139     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9140     break 2
9141   fi
9142 done
9143 done
9144
9145 fi
9146 fi
9147 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9148 if test -n "$GFORTRAN_FOR_TARGET"; then
9149   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9150 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9151 else
9152   echo "$as_me:$LINENO: result: no" >&5
9153 echo "${ECHO_T}no" >&6
9154 fi
9155
9156     fi
9157     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9158   done
9159 fi
9160
9161 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9162   set dummy gfortran
9163   if test $build = $target ; then
9164     GFORTRAN_FOR_TARGET="$2"
9165   else
9166     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9167   fi
9168 else
9169   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9170 fi
9171
9172
9173
9174 cat > conftest.c << \EOF
9175 #ifdef __GNUC__
9176   gcc_yay;
9177 #endif
9178 EOF
9179 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9180   have_gcc_for_target=yes
9181 else
9182   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9183   have_gcc_for_target=no
9184 fi
9185 rm conftest.c
9186
9187
9188
9189
9190 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9191   if test -n "$with_build_time_tools"; then
9192     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9193 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9194     if test -x $with_build_time_tools/ar; then
9195       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9196       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9197       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9198 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9199     else
9200       echo "$as_me:$LINENO: result: no" >&5
9201 echo "${ECHO_T}no" >&6
9202     fi
9203   elif test $build != $host && test $have_gcc_for_target = yes; then
9204     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9205     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9206     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9207   fi
9208 fi
9209 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9210   # Extract the first word of "ar", so it can be a program name with args.
9211 set dummy ar; ac_word=$2
9212 echo "$as_me:$LINENO: checking for $ac_word" >&5
9213 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9214 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9215   echo $ECHO_N "(cached) $ECHO_C" >&6
9216 else
9217   case $AR_FOR_TARGET in
9218   [\\/]* | ?:[\\/]*)
9219   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9220   ;;
9221   *)
9222   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9223 for as_dir in $gcc_cv_tool_dirs
9224 do
9225   IFS=$as_save_IFS
9226   test -z "$as_dir" && as_dir=.
9227   for ac_exec_ext in '' $ac_executable_extensions; do
9228   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9229     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9230     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9231     break 2
9232   fi
9233 done
9234 done
9235
9236   ;;
9237 esac
9238 fi
9239 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9240
9241 if test -n "$AR_FOR_TARGET"; then
9242   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9243 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9244 else
9245   echo "$as_me:$LINENO: result: no" >&5
9246 echo "${ECHO_T}no" >&6
9247 fi
9248
9249 fi
9250 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9251
9252
9253 if test -n "$AR_FOR_TARGET"; then
9254   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9255 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9256   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9257 fi
9258
9259 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9260   for ncn_progname in ar; do
9261     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9262 set dummy ${ncn_progname}; ac_word=$2
9263 echo "$as_me:$LINENO: checking for $ac_word" >&5
9264 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9265 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9266   echo $ECHO_N "(cached) $ECHO_C" >&6
9267 else
9268   if test -n "$AR_FOR_TARGET"; then
9269   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9270 else
9271 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9272 for as_dir in $PATH
9273 do
9274   IFS=$as_save_IFS
9275   test -z "$as_dir" && as_dir=.
9276   for ac_exec_ext in '' $ac_executable_extensions; do
9277   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9278     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9279     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9280     break 2
9281   fi
9282 done
9283 done
9284
9285 fi
9286 fi
9287 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9288 if test -n "$AR_FOR_TARGET"; then
9289   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9290 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9291 else
9292   echo "$as_me:$LINENO: result: no" >&5
9293 echo "${ECHO_T}no" >&6
9294 fi
9295
9296   done
9297 fi
9298
9299 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9300   for ncn_progname in ar; do
9301     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9302 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9303     if test -x $with_build_time_tools/${ncn_progname}; then
9304       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9305       echo "$as_me:$LINENO: result: yes" >&5
9306 echo "${ECHO_T}yes" >&6
9307       break
9308     else
9309       echo "$as_me:$LINENO: result: no" >&5
9310 echo "${ECHO_T}no" >&6
9311     fi
9312   done
9313 fi
9314
9315 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9316   for ncn_progname in ar; do
9317     if test -n "$ncn_target_tool_prefix"; then
9318       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9319 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9320 echo "$as_me:$LINENO: checking for $ac_word" >&5
9321 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9322 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9323   echo $ECHO_N "(cached) $ECHO_C" >&6
9324 else
9325   if test -n "$AR_FOR_TARGET"; then
9326   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9327 else
9328 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9329 for as_dir in $PATH
9330 do
9331   IFS=$as_save_IFS
9332   test -z "$as_dir" && as_dir=.
9333   for ac_exec_ext in '' $ac_executable_extensions; do
9334   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9335     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9336     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9337     break 2
9338   fi
9339 done
9340 done
9341
9342 fi
9343 fi
9344 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9345 if test -n "$AR_FOR_TARGET"; then
9346   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9347 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9348 else
9349   echo "$as_me:$LINENO: result: no" >&5
9350 echo "${ECHO_T}no" >&6
9351 fi
9352
9353     fi
9354     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9355       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9356 set dummy ${ncn_progname}; ac_word=$2
9357 echo "$as_me:$LINENO: checking for $ac_word" >&5
9358 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9359 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9360   echo $ECHO_N "(cached) $ECHO_C" >&6
9361 else
9362   if test -n "$AR_FOR_TARGET"; then
9363   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9364 else
9365 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9366 for as_dir in $PATH
9367 do
9368   IFS=$as_save_IFS
9369   test -z "$as_dir" && as_dir=.
9370   for ac_exec_ext in '' $ac_executable_extensions; do
9371   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9372     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9373     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9374     break 2
9375   fi
9376 done
9377 done
9378
9379 fi
9380 fi
9381 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9382 if test -n "$AR_FOR_TARGET"; then
9383   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9384 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9385 else
9386   echo "$as_me:$LINENO: result: no" >&5
9387 echo "${ECHO_T}no" >&6
9388 fi
9389
9390     fi
9391     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9392   done
9393 fi
9394
9395 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9396   set dummy ar
9397   if test $build = $target ; then
9398     AR_FOR_TARGET="$2"
9399   else
9400     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9401   fi
9402 else
9403   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9404 fi
9405
9406 else
9407   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9408 fi
9409
9410
9411
9412
9413 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9414   if test -n "$with_build_time_tools"; then
9415     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9416 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9417     if test -x $with_build_time_tools/as; then
9418       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9419       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9420       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9421 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9422     else
9423       echo "$as_me:$LINENO: result: no" >&5
9424 echo "${ECHO_T}no" >&6
9425     fi
9426   elif test $build != $host && test $have_gcc_for_target = yes; then
9427     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9428     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9429     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9430   fi
9431 fi
9432 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9433   # Extract the first word of "as", so it can be a program name with args.
9434 set dummy as; ac_word=$2
9435 echo "$as_me:$LINENO: checking for $ac_word" >&5
9436 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9437 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9438   echo $ECHO_N "(cached) $ECHO_C" >&6
9439 else
9440   case $AS_FOR_TARGET in
9441   [\\/]* | ?:[\\/]*)
9442   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9443   ;;
9444   *)
9445   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9446 for as_dir in $gcc_cv_tool_dirs
9447 do
9448   IFS=$as_save_IFS
9449   test -z "$as_dir" && as_dir=.
9450   for ac_exec_ext in '' $ac_executable_extensions; do
9451   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9452     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9453     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9454     break 2
9455   fi
9456 done
9457 done
9458
9459   ;;
9460 esac
9461 fi
9462 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9463
9464 if test -n "$AS_FOR_TARGET"; then
9465   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9466 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9467 else
9468   echo "$as_me:$LINENO: result: no" >&5
9469 echo "${ECHO_T}no" >&6
9470 fi
9471
9472 fi
9473 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9474
9475
9476 if test -n "$AS_FOR_TARGET"; then
9477   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9478 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9479   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9480 fi
9481
9482 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9483   for ncn_progname in as; do
9484     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9485 set dummy ${ncn_progname}; ac_word=$2
9486 echo "$as_me:$LINENO: checking for $ac_word" >&5
9487 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9488 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9489   echo $ECHO_N "(cached) $ECHO_C" >&6
9490 else
9491   if test -n "$AS_FOR_TARGET"; then
9492   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9493 else
9494 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9495 for as_dir in $PATH
9496 do
9497   IFS=$as_save_IFS
9498   test -z "$as_dir" && as_dir=.
9499   for ac_exec_ext in '' $ac_executable_extensions; do
9500   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9501     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9502     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9503     break 2
9504   fi
9505 done
9506 done
9507
9508 fi
9509 fi
9510 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9511 if test -n "$AS_FOR_TARGET"; then
9512   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9513 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9514 else
9515   echo "$as_me:$LINENO: result: no" >&5
9516 echo "${ECHO_T}no" >&6
9517 fi
9518
9519   done
9520 fi
9521
9522 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9523   for ncn_progname in as; do
9524     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9525 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9526     if test -x $with_build_time_tools/${ncn_progname}; then
9527       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9528       echo "$as_me:$LINENO: result: yes" >&5
9529 echo "${ECHO_T}yes" >&6
9530       break
9531     else
9532       echo "$as_me:$LINENO: result: no" >&5
9533 echo "${ECHO_T}no" >&6
9534     fi
9535   done
9536 fi
9537
9538 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9539   for ncn_progname in as; do
9540     if test -n "$ncn_target_tool_prefix"; then
9541       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9542 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9543 echo "$as_me:$LINENO: checking for $ac_word" >&5
9544 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9545 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9546   echo $ECHO_N "(cached) $ECHO_C" >&6
9547 else
9548   if test -n "$AS_FOR_TARGET"; then
9549   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9550 else
9551 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9552 for as_dir in $PATH
9553 do
9554   IFS=$as_save_IFS
9555   test -z "$as_dir" && as_dir=.
9556   for ac_exec_ext in '' $ac_executable_extensions; do
9557   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9558     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9559     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9560     break 2
9561   fi
9562 done
9563 done
9564
9565 fi
9566 fi
9567 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9568 if test -n "$AS_FOR_TARGET"; then
9569   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9570 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9571 else
9572   echo "$as_me:$LINENO: result: no" >&5
9573 echo "${ECHO_T}no" >&6
9574 fi
9575
9576     fi
9577     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9578       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9579 set dummy ${ncn_progname}; ac_word=$2
9580 echo "$as_me:$LINENO: checking for $ac_word" >&5
9581 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9582 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9583   echo $ECHO_N "(cached) $ECHO_C" >&6
9584 else
9585   if test -n "$AS_FOR_TARGET"; then
9586   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9587 else
9588 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9589 for as_dir in $PATH
9590 do
9591   IFS=$as_save_IFS
9592   test -z "$as_dir" && as_dir=.
9593   for ac_exec_ext in '' $ac_executable_extensions; do
9594   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9595     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9596     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9597     break 2
9598   fi
9599 done
9600 done
9601
9602 fi
9603 fi
9604 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9605 if test -n "$AS_FOR_TARGET"; then
9606   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9607 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9608 else
9609   echo "$as_me:$LINENO: result: no" >&5
9610 echo "${ECHO_T}no" >&6
9611 fi
9612
9613     fi
9614     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9615   done
9616 fi
9617
9618 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9619   set dummy as
9620   if test $build = $target ; then
9621     AS_FOR_TARGET="$2"
9622   else
9623     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9624   fi
9625 else
9626   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9627 fi
9628
9629 else
9630   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9631 fi
9632
9633
9634
9635
9636 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9637   if test -n "$with_build_time_tools"; then
9638     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9639 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9640     if test -x $with_build_time_tools/dlltool; then
9641       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9642       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9643       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9644 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9645     else
9646       echo "$as_me:$LINENO: result: no" >&5
9647 echo "${ECHO_T}no" >&6
9648     fi
9649   elif test $build != $host && test $have_gcc_for_target = yes; then
9650     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9651     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9652     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9653   fi
9654 fi
9655 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9656   # Extract the first word of "dlltool", so it can be a program name with args.
9657 set dummy dlltool; ac_word=$2
9658 echo "$as_me:$LINENO: checking for $ac_word" >&5
9659 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9660 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9661   echo $ECHO_N "(cached) $ECHO_C" >&6
9662 else
9663   case $DLLTOOL_FOR_TARGET in
9664   [\\/]* | ?:[\\/]*)
9665   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9666   ;;
9667   *)
9668   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9669 for as_dir in $gcc_cv_tool_dirs
9670 do
9671   IFS=$as_save_IFS
9672   test -z "$as_dir" && as_dir=.
9673   for ac_exec_ext in '' $ac_executable_extensions; do
9674   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9675     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9676     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9677     break 2
9678   fi
9679 done
9680 done
9681
9682   ;;
9683 esac
9684 fi
9685 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9686
9687 if test -n "$DLLTOOL_FOR_TARGET"; then
9688   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9689 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9690 else
9691   echo "$as_me:$LINENO: result: no" >&5
9692 echo "${ECHO_T}no" >&6
9693 fi
9694
9695 fi
9696 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9697
9698
9699 if test -n "$DLLTOOL_FOR_TARGET"; then
9700   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9701 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9702   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9703 fi
9704
9705 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9706   for ncn_progname in dlltool; do
9707     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9708 set dummy ${ncn_progname}; ac_word=$2
9709 echo "$as_me:$LINENO: checking for $ac_word" >&5
9710 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9711 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9712   echo $ECHO_N "(cached) $ECHO_C" >&6
9713 else
9714   if test -n "$DLLTOOL_FOR_TARGET"; then
9715   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9716 else
9717 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9718 for as_dir in $PATH
9719 do
9720   IFS=$as_save_IFS
9721   test -z "$as_dir" && as_dir=.
9722   for ac_exec_ext in '' $ac_executable_extensions; do
9723   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9724     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9725     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9726     break 2
9727   fi
9728 done
9729 done
9730
9731 fi
9732 fi
9733 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9734 if test -n "$DLLTOOL_FOR_TARGET"; then
9735   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9736 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9737 else
9738   echo "$as_me:$LINENO: result: no" >&5
9739 echo "${ECHO_T}no" >&6
9740 fi
9741
9742   done
9743 fi
9744
9745 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9746   for ncn_progname in dlltool; do
9747     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9748 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9749     if test -x $with_build_time_tools/${ncn_progname}; then
9750       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9751       echo "$as_me:$LINENO: result: yes" >&5
9752 echo "${ECHO_T}yes" >&6
9753       break
9754     else
9755       echo "$as_me:$LINENO: result: no" >&5
9756 echo "${ECHO_T}no" >&6
9757     fi
9758   done
9759 fi
9760
9761 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9762   for ncn_progname in dlltool; do
9763     if test -n "$ncn_target_tool_prefix"; then
9764       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9765 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9766 echo "$as_me:$LINENO: checking for $ac_word" >&5
9767 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9768 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9769   echo $ECHO_N "(cached) $ECHO_C" >&6
9770 else
9771   if test -n "$DLLTOOL_FOR_TARGET"; then
9772   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9773 else
9774 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9775 for as_dir in $PATH
9776 do
9777   IFS=$as_save_IFS
9778   test -z "$as_dir" && as_dir=.
9779   for ac_exec_ext in '' $ac_executable_extensions; do
9780   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9781     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9782     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9783     break 2
9784   fi
9785 done
9786 done
9787
9788 fi
9789 fi
9790 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9791 if test -n "$DLLTOOL_FOR_TARGET"; then
9792   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9793 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9794 else
9795   echo "$as_me:$LINENO: result: no" >&5
9796 echo "${ECHO_T}no" >&6
9797 fi
9798
9799     fi
9800     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9801       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9802 set dummy ${ncn_progname}; ac_word=$2
9803 echo "$as_me:$LINENO: checking for $ac_word" >&5
9804 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9805 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9806   echo $ECHO_N "(cached) $ECHO_C" >&6
9807 else
9808   if test -n "$DLLTOOL_FOR_TARGET"; then
9809   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9810 else
9811 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9812 for as_dir in $PATH
9813 do
9814   IFS=$as_save_IFS
9815   test -z "$as_dir" && as_dir=.
9816   for ac_exec_ext in '' $ac_executable_extensions; do
9817   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9818     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9819     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9820     break 2
9821   fi
9822 done
9823 done
9824
9825 fi
9826 fi
9827 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9828 if test -n "$DLLTOOL_FOR_TARGET"; then
9829   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9830 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9831 else
9832   echo "$as_me:$LINENO: result: no" >&5
9833 echo "${ECHO_T}no" >&6
9834 fi
9835
9836     fi
9837     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9838   done
9839 fi
9840
9841 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9842   set dummy dlltool
9843   if test $build = $target ; then
9844     DLLTOOL_FOR_TARGET="$2"
9845   else
9846     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9847   fi
9848 else
9849   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9850 fi
9851
9852 else
9853   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9854 fi
9855
9856
9857
9858
9859 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9860   if test -n "$with_build_time_tools"; then
9861     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9862 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9863     if test -x $with_build_time_tools/ld; then
9864       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9865       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9866       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9867 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9868     else
9869       echo "$as_me:$LINENO: result: no" >&5
9870 echo "${ECHO_T}no" >&6
9871     fi
9872   elif test $build != $host && test $have_gcc_for_target = yes; then
9873     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9874     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9875     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9876   fi
9877 fi
9878 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9879   # Extract the first word of "ld", so it can be a program name with args.
9880 set dummy ld; ac_word=$2
9881 echo "$as_me:$LINENO: checking for $ac_word" >&5
9882 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9883 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9884   echo $ECHO_N "(cached) $ECHO_C" >&6
9885 else
9886   case $LD_FOR_TARGET in
9887   [\\/]* | ?:[\\/]*)
9888   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9889   ;;
9890   *)
9891   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9892 for as_dir in $gcc_cv_tool_dirs
9893 do
9894   IFS=$as_save_IFS
9895   test -z "$as_dir" && as_dir=.
9896   for ac_exec_ext in '' $ac_executable_extensions; do
9897   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9898     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9899     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9900     break 2
9901   fi
9902 done
9903 done
9904
9905   ;;
9906 esac
9907 fi
9908 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9909
9910 if test -n "$LD_FOR_TARGET"; then
9911   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9912 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9913 else
9914   echo "$as_me:$LINENO: result: no" >&5
9915 echo "${ECHO_T}no" >&6
9916 fi
9917
9918 fi
9919 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9920
9921
9922 if test -n "$LD_FOR_TARGET"; then
9923   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9924 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9925   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9926 fi
9927
9928 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9929   for ncn_progname in ld; do
9930     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9931 set dummy ${ncn_progname}; ac_word=$2
9932 echo "$as_me:$LINENO: checking for $ac_word" >&5
9933 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9934 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9935   echo $ECHO_N "(cached) $ECHO_C" >&6
9936 else
9937   if test -n "$LD_FOR_TARGET"; then
9938   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9939 else
9940 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9941 for as_dir in $PATH
9942 do
9943   IFS=$as_save_IFS
9944   test -z "$as_dir" && as_dir=.
9945   for ac_exec_ext in '' $ac_executable_extensions; do
9946   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9947     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9948     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9949     break 2
9950   fi
9951 done
9952 done
9953
9954 fi
9955 fi
9956 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9957 if test -n "$LD_FOR_TARGET"; then
9958   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9959 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9960 else
9961   echo "$as_me:$LINENO: result: no" >&5
9962 echo "${ECHO_T}no" >&6
9963 fi
9964
9965   done
9966 fi
9967
9968 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9969   for ncn_progname in ld; do
9970     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9971 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9972     if test -x $with_build_time_tools/${ncn_progname}; then
9973       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9974       echo "$as_me:$LINENO: result: yes" >&5
9975 echo "${ECHO_T}yes" >&6
9976       break
9977     else
9978       echo "$as_me:$LINENO: result: no" >&5
9979 echo "${ECHO_T}no" >&6
9980     fi
9981   done
9982 fi
9983
9984 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9985   for ncn_progname in ld; do
9986     if test -n "$ncn_target_tool_prefix"; then
9987       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9988 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9989 echo "$as_me:$LINENO: checking for $ac_word" >&5
9990 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9991 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9992   echo $ECHO_N "(cached) $ECHO_C" >&6
9993 else
9994   if test -n "$LD_FOR_TARGET"; then
9995   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9996 else
9997 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9998 for as_dir in $PATH
9999 do
10000   IFS=$as_save_IFS
10001   test -z "$as_dir" && as_dir=.
10002   for ac_exec_ext in '' $ac_executable_extensions; do
10003   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10004     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10005     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10006     break 2
10007   fi
10008 done
10009 done
10010
10011 fi
10012 fi
10013 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10014 if test -n "$LD_FOR_TARGET"; then
10015   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10016 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10017 else
10018   echo "$as_me:$LINENO: result: no" >&5
10019 echo "${ECHO_T}no" >&6
10020 fi
10021
10022     fi
10023     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10024       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10025 set dummy ${ncn_progname}; ac_word=$2
10026 echo "$as_me:$LINENO: checking for $ac_word" >&5
10027 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10028 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10029   echo $ECHO_N "(cached) $ECHO_C" >&6
10030 else
10031   if test -n "$LD_FOR_TARGET"; then
10032   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10033 else
10034 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10035 for as_dir in $PATH
10036 do
10037   IFS=$as_save_IFS
10038   test -z "$as_dir" && as_dir=.
10039   for ac_exec_ext in '' $ac_executable_extensions; do
10040   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10041     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10042     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10043     break 2
10044   fi
10045 done
10046 done
10047
10048 fi
10049 fi
10050 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10051 if test -n "$LD_FOR_TARGET"; then
10052   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10053 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10054 else
10055   echo "$as_me:$LINENO: result: no" >&5
10056 echo "${ECHO_T}no" >&6
10057 fi
10058
10059     fi
10060     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10061   done
10062 fi
10063
10064 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10065   set dummy ld
10066   if test $build = $target ; then
10067     LD_FOR_TARGET="$2"
10068   else
10069     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10070   fi
10071 else
10072   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10073 fi
10074
10075 else
10076   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10077 fi
10078
10079
10080
10081
10082 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10083   if test -n "$with_build_time_tools"; then
10084     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10085 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10086     if test -x $with_build_time_tools/lipo; then
10087       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10088       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10089       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10090 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10091     else
10092       echo "$as_me:$LINENO: result: no" >&5
10093 echo "${ECHO_T}no" >&6
10094     fi
10095   elif test $build != $host && test $have_gcc_for_target = yes; then
10096     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10097     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10098     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10099   fi
10100 fi
10101 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10102   # Extract the first word of "lipo", so it can be a program name with args.
10103 set dummy lipo; ac_word=$2
10104 echo "$as_me:$LINENO: checking for $ac_word" >&5
10105 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10106 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10107   echo $ECHO_N "(cached) $ECHO_C" >&6
10108 else
10109   case $LIPO_FOR_TARGET in
10110   [\\/]* | ?:[\\/]*)
10111   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10112   ;;
10113   *)
10114   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10115 for as_dir in $gcc_cv_tool_dirs
10116 do
10117   IFS=$as_save_IFS
10118   test -z "$as_dir" && as_dir=.
10119   for ac_exec_ext in '' $ac_executable_extensions; do
10120   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10121     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10122     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10123     break 2
10124   fi
10125 done
10126 done
10127
10128   ;;
10129 esac
10130 fi
10131 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10132
10133 if test -n "$LIPO_FOR_TARGET"; then
10134   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10135 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10136 else
10137   echo "$as_me:$LINENO: result: no" >&5
10138 echo "${ECHO_T}no" >&6
10139 fi
10140
10141 fi
10142 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10143
10144
10145 if test -n "$LIPO_FOR_TARGET"; then
10146   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10147 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10148   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10149 fi
10150
10151 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10152   for ncn_progname in lipo; do
10153     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10154 set dummy ${ncn_progname}; ac_word=$2
10155 echo "$as_me:$LINENO: checking for $ac_word" >&5
10156 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10157 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10158   echo $ECHO_N "(cached) $ECHO_C" >&6
10159 else
10160   if test -n "$LIPO_FOR_TARGET"; then
10161   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10162 else
10163 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10164 for as_dir in $PATH
10165 do
10166   IFS=$as_save_IFS
10167   test -z "$as_dir" && as_dir=.
10168   for ac_exec_ext in '' $ac_executable_extensions; do
10169   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10170     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10171     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10172     break 2
10173   fi
10174 done
10175 done
10176
10177 fi
10178 fi
10179 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10180 if test -n "$LIPO_FOR_TARGET"; then
10181   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10182 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10183 else
10184   echo "$as_me:$LINENO: result: no" >&5
10185 echo "${ECHO_T}no" >&6
10186 fi
10187
10188   done
10189 fi
10190
10191 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10192   for ncn_progname in lipo; do
10193     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10194 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10195     if test -x $with_build_time_tools/${ncn_progname}; then
10196       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10197       echo "$as_me:$LINENO: result: yes" >&5
10198 echo "${ECHO_T}yes" >&6
10199       break
10200     else
10201       echo "$as_me:$LINENO: result: no" >&5
10202 echo "${ECHO_T}no" >&6
10203     fi
10204   done
10205 fi
10206
10207 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10208   for ncn_progname in lipo; do
10209     if test -n "$ncn_target_tool_prefix"; then
10210       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10211 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10212 echo "$as_me:$LINENO: checking for $ac_word" >&5
10213 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10214 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10215   echo $ECHO_N "(cached) $ECHO_C" >&6
10216 else
10217   if test -n "$LIPO_FOR_TARGET"; then
10218   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10219 else
10220 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10221 for as_dir in $PATH
10222 do
10223   IFS=$as_save_IFS
10224   test -z "$as_dir" && as_dir=.
10225   for ac_exec_ext in '' $ac_executable_extensions; do
10226   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10227     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10228     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10229     break 2
10230   fi
10231 done
10232 done
10233
10234 fi
10235 fi
10236 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10237 if test -n "$LIPO_FOR_TARGET"; then
10238   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10239 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10240 else
10241   echo "$as_me:$LINENO: result: no" >&5
10242 echo "${ECHO_T}no" >&6
10243 fi
10244
10245     fi
10246     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10247       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10248 set dummy ${ncn_progname}; ac_word=$2
10249 echo "$as_me:$LINENO: checking for $ac_word" >&5
10250 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10251 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10252   echo $ECHO_N "(cached) $ECHO_C" >&6
10253 else
10254   if test -n "$LIPO_FOR_TARGET"; then
10255   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10256 else
10257 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10258 for as_dir in $PATH
10259 do
10260   IFS=$as_save_IFS
10261   test -z "$as_dir" && as_dir=.
10262   for ac_exec_ext in '' $ac_executable_extensions; do
10263   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10264     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10265     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10266     break 2
10267   fi
10268 done
10269 done
10270
10271 fi
10272 fi
10273 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10274 if test -n "$LIPO_FOR_TARGET"; then
10275   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10276 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10277 else
10278   echo "$as_me:$LINENO: result: no" >&5
10279 echo "${ECHO_T}no" >&6
10280 fi
10281
10282     fi
10283     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10284   done
10285 fi
10286
10287 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10288   set dummy lipo
10289   if test $build = $target ; then
10290     LIPO_FOR_TARGET="$2"
10291   else
10292     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10293   fi
10294 else
10295   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10296 fi
10297
10298 else
10299   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10300 fi
10301
10302
10303
10304
10305 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10306   if test -n "$with_build_time_tools"; then
10307     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10308 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10309     if test -x $with_build_time_tools/nm; then
10310       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10311       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10312       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10313 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10314     else
10315       echo "$as_me:$LINENO: result: no" >&5
10316 echo "${ECHO_T}no" >&6
10317     fi
10318   elif test $build != $host && test $have_gcc_for_target = yes; then
10319     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10320     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10321     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10322   fi
10323 fi
10324 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10325   # Extract the first word of "nm", so it can be a program name with args.
10326 set dummy nm; ac_word=$2
10327 echo "$as_me:$LINENO: checking for $ac_word" >&5
10328 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10329 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10330   echo $ECHO_N "(cached) $ECHO_C" >&6
10331 else
10332   case $NM_FOR_TARGET in
10333   [\\/]* | ?:[\\/]*)
10334   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10335   ;;
10336   *)
10337   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10338 for as_dir in $gcc_cv_tool_dirs
10339 do
10340   IFS=$as_save_IFS
10341   test -z "$as_dir" && as_dir=.
10342   for ac_exec_ext in '' $ac_executable_extensions; do
10343   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10344     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10345     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10346     break 2
10347   fi
10348 done
10349 done
10350
10351   ;;
10352 esac
10353 fi
10354 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10355
10356 if test -n "$NM_FOR_TARGET"; then
10357   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10358 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10359 else
10360   echo "$as_me:$LINENO: result: no" >&5
10361 echo "${ECHO_T}no" >&6
10362 fi
10363
10364 fi
10365 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10366
10367
10368 if test -n "$NM_FOR_TARGET"; then
10369   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10370 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10371   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10372 fi
10373
10374 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10375   for ncn_progname in nm; do
10376     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10377 set dummy ${ncn_progname}; ac_word=$2
10378 echo "$as_me:$LINENO: checking for $ac_word" >&5
10379 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10380 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10381   echo $ECHO_N "(cached) $ECHO_C" >&6
10382 else
10383   if test -n "$NM_FOR_TARGET"; then
10384   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10385 else
10386 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10387 for as_dir in $PATH
10388 do
10389   IFS=$as_save_IFS
10390   test -z "$as_dir" && as_dir=.
10391   for ac_exec_ext in '' $ac_executable_extensions; do
10392   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10393     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10394     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10395     break 2
10396   fi
10397 done
10398 done
10399
10400 fi
10401 fi
10402 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10403 if test -n "$NM_FOR_TARGET"; then
10404   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10405 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10406 else
10407   echo "$as_me:$LINENO: result: no" >&5
10408 echo "${ECHO_T}no" >&6
10409 fi
10410
10411   done
10412 fi
10413
10414 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10415   for ncn_progname in nm; do
10416     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10417 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10418     if test -x $with_build_time_tools/${ncn_progname}; then
10419       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10420       echo "$as_me:$LINENO: result: yes" >&5
10421 echo "${ECHO_T}yes" >&6
10422       break
10423     else
10424       echo "$as_me:$LINENO: result: no" >&5
10425 echo "${ECHO_T}no" >&6
10426     fi
10427   done
10428 fi
10429
10430 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10431   for ncn_progname in nm; do
10432     if test -n "$ncn_target_tool_prefix"; then
10433       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10434 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10435 echo "$as_me:$LINENO: checking for $ac_word" >&5
10436 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10437 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10438   echo $ECHO_N "(cached) $ECHO_C" >&6
10439 else
10440   if test -n "$NM_FOR_TARGET"; then
10441   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10442 else
10443 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10444 for as_dir in $PATH
10445 do
10446   IFS=$as_save_IFS
10447   test -z "$as_dir" && as_dir=.
10448   for ac_exec_ext in '' $ac_executable_extensions; do
10449   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10450     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10451     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10452     break 2
10453   fi
10454 done
10455 done
10456
10457 fi
10458 fi
10459 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10460 if test -n "$NM_FOR_TARGET"; then
10461   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10462 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10463 else
10464   echo "$as_me:$LINENO: result: no" >&5
10465 echo "${ECHO_T}no" >&6
10466 fi
10467
10468     fi
10469     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10470       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10471 set dummy ${ncn_progname}; ac_word=$2
10472 echo "$as_me:$LINENO: checking for $ac_word" >&5
10473 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10474 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10475   echo $ECHO_N "(cached) $ECHO_C" >&6
10476 else
10477   if test -n "$NM_FOR_TARGET"; then
10478   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10479 else
10480 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10481 for as_dir in $PATH
10482 do
10483   IFS=$as_save_IFS
10484   test -z "$as_dir" && as_dir=.
10485   for ac_exec_ext in '' $ac_executable_extensions; do
10486   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10487     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10488     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10489     break 2
10490   fi
10491 done
10492 done
10493
10494 fi
10495 fi
10496 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10497 if test -n "$NM_FOR_TARGET"; then
10498   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10499 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10500 else
10501   echo "$as_me:$LINENO: result: no" >&5
10502 echo "${ECHO_T}no" >&6
10503 fi
10504
10505     fi
10506     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10507   done
10508 fi
10509
10510 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10511   set dummy nm
10512   if test $build = $target ; then
10513     NM_FOR_TARGET="$2"
10514   else
10515     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10516   fi
10517 else
10518   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10519 fi
10520
10521 else
10522   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10523 fi
10524
10525
10526
10527
10528 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10529   if test -n "$with_build_time_tools"; then
10530     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10531 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10532     if test -x $with_build_time_tools/objdump; then
10533       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10534       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10535       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10536 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10537     else
10538       echo "$as_me:$LINENO: result: no" >&5
10539 echo "${ECHO_T}no" >&6
10540     fi
10541   elif test $build != $host && test $have_gcc_for_target = yes; then
10542     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10543     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10544     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10545   fi
10546 fi
10547 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10548   # Extract the first word of "objdump", so it can be a program name with args.
10549 set dummy objdump; ac_word=$2
10550 echo "$as_me:$LINENO: checking for $ac_word" >&5
10551 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10552 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10553   echo $ECHO_N "(cached) $ECHO_C" >&6
10554 else
10555   case $OBJDUMP_FOR_TARGET in
10556   [\\/]* | ?:[\\/]*)
10557   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10558   ;;
10559   *)
10560   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10561 for as_dir in $gcc_cv_tool_dirs
10562 do
10563   IFS=$as_save_IFS
10564   test -z "$as_dir" && as_dir=.
10565   for ac_exec_ext in '' $ac_executable_extensions; do
10566   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10567     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10568     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10569     break 2
10570   fi
10571 done
10572 done
10573
10574   ;;
10575 esac
10576 fi
10577 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10578
10579 if test -n "$OBJDUMP_FOR_TARGET"; then
10580   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10581 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10582 else
10583   echo "$as_me:$LINENO: result: no" >&5
10584 echo "${ECHO_T}no" >&6
10585 fi
10586
10587 fi
10588 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10589
10590
10591 if test -n "$OBJDUMP_FOR_TARGET"; then
10592   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10593 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10594   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10595 fi
10596
10597 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10598   for ncn_progname in objdump; do
10599     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10600 set dummy ${ncn_progname}; ac_word=$2
10601 echo "$as_me:$LINENO: checking for $ac_word" >&5
10602 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10603 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10604   echo $ECHO_N "(cached) $ECHO_C" >&6
10605 else
10606   if test -n "$OBJDUMP_FOR_TARGET"; then
10607   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10608 else
10609 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10610 for as_dir in $PATH
10611 do
10612   IFS=$as_save_IFS
10613   test -z "$as_dir" && as_dir=.
10614   for ac_exec_ext in '' $ac_executable_extensions; do
10615   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10616     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10617     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10618     break 2
10619   fi
10620 done
10621 done
10622
10623 fi
10624 fi
10625 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10626 if test -n "$OBJDUMP_FOR_TARGET"; then
10627   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10628 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10629 else
10630   echo "$as_me:$LINENO: result: no" >&5
10631 echo "${ECHO_T}no" >&6
10632 fi
10633
10634   done
10635 fi
10636
10637 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10638   for ncn_progname in objdump; do
10639     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10640 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10641     if test -x $with_build_time_tools/${ncn_progname}; then
10642       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10643       echo "$as_me:$LINENO: result: yes" >&5
10644 echo "${ECHO_T}yes" >&6
10645       break
10646     else
10647       echo "$as_me:$LINENO: result: no" >&5
10648 echo "${ECHO_T}no" >&6
10649     fi
10650   done
10651 fi
10652
10653 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10654   for ncn_progname in objdump; do
10655     if test -n "$ncn_target_tool_prefix"; then
10656       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10657 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10658 echo "$as_me:$LINENO: checking for $ac_word" >&5
10659 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10660 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10661   echo $ECHO_N "(cached) $ECHO_C" >&6
10662 else
10663   if test -n "$OBJDUMP_FOR_TARGET"; then
10664   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10665 else
10666 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10667 for as_dir in $PATH
10668 do
10669   IFS=$as_save_IFS
10670   test -z "$as_dir" && as_dir=.
10671   for ac_exec_ext in '' $ac_executable_extensions; do
10672   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10673     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10674     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10675     break 2
10676   fi
10677 done
10678 done
10679
10680 fi
10681 fi
10682 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10683 if test -n "$OBJDUMP_FOR_TARGET"; then
10684   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10685 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10686 else
10687   echo "$as_me:$LINENO: result: no" >&5
10688 echo "${ECHO_T}no" >&6
10689 fi
10690
10691     fi
10692     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10693       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10694 set dummy ${ncn_progname}; ac_word=$2
10695 echo "$as_me:$LINENO: checking for $ac_word" >&5
10696 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10697 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10698   echo $ECHO_N "(cached) $ECHO_C" >&6
10699 else
10700   if test -n "$OBJDUMP_FOR_TARGET"; then
10701   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10702 else
10703 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10704 for as_dir in $PATH
10705 do
10706   IFS=$as_save_IFS
10707   test -z "$as_dir" && as_dir=.
10708   for ac_exec_ext in '' $ac_executable_extensions; do
10709   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10710     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10711     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10712     break 2
10713   fi
10714 done
10715 done
10716
10717 fi
10718 fi
10719 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10720 if test -n "$OBJDUMP_FOR_TARGET"; then
10721   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10722 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10723 else
10724   echo "$as_me:$LINENO: result: no" >&5
10725 echo "${ECHO_T}no" >&6
10726 fi
10727
10728     fi
10729     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10730   done
10731 fi
10732
10733 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10734   set dummy objdump
10735   if test $build = $target ; then
10736     OBJDUMP_FOR_TARGET="$2"
10737   else
10738     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10739   fi
10740 else
10741   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10742 fi
10743
10744 else
10745   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10746 fi
10747
10748
10749
10750
10751 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10752   if test -n "$with_build_time_tools"; then
10753     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10754 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10755     if test -x $with_build_time_tools/ranlib; then
10756       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10757       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10758       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10759 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10760     else
10761       echo "$as_me:$LINENO: result: no" >&5
10762 echo "${ECHO_T}no" >&6
10763     fi
10764   elif test $build != $host && test $have_gcc_for_target = yes; then
10765     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10766     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10767     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10768   fi
10769 fi
10770 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10771   # Extract the first word of "ranlib", so it can be a program name with args.
10772 set dummy ranlib; ac_word=$2
10773 echo "$as_me:$LINENO: checking for $ac_word" >&5
10774 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10775 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10776   echo $ECHO_N "(cached) $ECHO_C" >&6
10777 else
10778   case $RANLIB_FOR_TARGET in
10779   [\\/]* | ?:[\\/]*)
10780   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10781   ;;
10782   *)
10783   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10784 for as_dir in $gcc_cv_tool_dirs
10785 do
10786   IFS=$as_save_IFS
10787   test -z "$as_dir" && as_dir=.
10788   for ac_exec_ext in '' $ac_executable_extensions; do
10789   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10790     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10791     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10792     break 2
10793   fi
10794 done
10795 done
10796
10797   ;;
10798 esac
10799 fi
10800 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10801
10802 if test -n "$RANLIB_FOR_TARGET"; then
10803   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10804 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10805 else
10806   echo "$as_me:$LINENO: result: no" >&5
10807 echo "${ECHO_T}no" >&6
10808 fi
10809
10810 fi
10811 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10812
10813
10814 if test -n "$RANLIB_FOR_TARGET"; then
10815   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10816 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10817   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10818 fi
10819
10820 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10821   for ncn_progname in ranlib; do
10822     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10823 set dummy ${ncn_progname}; ac_word=$2
10824 echo "$as_me:$LINENO: checking for $ac_word" >&5
10825 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10826 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10827   echo $ECHO_N "(cached) $ECHO_C" >&6
10828 else
10829   if test -n "$RANLIB_FOR_TARGET"; then
10830   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10831 else
10832 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10833 for as_dir in $PATH
10834 do
10835   IFS=$as_save_IFS
10836   test -z "$as_dir" && as_dir=.
10837   for ac_exec_ext in '' $ac_executable_extensions; do
10838   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10839     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10840     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10841     break 2
10842   fi
10843 done
10844 done
10845
10846 fi
10847 fi
10848 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10849 if test -n "$RANLIB_FOR_TARGET"; then
10850   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10851 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10852 else
10853   echo "$as_me:$LINENO: result: no" >&5
10854 echo "${ECHO_T}no" >&6
10855 fi
10856
10857   done
10858 fi
10859
10860 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10861   for ncn_progname in ranlib; do
10862     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10863 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10864     if test -x $with_build_time_tools/${ncn_progname}; then
10865       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10866       echo "$as_me:$LINENO: result: yes" >&5
10867 echo "${ECHO_T}yes" >&6
10868       break
10869     else
10870       echo "$as_me:$LINENO: result: no" >&5
10871 echo "${ECHO_T}no" >&6
10872     fi
10873   done
10874 fi
10875
10876 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10877   for ncn_progname in ranlib; do
10878     if test -n "$ncn_target_tool_prefix"; then
10879       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10880 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10881 echo "$as_me:$LINENO: checking for $ac_word" >&5
10882 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10883 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10884   echo $ECHO_N "(cached) $ECHO_C" >&6
10885 else
10886   if test -n "$RANLIB_FOR_TARGET"; then
10887   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10888 else
10889 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10890 for as_dir in $PATH
10891 do
10892   IFS=$as_save_IFS
10893   test -z "$as_dir" && as_dir=.
10894   for ac_exec_ext in '' $ac_executable_extensions; do
10895   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10896     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10897     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10898     break 2
10899   fi
10900 done
10901 done
10902
10903 fi
10904 fi
10905 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10906 if test -n "$RANLIB_FOR_TARGET"; then
10907   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10908 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10909 else
10910   echo "$as_me:$LINENO: result: no" >&5
10911 echo "${ECHO_T}no" >&6
10912 fi
10913
10914     fi
10915     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10916       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10917 set dummy ${ncn_progname}; ac_word=$2
10918 echo "$as_me:$LINENO: checking for $ac_word" >&5
10919 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10920 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10921   echo $ECHO_N "(cached) $ECHO_C" >&6
10922 else
10923   if test -n "$RANLIB_FOR_TARGET"; then
10924   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10925 else
10926 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10927 for as_dir in $PATH
10928 do
10929   IFS=$as_save_IFS
10930   test -z "$as_dir" && as_dir=.
10931   for ac_exec_ext in '' $ac_executable_extensions; do
10932   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10933     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10934     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10935     break 2
10936   fi
10937 done
10938 done
10939
10940 fi
10941 fi
10942 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10943 if test -n "$RANLIB_FOR_TARGET"; then
10944   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10945 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10946 else
10947   echo "$as_me:$LINENO: result: no" >&5
10948 echo "${ECHO_T}no" >&6
10949 fi
10950
10951     fi
10952     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10953   done
10954 fi
10955
10956 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10957   set dummy ranlib
10958   if test $build = $target ; then
10959     RANLIB_FOR_TARGET="$2"
10960   else
10961     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10962   fi
10963 else
10964   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10965 fi
10966
10967 else
10968   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10969 fi
10970
10971
10972
10973
10974 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10975   if test -n "$with_build_time_tools"; then
10976     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10977 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10978     if test -x $with_build_time_tools/strip; then
10979       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10980       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10981       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10982 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10983     else
10984       echo "$as_me:$LINENO: result: no" >&5
10985 echo "${ECHO_T}no" >&6
10986     fi
10987   elif test $build != $host && test $have_gcc_for_target = yes; then
10988     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10989     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10990     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10991   fi
10992 fi
10993 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10994   # Extract the first word of "strip", so it can be a program name with args.
10995 set dummy strip; ac_word=$2
10996 echo "$as_me:$LINENO: checking for $ac_word" >&5
10997 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10998 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10999   echo $ECHO_N "(cached) $ECHO_C" >&6
11000 else
11001   case $STRIP_FOR_TARGET in
11002   [\\/]* | ?:[\\/]*)
11003   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11004   ;;
11005   *)
11006   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11007 for as_dir in $gcc_cv_tool_dirs
11008 do
11009   IFS=$as_save_IFS
11010   test -z "$as_dir" && as_dir=.
11011   for ac_exec_ext in '' $ac_executable_extensions; do
11012   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11013     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11014     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11015     break 2
11016   fi
11017 done
11018 done
11019
11020   ;;
11021 esac
11022 fi
11023 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11024
11025 if test -n "$STRIP_FOR_TARGET"; then
11026   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11027 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11028 else
11029   echo "$as_me:$LINENO: result: no" >&5
11030 echo "${ECHO_T}no" >&6
11031 fi
11032
11033 fi
11034 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11035
11036
11037 if test -n "$STRIP_FOR_TARGET"; then
11038   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11039 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11040   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11041 fi
11042
11043 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11044   for ncn_progname in strip; do
11045     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11046 set dummy ${ncn_progname}; ac_word=$2
11047 echo "$as_me:$LINENO: checking for $ac_word" >&5
11048 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11049 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11050   echo $ECHO_N "(cached) $ECHO_C" >&6
11051 else
11052   if test -n "$STRIP_FOR_TARGET"; then
11053   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11054 else
11055 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11056 for as_dir in $PATH
11057 do
11058   IFS=$as_save_IFS
11059   test -z "$as_dir" && as_dir=.
11060   for ac_exec_ext in '' $ac_executable_extensions; do
11061   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11062     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11063     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11064     break 2
11065   fi
11066 done
11067 done
11068
11069 fi
11070 fi
11071 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11072 if test -n "$STRIP_FOR_TARGET"; then
11073   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11074 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11075 else
11076   echo "$as_me:$LINENO: result: no" >&5
11077 echo "${ECHO_T}no" >&6
11078 fi
11079
11080   done
11081 fi
11082
11083 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11084   for ncn_progname in strip; do
11085     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11086 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11087     if test -x $with_build_time_tools/${ncn_progname}; then
11088       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11089       echo "$as_me:$LINENO: result: yes" >&5
11090 echo "${ECHO_T}yes" >&6
11091       break
11092     else
11093       echo "$as_me:$LINENO: result: no" >&5
11094 echo "${ECHO_T}no" >&6
11095     fi
11096   done
11097 fi
11098
11099 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11100   for ncn_progname in strip; do
11101     if test -n "$ncn_target_tool_prefix"; then
11102       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11103 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11104 echo "$as_me:$LINENO: checking for $ac_word" >&5
11105 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11106 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11107   echo $ECHO_N "(cached) $ECHO_C" >&6
11108 else
11109   if test -n "$STRIP_FOR_TARGET"; then
11110   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11111 else
11112 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11113 for as_dir in $PATH
11114 do
11115   IFS=$as_save_IFS
11116   test -z "$as_dir" && as_dir=.
11117   for ac_exec_ext in '' $ac_executable_extensions; do
11118   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11119     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11120     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11121     break 2
11122   fi
11123 done
11124 done
11125
11126 fi
11127 fi
11128 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11129 if test -n "$STRIP_FOR_TARGET"; then
11130   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11131 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11132 else
11133   echo "$as_me:$LINENO: result: no" >&5
11134 echo "${ECHO_T}no" >&6
11135 fi
11136
11137     fi
11138     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11139       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11140 set dummy ${ncn_progname}; ac_word=$2
11141 echo "$as_me:$LINENO: checking for $ac_word" >&5
11142 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11143 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11144   echo $ECHO_N "(cached) $ECHO_C" >&6
11145 else
11146   if test -n "$STRIP_FOR_TARGET"; then
11147   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11148 else
11149 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11150 for as_dir in $PATH
11151 do
11152   IFS=$as_save_IFS
11153   test -z "$as_dir" && as_dir=.
11154   for ac_exec_ext in '' $ac_executable_extensions; do
11155   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11156     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11157     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11158     break 2
11159   fi
11160 done
11161 done
11162
11163 fi
11164 fi
11165 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11166 if test -n "$STRIP_FOR_TARGET"; then
11167   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11168 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11169 else
11170   echo "$as_me:$LINENO: result: no" >&5
11171 echo "${ECHO_T}no" >&6
11172 fi
11173
11174     fi
11175     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11176   done
11177 fi
11178
11179 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11180   set dummy strip
11181   if test $build = $target ; then
11182     STRIP_FOR_TARGET="$2"
11183   else
11184     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11185   fi
11186 else
11187   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11188 fi
11189
11190 else
11191   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11192 fi
11193
11194
11195
11196
11197 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11198   if test -n "$with_build_time_tools"; then
11199     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11200 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11201     if test -x $with_build_time_tools/windres; then
11202       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11203       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11204       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11205 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11206     else
11207       echo "$as_me:$LINENO: result: no" >&5
11208 echo "${ECHO_T}no" >&6
11209     fi
11210   elif test $build != $host && test $have_gcc_for_target = yes; then
11211     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11212     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11213     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11214   fi
11215 fi
11216 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11217   # Extract the first word of "windres", so it can be a program name with args.
11218 set dummy windres; ac_word=$2
11219 echo "$as_me:$LINENO: checking for $ac_word" >&5
11220 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11221 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11222   echo $ECHO_N "(cached) $ECHO_C" >&6
11223 else
11224   case $WINDRES_FOR_TARGET in
11225   [\\/]* | ?:[\\/]*)
11226   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11227   ;;
11228   *)
11229   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11230 for as_dir in $gcc_cv_tool_dirs
11231 do
11232   IFS=$as_save_IFS
11233   test -z "$as_dir" && as_dir=.
11234   for ac_exec_ext in '' $ac_executable_extensions; do
11235   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11236     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11237     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11238     break 2
11239   fi
11240 done
11241 done
11242
11243   ;;
11244 esac
11245 fi
11246 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11247
11248 if test -n "$WINDRES_FOR_TARGET"; then
11249   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11250 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11251 else
11252   echo "$as_me:$LINENO: result: no" >&5
11253 echo "${ECHO_T}no" >&6
11254 fi
11255
11256 fi
11257 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11258
11259
11260 if test -n "$WINDRES_FOR_TARGET"; then
11261   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11262 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11263   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11264 fi
11265
11266 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11267   for ncn_progname in windres; do
11268     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11269 set dummy ${ncn_progname}; ac_word=$2
11270 echo "$as_me:$LINENO: checking for $ac_word" >&5
11271 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11272 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11273   echo $ECHO_N "(cached) $ECHO_C" >&6
11274 else
11275   if test -n "$WINDRES_FOR_TARGET"; then
11276   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11277 else
11278 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11279 for as_dir in $PATH
11280 do
11281   IFS=$as_save_IFS
11282   test -z "$as_dir" && as_dir=.
11283   for ac_exec_ext in '' $ac_executable_extensions; do
11284   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11285     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11286     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11287     break 2
11288   fi
11289 done
11290 done
11291
11292 fi
11293 fi
11294 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11295 if test -n "$WINDRES_FOR_TARGET"; then
11296   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11297 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11298 else
11299   echo "$as_me:$LINENO: result: no" >&5
11300 echo "${ECHO_T}no" >&6
11301 fi
11302
11303   done
11304 fi
11305
11306 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11307   for ncn_progname in windres; do
11308     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11309 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11310     if test -x $with_build_time_tools/${ncn_progname}; then
11311       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11312       echo "$as_me:$LINENO: result: yes" >&5
11313 echo "${ECHO_T}yes" >&6
11314       break
11315     else
11316       echo "$as_me:$LINENO: result: no" >&5
11317 echo "${ECHO_T}no" >&6
11318     fi
11319   done
11320 fi
11321
11322 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11323   for ncn_progname in windres; do
11324     if test -n "$ncn_target_tool_prefix"; then
11325       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11326 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11327 echo "$as_me:$LINENO: checking for $ac_word" >&5
11328 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11329 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11330   echo $ECHO_N "(cached) $ECHO_C" >&6
11331 else
11332   if test -n "$WINDRES_FOR_TARGET"; then
11333   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11334 else
11335 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11336 for as_dir in $PATH
11337 do
11338   IFS=$as_save_IFS
11339   test -z "$as_dir" && as_dir=.
11340   for ac_exec_ext in '' $ac_executable_extensions; do
11341   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11342     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11343     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11344     break 2
11345   fi
11346 done
11347 done
11348
11349 fi
11350 fi
11351 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11352 if test -n "$WINDRES_FOR_TARGET"; then
11353   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11354 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11355 else
11356   echo "$as_me:$LINENO: result: no" >&5
11357 echo "${ECHO_T}no" >&6
11358 fi
11359
11360     fi
11361     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11362       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11363 set dummy ${ncn_progname}; ac_word=$2
11364 echo "$as_me:$LINENO: checking for $ac_word" >&5
11365 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11366 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11367   echo $ECHO_N "(cached) $ECHO_C" >&6
11368 else
11369   if test -n "$WINDRES_FOR_TARGET"; then
11370   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11371 else
11372 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11373 for as_dir in $PATH
11374 do
11375   IFS=$as_save_IFS
11376   test -z "$as_dir" && as_dir=.
11377   for ac_exec_ext in '' $ac_executable_extensions; do
11378   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11379     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11380     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11381     break 2
11382   fi
11383 done
11384 done
11385
11386 fi
11387 fi
11388 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11389 if test -n "$WINDRES_FOR_TARGET"; then
11390   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11391 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11392 else
11393   echo "$as_me:$LINENO: result: no" >&5
11394 echo "${ECHO_T}no" >&6
11395 fi
11396
11397     fi
11398     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11399   done
11400 fi
11401
11402 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11403   set dummy windres
11404   if test $build = $target ; then
11405     WINDRES_FOR_TARGET="$2"
11406   else
11407     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11408   fi
11409 else
11410   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11411 fi
11412
11413 else
11414   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11415 fi
11416
11417
11418
11419
11420 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11421   if test -n "$with_build_time_tools"; then
11422     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11423 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11424     if test -x $with_build_time_tools/windmc; then
11425       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11426       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11427       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11428 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11429     else
11430       echo "$as_me:$LINENO: result: no" >&5
11431 echo "${ECHO_T}no" >&6
11432     fi
11433   elif test $build != $host && test $have_gcc_for_target = yes; then
11434     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11435     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11436     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11437   fi
11438 fi
11439 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11440   # Extract the first word of "windmc", so it can be a program name with args.
11441 set dummy windmc; ac_word=$2
11442 echo "$as_me:$LINENO: checking for $ac_word" >&5
11443 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11444 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11445   echo $ECHO_N "(cached) $ECHO_C" >&6
11446 else
11447   case $WINDMC_FOR_TARGET in
11448   [\\/]* | ?:[\\/]*)
11449   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11450   ;;
11451   *)
11452   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11453 for as_dir in $gcc_cv_tool_dirs
11454 do
11455   IFS=$as_save_IFS
11456   test -z "$as_dir" && as_dir=.
11457   for ac_exec_ext in '' $ac_executable_extensions; do
11458   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11459     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11460     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11461     break 2
11462   fi
11463 done
11464 done
11465
11466   ;;
11467 esac
11468 fi
11469 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11470
11471 if test -n "$WINDMC_FOR_TARGET"; then
11472   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11473 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11474 else
11475   echo "$as_me:$LINENO: result: no" >&5
11476 echo "${ECHO_T}no" >&6
11477 fi
11478
11479 fi
11480 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11481
11482
11483 if test -n "$WINDMC_FOR_TARGET"; then
11484   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11485 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11486   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11487 fi
11488
11489 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11490   for ncn_progname in windmc; do
11491     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11492 set dummy ${ncn_progname}; ac_word=$2
11493 echo "$as_me:$LINENO: checking for $ac_word" >&5
11494 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11495 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11496   echo $ECHO_N "(cached) $ECHO_C" >&6
11497 else
11498   if test -n "$WINDMC_FOR_TARGET"; then
11499   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11500 else
11501 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11502 for as_dir in $PATH
11503 do
11504   IFS=$as_save_IFS
11505   test -z "$as_dir" && as_dir=.
11506   for ac_exec_ext in '' $ac_executable_extensions; do
11507   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11508     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11509     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11510     break 2
11511   fi
11512 done
11513 done
11514
11515 fi
11516 fi
11517 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11518 if test -n "$WINDMC_FOR_TARGET"; then
11519   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11520 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11521 else
11522   echo "$as_me:$LINENO: result: no" >&5
11523 echo "${ECHO_T}no" >&6
11524 fi
11525
11526   done
11527 fi
11528
11529 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11530   for ncn_progname in windmc; do
11531     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11532 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11533     if test -x $with_build_time_tools/${ncn_progname}; then
11534       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11535       echo "$as_me:$LINENO: result: yes" >&5
11536 echo "${ECHO_T}yes" >&6
11537       break
11538     else
11539       echo "$as_me:$LINENO: result: no" >&5
11540 echo "${ECHO_T}no" >&6
11541     fi
11542   done
11543 fi
11544
11545 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11546   for ncn_progname in windmc; do
11547     if test -n "$ncn_target_tool_prefix"; then
11548       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11549 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11550 echo "$as_me:$LINENO: checking for $ac_word" >&5
11551 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11552 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11553   echo $ECHO_N "(cached) $ECHO_C" >&6
11554 else
11555   if test -n "$WINDMC_FOR_TARGET"; then
11556   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11557 else
11558 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11559 for as_dir in $PATH
11560 do
11561   IFS=$as_save_IFS
11562   test -z "$as_dir" && as_dir=.
11563   for ac_exec_ext in '' $ac_executable_extensions; do
11564   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11565     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11566     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11567     break 2
11568   fi
11569 done
11570 done
11571
11572 fi
11573 fi
11574 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11575 if test -n "$WINDMC_FOR_TARGET"; then
11576   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11577 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11578 else
11579   echo "$as_me:$LINENO: result: no" >&5
11580 echo "${ECHO_T}no" >&6
11581 fi
11582
11583     fi
11584     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11585       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11586 set dummy ${ncn_progname}; ac_word=$2
11587 echo "$as_me:$LINENO: checking for $ac_word" >&5
11588 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11589 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11590   echo $ECHO_N "(cached) $ECHO_C" >&6
11591 else
11592   if test -n "$WINDMC_FOR_TARGET"; then
11593   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11594 else
11595 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11596 for as_dir in $PATH
11597 do
11598   IFS=$as_save_IFS
11599   test -z "$as_dir" && as_dir=.
11600   for ac_exec_ext in '' $ac_executable_extensions; do
11601   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11602     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11603     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11604     break 2
11605   fi
11606 done
11607 done
11608
11609 fi
11610 fi
11611 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11612 if test -n "$WINDMC_FOR_TARGET"; then
11613   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11614 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11615 else
11616   echo "$as_me:$LINENO: result: no" >&5
11617 echo "${ECHO_T}no" >&6
11618 fi
11619
11620     fi
11621     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11622   done
11623 fi
11624
11625 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11626   set dummy windmc
11627   if test $build = $target ; then
11628     WINDMC_FOR_TARGET="$2"
11629   else
11630     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11631   fi
11632 else
11633   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11634 fi
11635
11636 else
11637   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11638 fi
11639
11640
11641 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11642
11643 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11644 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11645 if test "x${build}" != "x${host}" ; then
11646   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11647     # We already found the complete path
11648     ac_dir=`dirname $AR_FOR_TARGET`
11649     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11650 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11651   else
11652     # Canadian cross, just use what we found
11653     echo "$as_me:$LINENO: result: pre-installed" >&5
11654 echo "${ECHO_T}pre-installed" >&6
11655   fi
11656 else
11657   ok=yes
11658   case " ${configdirs} " in
11659     *" binutils "*) ;;
11660     *) ok=no ;;
11661   esac
11662
11663   if test $ok = yes; then
11664     # An in-tree tool is available and we can use it
11665     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11666     echo "$as_me:$LINENO: result: just compiled" >&5
11667 echo "${ECHO_T}just compiled" >&6
11668   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11669     # We already found the complete path
11670     ac_dir=`dirname $AR_FOR_TARGET`
11671     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11672 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11673   elif test "x$target" = "x$host"; then
11674     # We can use an host tool
11675     AR_FOR_TARGET='$(AR)'
11676     echo "$as_me:$LINENO: result: host tool" >&5
11677 echo "${ECHO_T}host tool" >&6
11678   else
11679     # We need a cross tool
11680     echo "$as_me:$LINENO: result: pre-installed" >&5
11681 echo "${ECHO_T}pre-installed" >&6
11682   fi
11683 fi
11684
11685 echo "$as_me:$LINENO: checking where to find the target as" >&5
11686 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11687 if test "x${build}" != "x${host}" ; then
11688   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11689     # We already found the complete path
11690     ac_dir=`dirname $AS_FOR_TARGET`
11691     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11692 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11693   else
11694     # Canadian cross, just use what we found
11695     echo "$as_me:$LINENO: result: pre-installed" >&5
11696 echo "${ECHO_T}pre-installed" >&6
11697   fi
11698 else
11699   ok=yes
11700   case " ${configdirs} " in
11701     *" gas "*) ;;
11702     *) ok=no ;;
11703   esac
11704
11705   if test $ok = yes; then
11706     # An in-tree tool is available and we can use it
11707     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11708     echo "$as_me:$LINENO: result: just compiled" >&5
11709 echo "${ECHO_T}just compiled" >&6
11710   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11711     # We already found the complete path
11712     ac_dir=`dirname $AS_FOR_TARGET`
11713     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11714 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11715   elif test "x$target" = "x$host"; then
11716     # We can use an host tool
11717     AS_FOR_TARGET='$(AS)'
11718     echo "$as_me:$LINENO: result: host tool" >&5
11719 echo "${ECHO_T}host tool" >&6
11720   else
11721     # We need a cross tool
11722     echo "$as_me:$LINENO: result: pre-installed" >&5
11723 echo "${ECHO_T}pre-installed" >&6
11724   fi
11725 fi
11726
11727 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11728 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11729 if test "x${build}" != "x${host}" ; then
11730   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11731     # We already found the complete path
11732     ac_dir=`dirname $CC_FOR_TARGET`
11733     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11734 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11735   else
11736     # Canadian cross, just use what we found
11737     echo "$as_me:$LINENO: result: pre-installed" >&5
11738 echo "${ECHO_T}pre-installed" >&6
11739   fi
11740 else
11741   ok=yes
11742   case " ${configdirs} " in
11743     *" gcc "*) ;;
11744     *) ok=no ;;
11745   esac
11746
11747   if test $ok = yes; then
11748     # An in-tree tool is available and we can use it
11749     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11750     echo "$as_me:$LINENO: result: just compiled" >&5
11751 echo "${ECHO_T}just compiled" >&6
11752   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11753     # We already found the complete path
11754     ac_dir=`dirname $CC_FOR_TARGET`
11755     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11756 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11757   elif test "x$target" = "x$host"; then
11758     # We can use an host tool
11759     CC_FOR_TARGET='$(CC)'
11760     echo "$as_me:$LINENO: result: host tool" >&5
11761 echo "${ECHO_T}host tool" >&6
11762   else
11763     # We need a cross tool
11764     echo "$as_me:$LINENO: result: pre-installed" >&5
11765 echo "${ECHO_T}pre-installed" >&6
11766   fi
11767 fi
11768
11769 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11770 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11771 if test "x${build}" != "x${host}" ; then
11772   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11773     # We already found the complete path
11774     ac_dir=`dirname $CXX_FOR_TARGET`
11775     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11776 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11777   else
11778     # Canadian cross, just use what we found
11779     echo "$as_me:$LINENO: result: pre-installed" >&5
11780 echo "${ECHO_T}pre-installed" >&6
11781   fi
11782 else
11783   ok=yes
11784   case " ${configdirs} " in
11785     *" gcc "*) ;;
11786     *) ok=no ;;
11787   esac
11788   case ,${enable_languages}, in
11789     *,c++,*) ;;
11790     *) ok=no ;;
11791   esac
11792   if test $ok = yes; then
11793     # An in-tree tool is available and we can use it
11794     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'
11795     echo "$as_me:$LINENO: result: just compiled" >&5
11796 echo "${ECHO_T}just compiled" >&6
11797   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11798     # We already found the complete path
11799     ac_dir=`dirname $CXX_FOR_TARGET`
11800     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11801 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11802   elif test "x$target" = "x$host"; then
11803     # We can use an host tool
11804     CXX_FOR_TARGET='$(CXX)'
11805     echo "$as_me:$LINENO: result: host tool" >&5
11806 echo "${ECHO_T}host tool" >&6
11807   else
11808     # We need a cross tool
11809     echo "$as_me:$LINENO: result: pre-installed" >&5
11810 echo "${ECHO_T}pre-installed" >&6
11811   fi
11812 fi
11813
11814 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11815 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11816 if test "x${build}" != "x${host}" ; then
11817   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11818     # We already found the complete path
11819     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11820     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11821 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11822   else
11823     # Canadian cross, just use what we found
11824     echo "$as_me:$LINENO: result: pre-installed" >&5
11825 echo "${ECHO_T}pre-installed" >&6
11826   fi
11827 else
11828   ok=yes
11829   case " ${configdirs} " in
11830     *" gcc "*) ;;
11831     *) ok=no ;;
11832   esac
11833   case ,${enable_languages}, in
11834     *,c++,*) ;;
11835     *) ok=no ;;
11836   esac
11837   if test $ok = yes; then
11838     # An in-tree tool is available and we can use it
11839     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'
11840     echo "$as_me:$LINENO: result: just compiled" >&5
11841 echo "${ECHO_T}just compiled" >&6
11842   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11843     # We already found the complete path
11844     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11845     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11846 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11847   elif test "x$target" = "x$host"; then
11848     # We can use an host tool
11849     RAW_CXX_FOR_TARGET='$(CXX)'
11850     echo "$as_me:$LINENO: result: host tool" >&5
11851 echo "${ECHO_T}host tool" >&6
11852   else
11853     # We need a cross tool
11854     echo "$as_me:$LINENO: result: pre-installed" >&5
11855 echo "${ECHO_T}pre-installed" >&6
11856   fi
11857 fi
11858
11859 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11860 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11861 if test "x${build}" != "x${host}" ; then
11862   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11863     # We already found the complete path
11864     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11865     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11866 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11867   else
11868     # Canadian cross, just use what we found
11869     echo "$as_me:$LINENO: result: pre-installed" >&5
11870 echo "${ECHO_T}pre-installed" >&6
11871   fi
11872 else
11873   ok=yes
11874   case " ${configdirs} " in
11875     *" binutils "*) ;;
11876     *) ok=no ;;
11877   esac
11878
11879   if test $ok = yes; then
11880     # An in-tree tool is available and we can use it
11881     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11882     echo "$as_me:$LINENO: result: just compiled" >&5
11883 echo "${ECHO_T}just compiled" >&6
11884   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11885     # We already found the complete path
11886     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11887     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11888 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11889   elif test "x$target" = "x$host"; then
11890     # We can use an host tool
11891     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11892     echo "$as_me:$LINENO: result: host tool" >&5
11893 echo "${ECHO_T}host tool" >&6
11894   else
11895     # We need a cross tool
11896     echo "$as_me:$LINENO: result: pre-installed" >&5
11897 echo "${ECHO_T}pre-installed" >&6
11898   fi
11899 fi
11900
11901 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11902 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11903 if test "x${build}" != "x${host}" ; then
11904   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11905     # We already found the complete path
11906     ac_dir=`dirname $GCC_FOR_TARGET`
11907     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11908 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11909   else
11910     # Canadian cross, just use what we found
11911     echo "$as_me:$LINENO: result: pre-installed" >&5
11912 echo "${ECHO_T}pre-installed" >&6
11913   fi
11914 else
11915   ok=yes
11916   case " ${configdirs} " in
11917     *" gcc "*) ;;
11918     *) ok=no ;;
11919   esac
11920
11921   if test $ok = yes; then
11922     # An in-tree tool is available and we can use it
11923     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11924     echo "$as_me:$LINENO: result: just compiled" >&5
11925 echo "${ECHO_T}just compiled" >&6
11926   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11927     # We already found the complete path
11928     ac_dir=`dirname $GCC_FOR_TARGET`
11929     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11930 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11931   elif test "x$target" = "x$host"; then
11932     # We can use an host tool
11933     GCC_FOR_TARGET='$()'
11934     echo "$as_me:$LINENO: result: host tool" >&5
11935 echo "${ECHO_T}host tool" >&6
11936   else
11937     # We need a cross tool
11938     echo "$as_me:$LINENO: result: pre-installed" >&5
11939 echo "${ECHO_T}pre-installed" >&6
11940   fi
11941 fi
11942
11943 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11944 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11945 if test "x${build}" != "x${host}" ; then
11946   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11947     # We already found the complete path
11948     ac_dir=`dirname $GCJ_FOR_TARGET`
11949     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11950 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11951   else
11952     # Canadian cross, just use what we found
11953     echo "$as_me:$LINENO: result: pre-installed" >&5
11954 echo "${ECHO_T}pre-installed" >&6
11955   fi
11956 else
11957   ok=yes
11958   case " ${configdirs} " in
11959     *" gcc "*) ;;
11960     *) ok=no ;;
11961   esac
11962   case ,${enable_languages}, in
11963     *,java,*) ;;
11964     *) ok=no ;;
11965   esac
11966   if test $ok = yes; then
11967     # An in-tree tool is available and we can use it
11968     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11969     echo "$as_me:$LINENO: result: just compiled" >&5
11970 echo "${ECHO_T}just compiled" >&6
11971   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11972     # We already found the complete path
11973     ac_dir=`dirname $GCJ_FOR_TARGET`
11974     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11975 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11976   elif test "x$target" = "x$host"; then
11977     # We can use an host tool
11978     GCJ_FOR_TARGET='$(GCJ)'
11979     echo "$as_me:$LINENO: result: host tool" >&5
11980 echo "${ECHO_T}host tool" >&6
11981   else
11982     # We need a cross tool
11983     echo "$as_me:$LINENO: result: pre-installed" >&5
11984 echo "${ECHO_T}pre-installed" >&6
11985   fi
11986 fi
11987
11988 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11989 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11990 if test "x${build}" != "x${host}" ; then
11991   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11992     # We already found the complete path
11993     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11994     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11995 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11996   else
11997     # Canadian cross, just use what we found
11998     echo "$as_me:$LINENO: result: pre-installed" >&5
11999 echo "${ECHO_T}pre-installed" >&6
12000   fi
12001 else
12002   ok=yes
12003   case " ${configdirs} " in
12004     *" gcc "*) ;;
12005     *) ok=no ;;
12006   esac
12007   case ,${enable_languages}, in
12008     *,fortran,*) ;;
12009     *) ok=no ;;
12010   esac
12011   if test $ok = yes; then
12012     # An in-tree tool is available and we can use it
12013     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12014     echo "$as_me:$LINENO: result: just compiled" >&5
12015 echo "${ECHO_T}just compiled" >&6
12016   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12017     # We already found the complete path
12018     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12019     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12020 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12021   elif test "x$target" = "x$host"; then
12022     # We can use an host tool
12023     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12024     echo "$as_me:$LINENO: result: host tool" >&5
12025 echo "${ECHO_T}host tool" >&6
12026   else
12027     # We need a cross tool
12028     echo "$as_me:$LINENO: result: pre-installed" >&5
12029 echo "${ECHO_T}pre-installed" >&6
12030   fi
12031 fi
12032
12033 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12034 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12035 if test "x${build}" != "x${host}" ; then
12036   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12037     # We already found the complete path
12038     ac_dir=`dirname $LD_FOR_TARGET`
12039     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12040 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12041   else
12042     # Canadian cross, just use what we found
12043     echo "$as_me:$LINENO: result: pre-installed" >&5
12044 echo "${ECHO_T}pre-installed" >&6
12045   fi
12046 else
12047   ok=yes
12048   case " ${configdirs} " in
12049     *" ld "*) ;;
12050     *) ok=no ;;
12051   esac
12052
12053   if test $ok = yes; then
12054     # An in-tree tool is available and we can use it
12055     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12056     echo "$as_me:$LINENO: result: just compiled" >&5
12057 echo "${ECHO_T}just compiled" >&6
12058   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12059     # We already found the complete path
12060     ac_dir=`dirname $LD_FOR_TARGET`
12061     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12062 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12063   elif test "x$target" = "x$host"; then
12064     # We can use an host tool
12065     LD_FOR_TARGET='$(LD)'
12066     echo "$as_me:$LINENO: result: host tool" >&5
12067 echo "${ECHO_T}host tool" >&6
12068   else
12069     # We need a cross tool
12070     echo "$as_me:$LINENO: result: pre-installed" >&5
12071 echo "${ECHO_T}pre-installed" >&6
12072   fi
12073 fi
12074
12075 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12076 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12077 if test "x${build}" != "x${host}" ; then
12078   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12079     # We already found the complete path
12080     ac_dir=`dirname $LIPO_FOR_TARGET`
12081     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12082 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12083   else
12084     # Canadian cross, just use what we found
12085     echo "$as_me:$LINENO: result: pre-installed" >&5
12086 echo "${ECHO_T}pre-installed" >&6
12087   fi
12088 else
12089   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12090     # We already found the complete path
12091     ac_dir=`dirname $LIPO_FOR_TARGET`
12092     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12093 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12094   elif test "x$target" = "x$host"; then
12095     # We can use an host tool
12096     LIPO_FOR_TARGET='$(LIPO)'
12097     echo "$as_me:$LINENO: result: host tool" >&5
12098 echo "${ECHO_T}host tool" >&6
12099   else
12100     # We need a cross tool
12101     echo "$as_me:$LINENO: result: pre-installed" >&5
12102 echo "${ECHO_T}pre-installed" >&6
12103   fi
12104 fi
12105
12106 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12107 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12108 if test "x${build}" != "x${host}" ; then
12109   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12110     # We already found the complete path
12111     ac_dir=`dirname $NM_FOR_TARGET`
12112     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12113 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12114   else
12115     # Canadian cross, just use what we found
12116     echo "$as_me:$LINENO: result: pre-installed" >&5
12117 echo "${ECHO_T}pre-installed" >&6
12118   fi
12119 else
12120   ok=yes
12121   case " ${configdirs} " in
12122     *" binutils "*) ;;
12123     *) ok=no ;;
12124   esac
12125
12126   if test $ok = yes; then
12127     # An in-tree tool is available and we can use it
12128     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12129     echo "$as_me:$LINENO: result: just compiled" >&5
12130 echo "${ECHO_T}just compiled" >&6
12131   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12132     # We already found the complete path
12133     ac_dir=`dirname $NM_FOR_TARGET`
12134     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12135 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12136   elif test "x$target" = "x$host"; then
12137     # We can use an host tool
12138     NM_FOR_TARGET='$(NM)'
12139     echo "$as_me:$LINENO: result: host tool" >&5
12140 echo "${ECHO_T}host tool" >&6
12141   else
12142     # We need a cross tool
12143     echo "$as_me:$LINENO: result: pre-installed" >&5
12144 echo "${ECHO_T}pre-installed" >&6
12145   fi
12146 fi
12147
12148 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12149 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12150 if test "x${build}" != "x${host}" ; then
12151   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12152     # We already found the complete path
12153     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12154     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12155 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12156   else
12157     # Canadian cross, just use what we found
12158     echo "$as_me:$LINENO: result: pre-installed" >&5
12159 echo "${ECHO_T}pre-installed" >&6
12160   fi
12161 else
12162   ok=yes
12163   case " ${configdirs} " in
12164     *" binutils "*) ;;
12165     *) ok=no ;;
12166   esac
12167
12168   if test $ok = yes; then
12169     # An in-tree tool is available and we can use it
12170     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12171     echo "$as_me:$LINENO: result: just compiled" >&5
12172 echo "${ECHO_T}just compiled" >&6
12173   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12174     # We already found the complete path
12175     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12176     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12177 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12178   elif test "x$target" = "x$host"; then
12179     # We can use an host tool
12180     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12181     echo "$as_me:$LINENO: result: host tool" >&5
12182 echo "${ECHO_T}host tool" >&6
12183   else
12184     # We need a cross tool
12185     echo "$as_me:$LINENO: result: pre-installed" >&5
12186 echo "${ECHO_T}pre-installed" >&6
12187   fi
12188 fi
12189
12190 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12191 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12192 if test "x${build}" != "x${host}" ; then
12193   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12194     # We already found the complete path
12195     ac_dir=`dirname $RANLIB_FOR_TARGET`
12196     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12197 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12198   else
12199     # Canadian cross, just use what we found
12200     echo "$as_me:$LINENO: result: pre-installed" >&5
12201 echo "${ECHO_T}pre-installed" >&6
12202   fi
12203 else
12204   ok=yes
12205   case " ${configdirs} " in
12206     *" binutils "*) ;;
12207     *) ok=no ;;
12208   esac
12209
12210   if test $ok = yes; then
12211     # An in-tree tool is available and we can use it
12212     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12213     echo "$as_me:$LINENO: result: just compiled" >&5
12214 echo "${ECHO_T}just compiled" >&6
12215   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12216     # We already found the complete path
12217     ac_dir=`dirname $RANLIB_FOR_TARGET`
12218     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12219 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12220   elif test "x$target" = "x$host"; then
12221     # We can use an host tool
12222     RANLIB_FOR_TARGET='$(RANLIB)'
12223     echo "$as_me:$LINENO: result: host tool" >&5
12224 echo "${ECHO_T}host tool" >&6
12225   else
12226     # We need a cross tool
12227     echo "$as_me:$LINENO: result: pre-installed" >&5
12228 echo "${ECHO_T}pre-installed" >&6
12229   fi
12230 fi
12231
12232 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12233 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12234 if test "x${build}" != "x${host}" ; then
12235   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12236     # We already found the complete path
12237     ac_dir=`dirname $STRIP_FOR_TARGET`
12238     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12239 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12240   else
12241     # Canadian cross, just use what we found
12242     echo "$as_me:$LINENO: result: pre-installed" >&5
12243 echo "${ECHO_T}pre-installed" >&6
12244   fi
12245 else
12246   ok=yes
12247   case " ${configdirs} " in
12248     *" binutils "*) ;;
12249     *) ok=no ;;
12250   esac
12251
12252   if test $ok = yes; then
12253     # An in-tree tool is available and we can use it
12254     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12255     echo "$as_me:$LINENO: result: just compiled" >&5
12256 echo "${ECHO_T}just compiled" >&6
12257   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12258     # We already found the complete path
12259     ac_dir=`dirname $STRIP_FOR_TARGET`
12260     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12261 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12262   elif test "x$target" = "x$host"; then
12263     # We can use an host tool
12264     STRIP_FOR_TARGET='$(STRIP)'
12265     echo "$as_me:$LINENO: result: host tool" >&5
12266 echo "${ECHO_T}host tool" >&6
12267   else
12268     # We need a cross tool
12269     echo "$as_me:$LINENO: result: pre-installed" >&5
12270 echo "${ECHO_T}pre-installed" >&6
12271   fi
12272 fi
12273
12274 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12275 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12276 if test "x${build}" != "x${host}" ; then
12277   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12278     # We already found the complete path
12279     ac_dir=`dirname $WINDRES_FOR_TARGET`
12280     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12281 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12282   else
12283     # Canadian cross, just use what we found
12284     echo "$as_me:$LINENO: result: pre-installed" >&5
12285 echo "${ECHO_T}pre-installed" >&6
12286   fi
12287 else
12288   ok=yes
12289   case " ${configdirs} " in
12290     *" binutils "*) ;;
12291     *) ok=no ;;
12292   esac
12293
12294   if test $ok = yes; then
12295     # An in-tree tool is available and we can use it
12296     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12297     echo "$as_me:$LINENO: result: just compiled" >&5
12298 echo "${ECHO_T}just compiled" >&6
12299   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12300     # We already found the complete path
12301     ac_dir=`dirname $WINDRES_FOR_TARGET`
12302     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12303 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12304   elif test "x$target" = "x$host"; then
12305     # We can use an host tool
12306     WINDRES_FOR_TARGET='$(WINDRES)'
12307     echo "$as_me:$LINENO: result: host tool" >&5
12308 echo "${ECHO_T}host tool" >&6
12309   else
12310     # We need a cross tool
12311     echo "$as_me:$LINENO: result: pre-installed" >&5
12312 echo "${ECHO_T}pre-installed" >&6
12313   fi
12314 fi
12315
12316 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12317 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12318 if test "x${build}" != "x${host}" ; then
12319   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12320     # We already found the complete path
12321     ac_dir=`dirname $WINDMC_FOR_TARGET`
12322     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12323 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12324   else
12325     # Canadian cross, just use what we found
12326     echo "$as_me:$LINENO: result: pre-installed" >&5
12327 echo "${ECHO_T}pre-installed" >&6
12328   fi
12329 else
12330   ok=yes
12331   case " ${configdirs} " in
12332     *" binutils "*) ;;
12333     *) ok=no ;;
12334   esac
12335
12336   if test $ok = yes; then
12337     # An in-tree tool is available and we can use it
12338     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12339     echo "$as_me:$LINENO: result: just compiled" >&5
12340 echo "${ECHO_T}just compiled" >&6
12341   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12342     # We already found the complete path
12343     ac_dir=`dirname $WINDMC_FOR_TARGET`
12344     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12345 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12346   elif test "x$target" = "x$host"; then
12347     # We can use an host tool
12348     WINDMC_FOR_TARGET='$(WINDMC)'
12349     echo "$as_me:$LINENO: result: host tool" >&5
12350 echo "${ECHO_T}host tool" >&6
12351   else
12352     # We need a cross tool
12353     echo "$as_me:$LINENO: result: pre-installed" >&5
12354 echo "${ECHO_T}pre-installed" >&6
12355   fi
12356 fi
12357
12358
12359
12360
12361
12362 # Certain tools may need extra flags.
12363 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12364 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12365 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12366
12367 # When building target libraries, except in a Canadian cross, we use
12368 # the same toolchain as the compiler we just built.
12369 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12370 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12371 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12372 if test $host = $build; then
12373   case " $configdirs " in
12374     *" gcc "*)
12375       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12376       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12377       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12378       ;;
12379   esac
12380 fi
12381
12382
12383
12384
12385
12386 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12387 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12388 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12389 if test "${enable_maintainer_mode+set}" = set; then
12390   enableval="$enable_maintainer_mode"
12391   USE_MAINTAINER_MODE=$enableval
12392 else
12393   USE_MAINTAINER_MODE=no
12394 fi;
12395 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12396 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12397
12398
12399 if test "$USE_MAINTAINER_MODE" = yes; then
12400   MAINTAINER_MODE_TRUE=
12401   MAINTAINER_MODE_FALSE='#'
12402 else
12403   MAINTAINER_MODE_TRUE='#'
12404   MAINTAINER_MODE_FALSE=
12405 fi
12406 MAINT=$MAINTAINER_MODE_TRUE
12407
12408 # ---------------------
12409 # GCC bootstrap support
12410 # ---------------------
12411
12412 # Stage specific cflags for build.
12413 stage1_cflags="-g"
12414 case $build in
12415   vax-*-*)
12416     case ${GCC} in
12417       yes) stage1_cflags="-g -Wa,-J" ;;
12418       *) stage1_cflags="-g -J" ;;
12419     esac ;;
12420 esac
12421
12422 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12423 if test "$GCC" = yes; then
12424   saved_CFLAGS="$CFLAGS"
12425
12426   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12427   CFLAGS="$CFLAGS -fkeep-inline-functions"
12428   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12429 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12430   cat >conftest.$ac_ext <<_ACEOF
12431 /* confdefs.h.  */
12432 _ACEOF
12433 cat confdefs.h >>conftest.$ac_ext
12434 cat >>conftest.$ac_ext <<_ACEOF
12435 /* end confdefs.h.  */
12436
12437 #if (__GNUC__ < 3) \
12438     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12439                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12440 #error http://gcc.gnu.org/PR29382
12441 #endif
12442
12443 int
12444 main ()
12445 {
12446
12447   ;
12448   return 0;
12449 }
12450 _ACEOF
12451 rm -f conftest.$ac_objext
12452 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12453   (eval $ac_compile) 2>conftest.er1
12454   ac_status=$?
12455   grep -v '^ *+' conftest.er1 >conftest.err
12456   rm -f conftest.er1
12457   cat conftest.err >&5
12458   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12459   (exit $ac_status); } &&
12460          { ac_try='test -z "$ac_c_werror_flag"
12461                          || test ! -s conftest.err'
12462   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12463   (eval $ac_try) 2>&5
12464   ac_status=$?
12465   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12466   (exit $ac_status); }; } &&
12467          { ac_try='test -s conftest.$ac_objext'
12468   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12469   (eval $ac_try) 2>&5
12470   ac_status=$?
12471   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12472   (exit $ac_status); }; }; then
12473   echo "$as_me:$LINENO: result: yes" >&5
12474 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12475 else
12476   echo "$as_me: failed program was:" >&5
12477 sed 's/^/| /' conftest.$ac_ext >&5
12478
12479 echo "$as_me:$LINENO: result: no" >&5
12480 echo "${ECHO_T}no" >&6
12481 fi
12482 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12483
12484   CFLAGS="$saved_CFLAGS"
12485 fi
12486
12487
12488
12489 # Enable --enable-checking in stage1 of the compiler.
12490 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12491 if test "${enable_stage1_checking+set}" = set; then
12492   enableval="$enable_stage1_checking"
12493   stage1_checking=--enable-checking=${enable_stage1_checking}
12494 else
12495   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12496   stage1_checking=--enable-checking=yes,types
12497 else
12498   stage1_checking=--enable-checking=$enable_checking,types
12499 fi
12500 fi;
12501
12502
12503 # Enable -Werror in bootstrap stage2 and later.
12504 # Check whether --enable-werror or --disable-werror was given.
12505 if test "${enable_werror+set}" = set; then
12506   enableval="$enable_werror"
12507
12508 else
12509   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12510   enable_werror=yes
12511 else
12512   enable_werror=no
12513 fi
12514 fi;
12515 case ${enable_werror} in
12516   yes) stage2_werror_flag="--enable-werror-always" ;;
12517   *) stage2_werror_flag="" ;;
12518 esac
12519
12520
12521 # Flags needed to enable html installing and building
12522
12523 # Check whether --with-datarootdir or --without-datarootdir was given.
12524 if test "${with_datarootdir+set}" = set; then
12525   withval="$with_datarootdir"
12526   datarootdir="\${prefix}/${withval}"
12527 else
12528   datarootdir="\${prefix}/share"
12529 fi;
12530
12531
12532 # Check whether --with-docdir or --without-docdir was given.
12533 if test "${with_docdir+set}" = set; then
12534   withval="$with_docdir"
12535   docdir="\${prefix}/${withval}"
12536 else
12537   docdir="\${datarootdir}/doc"
12538 fi;
12539
12540
12541 # Check whether --with-pdfdir or --without-pdfdir was given.
12542 if test "${with_pdfdir+set}" = set; then
12543   withval="$with_pdfdir"
12544   pdfdir="\${prefix}/${withval}"
12545 else
12546   pdfdir="\${docdir}"
12547 fi;
12548
12549
12550 # Check whether --with-htmldir or --without-htmldir was given.
12551 if test "${with_htmldir+set}" = set; then
12552   withval="$with_htmldir"
12553   htmldir="\${prefix}/${withval}"
12554 else
12555   htmldir="\${docdir}"
12556 fi;
12557
12558
12559
12560
12561
12562
12563           ac_config_files="$ac_config_files Makefile"
12564 cat >confcache <<\_ACEOF
12565 # This file is a shell script that caches the results of configure
12566 # tests run on this system so they can be shared between configure
12567 # scripts and configure runs, see configure's option --config-cache.
12568 # It is not useful on other systems.  If it contains results you don't
12569 # want to keep, you may remove or edit it.
12570 #
12571 # config.status only pays attention to the cache file if you give it
12572 # the --recheck option to rerun configure.
12573 #
12574 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12575 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12576 # following values.
12577
12578 _ACEOF
12579
12580 # The following way of writing the cache mishandles newlines in values,
12581 # but we know of no workaround that is simple, portable, and efficient.
12582 # So, don't put newlines in cache variables' values.
12583 # Ultrix sh set writes to stderr and can't be redirected directly,
12584 # and sets the high bit in the cache file unless we assign to the vars.
12585 {
12586   (set) 2>&1 |
12587     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12588     *ac_space=\ *)
12589       # `set' does not quote correctly, so add quotes (double-quote
12590       # substitution turns \\\\ into \\, and sed turns \\ into \).
12591       sed -n \
12592         "s/'/'\\\\''/g;
12593           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12594       ;;
12595     *)
12596       # `set' quotes correctly as required by POSIX, so do not add quotes.
12597       sed -n \
12598         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12599       ;;
12600     esac;
12601 } |
12602   sed '
12603      t clear
12604      : clear
12605      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12606      t end
12607      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12608      : end' >>confcache
12609 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12610   if test -w $cache_file; then
12611     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12612     cat confcache >$cache_file
12613   else
12614     echo "not updating unwritable cache $cache_file"
12615   fi
12616 fi
12617 rm -f confcache
12618
12619 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12620 # Let make expand exec_prefix.
12621 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12622
12623 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12624 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12625 # trailing colons and then remove the whole line if VPATH becomes empty
12626 # (actually we leave an empty line to preserve line numbers).
12627 if test "x$srcdir" = x.; then
12628   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12629 s/:*\$(srcdir):*/:/;
12630 s/:*\${srcdir}:*/:/;
12631 s/:*@srcdir@:*/:/;
12632 s/^\([^=]*=[     ]*\):*/\1/;
12633 s/:*$//;
12634 s/^[^=]*=[       ]*$//;
12635 }'
12636 fi
12637
12638 # Transform confdefs.h into DEFS.
12639 # Protect against shell expansion while executing Makefile rules.
12640 # Protect against Makefile macro expansion.
12641 #
12642 # If the first sed substitution is executed (which looks for macros that
12643 # take arguments), then we branch to the quote section.  Otherwise,
12644 # look for a macro that doesn't take arguments.
12645 cat >confdef2opt.sed <<\_ACEOF
12646 t clear
12647 : clear
12648 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12649 t quote
12650 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12651 t quote
12652 d
12653 : quote
12654 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12655 s,\[,\\&,g
12656 s,\],\\&,g
12657 s,\$,$$,g
12658 p
12659 _ACEOF
12660 # We use echo to avoid assuming a particular line-breaking character.
12661 # The extra dot is to prevent the shell from consuming trailing
12662 # line-breaks from the sub-command output.  A line-break within
12663 # single-quotes doesn't work because, if this script is created in a
12664 # platform that uses two characters for line-breaks (e.g., DOS), tr
12665 # would break.
12666 ac_LF_and_DOT=`echo; echo .`
12667 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12668 rm -f confdef2opt.sed
12669
12670
12671 ac_libobjs=
12672 ac_ltlibobjs=
12673 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12674   # 1. Remove the extension, and $U if already installed.
12675   ac_i=`echo "$ac_i" |
12676          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12677   # 2. Add them.
12678   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12679   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12680 done
12681 LIBOBJS=$ac_libobjs
12682
12683 LTLIBOBJS=$ac_ltlibobjs
12684
12685
12686
12687 : ${CONFIG_STATUS=./config.status}
12688 ac_clean_files_save=$ac_clean_files
12689 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12690 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12691 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12692 cat >$CONFIG_STATUS <<_ACEOF
12693 #! $SHELL
12694 # Generated by $as_me.
12695 # Run this file to recreate the current configuration.
12696 # Compiler output produced by configure, useful for debugging
12697 # configure, is in config.log if it exists.
12698
12699 debug=false
12700 ac_cs_recheck=false
12701 ac_cs_silent=false
12702 SHELL=\${CONFIG_SHELL-$SHELL}
12703 _ACEOF
12704
12705 cat >>$CONFIG_STATUS <<\_ACEOF
12706 ## --------------------- ##
12707 ## M4sh Initialization.  ##
12708 ## --------------------- ##
12709
12710 # Be Bourne compatible
12711 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12712   emulate sh
12713   NULLCMD=:
12714   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12715   # is contrary to our usage.  Disable this feature.
12716   alias -g '${1+"$@"}'='"$@"'
12717 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12718   set -o posix
12719 fi
12720 DUALCASE=1; export DUALCASE # for MKS sh
12721
12722 # Support unset when possible.
12723 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12724   as_unset=unset
12725 else
12726   as_unset=false
12727 fi
12728
12729
12730 # Work around bugs in pre-3.0 UWIN ksh.
12731 $as_unset ENV MAIL MAILPATH
12732 PS1='$ '
12733 PS2='> '
12734 PS4='+ '
12735
12736 # NLS nuisances.
12737 for as_var in \
12738   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12739   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12740   LC_TELEPHONE LC_TIME
12741 do
12742   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12743     eval $as_var=C; export $as_var
12744   else
12745     $as_unset $as_var
12746   fi
12747 done
12748
12749 # Required to use basename.
12750 if expr a : '\(a\)' >/dev/null 2>&1; then
12751   as_expr=expr
12752 else
12753   as_expr=false
12754 fi
12755
12756 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12757   as_basename=basename
12758 else
12759   as_basename=false
12760 fi
12761
12762
12763 # Name of the executable.
12764 as_me=`$as_basename "$0" ||
12765 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12766          X"$0" : 'X\(//\)$' \| \
12767          X"$0" : 'X\(/\)$' \| \
12768          .     : '\(.\)' 2>/dev/null ||
12769 echo X/"$0" |
12770     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12771           /^X\/\(\/\/\)$/{ s//\1/; q; }
12772           /^X\/\(\/\).*/{ s//\1/; q; }
12773           s/.*/./; q'`
12774
12775
12776 # PATH needs CR, and LINENO needs CR and PATH.
12777 # Avoid depending upon Character Ranges.
12778 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12779 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12780 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12781 as_cr_digits='0123456789'
12782 as_cr_alnum=$as_cr_Letters$as_cr_digits
12783
12784 # The user is always right.
12785 if test "${PATH_SEPARATOR+set}" != set; then
12786   echo "#! /bin/sh" >conf$$.sh
12787   echo  "exit 0"   >>conf$$.sh
12788   chmod +x conf$$.sh
12789   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12790     PATH_SEPARATOR=';'
12791   else
12792     PATH_SEPARATOR=:
12793   fi
12794   rm -f conf$$.sh
12795 fi
12796
12797
12798   as_lineno_1=$LINENO
12799   as_lineno_2=$LINENO
12800   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12801   test "x$as_lineno_1" != "x$as_lineno_2" &&
12802   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12803   # Find who we are.  Look in the path if we contain no path at all
12804   # relative or not.
12805   case $0 in
12806     *[\\/]* ) as_myself=$0 ;;
12807     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12808 for as_dir in $PATH
12809 do
12810   IFS=$as_save_IFS
12811   test -z "$as_dir" && as_dir=.
12812   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12813 done
12814
12815        ;;
12816   esac
12817   # We did not find ourselves, most probably we were run as `sh COMMAND'
12818   # in which case we are not to be found in the path.
12819   if test "x$as_myself" = x; then
12820     as_myself=$0
12821   fi
12822   if test ! -f "$as_myself"; then
12823     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12824 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12825    { (exit 1); exit 1; }; }
12826   fi
12827   case $CONFIG_SHELL in
12828   '')
12829     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12830 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12831 do
12832   IFS=$as_save_IFS
12833   test -z "$as_dir" && as_dir=.
12834   for as_base in sh bash ksh sh5; do
12835          case $as_dir in
12836          /*)
12837            if ("$as_dir/$as_base" -c '
12838   as_lineno_1=$LINENO
12839   as_lineno_2=$LINENO
12840   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12841   test "x$as_lineno_1" != "x$as_lineno_2" &&
12842   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12843              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12844              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12845              CONFIG_SHELL=$as_dir/$as_base
12846              export CONFIG_SHELL
12847              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12848            fi;;
12849          esac
12850        done
12851 done
12852 ;;
12853   esac
12854
12855   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12856   # uniformly replaced by the line number.  The first 'sed' inserts a
12857   # line-number line before each line; the second 'sed' does the real
12858   # work.  The second script uses 'N' to pair each line-number line
12859   # with the numbered line, and appends trailing '-' during
12860   # substitution so that $LINENO is not a special case at line end.
12861   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12862   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12863   sed '=' <$as_myself |
12864     sed '
12865       N
12866       s,$,-,
12867       : loop
12868       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12869       t loop
12870       s,-$,,
12871       s,^['$as_cr_digits']*\n,,
12872     ' >$as_me.lineno &&
12873   chmod +x $as_me.lineno ||
12874     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12875 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12876    { (exit 1); exit 1; }; }
12877
12878   # Don't try to exec as it changes $[0], causing all sort of problems
12879   # (the dirname of $[0] is not the place where we might find the
12880   # original and so on.  Autoconf is especially sensible to this).
12881   . ./$as_me.lineno
12882   # Exit status is that of the last command.
12883   exit
12884 }
12885
12886
12887 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12888   *c*,-n*) ECHO_N= ECHO_C='
12889 ' ECHO_T='      ' ;;
12890   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12891   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12892 esac
12893
12894 if expr a : '\(a\)' >/dev/null 2>&1; then
12895   as_expr=expr
12896 else
12897   as_expr=false
12898 fi
12899
12900 rm -f conf$$ conf$$.exe conf$$.file
12901 echo >conf$$.file
12902 if ln -s conf$$.file conf$$ 2>/dev/null; then
12903   # We could just check for DJGPP; but this test a) works b) is more generic
12904   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12905   if test -f conf$$.exe; then
12906     # Don't use ln at all; we don't have any links
12907     as_ln_s='cp -p'
12908   else
12909     as_ln_s='ln -s'
12910   fi
12911 elif ln conf$$.file conf$$ 2>/dev/null; then
12912   as_ln_s=ln
12913 else
12914   as_ln_s='cp -p'
12915 fi
12916 rm -f conf$$ conf$$.exe conf$$.file
12917
12918 if mkdir -p . 2>/dev/null; then
12919   as_mkdir_p=:
12920 else
12921   test -d ./-p && rmdir ./-p
12922   as_mkdir_p=false
12923 fi
12924
12925 as_executable_p="test -f"
12926
12927 # Sed expression to map a string onto a valid CPP name.
12928 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12929
12930 # Sed expression to map a string onto a valid variable name.
12931 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12932
12933
12934 # IFS
12935 # We need space, tab and new line, in precisely that order.
12936 as_nl='
12937 '
12938 IFS="   $as_nl"
12939
12940 # CDPATH.
12941 $as_unset CDPATH
12942
12943 exec 6>&1
12944
12945 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12946 # report actual input values of CONFIG_FILES etc. instead of their
12947 # values after options handling.  Logging --version etc. is OK.
12948 exec 5>>config.log
12949 {
12950   echo
12951   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12952 ## Running $as_me. ##
12953 _ASBOX
12954 } >&5
12955 cat >&5 <<_CSEOF
12956
12957 This file was extended by $as_me, which was
12958 generated by GNU Autoconf 2.59.  Invocation command line was
12959
12960   CONFIG_FILES    = $CONFIG_FILES
12961   CONFIG_HEADERS  = $CONFIG_HEADERS
12962   CONFIG_LINKS    = $CONFIG_LINKS
12963   CONFIG_COMMANDS = $CONFIG_COMMANDS
12964   $ $0 $@
12965
12966 _CSEOF
12967 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12968 echo >&5
12969 _ACEOF
12970
12971 # Files that config.status was made for.
12972 if test -n "$ac_config_files"; then
12973   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12974 fi
12975
12976 if test -n "$ac_config_headers"; then
12977   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12978 fi
12979
12980 if test -n "$ac_config_links"; then
12981   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12982 fi
12983
12984 if test -n "$ac_config_commands"; then
12985   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12986 fi
12987
12988 cat >>$CONFIG_STATUS <<\_ACEOF
12989
12990 ac_cs_usage="\
12991 \`$as_me' instantiates files from templates according to the
12992 current configuration.
12993
12994 Usage: $0 [OPTIONS] [FILE]...
12995
12996   -h, --help       print this help, then exit
12997   -V, --version    print version number, then exit
12998   -q, --quiet      do not print progress messages
12999   -d, --debug      don't remove temporary files
13000       --recheck    update $as_me by reconfiguring in the same conditions
13001   --file=FILE[:TEMPLATE]
13002                    instantiate the configuration file FILE
13003
13004 Configuration files:
13005 $config_files
13006
13007 Report bugs to <bug-autoconf@gnu.org>."
13008 _ACEOF
13009
13010 cat >>$CONFIG_STATUS <<_ACEOF
13011 ac_cs_version="\\
13012 config.status
13013 configured by $0, generated by GNU Autoconf 2.59,
13014   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13015
13016 Copyright (C) 2003 Free Software Foundation, Inc.
13017 This config.status script is free software; the Free Software Foundation
13018 gives unlimited permission to copy, distribute and modify it."
13019 srcdir=$srcdir
13020 INSTALL="$INSTALL"
13021 _ACEOF
13022
13023 cat >>$CONFIG_STATUS <<\_ACEOF
13024 # If no file are specified by the user, then we need to provide default
13025 # value.  By we need to know if files were specified by the user.
13026 ac_need_defaults=:
13027 while test $# != 0
13028 do
13029   case $1 in
13030   --*=*)
13031     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13032     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13033     ac_shift=:
13034     ;;
13035   -*)
13036     ac_option=$1
13037     ac_optarg=$2
13038     ac_shift=shift
13039     ;;
13040   *) # This is not an option, so the user has probably given explicit
13041      # arguments.
13042      ac_option=$1
13043      ac_need_defaults=false;;
13044   esac
13045
13046   case $ac_option in
13047   # Handling of the options.
13048 _ACEOF
13049 cat >>$CONFIG_STATUS <<\_ACEOF
13050   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13051     ac_cs_recheck=: ;;
13052   --version | --vers* | -V )
13053     echo "$ac_cs_version"; exit 0 ;;
13054   --he | --h)
13055     # Conflict between --help and --header
13056     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13057 Try \`$0 --help' for more information." >&5
13058 echo "$as_me: error: ambiguous option: $1
13059 Try \`$0 --help' for more information." >&2;}
13060    { (exit 1); exit 1; }; };;
13061   --help | --hel | -h )
13062     echo "$ac_cs_usage"; exit 0 ;;
13063   --debug | --d* | -d )
13064     debug=: ;;
13065   --file | --fil | --fi | --f )
13066     $ac_shift
13067     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13068     ac_need_defaults=false;;
13069   --header | --heade | --head | --hea )
13070     $ac_shift
13071     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13072     ac_need_defaults=false;;
13073   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13074   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13075     ac_cs_silent=: ;;
13076
13077   # This is an error.
13078   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13079 Try \`$0 --help' for more information." >&5
13080 echo "$as_me: error: unrecognized option: $1
13081 Try \`$0 --help' for more information." >&2;}
13082    { (exit 1); exit 1; }; } ;;
13083
13084   *) ac_config_targets="$ac_config_targets $1" ;;
13085
13086   esac
13087   shift
13088 done
13089
13090 ac_configure_extra_args=
13091
13092 if $ac_cs_silent; then
13093   exec 6>/dev/null
13094   ac_configure_extra_args="$ac_configure_extra_args --silent"
13095 fi
13096
13097 _ACEOF
13098 cat >>$CONFIG_STATUS <<_ACEOF
13099 if \$ac_cs_recheck; then
13100   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13101   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13102 fi
13103
13104 _ACEOF
13105
13106
13107
13108
13109
13110 cat >>$CONFIG_STATUS <<\_ACEOF
13111 for ac_config_target in $ac_config_targets
13112 do
13113   case "$ac_config_target" in
13114   # Handling of arguments.
13115   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13116   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13117 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13118    { (exit 1); exit 1; }; };;
13119   esac
13120 done
13121
13122 # If the user did not use the arguments to specify the items to instantiate,
13123 # then the envvar interface is used.  Set only those that are not.
13124 # We use the long form for the default assignment because of an extremely
13125 # bizarre bug on SunOS 4.1.3.
13126 if $ac_need_defaults; then
13127   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13128 fi
13129
13130 # Have a temporary directory for convenience.  Make it in the build tree
13131 # simply because there is no reason to put it here, and in addition,
13132 # creating and moving files from /tmp can sometimes cause problems.
13133 # Create a temporary directory, and hook for its removal unless debugging.
13134 $debug ||
13135 {
13136   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13137   trap '{ (exit 1); exit 1; }' 1 2 13 15
13138 }
13139
13140 # Create a (secure) tmp directory for tmp files.
13141
13142 {
13143   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13144   test -n "$tmp" && test -d "$tmp"
13145 }  ||
13146 {
13147   tmp=./confstat$$-$RANDOM
13148   (umask 077 && mkdir $tmp)
13149 } ||
13150 {
13151    echo "$me: cannot create a temporary directory in ." >&2
13152    { (exit 1); exit 1; }
13153 }
13154
13155 _ACEOF
13156
13157 cat >>$CONFIG_STATUS <<_ACEOF
13158
13159 #
13160 # CONFIG_FILES section.
13161 #
13162
13163 # No need to generate the scripts if there are no CONFIG_FILES.
13164 # This happens for instance when ./config.status config.h
13165 if test -n "\$CONFIG_FILES"; then
13166   # Protect against being on the right side of a sed subst in config.status.
13167   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13168    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13169 s,@SHELL@,$SHELL,;t t
13170 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13171 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13172 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13173 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13174 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13175 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13176 s,@exec_prefix@,$exec_prefix,;t t
13177 s,@prefix@,$prefix,;t t
13178 s,@program_transform_name@,$program_transform_name,;t t
13179 s,@bindir@,$bindir,;t t
13180 s,@sbindir@,$sbindir,;t t
13181 s,@libexecdir@,$libexecdir,;t t
13182 s,@datadir@,$datadir,;t t
13183 s,@sysconfdir@,$sysconfdir,;t t
13184 s,@sharedstatedir@,$sharedstatedir,;t t
13185 s,@localstatedir@,$localstatedir,;t t
13186 s,@libdir@,$libdir,;t t
13187 s,@includedir@,$includedir,;t t
13188 s,@oldincludedir@,$oldincludedir,;t t
13189 s,@infodir@,$infodir,;t t
13190 s,@mandir@,$mandir,;t t
13191 s,@build_alias@,$build_alias,;t t
13192 s,@host_alias@,$host_alias,;t t
13193 s,@target_alias@,$target_alias,;t t
13194 s,@DEFS@,$DEFS,;t t
13195 s,@ECHO_C@,$ECHO_C,;t t
13196 s,@ECHO_N@,$ECHO_N,;t t
13197 s,@ECHO_T@,$ECHO_T,;t t
13198 s,@LIBS@,$LIBS,;t t
13199 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13200 s,@build@,$build,;t t
13201 s,@build_cpu@,$build_cpu,;t t
13202 s,@build_vendor@,$build_vendor,;t t
13203 s,@build_os@,$build_os,;t t
13204 s,@build_noncanonical@,$build_noncanonical,;t t
13205 s,@host_noncanonical@,$host_noncanonical,;t t
13206 s,@target_noncanonical@,$target_noncanonical,;t t
13207 s,@host@,$host,;t t
13208 s,@host_cpu@,$host_cpu,;t t
13209 s,@host_vendor@,$host_vendor,;t t
13210 s,@host_os@,$host_os,;t t
13211 s,@target@,$target,;t t
13212 s,@target_cpu@,$target_cpu,;t t
13213 s,@target_vendor@,$target_vendor,;t t
13214 s,@target_os@,$target_os,;t t
13215 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13216 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13217 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13218 s,@LN@,$LN,;t t
13219 s,@LN_S@,$LN_S,;t t
13220 s,@build_libsubdir@,$build_libsubdir,;t t
13221 s,@build_subdir@,$build_subdir,;t t
13222 s,@host_subdir@,$host_subdir,;t t
13223 s,@target_subdir@,$target_subdir,;t t
13224 s,@CC@,$CC,;t t
13225 s,@CFLAGS@,$CFLAGS,;t t
13226 s,@LDFLAGS@,$LDFLAGS,;t t
13227 s,@CPPFLAGS@,$CPPFLAGS,;t t
13228 s,@ac_ct_CC@,$ac_ct_CC,;t t
13229 s,@EXEEXT@,$EXEEXT,;t t
13230 s,@OBJEXT@,$OBJEXT,;t t
13231 s,@CXX@,$CXX,;t t
13232 s,@CXXFLAGS@,$CXXFLAGS,;t t
13233 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13234 s,@GNATBIND@,$GNATBIND,;t t
13235 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13236 s,@GNATMAKE@,$GNATMAKE,;t t
13237 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13238 s,@do_compare@,$do_compare,;t t
13239 s,@gmplibs@,$gmplibs,;t t
13240 s,@gmpinc@,$gmpinc,;t t
13241 s,@ppllibs@,$ppllibs,;t t
13242 s,@pplinc@,$pplinc,;t t
13243 s,@clooglibs@,$clooglibs,;t t
13244 s,@clooginc@,$clooginc,;t t
13245 s,@stage1_languages@,$stage1_languages,;t t
13246 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13247 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13248 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13249 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13250 s,@CPPFLAGS_FOR_TARGET@,$CPPFLAGS_FOR_TARGET,;t t
13251 s,@LDFLAGS_FOR_TARGET@,$LDFLAGS_FOR_TARGET,;t t
13252 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13253 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13254 s,@tooldir@,$tooldir,;t t
13255 s,@build_tooldir@,$build_tooldir,;t t
13256 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13257 s,@GDB_TK@,$GDB_TK,;t t
13258 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13259 s,@build_configargs@,$build_configargs,;t t
13260 s,@build_configdirs@,$build_configdirs,;t t
13261 s,@host_configargs@,$host_configargs,;t t
13262 s,@configdirs@,$configdirs,;t t
13263 s,@target_configargs@,$target_configargs,;t t
13264 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13265 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13266 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13267 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13268 s,@CPPFLAGS_FOR_BUILD@,$CPPFLAGS_FOR_BUILD,;t t
13269 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13270 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13271 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13272 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13273 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13274 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13275 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13276 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13277 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13278 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13279 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13280 s,@config_shell@,$config_shell,;t t
13281 s,@YACC@,$YACC,;t t
13282 s,@BISON@,$BISON,;t t
13283 s,@M4@,$M4,;t t
13284 s,@LEX@,$LEX,;t t
13285 s,@FLEX@,$FLEX,;t t
13286 s,@MAKEINFO@,$MAKEINFO,;t t
13287 s,@EXPECT@,$EXPECT,;t t
13288 s,@RUNTEST@,$RUNTEST,;t t
13289 s,@AR@,$AR,;t t
13290 s,@AS@,$AS,;t t
13291 s,@DLLTOOL@,$DLLTOOL,;t t
13292 s,@LD@,$LD,;t t
13293 s,@LIPO@,$LIPO,;t t
13294 s,@NM@,$NM,;t t
13295 s,@RANLIB@,$RANLIB,;t t
13296 s,@STRIP@,$STRIP,;t t
13297 s,@WINDRES@,$WINDRES,;t t
13298 s,@WINDMC@,$WINDMC,;t t
13299 s,@OBJCOPY@,$OBJCOPY,;t t
13300 s,@OBJDUMP@,$OBJDUMP,;t t
13301 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13302 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13303 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13304 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13305 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13306 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13307 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13308 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13309 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13310 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13311 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13312 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13313 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13314 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13315 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13316 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13317 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13318 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13319 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13320 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13321 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13322 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13323 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13324 s,@MAINT@,$MAINT,;t t
13325 s,@stage1_cflags@,$stage1_cflags,;t t
13326 s,@stage1_checking@,$stage1_checking,;t t
13327 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13328 s,@datarootdir@,$datarootdir,;t t
13329 s,@docdir@,$docdir,;t t
13330 s,@pdfdir@,$pdfdir,;t t
13331 s,@htmldir@,$htmldir,;t t
13332 s,@LIBOBJS@,$LIBOBJS,;t t
13333 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13334 /@serialization_dependencies@/r $serialization_dependencies
13335 s,@serialization_dependencies@,,;t t
13336 /@host_makefile_frag@/r $host_makefile_frag
13337 s,@host_makefile_frag@,,;t t
13338 /@target_makefile_frag@/r $target_makefile_frag
13339 s,@target_makefile_frag@,,;t t
13340 /@alphaieee_frag@/r $alphaieee_frag
13341 s,@alphaieee_frag@,,;t t
13342 /@ospace_frag@/r $ospace_frag
13343 s,@ospace_frag@,,;t t
13344 CEOF
13345
13346 _ACEOF
13347
13348   cat >>$CONFIG_STATUS <<\_ACEOF
13349   # Split the substitutions into bite-sized pieces for seds with
13350   # small command number limits, like on Digital OSF/1 and HP-UX.
13351   ac_max_sed_lines=48
13352   ac_sed_frag=1 # Number of current file.
13353   ac_beg=1 # First line for current file.
13354   ac_end=$ac_max_sed_lines # Line after last line for current file.
13355   ac_more_lines=:
13356   ac_sed_cmds=
13357   while $ac_more_lines; do
13358     if test $ac_beg -gt 1; then
13359       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13360     else
13361       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13362     fi
13363     if test ! -s $tmp/subs.frag; then
13364       ac_more_lines=false
13365     else
13366       # The purpose of the label and of the branching condition is to
13367       # speed up the sed processing (if there are no `@' at all, there
13368       # is no need to browse any of the substitutions).
13369       # These are the two extra sed commands mentioned above.
13370       (echo ':t
13371   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13372       if test -z "$ac_sed_cmds"; then
13373         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13374       else
13375         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13376       fi
13377       ac_sed_frag=`expr $ac_sed_frag + 1`
13378       ac_beg=$ac_end
13379       ac_end=`expr $ac_end + $ac_max_sed_lines`
13380     fi
13381   done
13382   if test -z "$ac_sed_cmds"; then
13383     ac_sed_cmds=cat
13384   fi
13385 fi # test -n "$CONFIG_FILES"
13386
13387 _ACEOF
13388 cat >>$CONFIG_STATUS <<\_ACEOF
13389 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13390   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13391   case $ac_file in
13392   - | *:- | *:-:* ) # input from stdin
13393         cat >$tmp/stdin
13394         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13395         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13396   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13397         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13398   * )   ac_file_in=$ac_file.in ;;
13399   esac
13400
13401   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13402   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13403 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13404          X"$ac_file" : 'X\(//\)[^/]' \| \
13405          X"$ac_file" : 'X\(//\)$' \| \
13406          X"$ac_file" : 'X\(/\)' \| \
13407          .     : '\(.\)' 2>/dev/null ||
13408 echo X"$ac_file" |
13409     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13410           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13411           /^X\(\/\/\)$/{ s//\1/; q; }
13412           /^X\(\/\).*/{ s//\1/; q; }
13413           s/.*/./; q'`
13414   { if $as_mkdir_p; then
13415     mkdir -p "$ac_dir"
13416   else
13417     as_dir="$ac_dir"
13418     as_dirs=
13419     while test ! -d "$as_dir"; do
13420       as_dirs="$as_dir $as_dirs"
13421       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13422 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13423          X"$as_dir" : 'X\(//\)[^/]' \| \
13424          X"$as_dir" : 'X\(//\)$' \| \
13425          X"$as_dir" : 'X\(/\)' \| \
13426          .     : '\(.\)' 2>/dev/null ||
13427 echo X"$as_dir" |
13428     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13429           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13430           /^X\(\/\/\)$/{ s//\1/; q; }
13431           /^X\(\/\).*/{ s//\1/; q; }
13432           s/.*/./; q'`
13433     done
13434     test ! -n "$as_dirs" || mkdir $as_dirs
13435   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13436 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13437    { (exit 1); exit 1; }; }; }
13438
13439   ac_builddir=.
13440
13441 if test "$ac_dir" != .; then
13442   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13443   # A "../" for each directory in $ac_dir_suffix.
13444   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13445 else
13446   ac_dir_suffix= ac_top_builddir=
13447 fi
13448
13449 case $srcdir in
13450   .)  # No --srcdir option.  We are building in place.
13451     ac_srcdir=.
13452     if test -z "$ac_top_builddir"; then
13453        ac_top_srcdir=.
13454     else
13455        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13456     fi ;;
13457   [\\/]* | ?:[\\/]* )  # Absolute path.
13458     ac_srcdir=$srcdir$ac_dir_suffix;
13459     ac_top_srcdir=$srcdir ;;
13460   *) # Relative path.
13461     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13462     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13463 esac
13464
13465 # Do not use `cd foo && pwd` to compute absolute paths, because
13466 # the directories may not exist.
13467 case `pwd` in
13468 .) ac_abs_builddir="$ac_dir";;
13469 *)
13470   case "$ac_dir" in
13471   .) ac_abs_builddir=`pwd`;;
13472   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13473   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13474   esac;;
13475 esac
13476 case $ac_abs_builddir in
13477 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13478 *)
13479   case ${ac_top_builddir}. in
13480   .) ac_abs_top_builddir=$ac_abs_builddir;;
13481   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13482   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13483   esac;;
13484 esac
13485 case $ac_abs_builddir in
13486 .) ac_abs_srcdir=$ac_srcdir;;
13487 *)
13488   case $ac_srcdir in
13489   .) ac_abs_srcdir=$ac_abs_builddir;;
13490   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13491   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13492   esac;;
13493 esac
13494 case $ac_abs_builddir in
13495 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13496 *)
13497   case $ac_top_srcdir in
13498   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13499   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13500   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13501   esac;;
13502 esac
13503
13504
13505   case $INSTALL in
13506   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13507   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13508   esac
13509
13510   if test x"$ac_file" != x-; then
13511     { echo "$as_me:$LINENO: creating $ac_file" >&5
13512 echo "$as_me: creating $ac_file" >&6;}
13513     rm -f "$ac_file"
13514   fi
13515   # Let's still pretend it is `configure' which instantiates (i.e., don't
13516   # use $as_me), people would be surprised to read:
13517   #    /* config.h.  Generated by config.status.  */
13518   if test x"$ac_file" = x-; then
13519     configure_input=
13520   else
13521     configure_input="$ac_file.  "
13522   fi
13523   configure_input=$configure_input"Generated from `echo $ac_file_in |
13524                                      sed 's,.*/,,'` by configure."
13525
13526   # First look for the input files in the build tree, otherwise in the
13527   # src tree.
13528   ac_file_inputs=`IFS=:
13529     for f in $ac_file_in; do
13530       case $f in
13531       -) echo $tmp/stdin ;;
13532       [\\/$]*)
13533          # Absolute (can't be DOS-style, as IFS=:)
13534          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13535 echo "$as_me: error: cannot find input file: $f" >&2;}
13536    { (exit 1); exit 1; }; }
13537          echo "$f";;
13538       *) # Relative
13539          if test -f "$f"; then
13540            # Build tree
13541            echo "$f"
13542          elif test -f "$srcdir/$f"; then
13543            # Source tree
13544            echo "$srcdir/$f"
13545          else
13546            # /dev/null tree
13547            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13548 echo "$as_me: error: cannot find input file: $f" >&2;}
13549    { (exit 1); exit 1; }; }
13550          fi;;
13551       esac
13552     done` || { (exit 1); exit 1; }
13553 _ACEOF
13554 cat >>$CONFIG_STATUS <<_ACEOF
13555   sed "$ac_vpsub
13556 $extrasub
13557 _ACEOF
13558 cat >>$CONFIG_STATUS <<\_ACEOF
13559 :t
13560 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13561 s,@configure_input@,$configure_input,;t t
13562 s,@srcdir@,$ac_srcdir,;t t
13563 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13564 s,@top_srcdir@,$ac_top_srcdir,;t t
13565 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13566 s,@builddir@,$ac_builddir,;t t
13567 s,@abs_builddir@,$ac_abs_builddir,;t t
13568 s,@top_builddir@,$ac_top_builddir,;t t
13569 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13570 s,@INSTALL@,$ac_INSTALL,;t t
13571 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13572   rm -f $tmp/stdin
13573   if test x"$ac_file" != x-; then
13574     mv $tmp/out $ac_file
13575   else
13576     cat $tmp/out
13577     rm -f $tmp/out
13578   fi
13579
13580 done
13581 _ACEOF
13582
13583 cat >>$CONFIG_STATUS <<\_ACEOF
13584
13585 { (exit 0); exit 0; }
13586 _ACEOF
13587 chmod +x $CONFIG_STATUS
13588 ac_clean_files=$ac_clean_files_save
13589
13590
13591 # configure is writing to config.log, and then calls config.status.
13592 # config.status does its own redirection, appending to config.log.
13593 # Unfortunately, on DOS this fails, as config.log is still kept open
13594 # by configure, so config.status won't be able to write to it; its
13595 # output is simply discarded.  So we exec the FD to /dev/null,
13596 # effectively closing config.log, so it can be properly (re)opened and
13597 # appended to by config.status.  When coming back to configure, we
13598 # need to make the FD available again.
13599 if test "$no_create" != yes; then
13600   ac_cs_success=:
13601   ac_config_status_args=
13602   test "$silent" = yes &&
13603     ac_config_status_args="$ac_config_status_args --quiet"
13604   exec 5>/dev/null
13605   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13606   exec 5>>config.log
13607   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13608   # would make configure fail if this is the last instruction.
13609   $ac_cs_success || { (exit 1); exit 1; }
13610 fi
13611