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   v810-*-*)
2659     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2660     ;;
2661   v850-*-*)
2662     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2663     ;;
2664   v850e-*-*)
2665     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2666     ;;
2667   v850ea-*-*)
2668     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2669     ;;
2670   vax-*-vms)
2671     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2672     ;;
2673   vax-*-*)
2674     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2675     ;;
2676   xtensa*-*-*)
2677     noconfigdirs="$noconfigdirs ${libgcj}"
2678     ;;
2679   ip2k-*-*)
2680     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2681     ;;
2682   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2683     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2684     ;;
2685   *-*-lynxos*)
2686     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2687     ;;
2688   *-*-*)
2689     noconfigdirs="$noconfigdirs ${libgcj}"
2690     ;;
2691 esac
2692
2693 # If we aren't building newlib, then don't build libgloss, since libgloss
2694 # depends upon some newlib header files.
2695 case "${noconfigdirs}" in
2696   *target-libgloss*) ;;
2697   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2698 esac
2699
2700 # Work in distributions that contain no compiler tools, like Autoconf.
2701 tentative_cc=""
2702 host_makefile_frag=/dev/null
2703 if test -d ${srcdir}/config ; then
2704 case "${host}" in
2705   m68k-hp-hpux*)
2706     # Avoid "too much defining" errors from HPUX compiler.
2707     tentative_cc="cc -Wp,-H256000"
2708     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2709     # If it's HP/UX ar, this should be harmless.
2710     RANLIB="ar ts"
2711     ;;
2712   m68k-apollo-sysv*)
2713     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2714     ;;
2715   m68k-apollo-bsd*)
2716     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2717     # chokes on bfd, the compiler won't let you assign integers to enums, and
2718     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2719     # the apollo compiler" (the preferred version of GCC could be called cc,
2720     # or whatever), but I'm not sure leaving CC as cc is any better...
2721     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2722     # Used to have BISON=yacc.
2723     tentative_cc=gcc
2724     ;;
2725   m88k-dg-dgux*)
2726     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2727     ;;
2728   m88k-harris-cxux*)
2729     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2730     tentative_cc="cc -Xa"
2731     host_makefile_frag="config/mh-cxux"
2732     ;;
2733   m88k-motorola-sysv*)
2734     ;;
2735   mips*-dec-ultrix*)
2736     tentative_cc="cc -Wf,-XNg1000"
2737     host_makefile_frag="config/mh-decstation"
2738     ;;
2739   mips*-nec-sysv4*)
2740     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2741     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2742     host_makefile_frag="config/mh-necv4"
2743     ;;
2744   mips*-sgi-irix4*)
2745     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2746     # environment.  Also bump switch table size so that cp-parse will
2747     # compile.  Bump string length limit so linker builds.
2748     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2749     ;;
2750   mips*-*-sysv4*)
2751     host_makefile_frag="config/mh-sysv4"
2752     ;;
2753   mips*-*-sysv*)
2754     # This is for a MIPS running RISC/os 4.52C.
2755
2756     # This is needed for GDB, but needs to be in the top-level make because
2757     # if a library is compiled with the bsd headers and gets linked with the
2758     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2759     # a different size).
2760     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2761     # known except to select the sysv environment.  Could we use /proc instead?
2762     # These "sysv environments" and "bsd environments" often end up being a pain.
2763     #
2764     # This is not part of CFLAGS because perhaps not all C compilers have this
2765     # option.
2766     tentative_cc="cc -systype sysv"
2767     ;;
2768   i370-ibm-opened*)
2769     tentative_cc="c89"
2770     ;;
2771   i[3456789]86-*-sysv5*)
2772     host_makefile_frag="config/mh-sysv5"
2773     ;;
2774   i[3456789]86-*-dgux*)
2775     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2776     host_makefile_frag="config/mh-dgux386"
2777     ;;
2778   i[3456789]86-ncr-sysv4.3*)
2779     # The MetaWare compiler will generate a copyright message unless you
2780     # turn it off by adding the -Hnocopyr flag.
2781     tentative_cc="cc -Hnocopyr"
2782     ;;
2783   i[3456789]86-ncr-sysv4*)
2784     # for an NCR 3000 (i486/SVR4) system.
2785     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2786     # This compiler not only emits obnoxious copyright messages every time
2787     # you run it, but it chokes and dies on a whole bunch of GNU source
2788     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2789     tentative_cc="/usr/ccs/ATT/cc"
2790     host_makefile_frag="config/mh-ncr3000"
2791     ;;
2792   i[3456789]86-*-sco3.2v5*)
2793     ;;
2794   i[3456789]86-*-sco*)
2795     # The native C compiler botches some simple uses of const.  Unfortunately,
2796     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2797     tentative_cc="cc -Dconst="
2798     host_makefile_frag="config/mh-sco"
2799     ;;
2800   i[3456789]86-*-udk*)
2801     host_makefile_frag="config/mh-sysv5"
2802     ;;
2803   i[3456789]86-*-solaris2*)
2804     host_makefile_frag="config/mh-sysv4"
2805     ;;
2806   i[3456789]86-*-msdosdjgpp*)
2807     host_makefile_frag="config/mh-djgpp"
2808     ;;
2809   *-cygwin*)
2810
2811 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2812 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2813 echo a >cygwin-cat-check
2814 if test `cat cygwin-cat-check` == a ; then
2815   rm cygwin-cat-check
2816   echo "$as_me:$LINENO: result: yes" >&5
2817 echo "${ECHO_T}yes" >&6
2818 else
2819   rm cygwin-cat-check
2820   echo "$as_me:$LINENO: result: no" >&5
2821 echo "${ECHO_T}no" >&6
2822   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2823   Please either mount the build directory in binary mode or run the following
2824   commands before running any configure script:
2825 set -o igncr
2826 export SHELLOPTS
2827   " >&5
2828 echo "$as_me: error: The cat command does not ignore carriage return characters.
2829   Please either mount the build directory in binary mode or run the following
2830   commands before running any configure script:
2831 set -o igncr
2832 export SHELLOPTS
2833   " >&2;}
2834    { (exit 1); exit 1; }; }
2835 fi
2836
2837     host_makefile_frag="config/mh-cygwin"
2838     ;;
2839   *-mingw*)
2840     host_makefile_frag="config/mh-mingw"
2841     ;;
2842   *-interix*)
2843     host_makefile_frag="config/mh-interix"
2844     ;;
2845   vax-*-ultrix2*)
2846     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2847     tentative_cc=gcc
2848     ;;
2849   *-*-solaris2*)
2850     host_makefile_frag="config/mh-solaris"
2851     ;;
2852   m68k-sun-sunos*)
2853     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2854     # without overflowing the jump tables (-J says to use a 32 bit table)
2855     tentative_cc="cc -J"
2856     ;;
2857   hppa*-hp-hpux10*)
2858     tentative_cc="cc -Wp,-H256000"
2859     host_makefile_frag="config/mh-pa-hpux10"
2860     ;;
2861   hppa*-hp-hpux* | hppa*-*-hiux*)
2862     tentative_cc="cc -Wp,-H256000"
2863     host_makefile_frag="config/mh-pa"
2864     ;;
2865   hppa*-*)
2866     host_makefile_frag="config/mh-pa"
2867     ;;
2868   *-hp-hpux* | *-*-hiux*)
2869     tentative_cc="cc -Wp,-H256000"
2870     ;;
2871   rs6000-*-lynxos*)
2872     # /bin/cc is less than useful for our purposes.  Always use GCC
2873     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2874     host_makefile_frag="config/mh-lynxrs6k"
2875     ;;
2876   powerpc-*-darwin*)
2877     host_makefile_frag="config/mh-ppc-darwin"
2878     ;;
2879   powerpc-*-aix*)
2880     host_makefile_frag="config/mh-ppc-aix"
2881     ;;
2882   rs6000-*-aix*)
2883     host_makefile_frag="config/mh-ppc-aix"
2884     ;;
2885   *-*-lynxos*)
2886     # /bin/cc is less than useful for our purposes.  Always use GCC
2887     tentative_cc="/bin/gcc"
2888     ;;
2889   *-*-sysv4*)
2890     host_makefile_frag="config/mh-sysv4"
2891     ;;
2892   # This is placed last to prevent interfering with the cases above.
2893   i[3456789]86-*-*)
2894     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2895     host_makefile_frag="config/mh-x86omitfp"
2896     ;;
2897 esac
2898 fi
2899
2900 # If we aren't going to be using gcc, see if we can extract a definition
2901 # of CC from the fragment.
2902 # Actually, use the 'pre-extracted' version above.
2903 if test -z "${CC}" && test "${build}" = "${host}" ; then
2904   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2905   found=
2906   for dir in $PATH; do
2907     test -z "$dir" && dir=.
2908     if test -f $dir/gcc; then
2909       found=yes
2910       break
2911     fi
2912   done
2913   IFS="$save_ifs"
2914   if test -z "${found}" && test -n "${tentative_cc}" ; then
2915     CC=$tentative_cc
2916   fi
2917 fi
2918
2919 if test "${build}" != "${host}" ; then
2920   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2921   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2922   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2923   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2924   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2925   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2926   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2927   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2928   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2929   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2930   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2931   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2932 else
2933   AR_FOR_BUILD="\$(AR)"
2934   AS_FOR_BUILD="\$(AS)"
2935   CC_FOR_BUILD="\$(CC)"
2936   CXX_FOR_BUILD="\$(CXX)"
2937   GCJ_FOR_BUILD="\$(GCJ)"
2938   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2939   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2940   LD_FOR_BUILD="\$(LD)"
2941   NM_FOR_BUILD="\$(NM)"
2942   RANLIB_FOR_BUILD="\$(RANLIB)"
2943   WINDRES_FOR_BUILD="\$(WINDRES)"
2944   WINDMC_FOR_BUILD="\$(WINDMC)"
2945 fi
2946
2947 ac_ext=c
2948 ac_cpp='$CPP $CPPFLAGS'
2949 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2950 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2951 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2952 if test -n "$ac_tool_prefix"; then
2953   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2954 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2955 echo "$as_me:$LINENO: checking for $ac_word" >&5
2956 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2957 if test "${ac_cv_prog_CC+set}" = set; then
2958   echo $ECHO_N "(cached) $ECHO_C" >&6
2959 else
2960   if test -n "$CC"; then
2961   ac_cv_prog_CC="$CC" # Let the user override the test.
2962 else
2963 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2964 for as_dir in $PATH
2965 do
2966   IFS=$as_save_IFS
2967   test -z "$as_dir" && as_dir=.
2968   for ac_exec_ext in '' $ac_executable_extensions; do
2969   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2970     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2971     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2972     break 2
2973   fi
2974 done
2975 done
2976
2977 fi
2978 fi
2979 CC=$ac_cv_prog_CC
2980 if test -n "$CC"; then
2981   echo "$as_me:$LINENO: result: $CC" >&5
2982 echo "${ECHO_T}$CC" >&6
2983 else
2984   echo "$as_me:$LINENO: result: no" >&5
2985 echo "${ECHO_T}no" >&6
2986 fi
2987
2988 fi
2989 if test -z "$ac_cv_prog_CC"; then
2990   ac_ct_CC=$CC
2991   # Extract the first word of "gcc", so it can be a program name with args.
2992 set dummy gcc; ac_word=$2
2993 echo "$as_me:$LINENO: checking for $ac_word" >&5
2994 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2995 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2996   echo $ECHO_N "(cached) $ECHO_C" >&6
2997 else
2998   if test -n "$ac_ct_CC"; then
2999   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3000 else
3001 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3002 for as_dir in $PATH
3003 do
3004   IFS=$as_save_IFS
3005   test -z "$as_dir" && as_dir=.
3006   for ac_exec_ext in '' $ac_executable_extensions; do
3007   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3008     ac_cv_prog_ac_ct_CC="gcc"
3009     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3010     break 2
3011   fi
3012 done
3013 done
3014
3015 fi
3016 fi
3017 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3018 if test -n "$ac_ct_CC"; then
3019   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3020 echo "${ECHO_T}$ac_ct_CC" >&6
3021 else
3022   echo "$as_me:$LINENO: result: no" >&5
3023 echo "${ECHO_T}no" >&6
3024 fi
3025
3026   CC=$ac_ct_CC
3027 else
3028   CC="$ac_cv_prog_CC"
3029 fi
3030
3031 if test -z "$CC"; then
3032   if test -n "$ac_tool_prefix"; then
3033   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3034 set dummy ${ac_tool_prefix}cc; ac_word=$2
3035 echo "$as_me:$LINENO: checking for $ac_word" >&5
3036 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3037 if test "${ac_cv_prog_CC+set}" = set; then
3038   echo $ECHO_N "(cached) $ECHO_C" >&6
3039 else
3040   if test -n "$CC"; then
3041   ac_cv_prog_CC="$CC" # Let the user override the test.
3042 else
3043 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3044 for as_dir in $PATH
3045 do
3046   IFS=$as_save_IFS
3047   test -z "$as_dir" && as_dir=.
3048   for ac_exec_ext in '' $ac_executable_extensions; do
3049   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3050     ac_cv_prog_CC="${ac_tool_prefix}cc"
3051     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3052     break 2
3053   fi
3054 done
3055 done
3056
3057 fi
3058 fi
3059 CC=$ac_cv_prog_CC
3060 if test -n "$CC"; then
3061   echo "$as_me:$LINENO: result: $CC" >&5
3062 echo "${ECHO_T}$CC" >&6
3063 else
3064   echo "$as_me:$LINENO: result: no" >&5
3065 echo "${ECHO_T}no" >&6
3066 fi
3067
3068 fi
3069 if test -z "$ac_cv_prog_CC"; then
3070   ac_ct_CC=$CC
3071   # Extract the first word of "cc", so it can be a program name with args.
3072 set dummy cc; ac_word=$2
3073 echo "$as_me:$LINENO: checking for $ac_word" >&5
3074 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3075 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3076   echo $ECHO_N "(cached) $ECHO_C" >&6
3077 else
3078   if test -n "$ac_ct_CC"; then
3079   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3080 else
3081 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3082 for as_dir in $PATH
3083 do
3084   IFS=$as_save_IFS
3085   test -z "$as_dir" && as_dir=.
3086   for ac_exec_ext in '' $ac_executable_extensions; do
3087   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3088     ac_cv_prog_ac_ct_CC="cc"
3089     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3090     break 2
3091   fi
3092 done
3093 done
3094
3095 fi
3096 fi
3097 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3098 if test -n "$ac_ct_CC"; then
3099   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3100 echo "${ECHO_T}$ac_ct_CC" >&6
3101 else
3102   echo "$as_me:$LINENO: result: no" >&5
3103 echo "${ECHO_T}no" >&6
3104 fi
3105
3106   CC=$ac_ct_CC
3107 else
3108   CC="$ac_cv_prog_CC"
3109 fi
3110
3111 fi
3112 if test -z "$CC"; then
3113   # Extract the first word of "cc", so it can be a program name with args.
3114 set dummy cc; ac_word=$2
3115 echo "$as_me:$LINENO: checking for $ac_word" >&5
3116 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3117 if test "${ac_cv_prog_CC+set}" = set; then
3118   echo $ECHO_N "(cached) $ECHO_C" >&6
3119 else
3120   if test -n "$CC"; then
3121   ac_cv_prog_CC="$CC" # Let the user override the test.
3122 else
3123   ac_prog_rejected=no
3124 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3125 for as_dir in $PATH
3126 do
3127   IFS=$as_save_IFS
3128   test -z "$as_dir" && as_dir=.
3129   for ac_exec_ext in '' $ac_executable_extensions; do
3130   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3131     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3132        ac_prog_rejected=yes
3133        continue
3134      fi
3135     ac_cv_prog_CC="cc"
3136     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3137     break 2
3138   fi
3139 done
3140 done
3141
3142 if test $ac_prog_rejected = yes; then
3143   # We found a bogon in the path, so make sure we never use it.
3144   set dummy $ac_cv_prog_CC
3145   shift
3146   if test $# != 0; then
3147     # We chose a different compiler from the bogus one.
3148     # However, it has the same basename, so the bogon will be chosen
3149     # first if we set CC to just the basename; use the full file name.
3150     shift
3151     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3152   fi
3153 fi
3154 fi
3155 fi
3156 CC=$ac_cv_prog_CC
3157 if test -n "$CC"; then
3158   echo "$as_me:$LINENO: result: $CC" >&5
3159 echo "${ECHO_T}$CC" >&6
3160 else
3161   echo "$as_me:$LINENO: result: no" >&5
3162 echo "${ECHO_T}no" >&6
3163 fi
3164
3165 fi
3166 if test -z "$CC"; then
3167   if test -n "$ac_tool_prefix"; then
3168   for ac_prog in cl
3169   do
3170     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3171 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3172 echo "$as_me:$LINENO: checking for $ac_word" >&5
3173 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3174 if test "${ac_cv_prog_CC+set}" = set; then
3175   echo $ECHO_N "(cached) $ECHO_C" >&6
3176 else
3177   if test -n "$CC"; then
3178   ac_cv_prog_CC="$CC" # Let the user override the test.
3179 else
3180 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3181 for as_dir in $PATH
3182 do
3183   IFS=$as_save_IFS
3184   test -z "$as_dir" && as_dir=.
3185   for ac_exec_ext in '' $ac_executable_extensions; do
3186   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3187     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3188     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3189     break 2
3190   fi
3191 done
3192 done
3193
3194 fi
3195 fi
3196 CC=$ac_cv_prog_CC
3197 if test -n "$CC"; then
3198   echo "$as_me:$LINENO: result: $CC" >&5
3199 echo "${ECHO_T}$CC" >&6
3200 else
3201   echo "$as_me:$LINENO: result: no" >&5
3202 echo "${ECHO_T}no" >&6
3203 fi
3204
3205     test -n "$CC" && break
3206   done
3207 fi
3208 if test -z "$CC"; then
3209   ac_ct_CC=$CC
3210   for ac_prog in cl
3211 do
3212   # Extract the first word of "$ac_prog", so it can be a program name with args.
3213 set dummy $ac_prog; ac_word=$2
3214 echo "$as_me:$LINENO: checking for $ac_word" >&5
3215 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3216 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3217   echo $ECHO_N "(cached) $ECHO_C" >&6
3218 else
3219   if test -n "$ac_ct_CC"; then
3220   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3221 else
3222 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3223 for as_dir in $PATH
3224 do
3225   IFS=$as_save_IFS
3226   test -z "$as_dir" && as_dir=.
3227   for ac_exec_ext in '' $ac_executable_extensions; do
3228   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3229     ac_cv_prog_ac_ct_CC="$ac_prog"
3230     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3231     break 2
3232   fi
3233 done
3234 done
3235
3236 fi
3237 fi
3238 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3239 if test -n "$ac_ct_CC"; then
3240   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3241 echo "${ECHO_T}$ac_ct_CC" >&6
3242 else
3243   echo "$as_me:$LINENO: result: no" >&5
3244 echo "${ECHO_T}no" >&6
3245 fi
3246
3247   test -n "$ac_ct_CC" && break
3248 done
3249
3250   CC=$ac_ct_CC
3251 fi
3252
3253 fi
3254
3255
3256 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3257 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3258 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3259 See \`config.log' for more details." >&5
3260 echo "$as_me: error: no acceptable C compiler found in \$PATH
3261 See \`config.log' for more details." >&2;}
3262    { (exit 1); exit 1; }; }; }
3263
3264 # Provide some information about the compiler.
3265 echo "$as_me:$LINENO:" \
3266      "checking for C compiler version" >&5
3267 ac_compiler=`set X $ac_compile; echo $2`
3268 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3269   (eval $ac_compiler --version </dev/null >&5) 2>&5
3270   ac_status=$?
3271   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3272   (exit $ac_status); }
3273 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3274   (eval $ac_compiler -v </dev/null >&5) 2>&5
3275   ac_status=$?
3276   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3277   (exit $ac_status); }
3278 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3279   (eval $ac_compiler -V </dev/null >&5) 2>&5
3280   ac_status=$?
3281   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3282   (exit $ac_status); }
3283
3284 cat >conftest.$ac_ext <<_ACEOF
3285 /* confdefs.h.  */
3286 _ACEOF
3287 cat confdefs.h >>conftest.$ac_ext
3288 cat >>conftest.$ac_ext <<_ACEOF
3289 /* end confdefs.h.  */
3290
3291 int
3292 main ()
3293 {
3294
3295   ;
3296   return 0;
3297 }
3298 _ACEOF
3299 ac_clean_files_save=$ac_clean_files
3300 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3301 # Try to create an executable without -o first, disregard a.out.
3302 # It will help us diagnose broken compilers, and finding out an intuition
3303 # of exeext.
3304 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3305 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3306 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3307 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3308   (eval $ac_link_default) 2>&5
3309   ac_status=$?
3310   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3311   (exit $ac_status); }; then
3312   # Find the output, starting from the most likely.  This scheme is
3313 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3314 # resort.
3315
3316 # Be careful to initialize this variable, since it used to be cached.
3317 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3318 ac_cv_exeext=
3319 # b.out is created by i960 compilers.
3320 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3321 do
3322   test -f "$ac_file" || continue
3323   case $ac_file in
3324     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3325         ;;
3326     conftest.$ac_ext )
3327         # This is the source file.
3328         ;;
3329     [ab].out )
3330         # We found the default executable, but exeext='' is most
3331         # certainly right.
3332         break;;
3333     *.* )
3334         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3335         # FIXME: I believe we export ac_cv_exeext for Libtool,
3336         # but it would be cool to find out if it's true.  Does anybody
3337         # maintain Libtool? --akim.
3338         export ac_cv_exeext
3339         break;;
3340     * )
3341         break;;
3342   esac
3343 done
3344 else
3345   echo "$as_me: failed program was:" >&5
3346 sed 's/^/| /' conftest.$ac_ext >&5
3347
3348 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3349 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3350 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3351 See \`config.log' for more details." >&5
3352 echo "$as_me: error: C compiler cannot create executables
3353 See \`config.log' for more details." >&2;}
3354    { (exit 77); exit 77; }; }; }
3355 fi
3356
3357 ac_exeext=$ac_cv_exeext
3358 echo "$as_me:$LINENO: result: $ac_file" >&5
3359 echo "${ECHO_T}$ac_file" >&6
3360
3361 # Check the compiler produces executables we can run.  If not, either
3362 # the compiler is broken, or we cross compile.
3363 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3364 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3365 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3366 # If not cross compiling, check that we can run a simple program.
3367 if test "$cross_compiling" != yes; then
3368   if { ac_try='./$ac_file'
3369   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3370   (eval $ac_try) 2>&5
3371   ac_status=$?
3372   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3373   (exit $ac_status); }; }; then
3374     cross_compiling=no
3375   else
3376     if test "$cross_compiling" = maybe; then
3377         cross_compiling=yes
3378     else
3379         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3380 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3381 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3382 If you meant to cross compile, use \`--host'.
3383 See \`config.log' for more details." >&5
3384 echo "$as_me: error: cannot run C compiled programs.
3385 If you meant to cross compile, use \`--host'.
3386 See \`config.log' for more details." >&2;}
3387    { (exit 1); exit 1; }; }; }
3388     fi
3389   fi
3390 fi
3391 echo "$as_me:$LINENO: result: yes" >&5
3392 echo "${ECHO_T}yes" >&6
3393
3394 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3395 ac_clean_files=$ac_clean_files_save
3396 # Check the compiler produces executables we can run.  If not, either
3397 # the compiler is broken, or we cross compile.
3398 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3399 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3400 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3401 echo "${ECHO_T}$cross_compiling" >&6
3402
3403 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3404 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3405 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3406   (eval $ac_link) 2>&5
3407   ac_status=$?
3408   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3409   (exit $ac_status); }; then
3410   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3411 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3412 # work properly (i.e., refer to `conftest.exe'), while it won't with
3413 # `rm'.
3414 for ac_file in conftest.exe conftest conftest.*; do
3415   test -f "$ac_file" || continue
3416   case $ac_file in
3417     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3418     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3419           export ac_cv_exeext
3420           break;;
3421     * ) break;;
3422   esac
3423 done
3424 else
3425   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3426 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3427 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3428 See \`config.log' for more details." >&5
3429 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3430 See \`config.log' for more details." >&2;}
3431    { (exit 1); exit 1; }; }; }
3432 fi
3433
3434 rm -f conftest$ac_cv_exeext
3435 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3436 echo "${ECHO_T}$ac_cv_exeext" >&6
3437
3438 rm -f conftest.$ac_ext
3439 EXEEXT=$ac_cv_exeext
3440 ac_exeext=$EXEEXT
3441 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3442 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3443 if test "${ac_cv_objext+set}" = set; then
3444   echo $ECHO_N "(cached) $ECHO_C" >&6
3445 else
3446   cat >conftest.$ac_ext <<_ACEOF
3447 /* confdefs.h.  */
3448 _ACEOF
3449 cat confdefs.h >>conftest.$ac_ext
3450 cat >>conftest.$ac_ext <<_ACEOF
3451 /* end confdefs.h.  */
3452
3453 int
3454 main ()
3455 {
3456
3457   ;
3458   return 0;
3459 }
3460 _ACEOF
3461 rm -f conftest.o conftest.obj
3462 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3463   (eval $ac_compile) 2>&5
3464   ac_status=$?
3465   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3466   (exit $ac_status); }; then
3467   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3468   case $ac_file in
3469     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3470     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3471        break;;
3472   esac
3473 done
3474 else
3475   echo "$as_me: failed program was:" >&5
3476 sed 's/^/| /' conftest.$ac_ext >&5
3477
3478 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3479 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3480 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3481 See \`config.log' for more details." >&5
3482 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3483 See \`config.log' for more details." >&2;}
3484    { (exit 1); exit 1; }; }; }
3485 fi
3486
3487 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3488 fi
3489 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3490 echo "${ECHO_T}$ac_cv_objext" >&6
3491 OBJEXT=$ac_cv_objext
3492 ac_objext=$OBJEXT
3493 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3494 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3495 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3496   echo $ECHO_N "(cached) $ECHO_C" >&6
3497 else
3498   cat >conftest.$ac_ext <<_ACEOF
3499 /* confdefs.h.  */
3500 _ACEOF
3501 cat confdefs.h >>conftest.$ac_ext
3502 cat >>conftest.$ac_ext <<_ACEOF
3503 /* end confdefs.h.  */
3504
3505 int
3506 main ()
3507 {
3508 #ifndef __GNUC__
3509        choke me
3510 #endif
3511
3512   ;
3513   return 0;
3514 }
3515 _ACEOF
3516 rm -f conftest.$ac_objext
3517 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3518   (eval $ac_compile) 2>conftest.er1
3519   ac_status=$?
3520   grep -v '^ *+' conftest.er1 >conftest.err
3521   rm -f conftest.er1
3522   cat conftest.err >&5
3523   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3524   (exit $ac_status); } &&
3525          { ac_try='test -z "$ac_c_werror_flag"
3526                          || test ! -s conftest.err'
3527   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3528   (eval $ac_try) 2>&5
3529   ac_status=$?
3530   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3531   (exit $ac_status); }; } &&
3532          { ac_try='test -s conftest.$ac_objext'
3533   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3534   (eval $ac_try) 2>&5
3535   ac_status=$?
3536   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3537   (exit $ac_status); }; }; then
3538   ac_compiler_gnu=yes
3539 else
3540   echo "$as_me: failed program was:" >&5
3541 sed 's/^/| /' conftest.$ac_ext >&5
3542
3543 ac_compiler_gnu=no
3544 fi
3545 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3546 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3547
3548 fi
3549 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3550 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3551 GCC=`test $ac_compiler_gnu = yes && echo yes`
3552 ac_test_CFLAGS=${CFLAGS+set}
3553 ac_save_CFLAGS=$CFLAGS
3554 CFLAGS="-g"
3555 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3556 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3557 if test "${ac_cv_prog_cc_g+set}" = set; then
3558   echo $ECHO_N "(cached) $ECHO_C" >&6
3559 else
3560   cat >conftest.$ac_ext <<_ACEOF
3561 /* confdefs.h.  */
3562 _ACEOF
3563 cat confdefs.h >>conftest.$ac_ext
3564 cat >>conftest.$ac_ext <<_ACEOF
3565 /* end confdefs.h.  */
3566
3567 int
3568 main ()
3569 {
3570
3571   ;
3572   return 0;
3573 }
3574 _ACEOF
3575 rm -f conftest.$ac_objext
3576 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3577   (eval $ac_compile) 2>conftest.er1
3578   ac_status=$?
3579   grep -v '^ *+' conftest.er1 >conftest.err
3580   rm -f conftest.er1
3581   cat conftest.err >&5
3582   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3583   (exit $ac_status); } &&
3584          { ac_try='test -z "$ac_c_werror_flag"
3585                          || test ! -s conftest.err'
3586   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3587   (eval $ac_try) 2>&5
3588   ac_status=$?
3589   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3590   (exit $ac_status); }; } &&
3591          { ac_try='test -s conftest.$ac_objext'
3592   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3593   (eval $ac_try) 2>&5
3594   ac_status=$?
3595   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3596   (exit $ac_status); }; }; then
3597   ac_cv_prog_cc_g=yes
3598 else
3599   echo "$as_me: failed program was:" >&5
3600 sed 's/^/| /' conftest.$ac_ext >&5
3601
3602 ac_cv_prog_cc_g=no
3603 fi
3604 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3605 fi
3606 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3607 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3608 if test "$ac_test_CFLAGS" = set; then
3609   CFLAGS=$ac_save_CFLAGS
3610 elif test $ac_cv_prog_cc_g = yes; then
3611   if test "$GCC" = yes; then
3612     CFLAGS="-g -O2"
3613   else
3614     CFLAGS="-g"
3615   fi
3616 else
3617   if test "$GCC" = yes; then
3618     CFLAGS="-O2"
3619   else
3620     CFLAGS=
3621   fi
3622 fi
3623 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3624 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3625 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3626   echo $ECHO_N "(cached) $ECHO_C" >&6
3627 else
3628   ac_cv_prog_cc_stdc=no
3629 ac_save_CC=$CC
3630 cat >conftest.$ac_ext <<_ACEOF
3631 /* confdefs.h.  */
3632 _ACEOF
3633 cat confdefs.h >>conftest.$ac_ext
3634 cat >>conftest.$ac_ext <<_ACEOF
3635 /* end confdefs.h.  */
3636 #include <stdarg.h>
3637 #include <stdio.h>
3638 #include <sys/types.h>
3639 #include <sys/stat.h>
3640 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3641 struct buf { int x; };
3642 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3643 static char *e (p, i)
3644      char **p;
3645      int i;
3646 {
3647   return p[i];
3648 }
3649 static char *f (char * (*g) (char **, int), char **p, ...)
3650 {
3651   char *s;
3652   va_list v;
3653   va_start (v,p);
3654   s = g (p, va_arg (v,int));
3655   va_end (v);
3656   return s;
3657 }
3658
3659 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3660    function prototypes and stuff, but not '\xHH' hex character constants.
3661    These don't provoke an error unfortunately, instead are silently treated
3662    as 'x'.  The following induces an error, until -std1 is added to get
3663    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3664    array size at least.  It's necessary to write '\x00'==0 to get something
3665    that's true only with -std1.  */
3666 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3667
3668 int test (int i, double x);
3669 struct s1 {int (*f) (int a);};
3670 struct s2 {int (*f) (double a);};
3671 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3672 int argc;
3673 char **argv;
3674 int
3675 main ()
3676 {
3677 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3678   ;
3679   return 0;
3680 }
3681 _ACEOF
3682 # Don't try gcc -ansi; that turns off useful extensions and
3683 # breaks some systems' header files.
3684 # AIX                   -qlanglvl=ansi
3685 # Ultrix and OSF/1      -std1
3686 # HP-UX 10.20 and later -Ae
3687 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3688 # SVR4                  -Xc -D__EXTENSIONS__
3689 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3690 do
3691   CC="$ac_save_CC $ac_arg"
3692   rm -f conftest.$ac_objext
3693 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3694   (eval $ac_compile) 2>conftest.er1
3695   ac_status=$?
3696   grep -v '^ *+' conftest.er1 >conftest.err
3697   rm -f conftest.er1
3698   cat conftest.err >&5
3699   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3700   (exit $ac_status); } &&
3701          { ac_try='test -z "$ac_c_werror_flag"
3702                          || test ! -s conftest.err'
3703   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3704   (eval $ac_try) 2>&5
3705   ac_status=$?
3706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3707   (exit $ac_status); }; } &&
3708          { ac_try='test -s conftest.$ac_objext'
3709   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3710   (eval $ac_try) 2>&5
3711   ac_status=$?
3712   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3713   (exit $ac_status); }; }; then
3714   ac_cv_prog_cc_stdc=$ac_arg
3715 break
3716 else
3717   echo "$as_me: failed program was:" >&5
3718 sed 's/^/| /' conftest.$ac_ext >&5
3719
3720 fi
3721 rm -f conftest.err conftest.$ac_objext
3722 done
3723 rm -f conftest.$ac_ext conftest.$ac_objext
3724 CC=$ac_save_CC
3725
3726 fi
3727
3728 case "x$ac_cv_prog_cc_stdc" in
3729   x|xno)
3730     echo "$as_me:$LINENO: result: none needed" >&5
3731 echo "${ECHO_T}none needed" >&6 ;;
3732   *)
3733     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3734 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3735     CC="$CC $ac_cv_prog_cc_stdc" ;;
3736 esac
3737
3738 # Some people use a C++ compiler to compile C.  Since we use `exit',
3739 # in C++ we need to declare it.  In case someone uses the same compiler
3740 # for both compiling C and C++ we need to have the C++ compiler decide
3741 # the declaration of exit, since it's the most demanding environment.
3742 cat >conftest.$ac_ext <<_ACEOF
3743 #ifndef __cplusplus
3744   choke me
3745 #endif
3746 _ACEOF
3747 rm -f conftest.$ac_objext
3748 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3749   (eval $ac_compile) 2>conftest.er1
3750   ac_status=$?
3751   grep -v '^ *+' conftest.er1 >conftest.err
3752   rm -f conftest.er1
3753   cat conftest.err >&5
3754   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3755   (exit $ac_status); } &&
3756          { ac_try='test -z "$ac_c_werror_flag"
3757                          || test ! -s conftest.err'
3758   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3759   (eval $ac_try) 2>&5
3760   ac_status=$?
3761   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3762   (exit $ac_status); }; } &&
3763          { ac_try='test -s conftest.$ac_objext'
3764   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3765   (eval $ac_try) 2>&5
3766   ac_status=$?
3767   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3768   (exit $ac_status); }; }; then
3769   for ac_declaration in \
3770    '' \
3771    'extern "C" void std::exit (int) throw (); using std::exit;' \
3772    'extern "C" void std::exit (int); using std::exit;' \
3773    'extern "C" void exit (int) throw ();' \
3774    'extern "C" void exit (int);' \
3775    'void exit (int);'
3776 do
3777   cat >conftest.$ac_ext <<_ACEOF
3778 /* confdefs.h.  */
3779 _ACEOF
3780 cat confdefs.h >>conftest.$ac_ext
3781 cat >>conftest.$ac_ext <<_ACEOF
3782 /* end confdefs.h.  */
3783 $ac_declaration
3784 #include <stdlib.h>
3785 int
3786 main ()
3787 {
3788 exit (42);
3789   ;
3790   return 0;
3791 }
3792 _ACEOF
3793 rm -f conftest.$ac_objext
3794 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3795   (eval $ac_compile) 2>conftest.er1
3796   ac_status=$?
3797   grep -v '^ *+' conftest.er1 >conftest.err
3798   rm -f conftest.er1
3799   cat conftest.err >&5
3800   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3801   (exit $ac_status); } &&
3802          { ac_try='test -z "$ac_c_werror_flag"
3803                          || test ! -s conftest.err'
3804   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3805   (eval $ac_try) 2>&5
3806   ac_status=$?
3807   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3808   (exit $ac_status); }; } &&
3809          { ac_try='test -s conftest.$ac_objext'
3810   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3811   (eval $ac_try) 2>&5
3812   ac_status=$?
3813   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3814   (exit $ac_status); }; }; then
3815   :
3816 else
3817   echo "$as_me: failed program was:" >&5
3818 sed 's/^/| /' conftest.$ac_ext >&5
3819
3820 continue
3821 fi
3822 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3823   cat >conftest.$ac_ext <<_ACEOF
3824 /* confdefs.h.  */
3825 _ACEOF
3826 cat confdefs.h >>conftest.$ac_ext
3827 cat >>conftest.$ac_ext <<_ACEOF
3828 /* end confdefs.h.  */
3829 $ac_declaration
3830 int
3831 main ()
3832 {
3833 exit (42);
3834   ;
3835   return 0;
3836 }
3837 _ACEOF
3838 rm -f conftest.$ac_objext
3839 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3840   (eval $ac_compile) 2>conftest.er1
3841   ac_status=$?
3842   grep -v '^ *+' conftest.er1 >conftest.err
3843   rm -f conftest.er1
3844   cat conftest.err >&5
3845   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3846   (exit $ac_status); } &&
3847          { ac_try='test -z "$ac_c_werror_flag"
3848                          || test ! -s conftest.err'
3849   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3850   (eval $ac_try) 2>&5
3851   ac_status=$?
3852   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3853   (exit $ac_status); }; } &&
3854          { ac_try='test -s conftest.$ac_objext'
3855   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3856   (eval $ac_try) 2>&5
3857   ac_status=$?
3858   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3859   (exit $ac_status); }; }; then
3860   break
3861 else
3862   echo "$as_me: failed program was:" >&5
3863 sed 's/^/| /' conftest.$ac_ext >&5
3864
3865 fi
3866 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3867 done
3868 rm -f conftest*
3869 if test -n "$ac_declaration"; then
3870   echo '#ifdef __cplusplus' >>confdefs.h
3871   echo $ac_declaration      >>confdefs.h
3872   echo '#endif'             >>confdefs.h
3873 fi
3874
3875 else
3876   echo "$as_me: failed program was:" >&5
3877 sed 's/^/| /' conftest.$ac_ext >&5
3878
3879 fi
3880 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3881 ac_ext=c
3882 ac_cpp='$CPP $CPPFLAGS'
3883 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3884 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3885 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3886
3887 ac_ext=cc
3888 ac_cpp='$CXXCPP $CPPFLAGS'
3889 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3890 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3891 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3892 if test -n "$ac_tool_prefix"; then
3893   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3894   do
3895     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3896 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3897 echo "$as_me:$LINENO: checking for $ac_word" >&5
3898 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3899 if test "${ac_cv_prog_CXX+set}" = set; then
3900   echo $ECHO_N "(cached) $ECHO_C" >&6
3901 else
3902   if test -n "$CXX"; then
3903   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3904 else
3905 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3906 for as_dir in $PATH
3907 do
3908   IFS=$as_save_IFS
3909   test -z "$as_dir" && as_dir=.
3910   for ac_exec_ext in '' $ac_executable_extensions; do
3911   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3912     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3913     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3914     break 2
3915   fi
3916 done
3917 done
3918
3919 fi
3920 fi
3921 CXX=$ac_cv_prog_CXX
3922 if test -n "$CXX"; then
3923   echo "$as_me:$LINENO: result: $CXX" >&5
3924 echo "${ECHO_T}$CXX" >&6
3925 else
3926   echo "$as_me:$LINENO: result: no" >&5
3927 echo "${ECHO_T}no" >&6
3928 fi
3929
3930     test -n "$CXX" && break
3931   done
3932 fi
3933 if test -z "$CXX"; then
3934   ac_ct_CXX=$CXX
3935   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3936 do
3937   # Extract the first word of "$ac_prog", so it can be a program name with args.
3938 set dummy $ac_prog; ac_word=$2
3939 echo "$as_me:$LINENO: checking for $ac_word" >&5
3940 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3941 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3942   echo $ECHO_N "(cached) $ECHO_C" >&6
3943 else
3944   if test -n "$ac_ct_CXX"; then
3945   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3946 else
3947 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3948 for as_dir in $PATH
3949 do
3950   IFS=$as_save_IFS
3951   test -z "$as_dir" && as_dir=.
3952   for ac_exec_ext in '' $ac_executable_extensions; do
3953   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3954     ac_cv_prog_ac_ct_CXX="$ac_prog"
3955     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3956     break 2
3957   fi
3958 done
3959 done
3960
3961 fi
3962 fi
3963 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3964 if test -n "$ac_ct_CXX"; then
3965   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3966 echo "${ECHO_T}$ac_ct_CXX" >&6
3967 else
3968   echo "$as_me:$LINENO: result: no" >&5
3969 echo "${ECHO_T}no" >&6
3970 fi
3971
3972   test -n "$ac_ct_CXX" && break
3973 done
3974 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3975
3976   CXX=$ac_ct_CXX
3977 fi
3978
3979
3980 # Provide some information about the compiler.
3981 echo "$as_me:$LINENO:" \
3982      "checking for C++ compiler version" >&5
3983 ac_compiler=`set X $ac_compile; echo $2`
3984 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3985   (eval $ac_compiler --version </dev/null >&5) 2>&5
3986   ac_status=$?
3987   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3988   (exit $ac_status); }
3989 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3990   (eval $ac_compiler -v </dev/null >&5) 2>&5
3991   ac_status=$?
3992   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3993   (exit $ac_status); }
3994 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3995   (eval $ac_compiler -V </dev/null >&5) 2>&5
3996   ac_status=$?
3997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3998   (exit $ac_status); }
3999
4000 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4001 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4002 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4003   echo $ECHO_N "(cached) $ECHO_C" >&6
4004 else
4005   cat >conftest.$ac_ext <<_ACEOF
4006 /* confdefs.h.  */
4007 _ACEOF
4008 cat confdefs.h >>conftest.$ac_ext
4009 cat >>conftest.$ac_ext <<_ACEOF
4010 /* end confdefs.h.  */
4011
4012 int
4013 main ()
4014 {
4015 #ifndef __GNUC__
4016        choke me
4017 #endif
4018
4019   ;
4020   return 0;
4021 }
4022 _ACEOF
4023 rm -f conftest.$ac_objext
4024 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4025   (eval $ac_compile) 2>conftest.er1
4026   ac_status=$?
4027   grep -v '^ *+' conftest.er1 >conftest.err
4028   rm -f conftest.er1
4029   cat conftest.err >&5
4030   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4031   (exit $ac_status); } &&
4032          { ac_try='test -z "$ac_cxx_werror_flag"
4033                          || test ! -s conftest.err'
4034   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4035   (eval $ac_try) 2>&5
4036   ac_status=$?
4037   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4038   (exit $ac_status); }; } &&
4039          { ac_try='test -s conftest.$ac_objext'
4040   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4041   (eval $ac_try) 2>&5
4042   ac_status=$?
4043   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4044   (exit $ac_status); }; }; then
4045   ac_compiler_gnu=yes
4046 else
4047   echo "$as_me: failed program was:" >&5
4048 sed 's/^/| /' conftest.$ac_ext >&5
4049
4050 ac_compiler_gnu=no
4051 fi
4052 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4053 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4054
4055 fi
4056 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4057 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4058 GXX=`test $ac_compiler_gnu = yes && echo yes`
4059 ac_test_CXXFLAGS=${CXXFLAGS+set}
4060 ac_save_CXXFLAGS=$CXXFLAGS
4061 CXXFLAGS="-g"
4062 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4063 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4064 if test "${ac_cv_prog_cxx_g+set}" = set; then
4065   echo $ECHO_N "(cached) $ECHO_C" >&6
4066 else
4067   cat >conftest.$ac_ext <<_ACEOF
4068 /* confdefs.h.  */
4069 _ACEOF
4070 cat confdefs.h >>conftest.$ac_ext
4071 cat >>conftest.$ac_ext <<_ACEOF
4072 /* end confdefs.h.  */
4073
4074 int
4075 main ()
4076 {
4077
4078   ;
4079   return 0;
4080 }
4081 _ACEOF
4082 rm -f conftest.$ac_objext
4083 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4084   (eval $ac_compile) 2>conftest.er1
4085   ac_status=$?
4086   grep -v '^ *+' conftest.er1 >conftest.err
4087   rm -f conftest.er1
4088   cat conftest.err >&5
4089   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4090   (exit $ac_status); } &&
4091          { ac_try='test -z "$ac_cxx_werror_flag"
4092                          || test ! -s conftest.err'
4093   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4094   (eval $ac_try) 2>&5
4095   ac_status=$?
4096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4097   (exit $ac_status); }; } &&
4098          { ac_try='test -s conftest.$ac_objext'
4099   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4100   (eval $ac_try) 2>&5
4101   ac_status=$?
4102   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4103   (exit $ac_status); }; }; then
4104   ac_cv_prog_cxx_g=yes
4105 else
4106   echo "$as_me: failed program was:" >&5
4107 sed 's/^/| /' conftest.$ac_ext >&5
4108
4109 ac_cv_prog_cxx_g=no
4110 fi
4111 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4112 fi
4113 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4114 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4115 if test "$ac_test_CXXFLAGS" = set; then
4116   CXXFLAGS=$ac_save_CXXFLAGS
4117 elif test $ac_cv_prog_cxx_g = yes; then
4118   if test "$GXX" = yes; then
4119     CXXFLAGS="-g -O2"
4120   else
4121     CXXFLAGS="-g"
4122   fi
4123 else
4124   if test "$GXX" = yes; then
4125     CXXFLAGS="-O2"
4126   else
4127     CXXFLAGS=
4128   fi
4129 fi
4130 for ac_declaration in \
4131    '' \
4132    'extern "C" void std::exit (int) throw (); using std::exit;' \
4133    'extern "C" void std::exit (int); using std::exit;' \
4134    'extern "C" void exit (int) throw ();' \
4135    'extern "C" void exit (int);' \
4136    'void exit (int);'
4137 do
4138   cat >conftest.$ac_ext <<_ACEOF
4139 /* confdefs.h.  */
4140 _ACEOF
4141 cat confdefs.h >>conftest.$ac_ext
4142 cat >>conftest.$ac_ext <<_ACEOF
4143 /* end confdefs.h.  */
4144 $ac_declaration
4145 #include <stdlib.h>
4146 int
4147 main ()
4148 {
4149 exit (42);
4150   ;
4151   return 0;
4152 }
4153 _ACEOF
4154 rm -f conftest.$ac_objext
4155 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4156   (eval $ac_compile) 2>conftest.er1
4157   ac_status=$?
4158   grep -v '^ *+' conftest.er1 >conftest.err
4159   rm -f conftest.er1
4160   cat conftest.err >&5
4161   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4162   (exit $ac_status); } &&
4163          { ac_try='test -z "$ac_cxx_werror_flag"
4164                          || test ! -s conftest.err'
4165   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4166   (eval $ac_try) 2>&5
4167   ac_status=$?
4168   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4169   (exit $ac_status); }; } &&
4170          { ac_try='test -s conftest.$ac_objext'
4171   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4172   (eval $ac_try) 2>&5
4173   ac_status=$?
4174   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4175   (exit $ac_status); }; }; then
4176   :
4177 else
4178   echo "$as_me: failed program was:" >&5
4179 sed 's/^/| /' conftest.$ac_ext >&5
4180
4181 continue
4182 fi
4183 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4184   cat >conftest.$ac_ext <<_ACEOF
4185 /* confdefs.h.  */
4186 _ACEOF
4187 cat confdefs.h >>conftest.$ac_ext
4188 cat >>conftest.$ac_ext <<_ACEOF
4189 /* end confdefs.h.  */
4190 $ac_declaration
4191 int
4192 main ()
4193 {
4194 exit (42);
4195   ;
4196   return 0;
4197 }
4198 _ACEOF
4199 rm -f conftest.$ac_objext
4200 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4201   (eval $ac_compile) 2>conftest.er1
4202   ac_status=$?
4203   grep -v '^ *+' conftest.er1 >conftest.err
4204   rm -f conftest.er1
4205   cat conftest.err >&5
4206   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4207   (exit $ac_status); } &&
4208          { ac_try='test -z "$ac_cxx_werror_flag"
4209                          || test ! -s conftest.err'
4210   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4211   (eval $ac_try) 2>&5
4212   ac_status=$?
4213   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4214   (exit $ac_status); }; } &&
4215          { ac_try='test -s conftest.$ac_objext'
4216   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4217   (eval $ac_try) 2>&5
4218   ac_status=$?
4219   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4220   (exit $ac_status); }; }; then
4221   break
4222 else
4223   echo "$as_me: failed program was:" >&5
4224 sed 's/^/| /' conftest.$ac_ext >&5
4225
4226 fi
4227 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4228 done
4229 rm -f conftest*
4230 if test -n "$ac_declaration"; then
4231   echo '#ifdef __cplusplus' >>confdefs.h
4232   echo $ac_declaration      >>confdefs.h
4233   echo '#endif'             >>confdefs.h
4234 fi
4235
4236 ac_ext=c
4237 ac_cpp='$CPP $CPPFLAGS'
4238 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4239 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4240 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4241
4242
4243 # We must set the default linker to the linker used by gcc for the correct
4244 # operation of libtool.  If LD is not defined and we are using gcc, try to
4245 # set the LD default to the ld used by gcc.
4246 if test -z "$LD"; then
4247   if test "$GCC" = yes; then
4248     case $build in
4249     *-*-mingw*)
4250       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4251     *)
4252       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4253     esac
4254     case $gcc_prog_ld in
4255     # Accept absolute paths.
4256     [\\/]* | [A-Za-z]:[\\/]*)
4257       LD="$gcc_prog_ld" ;;
4258     esac
4259   fi
4260 fi
4261
4262
4263
4264
4265 if test -n "$ac_tool_prefix"; then
4266   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4267 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4268 echo "$as_me:$LINENO: checking for $ac_word" >&5
4269 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4270 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4271   echo $ECHO_N "(cached) $ECHO_C" >&6
4272 else
4273   if test -n "$GNATBIND"; then
4274   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4275 else
4276 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4277 for as_dir in $PATH
4278 do
4279   IFS=$as_save_IFS
4280   test -z "$as_dir" && as_dir=.
4281   for ac_exec_ext in '' $ac_executable_extensions; do
4282   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4283     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4284     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4285     break 2
4286   fi
4287 done
4288 done
4289
4290 fi
4291 fi
4292 GNATBIND=$ac_cv_prog_GNATBIND
4293 if test -n "$GNATBIND"; then
4294   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4295 echo "${ECHO_T}$GNATBIND" >&6
4296 else
4297   echo "$as_me:$LINENO: result: no" >&5
4298 echo "${ECHO_T}no" >&6
4299 fi
4300
4301 fi
4302 if test -z "$ac_cv_prog_GNATBIND"; then
4303   ac_ct_GNATBIND=$GNATBIND
4304   # Extract the first word of "gnatbind", so it can be a program name with args.
4305 set dummy gnatbind; ac_word=$2
4306 echo "$as_me:$LINENO: checking for $ac_word" >&5
4307 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4308 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4309   echo $ECHO_N "(cached) $ECHO_C" >&6
4310 else
4311   if test -n "$ac_ct_GNATBIND"; then
4312   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4313 else
4314 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4315 for as_dir in $PATH
4316 do
4317   IFS=$as_save_IFS
4318   test -z "$as_dir" && as_dir=.
4319   for ac_exec_ext in '' $ac_executable_extensions; do
4320   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4321     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4322     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4323     break 2
4324   fi
4325 done
4326 done
4327
4328   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4329 fi
4330 fi
4331 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4332 if test -n "$ac_ct_GNATBIND"; then
4333   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4334 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4335 else
4336   echo "$as_me:$LINENO: result: no" >&5
4337 echo "${ECHO_T}no" >&6
4338 fi
4339
4340   GNATBIND=$ac_ct_GNATBIND
4341 else
4342   GNATBIND="$ac_cv_prog_GNATBIND"
4343 fi
4344
4345 if test -n "$ac_tool_prefix"; then
4346   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4347 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4348 echo "$as_me:$LINENO: checking for $ac_word" >&5
4349 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4350 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4351   echo $ECHO_N "(cached) $ECHO_C" >&6
4352 else
4353   if test -n "$GNATMAKE"; then
4354   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4355 else
4356 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4357 for as_dir in $PATH
4358 do
4359   IFS=$as_save_IFS
4360   test -z "$as_dir" && as_dir=.
4361   for ac_exec_ext in '' $ac_executable_extensions; do
4362   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4363     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4364     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4365     break 2
4366   fi
4367 done
4368 done
4369
4370 fi
4371 fi
4372 GNATMAKE=$ac_cv_prog_GNATMAKE
4373 if test -n "$GNATMAKE"; then
4374   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4375 echo "${ECHO_T}$GNATMAKE" >&6
4376 else
4377   echo "$as_me:$LINENO: result: no" >&5
4378 echo "${ECHO_T}no" >&6
4379 fi
4380
4381 fi
4382 if test -z "$ac_cv_prog_GNATMAKE"; then
4383   ac_ct_GNATMAKE=$GNATMAKE
4384   # Extract the first word of "gnatmake", so it can be a program name with args.
4385 set dummy gnatmake; ac_word=$2
4386 echo "$as_me:$LINENO: checking for $ac_word" >&5
4387 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4388 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4389   echo $ECHO_N "(cached) $ECHO_C" >&6
4390 else
4391   if test -n "$ac_ct_GNATMAKE"; then
4392   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4393 else
4394 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4395 for as_dir in $PATH
4396 do
4397   IFS=$as_save_IFS
4398   test -z "$as_dir" && as_dir=.
4399   for ac_exec_ext in '' $ac_executable_extensions; do
4400   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4401     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4402     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4403     break 2
4404   fi
4405 done
4406 done
4407
4408   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4409 fi
4410 fi
4411 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4412 if test -n "$ac_ct_GNATMAKE"; then
4413   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4414 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4415 else
4416   echo "$as_me:$LINENO: result: no" >&5
4417 echo "${ECHO_T}no" >&6
4418 fi
4419
4420   GNATMAKE=$ac_ct_GNATMAKE
4421 else
4422   GNATMAKE="$ac_cv_prog_GNATMAKE"
4423 fi
4424
4425 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4426 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4427 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4428   echo $ECHO_N "(cached) $ECHO_C" >&6
4429 else
4430   cat >conftest.adb <<EOF
4431 procedure conftest is begin null; end conftest;
4432 EOF
4433 acx_cv_cc_gcc_supports_ada=no
4434 # There is a bug in old released versions of GCC which causes the
4435 # driver to exit successfully when the appropriate language module
4436 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4437 # Therefore we must check for the error message as well as an
4438 # unsuccessful exit.
4439 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4440 # given a .adb file, but produce no object file.  So we must check
4441 # if an object file was really produced to guard against this.
4442 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4443 if test x"$errors" = x && test -f conftest.$ac_objext; then
4444   acx_cv_cc_gcc_supports_ada=yes
4445 fi
4446 rm -f conftest.*
4447 fi
4448 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4449 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4450
4451 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4452   have_gnat=yes
4453 else
4454   have_gnat=no
4455 fi
4456
4457 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4458 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4459 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4460   echo $ECHO_N "(cached) $ECHO_C" >&6
4461 else
4462    echo abfoo >t1
4463   echo cdfoo >t2
4464   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4465   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4466     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4467       :
4468     else
4469       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4470     fi
4471   fi
4472   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4473     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4474       :
4475     else
4476       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4477     fi
4478   fi
4479   rm t1 t2
4480
4481 fi
4482 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4483 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4484 do_compare="$gcc_cv_prog_cmp_skip"
4485
4486
4487
4488 # Check for GMP and MPFR
4489 gmplibs="-lmpfr -lgmp"
4490 gmpinc=
4491 have_gmp=no
4492
4493 # Specify a location for mpfr
4494 # check for this first so it ends up on the link line before gmp.
4495
4496 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4497 if test "${with_mpfr_dir+set}" = set; then
4498   withval="$with_mpfr_dir"
4499   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4500 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4501 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4502 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4503    { (exit 1); exit 1; }; }
4504 fi;
4505
4506
4507 # Check whether --with-mpfr or --without-mpfr was given.
4508 if test "${with_mpfr+set}" = set; then
4509   withval="$with_mpfr"
4510
4511 fi;
4512
4513 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4514 if test "${with_mpfr_include+set}" = set; then
4515   withval="$with_mpfr_include"
4516
4517 fi;
4518
4519 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4520 if test "${with_mpfr_lib+set}" = set; then
4521   withval="$with_mpfr_lib"
4522
4523 fi;
4524
4525 if test "x$with_mpfr" != x; then
4526   gmplibs="-L$with_mpfr/lib $gmplibs"
4527   gmpinc="-I$with_mpfr/include"
4528 fi
4529 if test "x$with_mpfr_include" != x; then
4530   gmpinc="-I$with_mpfr_include"
4531 fi
4532 if test "x$with_mpfr_lib" != x; then
4533   gmplibs="-L$with_mpfr_lib $gmplibs"
4534 fi
4535 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4536   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4537   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4538   # Do not test the mpfr version.  Assume that it is sufficient, since
4539   # it is in the source tree, and the library has not been built yet
4540   # but it would be included on the link line in the version check below
4541   # hence making the test fail.
4542   have_gmp=yes
4543 fi
4544
4545 # Specify a location for gmp
4546
4547 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4548 if test "${with_gmp_dir+set}" = set; then
4549   withval="$with_gmp_dir"
4550   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4551 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4552 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4553 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4554    { (exit 1); exit 1; }; }
4555 fi;
4556
4557
4558 # Check whether --with-gmp or --without-gmp was given.
4559 if test "${with_gmp+set}" = set; then
4560   withval="$with_gmp"
4561
4562 fi;
4563
4564 # Check whether --with-gmp_include or --without-gmp_include was given.
4565 if test "${with_gmp_include+set}" = set; then
4566   withval="$with_gmp_include"
4567
4568 fi;
4569
4570 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4571 if test "${with_gmp_lib+set}" = set; then
4572   withval="$with_gmp_lib"
4573
4574 fi;
4575
4576
4577 if test "x$with_gmp" != x; then
4578   gmplibs="-L$with_gmp/lib $gmplibs"
4579   gmpinc="-I$with_gmp/include $gmpinc"
4580 fi
4581 if test "x$with_gmp_include" != x; then
4582   gmpinc="-I$with_gmp_include $gmpinc"
4583 fi
4584 if test "x$with_gmp_lib" != x; then
4585   gmplibs="-L$with_gmp_lib $gmplibs"
4586 fi
4587 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4588   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4589   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4590   # Do not test the gmp version.  Assume that it is sufficient, since
4591   # it is in the source tree, and the library has not been built yet
4592   # but it would be included on the link line in the version check below
4593   # hence making the test fail.
4594   have_gmp=yes
4595 fi
4596
4597 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4598   have_gmp=yes
4599   saved_CFLAGS="$CFLAGS"
4600   CFLAGS="$CFLAGS $gmpinc"
4601   # Check GMP actually works
4602   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4603 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4604
4605 cat >conftest.$ac_ext <<_ACEOF
4606 /* confdefs.h.  */
4607 _ACEOF
4608 cat confdefs.h >>conftest.$ac_ext
4609 cat >>conftest.$ac_ext <<_ACEOF
4610 /* end confdefs.h.  */
4611 #include "gmp.h"
4612 int
4613 main ()
4614 {
4615
4616   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4617   choke me
4618   #endif
4619
4620   ;
4621   return 0;
4622 }
4623 _ACEOF
4624 rm -f conftest.$ac_objext
4625 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4626   (eval $ac_compile) 2>conftest.er1
4627   ac_status=$?
4628   grep -v '^ *+' conftest.er1 >conftest.err
4629   rm -f conftest.er1
4630   cat conftest.err >&5
4631   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4632   (exit $ac_status); } &&
4633          { ac_try='test -z "$ac_c_werror_flag"
4634                          || test ! -s conftest.err'
4635   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4636   (eval $ac_try) 2>&5
4637   ac_status=$?
4638   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4639   (exit $ac_status); }; } &&
4640          { ac_try='test -s conftest.$ac_objext'
4641   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4642   (eval $ac_try) 2>&5
4643   ac_status=$?
4644   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4645   (exit $ac_status); }; }; then
4646   echo "$as_me:$LINENO: result: yes" >&5
4647 echo "${ECHO_T}yes" >&6
4648 else
4649   echo "$as_me: failed program was:" >&5
4650 sed 's/^/| /' conftest.$ac_ext >&5
4651
4652 echo "$as_me:$LINENO: result: no" >&5
4653 echo "${ECHO_T}no" >&6; have_gmp=no
4654 fi
4655 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4656
4657   if test x"$have_gmp" = xyes; then
4658     saved_LIBS="$LIBS"
4659     LIBS="$LIBS $gmplibs"
4660         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4661 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4662     cat >conftest.$ac_ext <<_ACEOF
4663 /* confdefs.h.  */
4664 _ACEOF
4665 cat confdefs.h >>conftest.$ac_ext
4666 cat >>conftest.$ac_ext <<_ACEOF
4667 /* end confdefs.h.  */
4668 #include <gmp.h>
4669     #include <mpfr.h>
4670 int
4671 main ()
4672 {
4673
4674     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4675     choke me
4676     #endif
4677     mpfr_t n;
4678     mpfr_t x;
4679     int t;
4680     mpfr_init (n);
4681     mpfr_init (x);
4682     mpfr_atan2 (n, n, x, GMP_RNDN);
4683     mpfr_erfc (n, x, GMP_RNDN);
4684     mpfr_subnormalize (x, t, GMP_RNDN);
4685
4686   ;
4687   return 0;
4688 }
4689 _ACEOF
4690 rm -f conftest.$ac_objext conftest$ac_exeext
4691 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4692   (eval $ac_link) 2>conftest.er1
4693   ac_status=$?
4694   grep -v '^ *+' conftest.er1 >conftest.err
4695   rm -f conftest.er1
4696   cat conftest.err >&5
4697   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4698   (exit $ac_status); } &&
4699          { ac_try='test -z "$ac_c_werror_flag"
4700                          || test ! -s conftest.err'
4701   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4702   (eval $ac_try) 2>&5
4703   ac_status=$?
4704   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4705   (exit $ac_status); }; } &&
4706          { ac_try='test -s conftest$ac_exeext'
4707   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4708   (eval $ac_try) 2>&5
4709   ac_status=$?
4710   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4711   (exit $ac_status); }; }; then
4712   cat >conftest.$ac_ext <<_ACEOF
4713 /* confdefs.h.  */
4714 _ACEOF
4715 cat confdefs.h >>conftest.$ac_ext
4716 cat >>conftest.$ac_ext <<_ACEOF
4717 /* end confdefs.h.  */
4718 #include <gmp.h>
4719     #include <mpfr.h>
4720 int
4721 main ()
4722 {
4723
4724     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,2)
4725     choke me
4726     #endif
4727     mpfr_t n; mpfr_init(n);
4728
4729   ;
4730   return 0;
4731 }
4732 _ACEOF
4733 rm -f conftest.$ac_objext conftest$ac_exeext
4734 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4735   (eval $ac_link) 2>conftest.er1
4736   ac_status=$?
4737   grep -v '^ *+' conftest.er1 >conftest.err
4738   rm -f conftest.er1
4739   cat conftest.err >&5
4740   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4741   (exit $ac_status); } &&
4742          { ac_try='test -z "$ac_c_werror_flag"
4743                          || test ! -s conftest.err'
4744   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4745   (eval $ac_try) 2>&5
4746   ac_status=$?
4747   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4748   (exit $ac_status); }; } &&
4749          { ac_try='test -s conftest$ac_exeext'
4750   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4751   (eval $ac_try) 2>&5
4752   ac_status=$?
4753   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4754   (exit $ac_status); }; }; then
4755   echo "$as_me:$LINENO: result: yes" >&5
4756 echo "${ECHO_T}yes" >&6
4757 else
4758   echo "$as_me: failed program was:" >&5
4759 sed 's/^/| /' conftest.$ac_ext >&5
4760
4761 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4762 echo "${ECHO_T}buggy but acceptable" >&6
4763 fi
4764 rm -f conftest.err conftest.$ac_objext \
4765       conftest$ac_exeext conftest.$ac_ext
4766 else
4767   echo "$as_me: failed program was:" >&5
4768 sed 's/^/| /' conftest.$ac_ext >&5
4769
4770 echo "$as_me:$LINENO: result: no" >&5
4771 echo "${ECHO_T}no" >&6; have_gmp=no
4772 fi
4773 rm -f conftest.err conftest.$ac_objext \
4774       conftest$ac_exeext conftest.$ac_ext
4775       LIBS="$saved_LIBS"
4776   fi
4777   CFLAGS="$saved_CFLAGS"
4778
4779   if test x$have_gmp != xyes; then
4780     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.2+.
4781 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4782 Copies of these libraries' source code can be found at their respective
4783 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4784 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4785 If you obtained GMP and/or MPFR from a vendor distribution package, make
4786 sure that you have installed both the libraries and the header files.
4787 They may be located in separate packages." >&5
4788 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.2+.
4789 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4790 Copies of these libraries' source code can be found at their respective
4791 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4792 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4793 If you obtained GMP and/or MPFR from a vendor distribution package, make
4794 sure that you have installed both the libraries and the header files.
4795 They may be located in separate packages." >&2;}
4796    { (exit 1); exit 1; }; }
4797   fi
4798 fi
4799
4800 # Flags needed for both GMP and/or MPFR
4801
4802
4803
4804
4805 # Check for PPL
4806 ppl_major_version=0
4807 ppl_minor_version=10
4808 ppllibs=
4809 pplinc=
4810
4811
4812 # Check whether --with-ppl or --without-ppl was given.
4813 if test "${with_ppl+set}" = set; then
4814   withval="$with_ppl"
4815
4816 fi;
4817
4818 # Check whether --with-ppl_include or --without-ppl_include was given.
4819 if test "${with_ppl_include+set}" = set; then
4820   withval="$with_ppl_include"
4821
4822 fi;
4823
4824 # Check whether --with-ppl_lib or --without-ppl_lib was given.
4825 if test "${with_ppl_lib+set}" = set; then
4826   withval="$with_ppl_lib"
4827
4828 fi;
4829
4830 if test "x$with_ppl" != x; then
4831   ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx"
4832   pplinc="-I$with_ppl/include $pplinc"
4833   LIBS="$ppllibs $LIBS"
4834 fi
4835 if test "x$with_ppl_include" != x; then
4836   pplinc="-I$with_ppl_include $pplinc"
4837 fi
4838 if test "x$with_ppl_lib" != x; then
4839   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx"
4840   LIBS="$ppllibs $LIBS"
4841 fi
4842 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
4843   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '
4844   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
4845   LIBS="$ppllibs $LIBS"
4846 fi
4847
4848 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
4849 if test "${enable_ppl_version_check+set}" = set; then
4850   enableval="$enable_ppl_version_check"
4851   ENABLE_PPL_CHECK=$enableval
4852 else
4853   ENABLE_PPL_CHECK=yes
4854 fi;
4855
4856 if test "${ENABLE_PPL_CHECK}" = "yes"; then
4857   saved_CFLAGS="$CFLAGS"
4858   CFLAGS="$CFLAGS $pplinc $gmpinc"
4859   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
4860 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
4861   cat >conftest.$ac_ext <<_ACEOF
4862 /* confdefs.h.  */
4863 _ACEOF
4864 cat confdefs.h >>conftest.$ac_ext
4865 cat >>conftest.$ac_ext <<_ACEOF
4866 /* end confdefs.h.  */
4867 #include "ppl_c.h"
4868 int
4869 main ()
4870 {
4871
4872   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
4873   choke me
4874   #endif
4875
4876   ;
4877   return 0;
4878 }
4879 _ACEOF
4880 rm -f conftest.$ac_objext
4881 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4882   (eval $ac_compile) 2>conftest.er1
4883   ac_status=$?
4884   grep -v '^ *+' conftest.er1 >conftest.err
4885   rm -f conftest.er1
4886   cat conftest.err >&5
4887   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4888   (exit $ac_status); } &&
4889          { ac_try='test -z "$ac_c_werror_flag"
4890                          || test ! -s conftest.err'
4891   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4892   (eval $ac_try) 2>&5
4893   ac_status=$?
4894   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4895   (exit $ac_status); }; } &&
4896          { ac_try='test -s conftest.$ac_objext'
4897   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4898   (eval $ac_try) 2>&5
4899   ac_status=$?
4900   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4901   (exit $ac_status); }; }; then
4902   echo "$as_me:$LINENO: result: yes" >&5
4903 echo "${ECHO_T}yes" >&6
4904 else
4905   echo "$as_me: failed program was:" >&5
4906 sed 's/^/| /' conftest.$ac_ext >&5
4907
4908 echo "$as_me:$LINENO: result: no" >&5
4909 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
4910 fi
4911 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4912   CFLAGS="$saved_CFLAGS"
4913 fi
4914
4915 # Flags needed for PPL
4916
4917
4918
4919
4920 # Check for CLOOG
4921 clooglibs=" -lcloog "
4922 clooginc=" -DCLOOG_PPL_BACKEND "
4923
4924
4925 # Check whether --with-cloog or --without-cloog was given.
4926 if test "${with_cloog+set}" = set; then
4927   withval="$with_cloog"
4928
4929 fi;
4930
4931 # Check whether --with-cloog_include or --without-cloog_include was given.
4932 if test "${with_cloog_include+set}" = set; then
4933   withval="$with_cloog_include"
4934
4935 fi;
4936
4937 # Check whether --with-cloog_lib or --without-cloog_lib was given.
4938 if test "${with_cloog_lib+set}" = set; then
4939   withval="$with_cloog_lib"
4940
4941 fi;
4942
4943 # Check whether --with-cloog-polylib or --without-cloog-polylib was given.
4944 if test "${with_cloog_polylib+set}" = set; then
4945   withval="$with_cloog_polylib"
4946
4947 fi;
4948
4949 if test "x$with_cloog" != x; then
4950   clooglibs="-L$with_cloog/lib -lcloog"
4951   clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
4952   LIBS="$clooglibs $LIBS"
4953 fi
4954 if test "x$with_cloog_polylib" != x; then
4955   clooglibs="-L$with_cloog/lib -lcloog"
4956   clooginc="-I$with_cloog/include "
4957   LIBS="$clooglibs $LIBS"
4958 fi
4959 if test "x$with_cloog_include" != x; then
4960   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
4961 fi
4962 if test "x$with_cloog_lib" != x; then
4963   clooglibs="-L$with_cloog_lib -lcloog"
4964   LIBS="$clooglibs $LIBS"
4965 fi
4966 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
4967   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
4968   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
4969   LIBS="$clooglibs $LIBS"
4970 fi
4971
4972 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
4973 if test "${enable_cloog_version_check+set}" = set; then
4974   enableval="$enable_cloog_version_check"
4975   ENABLE_CLOOG_CHECK=$enableval
4976 else
4977   ENABLE_CLOOG_CHECK=yes
4978 fi;
4979
4980 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
4981   saved_CFLAGS="$CFLAGS"
4982   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
4983   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
4984 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
4985   cat >conftest.$ac_ext <<_ACEOF
4986 /* confdefs.h.  */
4987 _ACEOF
4988 cat confdefs.h >>conftest.$ac_ext
4989 cat >>conftest.$ac_ext <<_ACEOF
4990 /* end confdefs.h.  */
4991 #include "cloog/cloog.h"
4992 int
4993 main ()
4994 {
4995
4996   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
4997   choke me
4998   #endif
4999
5000   ;
5001   return 0;
5002 }
5003 _ACEOF
5004 rm -f conftest.$ac_objext
5005 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5006   (eval $ac_compile) 2>conftest.er1
5007   ac_status=$?
5008   grep -v '^ *+' conftest.er1 >conftest.err
5009   rm -f conftest.er1
5010   cat conftest.err >&5
5011   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5012   (exit $ac_status); } &&
5013          { ac_try='test -z "$ac_c_werror_flag"
5014                          || test ! -s conftest.err'
5015   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5016   (eval $ac_try) 2>&5
5017   ac_status=$?
5018   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5019   (exit $ac_status); }; } &&
5020          { ac_try='test -s conftest.$ac_objext'
5021   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5022   (eval $ac_try) 2>&5
5023   ac_status=$?
5024   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5025   (exit $ac_status); }; }; then
5026   echo "$as_me:$LINENO: result: yes" >&5
5027 echo "${ECHO_T}yes" >&6
5028 else
5029   echo "$as_me: failed program was:" >&5
5030 sed 's/^/| /' conftest.$ac_ext >&5
5031
5032 echo "$as_me:$LINENO: result: no" >&5
5033 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5034 fi
5035 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5036   CFLAGS="$saved_CFLAGS"
5037 fi
5038
5039 # Flags needed for CLOOG
5040
5041
5042
5043
5044 # By default, C is the only stage 1 language.
5045 stage1_languages=,c,
5046
5047 # Figure out what language subdirectories are present.
5048 # Look if the user specified --enable-languages="..."; if not, use
5049 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5050 # go away some day.
5051 # NB:  embedded tabs in this IF block -- do not untabify
5052 if test -d ${srcdir}/gcc; then
5053   if test x"${enable_languages+set}" != xset; then
5054     if test x"${LANGUAGES+set}" = xset; then
5055       enable_languages="${LANGUAGES}"
5056         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5057     else
5058       enable_languages=all
5059     fi
5060   else
5061     if test x"${enable_languages}" = x ||
5062        test x"${enable_languages}" = xyes;
5063        then
5064       echo configure.in: --enable-languages needs at least one language argument 1>&2
5065       exit 1
5066     fi
5067   fi
5068   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5069
5070   # 'f95' is the old name for the 'fortran' language. We issue a warning
5071   # and make the substitution.
5072   case ,${enable_languages}, in
5073     *,f95,*)
5074       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5075       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5076       ;;
5077   esac
5078
5079   # First scan to see if an enabled language requires some other language.
5080   # We assume that a given config-lang.in will list all the language
5081   # front ends it requires, even if some are required indirectly.
5082   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5083     case ${lang_frag} in
5084       ..) ;;
5085       # The odd quoting in the next line works around
5086       # an apparent bug in bash 1.12 on linux.
5087       ${srcdir}/gcc/[*]/config-lang.in) ;;
5088       *)
5089         # From the config-lang.in, get $language, $lang_requires
5090         language=
5091         lang_requires=
5092         . ${lang_frag}
5093         for other in ${lang_requires} ; do
5094           case ,${enable_languages}, in
5095             *,$other,*) ;;
5096             *,all,*) ;;
5097             *,$language,*)
5098               echo " \`$other' language required by \`$language'; enabling" 1>&2
5099               enable_languages="${enable_languages},${other}"
5100               ;;
5101           esac
5102         done
5103         ;;
5104     esac
5105   done
5106
5107   new_enable_languages=,c,
5108   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5109   potential_languages=,c,
5110
5111   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5112     case ${lang_frag} in
5113       ..) ;;
5114       # The odd quoting in the next line works around
5115       # an apparent bug in bash 1.12 on linux.
5116       ${srcdir}/gcc/[*]/config-lang.in) ;;
5117       *)
5118         # From the config-lang.in, get $language, $target_libs,
5119         # $lang_dirs, $boot_language, and $build_by_default
5120         language=
5121         target_libs=
5122         lang_dirs=
5123         subdir_requires=
5124         boot_language=no
5125         build_by_default=yes
5126         . ${lang_frag}
5127         if test x${language} = x; then
5128           echo "${lang_frag} doesn't set \$language." 1>&2
5129           exit 1
5130         fi
5131
5132         case ,${enable_languages}, in
5133           *,${language},*)
5134             # Language was explicitly selected; include it.
5135             add_this_lang=yes
5136             ;;
5137           *,all,*)
5138             # 'all' was selected, select it if it is a default language
5139             add_this_lang=${build_by_default}
5140             ;;
5141           *)
5142             add_this_lang=no
5143             ;;
5144         esac
5145
5146         # Disable languages that need other directories if these aren't available.
5147         for i in $subdir_requires; do
5148           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5149           case ,${enable_languages}, in
5150             *,${language},*)
5151               # Specifically requested language; tell them.
5152               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5153 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5154    { (exit 1); exit 1; }; }
5155               ;;
5156             *)
5157               # Silently disable.
5158               add_this_lang=unsupported
5159               ;;
5160           esac
5161         done
5162
5163         # Disable Ada if no preexisting GNAT is available.
5164         case ,${enable_languages},:${language}:${have_gnat} in
5165           *,${language},*:ada:no)
5166             # Specifically requested language; tell them.
5167             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5168 echo "$as_me: error: GNAT is required to build $language" >&2;}
5169    { (exit 1); exit 1; }; }
5170             ;;
5171           *:ada:no)
5172             # Silently disable.
5173             add_this_lang=unsupported
5174             ;;
5175         esac
5176
5177         # Disable a language that is unsupported by the target.
5178         case " $unsupported_languages " in
5179           *" $language "*)
5180             add_this_lang=unsupported
5181             ;;
5182         esac
5183
5184         case $add_this_lang in
5185           unsupported)
5186             # Remove language-dependent dirs.
5187             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5188             ;;
5189           no)
5190             # Remove language-dependent dirs; still show language as supported.
5191             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5192             potential_languages="${potential_languages}${language},"
5193             ;;
5194           yes)
5195             new_enable_languages="${new_enable_languages}${language},"
5196             potential_languages="${potential_languages}${language},"
5197             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5198             case ${boot_language} in
5199               yes)
5200                 # Add to (comma-separated) list of stage 1 languages.
5201                 stage1_languages="${stage1_languages}${language},"
5202                 ;;
5203             esac
5204             ;;
5205         esac
5206         ;;
5207     esac
5208   done
5209
5210   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5211 if test "${enable_stage1_languages+set}" = set; then
5212   enableval="$enable_stage1_languages"
5213   case ,${enable_stage1_languages}, in
5214     ,no,|,,)
5215       # Set it to something that will have no effect in the loop below
5216       enable_stage1_languages=c ;;
5217     ,yes,)
5218       enable_stage1_languages=`echo $new_enable_languages | \
5219         sed -e "s/^,//" -e "s/,$//" ` ;;
5220     *,all,*)
5221       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5222         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5223   esac
5224
5225   # Add "good" languages from enable_stage1_languages to stage1_languages,
5226   # while "bad" languages go in missing_languages.  Leave no duplicates.
5227   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5228     case $potential_languages in
5229       *,$i,*)
5230         case $stage1_languages in
5231           *,$i,*) ;;
5232           *) stage1_languages="$stage1_languages$i," ;;
5233         esac ;;
5234       *)
5235         case $missing_languages in
5236           *,$i,*) ;;
5237           *) missing_languages="$missing_languages$i," ;;
5238         esac ;;
5239      esac
5240   done
5241 fi;
5242
5243   # Remove leading/trailing commas that were added for simplicity
5244   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5245   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5246   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5247   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5248
5249   if test "x$missing_languages" != x; then
5250     { { echo "$as_me:$LINENO: error:
5251 The following requested languages could not be built: ${missing_languages}
5252 Supported languages are: ${potential_languages}" >&5
5253 echo "$as_me: error:
5254 The following requested languages could not be built: ${missing_languages}
5255 Supported languages are: ${potential_languages}" >&2;}
5256    { (exit 1); exit 1; }; }
5257   fi
5258   if test "x$new_enable_languages" != "x$enable_languages"; then
5259     echo The following languages will be built: ${new_enable_languages}
5260     enable_languages="$new_enable_languages"
5261   fi
5262
5263
5264   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5265 fi
5266
5267 # Handle --disable-<component> generically.
5268 for dir in $configdirs $build_configdirs $target_configdirs ; do
5269   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5270   varname=`echo $dirname | sed -e s/+/_/g`
5271   if eval test x\${enable_${varname}} "=" xno ; then
5272     noconfigdirs="$noconfigdirs $dir"
5273   fi
5274 done
5275
5276 # Check for Boehm's garbage collector
5277 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5278 if test "${enable_objc_gc+set}" = set; then
5279   enableval="$enable_objc_gc"
5280   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5281   *,objc,*:*:yes:*target-boehm-gc*)
5282     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5283 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5284    { (exit 1); exit 1; }; }
5285     ;;
5286 esac
5287 fi;
5288
5289 # Make sure we only build Boehm's garbage collector if required.
5290 case ,${enable_languages},:${enable_objc_gc} in
5291   *,objc,*:yes)
5292     # Keep target-boehm-gc if requested for Objective-C.
5293     ;;
5294   *)
5295     # Otherwise remove target-boehm-gc depending on target-libjava.
5296     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5297       noconfigdirs="$noconfigdirs target-boehm-gc"
5298     fi
5299     ;;
5300 esac
5301
5302 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5303 # $build_configdirs and $target_configdirs.
5304 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5305
5306 notsupp=""
5307 for dir in . $skipdirs $noconfigdirs ; do
5308   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5309   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5310     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5311     if test -r $srcdir/$dirname/configure ; then
5312       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5313         true
5314       else
5315         notsupp="$notsupp $dir"
5316       fi
5317     fi
5318   fi
5319   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5320     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5321     if test -r $srcdir/$dirname/configure ; then
5322       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5323         true
5324       else
5325         notsupp="$notsupp $dir"
5326       fi
5327     fi
5328   fi
5329   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5330     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5331     if test -r $srcdir/$dirname/configure ; then
5332       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5333         true
5334       else
5335         notsupp="$notsupp $dir"
5336       fi
5337     fi
5338   fi
5339 done
5340
5341 # Sometimes the tools are distributed with libiberty but with no other
5342 # libraries.  In that case, we don't want to build target-libiberty.
5343 # Don't let libgcc imply libiberty either.
5344 if test -n "${target_configdirs}" ; then
5345   libgcc=
5346   others=
5347   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5348     if test "$i" = "libgcc"; then
5349       libgcc=target-libgcc
5350     elif test "$i" != "libiberty" ; then
5351       if test -r $srcdir/$i/configure ; then
5352         others=yes;
5353         break;
5354       fi
5355     fi
5356   done
5357   if test -z "${others}" ; then
5358     target_configdirs=$libgcc
5359   fi
5360 fi
5361
5362 # Quietly strip out all directories which aren't configurable in this tree.
5363 # This relies on all configurable subdirectories being autoconfiscated, which
5364 # is now the case.
5365 build_configdirs_all="$build_configdirs"
5366 build_configdirs=
5367 for i in ${build_configdirs_all} ; do
5368   j=`echo $i | sed -e s/build-//g`
5369   if test -f ${srcdir}/$j/configure ; then
5370     build_configdirs="${build_configdirs} $i"
5371   fi
5372 done
5373
5374 configdirs_all="$configdirs"
5375 configdirs=
5376 for i in ${configdirs_all} ; do
5377   if test -f ${srcdir}/$i/configure ; then
5378     configdirs="${configdirs} $i"
5379   fi
5380 done
5381
5382 target_configdirs_all="$target_configdirs"
5383 target_configdirs=
5384 for i in ${target_configdirs_all} ; do
5385   j=`echo $i | sed -e s/target-//g`
5386   if test -f ${srcdir}/$j/configure ; then
5387     target_configdirs="${target_configdirs} $i"
5388   fi
5389 done
5390
5391 # Produce a warning message for the subdirs we can't configure.
5392 # This isn't especially interesting in the Cygnus tree, but in the individual
5393 # FSF releases, it's important to let people know when their machine isn't
5394 # supported by the one or two programs in a package.
5395
5396 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5397   # If $appdirs is non-empty, at least one of those directories must still
5398   # be configured, or we error out.  (E.g., if the gas release supports a
5399   # specified target in some subdirs but not the gas subdir, we shouldn't
5400   # pretend that all is well.)
5401   if test -n "$appdirs" ; then
5402     for dir in $appdirs ; do
5403       if test -r $dir/Makefile.in ; then
5404         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5405           appdirs=""
5406           break
5407         fi
5408         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5409           appdirs=""
5410           break
5411         fi
5412       fi
5413     done
5414     if test -n "$appdirs" ; then
5415       echo "*** This configuration is not supported by this package." 1>&2
5416       exit 1
5417     fi
5418   fi
5419   # Okay, some application will build, or we don't care to check.  Still
5420   # notify of subdirs not getting built.
5421   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5422   echo "    ${notsupp}" 1>&2
5423   echo "    (Any other directories should still work fine.)" 1>&2
5424 fi
5425
5426 case "$host" in
5427   *msdosdjgpp*)
5428     enable_gdbtk=no ;;
5429 esac
5430
5431 # To find our prefix, in gcc_cv_tool_prefix.
5432
5433 # The user is always right.
5434 if test "${PATH_SEPARATOR+set}" != set; then
5435   echo "#! /bin/sh" >conf$$.sh
5436   echo  "exit 0"   >>conf$$.sh
5437   chmod +x conf$$.sh
5438   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5439     PATH_SEPARATOR=';'
5440   else
5441     PATH_SEPARATOR=:
5442   fi
5443   rm -f conf$$.sh
5444 fi
5445
5446
5447
5448 if test "x$exec_prefix" = xNONE; then
5449         if test "x$prefix" = xNONE; then
5450                 gcc_cv_tool_prefix=$ac_default_prefix
5451         else
5452                 gcc_cv_tool_prefix=$prefix
5453         fi
5454 else
5455         gcc_cv_tool_prefix=$exec_prefix
5456 fi
5457
5458 # If there is no compiler in the tree, use the PATH only.  In any
5459 # case, if there is no compiler in the tree nobody should use
5460 # AS_FOR_TARGET and LD_FOR_TARGET.
5461 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5462     gcc_version=`cat $srcdir/gcc/BASE-VER`
5463     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5464     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5465     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5466     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5467     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5468     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5469 else
5470     gcc_cv_tool_dirs=
5471 fi
5472
5473 if test x$build = x$target && test -n "$md_exec_prefix"; then
5474         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5475 fi
5476
5477
5478
5479 copy_dirs=
5480
5481
5482 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5483 if test "${with_build_sysroot+set}" = set; then
5484   withval="$with_build_sysroot"
5485   if test x"$withval" != x ; then
5486      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5487    fi
5488 else
5489   SYSROOT_CFLAGS_FOR_TARGET=
5490 fi;
5491
5492
5493
5494 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5495 if test "${with_debug_prefix_map+set}" = set; then
5496   withval="$with_debug_prefix_map"
5497   if test x"$withval" != x; then
5498      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5499      for debug_map in $withval; do
5500        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5501      done
5502    fi
5503 else
5504   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5505 fi;
5506
5507
5508 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5509 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5510 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5511 # We want to ensure that TARGET libraries (which we know are built with
5512 # gcc) are built with "-O2 -g", so include those options when setting
5513 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5514 if test "x$CFLAGS_FOR_TARGET" = x; then
5515   CFLAGS_FOR_TARGET=$CFLAGS
5516   case " $CFLAGS " in
5517     *" -O2 "*) ;;
5518     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5519   esac
5520   case " $CFLAGS " in
5521     *" -g "* | *" -g3 "*) ;;
5522     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5523   esac
5524 fi
5525
5526
5527 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5528   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5529   case " $CXXFLAGS " in
5530     *" -O2 "*) ;;
5531     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5532   esac
5533   case " $CXXFLAGS " in
5534     *" -g "* | *" -g3 "*) ;;
5535     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5536   esac
5537 fi
5538
5539
5540 # Other target tools.
5541 CPPFLAGS_FOR_TARGET=${CPPFLAGS_FOR_TARGET-${CPPFLAGS}}
5542
5543 LDFLAGS_FOR_TARGET=${LDFLAGS_FOR_TARGET-${LDFLAGS}}
5544
5545
5546 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5547 # the named directory are copied to $(tooldir)/sys-include.
5548 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5549   if test x${is_cross_compiler} = xno ; then
5550     echo 1>&2 '***' --with-headers is only supported when cross compiling
5551     exit 1
5552   fi
5553   if test x"${with_headers}" != xyes ; then
5554     x=${gcc_cv_tool_prefix}
5555     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5556   fi
5557 fi
5558
5559 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5560 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5561 # are permitted.
5562 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5563   if test x${is_cross_compiler} = xno ; then
5564     echo 1>&2 '***' --with-libs is only supported when cross compiling
5565     exit 1
5566   fi
5567   if test x"${with_libs}" != xyes ; then
5568     # Copy the libraries in reverse order, so that files in the first named
5569     # library override files in subsequent libraries.
5570     x=${gcc_cv_tool_prefix}
5571     for l in ${with_libs}; do
5572       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5573     done
5574   fi
5575 fi
5576
5577 # Set with_gnu_as and with_gnu_ld as appropriate.
5578 #
5579 # This is done by determining whether or not the appropriate directory
5580 # is available, and by checking whether or not specific configurations
5581 # have requested that this magic not happen.
5582 #
5583 # The command line options always override the explicit settings in
5584 # configure.in, and the settings in configure.in override this magic.
5585 #
5586 # If the default for a toolchain is to use GNU as and ld, and you don't
5587 # want to do that, then you should use the --without-gnu-as and
5588 # --without-gnu-ld options for the configure script.
5589
5590 if test x${use_gnu_as} = x &&
5591    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5592   with_gnu_as=yes
5593   extra_host_args="$extra_host_args --with-gnu-as"
5594 fi
5595
5596 if test x${use_gnu_ld} = x &&
5597    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5598   with_gnu_ld=yes
5599   extra_host_args="$extra_host_args --with-gnu-ld"
5600 fi
5601
5602 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5603 # can detect this case.
5604
5605 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5606   with_newlib=yes
5607   extra_host_args="$extra_host_args --with-newlib"
5608 fi
5609
5610 # Handle ${copy_dirs}
5611 set fnord ${copy_dirs}
5612 shift
5613 while test $# != 0 ; do
5614   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5615     :
5616   else
5617     echo Copying $1 to $2
5618
5619     # Use the install script to create the directory and all required
5620     # parent directories.
5621     if test -d $2 ; then
5622       :
5623     else
5624       echo >config.temp
5625       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5626     fi
5627
5628     # Copy the directory, assuming we have tar.
5629     # FIXME: Should we use B in the second tar?  Not all systems support it.
5630     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5631
5632     # It is the responsibility of the user to correctly adjust all
5633     # symlinks.  If somebody can figure out how to handle them correctly
5634     # here, feel free to add the code.
5635
5636     echo $1 > $2/COPIED
5637   fi
5638   shift; shift
5639 done
5640
5641 # Determine a target-dependent exec_prefix that the installed
5642 # gcc will search in.  Keep this list sorted by triplet, with
5643 # the *-*-osname triplets last.
5644 md_exec_prefix=
5645 case "${target}" in
5646   alpha*-*-*vms*)
5647     md_exec_prefix=/gnu/lib/gcc-lib
5648     ;;
5649   i[34567]86-pc-msdosdjgpp*)
5650     md_exec_prefix=/dev/env/DJDIR/bin
5651     ;;
5652   i[34567]86-*-sco3.2v5*)
5653     if test $with_gnu_as = yes; then
5654       md_exec_prefix=/usr/gnu/bin
5655     else
5656       md_exec_prefix=/usr/ccs/bin/elf
5657     fi
5658     ;;
5659
5660   mn10300-*-* | \
5661   powerpc-*-chorusos* | \
5662   powerpc*-*-eabi* | \
5663   powerpc*-*-sysv* | \
5664   powerpc*-*-kaos* | \
5665   s390x-ibm-tpf*)
5666     md_exec_prefix=/usr/ccs/bin
5667     ;;
5668   sparc64-*-elf*)
5669     ;;
5670   v850*-*-*)
5671     md_exec_prefix=/usr/ccs/bin
5672     ;;
5673   xtensa*-*-elf*)
5674     ;;
5675
5676   *-*-beos* | \
5677   *-*-elf* | \
5678   *-*-hpux* | \
5679   *-*-netware* | \
5680   *-*-nto-qnx* | \
5681   *-*-rtems* | \
5682   *-*-solaris2* | \
5683   *-*-sysv[45]* | \
5684   *-*-vxworks* | \
5685   *-wrs-windiss)
5686     md_exec_prefix=/usr/ccs/bin
5687     ;;
5688 esac
5689
5690 extra_arflags_for_target=
5691 extra_nmflags_for_target=
5692 extra_ranlibflags_for_target=
5693 target_makefile_frag=/dev/null
5694 case "${target}" in
5695   mep*-*-*)
5696     target_makefile_frag="config/mt-mep"
5697     ;;
5698   spu-*-*)
5699     target_makefile_frag="config/mt-spu"
5700     ;;
5701   mips*-sde-elf*)
5702     target_makefile_frag="config/mt-sde"
5703     ;;
5704   mipsisa*-*-elfoabi*)
5705     target_makefile_frag="config/mt-mips-elfoabi"
5706     ;;
5707   mips*-*-*linux* | mips*-*-gnu*)
5708     target_makefile_frag="config/mt-mips-gnu"
5709     ;;
5710   *-*-netware*)
5711     target_makefile_frag="config/mt-netware"
5712     ;;
5713   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5714     target_makefile_frag="config/mt-gnu"
5715     ;;
5716   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5717     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5718     # commands to handle both 32-bit and 64-bit objects.  These flags are
5719     # harmless if we're using GNU nm or ar.
5720     extra_arflags_for_target=" -X32_64"
5721     extra_nmflags_for_target=" -B -X32_64"
5722     ;;
5723   *-*-darwin*)
5724     # ranlib from Darwin requires the -c flag to look at common symbols.
5725     extra_ranlibflags_for_target=" -c"
5726     ;;
5727   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5728     target_makefile_frag="config/mt-wince"
5729     ;;
5730 esac
5731
5732 alphaieee_frag=/dev/null
5733 case $target in
5734   alpha*-*-*)
5735     # This just makes sure to use the -mieee option to build target libs.
5736     # This should probably be set individually by each library.
5737     alphaieee_frag="config/mt-alphaieee"
5738     ;;
5739 esac
5740
5741 # If --enable-target-optspace always use -Os instead of -O2 to build
5742 # the target libraries, similarly if it is not specified, use -Os
5743 # on selected platforms.
5744 ospace_frag=/dev/null
5745 case "${enable_target_optspace}:${target}" in
5746   yes:*)
5747     ospace_frag="config/mt-ospace"
5748     ;;
5749   :d30v-*)
5750     ospace_frag="config/mt-d30v"
5751     ;;
5752   :m32r-* | :d10v-* | :fr30-*)
5753     ospace_frag="config/mt-ospace"
5754     ;;
5755   no:* | :*)
5756     ;;
5757   *)
5758     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5759     ;;
5760 esac
5761
5762 # Default to using --with-stabs for certain targets.
5763 if test x${with_stabs} = x ; then
5764   case "${target}" in
5765   mips*-*-irix[56]*)
5766     ;;
5767   mips*-*-* | alpha*-*-osf*)
5768     with_stabs=yes;
5769     extra_host_args="${extra_host_args} --with-stabs"
5770     ;;
5771   esac
5772 fi
5773
5774 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5775 # them automatically.
5776 case "${host}" in
5777   hppa*64*-*-hpux11*)
5778     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5779     ;;
5780 esac
5781
5782 # Some systems (e.g., one of the i386-aix systems the gas testers are
5783 # using) don't handle "\$" correctly, so don't use it here.
5784 tooldir='${exec_prefix}'/${target_noncanonical}
5785 build_tooldir=${tooldir}
5786
5787 # Create a .gdbinit file which runs the one in srcdir
5788 # and tells GDB to look there for source files.
5789
5790 if test -r ${srcdir}/.gdbinit ; then
5791   case ${srcdir} in
5792     .) ;;
5793     *) cat > ./.gdbinit <<EOF
5794 # ${NO_EDIT}
5795 dir ${srcdir}
5796 dir .
5797 source ${srcdir}/.gdbinit
5798 EOF
5799     ;;
5800   esac
5801 fi
5802
5803 # Make sure that the compiler is able to generate an executable.  If it
5804 # can't, we are probably in trouble.  We don't care whether we can run the
5805 # executable--we might be using a cross compiler--we only care whether it
5806 # can be created.  At this point the main configure script has set CC.
5807 we_are_ok=no
5808 echo "int main () { return 0; }" > conftest.c
5809 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5810 if test $? = 0 ; then
5811   if test -s conftest || test -s conftest.exe ; then
5812     we_are_ok=yes
5813   fi
5814 fi
5815 case $we_are_ok in
5816   no)
5817     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5818     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5819     rm -f conftest*
5820     exit 1
5821     ;;
5822 esac
5823 rm -f conftest*
5824
5825 # The Solaris /usr/ucb/cc compiler does not appear to work.
5826 case "${host}" in
5827   sparc-sun-solaris2*)
5828       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5829       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5830           could_use=
5831           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5832           if test -d /opt/cygnus/bin ; then
5833               if test "$could_use" = "" ; then
5834                   could_use="/opt/cygnus/bin"
5835               else
5836                   could_use="$could_use or /opt/cygnus/bin"
5837               fi
5838           fi
5839         if test "$could_use" = "" ; then
5840             echo "Warning: compilation may fail because you're using"
5841             echo "/usr/ucb/cc.  You should change your PATH or CC "
5842             echo "variable and rerun configure."
5843         else
5844             echo "Warning: compilation may fail because you're using"
5845             echo "/usr/ucb/cc, when you should use the C compiler from"
5846             echo "$could_use.  You should change your"
5847             echo "PATH or CC variable and rerun configure."
5848         fi
5849       fi
5850   ;;
5851 esac
5852
5853 # Decide which environment variable is used to find dynamic libraries.
5854 case "${host}" in
5855   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5856   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5857   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5858   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5859 esac
5860
5861 # On systems where the dynamic library environment variable is PATH,
5862 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
5863 # built executables to PATH.
5864 if test "$RPATH_ENVVAR" = PATH; then
5865   GCC_SHLIB_SUBDIR=/shlib
5866 else
5867   GCC_SHLIB_SUBDIR=
5868 fi
5869
5870 # Record target_configdirs and the configure arguments for target and
5871 # build configuration in Makefile.
5872 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5873 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5874
5875 # Determine whether gdb needs tk/tcl or not.
5876 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5877 # and in that case we want gdb to be built without tk.  Ugh!
5878 # In fact I believe gdb is the *only* package directly dependent on tk,
5879 # so we should be able to put the 'maybe's in unconditionally and
5880 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5881 # 100% sure that that's safe though.
5882
5883 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5884 case "$enable_gdbtk" in
5885   no)
5886     GDB_TK="" ;;
5887   yes)
5888     GDB_TK="${gdb_tk}" ;;
5889   *)
5890     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5891     # distro.  Eventually someone will fix this and move Insight, nee
5892     # gdbtk to a separate directory.
5893     if test -d ${srcdir}/gdb/gdbtk ; then
5894       GDB_TK="${gdb_tk}"
5895     else
5896       GDB_TK=""
5897     fi
5898     ;;
5899 esac
5900 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5901 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5902
5903 # Strip out unwanted targets.
5904
5905 # While at that, we remove Makefiles if we were started for recursive
5906 # configuration, so that the top-level Makefile reconfigures them,
5907 # like we used to do when configure itself was recursive.
5908
5909 # Loop over modules.  $extrasub must be used with care, limiting as
5910 # much as possible the usage of range addresses.  That's because autoconf
5911 # splits the sed script to overcome limits in the number of commands,
5912 # and relying on carefully-timed sed passes may turn out to be very hard
5913 # to maintain later.  In this particular case, you just have to be careful
5914 # not to nest @if/@endif pairs, because configure will not warn you at all.
5915
5916 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5917 if test "${enable_bootstrap+set}" = set; then
5918   enableval="$enable_bootstrap"
5919
5920 else
5921   enable_bootstrap=default
5922 fi;
5923
5924 # Issue errors and warnings for invalid/strange bootstrap combinations.
5925 case "$configdirs" in
5926   *gcc*) have_compiler=yes ;;
5927   *) have_compiler=no ;;
5928 esac
5929
5930 case "$have_compiler:$host:$target:$enable_bootstrap" in
5931   *:*:*:no) ;;
5932
5933   # Default behavior.  Enable bootstrap if we have a compiler
5934   # and we are in a native configuration.
5935   yes:$build:$build:default)
5936     enable_bootstrap=yes ;;
5937
5938   *:*:*:default)
5939     enable_bootstrap=no ;;
5940
5941   # We have a compiler and we are in a native configuration, bootstrap is ok
5942   yes:$build:$build:yes)
5943     ;;
5944
5945   # Other configurations, but we have a compiler.  Assume the user knows
5946   # what he's doing.
5947   yes:*:*:yes)
5948     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5949 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5950     ;;
5951
5952   # No compiler: if they passed --enable-bootstrap explicitly, fail
5953   no:*:*:yes)
5954     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5955 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5956    { (exit 1); exit 1; }; } ;;
5957
5958   # Fail if wrong command line
5959   *)
5960     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5961 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5962    { (exit 1); exit 1; }; }
5963     ;;
5964 esac
5965
5966 # Adjust the toplevel makefile according to whether bootstrap was selected.
5967 case "$enable_bootstrap" in
5968   yes)
5969     bootstrap_suffix=bootstrap ;;
5970   no)
5971     bootstrap_suffix=no-bootstrap ;;
5972 esac
5973
5974 for module in ${build_configdirs} ; do
5975   if test -z "${no_recursion}" \
5976      && test -f ${build_subdir}/${module}/Makefile; then
5977     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5978     rm -f ${build_subdir}/${module}/Makefile
5979   fi
5980   extrasub="$extrasub
5981 /^@if build-$module\$/d
5982 /^@endif build-$module\$/d
5983 /^@if build-$module-$bootstrap_suffix\$/d
5984 /^@endif build-$module-$bootstrap_suffix\$/d"
5985 done
5986 for module in ${configdirs} ; do
5987   if test -z "${no_recursion}"; then
5988     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5989       if test -f ${file}; then
5990         echo 1>&2 "*** removing ${file} to force reconfigure"
5991         rm -f ${file}
5992       fi
5993     done
5994   fi
5995   extrasub="$extrasub
5996 /^@if $module\$/d
5997 /^@endif $module\$/d
5998 /^@if $module-$bootstrap_suffix\$/d
5999 /^@endif $module-$bootstrap_suffix\$/d"
6000 done
6001 for module in ${target_configdirs} ; do
6002   if test -z "${no_recursion}" \
6003      && test -f ${target_subdir}/${module}/Makefile; then
6004     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6005     rm -f ${target_subdir}/${module}/Makefile
6006   fi
6007   extrasub="$extrasub
6008 /^@if target-$module\$/d
6009 /^@endif target-$module\$/d
6010 /^@if target-$module-$bootstrap_suffix\$/d
6011 /^@endif target-$module-$bootstrap_suffix\$/d"
6012 done
6013
6014 extrasub="$extrasub
6015 /^@if /,/^@endif /d"
6016
6017 # Create the serialization dependencies.  This uses a temporary file.
6018
6019 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6020 if test "${enable_serial_configure+set}" = set; then
6021   enableval="$enable_serial_configure"
6022
6023 fi;
6024
6025 case ${enable_serial_configure} in
6026   yes)
6027     enable_serial_build_configure=yes
6028     enable_serial_host_configure=yes
6029     enable_serial_target_configure=yes
6030     ;;
6031 esac
6032
6033 # These force 'configure's to be done one at a time, to avoid problems
6034 # with contention over a shared config.cache.
6035 rm -f serdep.tmp
6036 echo '# serdep.tmp' > serdep.tmp
6037 olditem=
6038 test "x${enable_serial_build_configure}" = xyes &&
6039 for item in ${build_configdirs} ; do
6040   case ${olditem} in
6041     "") ;;
6042     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6043   esac
6044   olditem=${item}
6045 done
6046 olditem=
6047 test "x${enable_serial_host_configure}" = xyes &&
6048 for item in ${configdirs} ; do
6049   case ${olditem} in
6050     "") ;;
6051     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6052   esac
6053   olditem=${item}
6054 done
6055 olditem=
6056 test "x${enable_serial_target_configure}" = xyes &&
6057 for item in ${target_configdirs} ; do
6058   case ${olditem} in
6059     "") ;;
6060     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6061   esac
6062   olditem=${item}
6063 done
6064 serialization_dependencies=serdep.tmp
6065
6066
6067 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6068 # target, nonopt, and variable assignments.  These are the ones we
6069 # might not want to pass down to subconfigures.  Also strip
6070 # program-prefix, program-suffix, and program-transform-name, so that
6071 # we can pass down a consistent program-transform-name.
6072 baseargs=
6073 keep_next=no
6074 skip_next=no
6075 eval "set -- $ac_configure_args"
6076 for ac_arg
6077 do
6078   if test X"$skip_next" = X"yes"; then
6079     skip_next=no
6080     continue
6081   fi
6082   if test X"$keep_next" = X"yes"; then
6083     case $ac_arg in
6084       *\'*)
6085         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6086     esac
6087     baseargs="$baseargs '$ac_arg'"
6088     keep_next=no
6089     continue
6090   fi
6091
6092   # Handle separated arguments.  Based on the logic generated by
6093   # autoconf 2.59.
6094   case $ac_arg in
6095     *=* | --config-cache | -C | -disable-* | --disable-* \
6096       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6097       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6098       | -with-* | --with-* | -without-* | --without-* | --x)
6099       separate_arg=no
6100       ;;
6101     -*)
6102       separate_arg=yes
6103       ;;
6104     *)
6105       separate_arg=no
6106       ;;
6107   esac
6108
6109   case "$ac_arg" in
6110     --no*)
6111       continue
6112       ;;
6113     --c* | \
6114     --sr* | \
6115     --ho* | \
6116     --bu* | \
6117     --t* | \
6118     --program-* | \
6119     -cache_file* | \
6120     -srcdir* | \
6121     -host* | \
6122     -build* | \
6123     -target* | \
6124     -program-prefix* | \
6125     -program-suffix* | \
6126     -program-transform-name* )
6127       skip_next=$separate_arg
6128       continue
6129       ;;
6130     -*)
6131       # An option.  Add it.
6132       case $ac_arg in
6133         *\'*)
6134           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6135       esac
6136       baseargs="$baseargs '$ac_arg'"
6137       keep_next=$separate_arg
6138       ;;
6139     *)
6140       # Either a variable assignment, or a nonopt (triplet).  Don't
6141       # pass it down; let the Makefile handle this.
6142       continue
6143       ;;
6144   esac
6145 done
6146 # Remove the initial space we just introduced and, as these will be
6147 # expanded by make, quote '$'.
6148 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6149
6150 # Add in --program-transform-name, after --program-prefix and
6151 # --program-suffix have been applied to it.  Autoconf has already
6152 # doubled dollar signs and backslashes in program_transform_name; we want
6153 # the backslashes un-doubled, and then the entire thing wrapped in single
6154 # quotes, because this will be expanded first by make and then by the shell.
6155 # Also, because we want to override the logic in subdir configure scripts to
6156 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6157 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6158 ${program_transform_name}
6159 EOF_SED
6160 gcc_transform_name=`cat conftestsed.out`
6161 rm -f conftestsed.out
6162 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6163 if test "$silent" = yes; then
6164   baseargs="$baseargs --silent"
6165 fi
6166
6167 # For the build-side libraries, we just need to pretend we're native,
6168 # and not use the same cache file.  Multilibs are neither needed nor
6169 # desired.
6170 build_configargs="--cache-file=../config.cache ${baseargs}"
6171
6172 # For host modules, accept cache file option, or specification as blank.
6173 case "${cache_file}" in
6174 "") # empty
6175   cache_file_option="" ;;
6176 /* | [A-Za-z]:[\\/]* ) # absolute path
6177   cache_file_option="--cache-file=${cache_file}" ;;
6178 *) # relative path
6179   cache_file_option="--cache-file=../${cache_file}" ;;
6180 esac
6181
6182 # Host dirs don't like to share a cache file either, horribly enough.
6183 # This seems to be due to autoconf 2.5x stupidity.
6184 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6185
6186 target_configargs=${baseargs}
6187
6188 # Passing a --with-cross-host argument lets the target libraries know
6189 # whether they are being built with a cross-compiler or being built
6190 # native.  However, it would be better to use other mechanisms to make the
6191 # sorts of decisions they want to make on this basis.  Please consider
6192 # this option to be deprecated.  FIXME.
6193 if test x${is_cross_compiler} = xyes ; then
6194   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6195 fi
6196
6197 # Default to --enable-multilib.
6198 if test x${enable_multilib} = x ; then
6199   target_configargs="--enable-multilib ${target_configargs}"
6200 fi
6201
6202 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6203 # changed from the earlier setting of with_newlib.
6204 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6205   target_configargs="--with-newlib ${target_configargs}"
6206 fi
6207
6208 # Different target subdirs use different values of certain variables
6209 # (notably CXX).  Worse, multilibs use *lots* of different values.
6210 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6211 # it doesn't automatically accept command-line overrides of them.
6212 # This means it's not safe for target subdirs to share a cache file,
6213 # which is disgusting, but there you have it.  Hopefully this can be
6214 # fixed in future.  It's still worthwhile to use a cache file for each
6215 # directory.  I think.
6216
6217 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6218 # We need to pass --target, as newer autoconf's requires consistency
6219 # for target_alias and gcc doesn't manage it consistently.
6220 target_configargs="--cache-file=./config.cache ${target_configargs}"
6221
6222 FLAGS_FOR_TARGET=
6223 case " $target_configdirs " in
6224  *" newlib "*)
6225   case " $target_configargs " in
6226   *" --with-newlib "*)
6227    case "$target" in
6228    *-cygwin*)
6229      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' ;;
6230    esac
6231
6232    # If we're not building GCC, don't discard standard headers.
6233    if test -d ${srcdir}/gcc; then
6234      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6235
6236      if test "${build}" != "${host}"; then
6237        # On Canadian crosses, CC_FOR_TARGET will have already been set
6238        # by `configure', so we won't have an opportunity to add -Bgcc/
6239        # to it.  This is right: we don't want to search that directory
6240        # for binaries, but we want the header files in there, so add
6241        # them explicitly.
6242        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6243
6244        # Someone might think of using the pre-installed headers on
6245        # Canadian crosses, in case the installed compiler is not fully
6246        # compatible with the compiler being built.  In this case, it
6247        # would be better to flag an error than risking having
6248        # incompatible object files being constructed.  We can't
6249        # guarantee that an error will be flagged, but let's hope the
6250        # compiler will do it, when presented with incompatible header
6251        # files.
6252      fi
6253    fi
6254
6255    case "${target}-${is_cross_compiler}" in
6256    i[3456789]86-*-linux*-no)
6257       # Here host == target, so we don't need to build gcc,
6258       # so we don't want to discard standard headers.
6259       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6260       ;;
6261    *)
6262       # If we're building newlib, use its generic headers last, but search
6263       # for any libc-related directories first (so make it the last -B
6264       # switch).
6265       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6266
6267       # If we're building libgloss, find the startup file, simulator library
6268       # and linker script.
6269       case " $target_configdirs " in
6270         *" libgloss "*)
6271         # Look for startup file, simulator library and maybe linker script.
6272         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6273         # Look for libnosys.a in case the target needs it.
6274         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6275         # Most targets have the linker script in the source directory.
6276         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6277         ;;
6278       esac
6279       ;;
6280    esac
6281    ;;
6282   esac
6283   ;;
6284 esac
6285 case "$target" in
6286 *-mingw*)
6287   # Can't be handled as Cygwin above since Mingw does not use newlib.
6288   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' ;;
6289 esac
6290
6291 # Allow the user to override the flags for
6292 # our build compiler if desired.
6293 if test x"${build}" = x"${host}" ; then
6294   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6295   CPPFLAGS_FOR_BUILD=${CPPFLAGS_FOR_BUILD-${CPPFLAGS}}
6296   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6297   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6298 fi
6299
6300 # On Canadian crosses, we'll be searching the right directories for
6301 # the previously-installed cross compiler, so don't bother to add
6302 # flags for directories within the install tree of the compiler
6303 # being built; programs in there won't even run.
6304 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6305   # Search for pre-installed headers if nothing else fits.
6306   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6307 fi
6308
6309 if test "x${use_gnu_ld}" = x &&
6310    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6311   # Arrange for us to find uninstalled linker scripts.
6312   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6313 fi
6314
6315 # Search for other target-specific linker scripts and such.
6316 case "${target}" in
6317   mep*)
6318     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6319     ;;
6320 esac
6321
6322 # Makefile fragments.
6323 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6324 do
6325   eval fragval=\$$frag
6326   if test $fragval != /dev/null; then
6327     eval $frag=${srcdir}/$fragval
6328   fi
6329 done
6330
6331
6332
6333
6334
6335 # Miscellanea: directories, flags, etc.
6336
6337
6338
6339
6340
6341
6342
6343
6344 # Build module lists & subconfigure args.
6345
6346
6347
6348 # Host module lists & subconfigure args.
6349
6350
6351
6352 # Target module lists & subconfigure args.
6353
6354
6355
6356 # Build tools.
6357
6358
6359
6360
6361
6362
6363
6364
6365
6366
6367
6368
6369
6370
6371
6372
6373
6374
6375 # Generate default definitions for YACC, M4, LEX and other programs that run
6376 # on the build machine.  These are used if the Makefile can't locate these
6377 # programs in objdir.
6378 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6379
6380 for ac_prog in 'bison -y' byacc yacc
6381 do
6382   # Extract the first word of "$ac_prog", so it can be a program name with args.
6383 set dummy $ac_prog; ac_word=$2
6384 echo "$as_me:$LINENO: checking for $ac_word" >&5
6385 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6386 if test "${ac_cv_prog_YACC+set}" = set; then
6387   echo $ECHO_N "(cached) $ECHO_C" >&6
6388 else
6389   if test -n "$YACC"; then
6390   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6391 else
6392 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6393 for as_dir in $PATH
6394 do
6395   IFS=$as_save_IFS
6396   test -z "$as_dir" && as_dir=.
6397   for ac_exec_ext in '' $ac_executable_extensions; do
6398   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6399     ac_cv_prog_YACC="$ac_prog"
6400     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6401     break 2
6402   fi
6403 done
6404 done
6405
6406 fi
6407 fi
6408 YACC=$ac_cv_prog_YACC
6409 if test -n "$YACC"; then
6410   echo "$as_me:$LINENO: result: $YACC" >&5
6411 echo "${ECHO_T}$YACC" >&6
6412 else
6413   echo "$as_me:$LINENO: result: no" >&5
6414 echo "${ECHO_T}no" >&6
6415 fi
6416
6417   test -n "$YACC" && break
6418 done
6419 test -n "$YACC" || YACC="$MISSING bison -y"
6420
6421 case " $build_configdirs " in
6422   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6423   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6424 esac
6425
6426 for ac_prog in bison
6427 do
6428   # Extract the first word of "$ac_prog", so it can be a program name with args.
6429 set dummy $ac_prog; ac_word=$2
6430 echo "$as_me:$LINENO: checking for $ac_word" >&5
6431 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6432 if test "${ac_cv_prog_BISON+set}" = set; then
6433   echo $ECHO_N "(cached) $ECHO_C" >&6
6434 else
6435   if test -n "$BISON"; then
6436   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6437 else
6438 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6439 for as_dir in $PATH
6440 do
6441   IFS=$as_save_IFS
6442   test -z "$as_dir" && as_dir=.
6443   for ac_exec_ext in '' $ac_executable_extensions; do
6444   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6445     ac_cv_prog_BISON="$ac_prog"
6446     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6447     break 2
6448   fi
6449 done
6450 done
6451
6452 fi
6453 fi
6454 BISON=$ac_cv_prog_BISON
6455 if test -n "$BISON"; then
6456   echo "$as_me:$LINENO: result: $BISON" >&5
6457 echo "${ECHO_T}$BISON" >&6
6458 else
6459   echo "$as_me:$LINENO: result: no" >&5
6460 echo "${ECHO_T}no" >&6
6461 fi
6462
6463   test -n "$BISON" && break
6464 done
6465 test -n "$BISON" || BISON="$MISSING bison"
6466
6467 case " $build_configdirs " in
6468   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6469 esac
6470
6471 for ac_prog in gm4 gnum4 m4
6472 do
6473   # Extract the first word of "$ac_prog", so it can be a program name with args.
6474 set dummy $ac_prog; ac_word=$2
6475 echo "$as_me:$LINENO: checking for $ac_word" >&5
6476 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6477 if test "${ac_cv_prog_M4+set}" = set; then
6478   echo $ECHO_N "(cached) $ECHO_C" >&6
6479 else
6480   if test -n "$M4"; then
6481   ac_cv_prog_M4="$M4" # Let the user override the test.
6482 else
6483 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6484 for as_dir in $PATH
6485 do
6486   IFS=$as_save_IFS
6487   test -z "$as_dir" && as_dir=.
6488   for ac_exec_ext in '' $ac_executable_extensions; do
6489   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6490     ac_cv_prog_M4="$ac_prog"
6491     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6492     break 2
6493   fi
6494 done
6495 done
6496
6497 fi
6498 fi
6499 M4=$ac_cv_prog_M4
6500 if test -n "$M4"; then
6501   echo "$as_me:$LINENO: result: $M4" >&5
6502 echo "${ECHO_T}$M4" >&6
6503 else
6504   echo "$as_me:$LINENO: result: no" >&5
6505 echo "${ECHO_T}no" >&6
6506 fi
6507
6508   test -n "$M4" && break
6509 done
6510 test -n "$M4" || M4="$MISSING m4"
6511
6512 case " $build_configdirs " in
6513   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6514 esac
6515
6516 for ac_prog in flex lex
6517 do
6518   # Extract the first word of "$ac_prog", so it can be a program name with args.
6519 set dummy $ac_prog; ac_word=$2
6520 echo "$as_me:$LINENO: checking for $ac_word" >&5
6521 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6522 if test "${ac_cv_prog_LEX+set}" = set; then
6523   echo $ECHO_N "(cached) $ECHO_C" >&6
6524 else
6525   if test -n "$LEX"; then
6526   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6527 else
6528 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6529 for as_dir in $PATH
6530 do
6531   IFS=$as_save_IFS
6532   test -z "$as_dir" && as_dir=.
6533   for ac_exec_ext in '' $ac_executable_extensions; do
6534   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6535     ac_cv_prog_LEX="$ac_prog"
6536     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6537     break 2
6538   fi
6539 done
6540 done
6541
6542 fi
6543 fi
6544 LEX=$ac_cv_prog_LEX
6545 if test -n "$LEX"; then
6546   echo "$as_me:$LINENO: result: $LEX" >&5
6547 echo "${ECHO_T}$LEX" >&6
6548 else
6549   echo "$as_me:$LINENO: result: no" >&5
6550 echo "${ECHO_T}no" >&6
6551 fi
6552
6553   test -n "$LEX" && break
6554 done
6555 test -n "$LEX" || LEX="$MISSING flex"
6556
6557 case " $build_configdirs " in
6558   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6559   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6560 esac
6561
6562 for ac_prog in flex
6563 do
6564   # Extract the first word of "$ac_prog", so it can be a program name with args.
6565 set dummy $ac_prog; ac_word=$2
6566 echo "$as_me:$LINENO: checking for $ac_word" >&5
6567 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6568 if test "${ac_cv_prog_FLEX+set}" = set; then
6569   echo $ECHO_N "(cached) $ECHO_C" >&6
6570 else
6571   if test -n "$FLEX"; then
6572   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6573 else
6574 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6575 for as_dir in $PATH
6576 do
6577   IFS=$as_save_IFS
6578   test -z "$as_dir" && as_dir=.
6579   for ac_exec_ext in '' $ac_executable_extensions; do
6580   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6581     ac_cv_prog_FLEX="$ac_prog"
6582     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6583     break 2
6584   fi
6585 done
6586 done
6587
6588 fi
6589 fi
6590 FLEX=$ac_cv_prog_FLEX
6591 if test -n "$FLEX"; then
6592   echo "$as_me:$LINENO: result: $FLEX" >&5
6593 echo "${ECHO_T}$FLEX" >&6
6594 else
6595   echo "$as_me:$LINENO: result: no" >&5
6596 echo "${ECHO_T}no" >&6
6597 fi
6598
6599   test -n "$FLEX" && break
6600 done
6601 test -n "$FLEX" || FLEX="$MISSING flex"
6602
6603 case " $build_configdirs " in
6604   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6605 esac
6606
6607 for ac_prog in makeinfo
6608 do
6609   # Extract the first word of "$ac_prog", so it can be a program name with args.
6610 set dummy $ac_prog; ac_word=$2
6611 echo "$as_me:$LINENO: checking for $ac_word" >&5
6612 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6613 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6614   echo $ECHO_N "(cached) $ECHO_C" >&6
6615 else
6616   if test -n "$MAKEINFO"; then
6617   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6618 else
6619 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6620 for as_dir in $PATH
6621 do
6622   IFS=$as_save_IFS
6623   test -z "$as_dir" && as_dir=.
6624   for ac_exec_ext in '' $ac_executable_extensions; do
6625   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6626     ac_cv_prog_MAKEINFO="$ac_prog"
6627     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6628     break 2
6629   fi
6630 done
6631 done
6632
6633 fi
6634 fi
6635 MAKEINFO=$ac_cv_prog_MAKEINFO
6636 if test -n "$MAKEINFO"; then
6637   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6638 echo "${ECHO_T}$MAKEINFO" >&6
6639 else
6640   echo "$as_me:$LINENO: result: no" >&5
6641 echo "${ECHO_T}no" >&6
6642 fi
6643
6644   test -n "$MAKEINFO" && break
6645 done
6646 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6647
6648 case " $build_configdirs " in
6649   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6650   *)
6651
6652     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6653     # higher, else we use the "missing" dummy.
6654     if ${MAKEINFO} --version \
6655        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6656       :
6657     else
6658       MAKEINFO="$MISSING makeinfo"
6659     fi
6660     ;;
6661
6662 esac
6663
6664 # FIXME: expect and dejagnu may become build tools?
6665
6666 for ac_prog in expect
6667 do
6668   # Extract the first word of "$ac_prog", so it can be a program name with args.
6669 set dummy $ac_prog; ac_word=$2
6670 echo "$as_me:$LINENO: checking for $ac_word" >&5
6671 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6672 if test "${ac_cv_prog_EXPECT+set}" = set; then
6673   echo $ECHO_N "(cached) $ECHO_C" >&6
6674 else
6675   if test -n "$EXPECT"; then
6676   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6677 else
6678 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6679 for as_dir in $PATH
6680 do
6681   IFS=$as_save_IFS
6682   test -z "$as_dir" && as_dir=.
6683   for ac_exec_ext in '' $ac_executable_extensions; do
6684   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6685     ac_cv_prog_EXPECT="$ac_prog"
6686     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6687     break 2
6688   fi
6689 done
6690 done
6691
6692 fi
6693 fi
6694 EXPECT=$ac_cv_prog_EXPECT
6695 if test -n "$EXPECT"; then
6696   echo "$as_me:$LINENO: result: $EXPECT" >&5
6697 echo "${ECHO_T}$EXPECT" >&6
6698 else
6699   echo "$as_me:$LINENO: result: no" >&5
6700 echo "${ECHO_T}no" >&6
6701 fi
6702
6703   test -n "$EXPECT" && break
6704 done
6705 test -n "$EXPECT" || EXPECT="expect"
6706
6707 case " $configdirs " in
6708   *" expect "*)
6709     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6710     ;;
6711 esac
6712
6713 for ac_prog in runtest
6714 do
6715   # Extract the first word of "$ac_prog", so it can be a program name with args.
6716 set dummy $ac_prog; ac_word=$2
6717 echo "$as_me:$LINENO: checking for $ac_word" >&5
6718 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6719 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6720   echo $ECHO_N "(cached) $ECHO_C" >&6
6721 else
6722   if test -n "$RUNTEST"; then
6723   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6724 else
6725 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6726 for as_dir in $PATH
6727 do
6728   IFS=$as_save_IFS
6729   test -z "$as_dir" && as_dir=.
6730   for ac_exec_ext in '' $ac_executable_extensions; do
6731   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6732     ac_cv_prog_RUNTEST="$ac_prog"
6733     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6734     break 2
6735   fi
6736 done
6737 done
6738
6739 fi
6740 fi
6741 RUNTEST=$ac_cv_prog_RUNTEST
6742 if test -n "$RUNTEST"; then
6743   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6744 echo "${ECHO_T}$RUNTEST" >&6
6745 else
6746   echo "$as_me:$LINENO: result: no" >&5
6747 echo "${ECHO_T}no" >&6
6748 fi
6749
6750   test -n "$RUNTEST" && break
6751 done
6752 test -n "$RUNTEST" || RUNTEST="runtest"
6753
6754 case " $configdirs " in
6755   *" dejagnu "*)
6756     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6757     ;;
6758 esac
6759
6760
6761 # Host tools.
6762 ncn_tool_prefix=
6763 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6764 ncn_target_tool_prefix=
6765 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6766
6767
6768
6769 if test -n "$AR"; then
6770   ac_cv_prog_AR=$AR
6771 elif test -n "$ac_cv_prog_AR"; then
6772   AR=$ac_cv_prog_AR
6773 fi
6774
6775 if test -n "$ac_cv_prog_AR"; then
6776   for ncn_progname in ar; do
6777     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6778 set dummy ${ncn_progname}; ac_word=$2
6779 echo "$as_me:$LINENO: checking for $ac_word" >&5
6780 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6781 if test "${ac_cv_prog_AR+set}" = set; then
6782   echo $ECHO_N "(cached) $ECHO_C" >&6
6783 else
6784   if test -n "$AR"; then
6785   ac_cv_prog_AR="$AR" # Let the user override the test.
6786 else
6787 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6788 for as_dir in $PATH
6789 do
6790   IFS=$as_save_IFS
6791   test -z "$as_dir" && as_dir=.
6792   for ac_exec_ext in '' $ac_executable_extensions; do
6793   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6794     ac_cv_prog_AR="${ncn_progname}"
6795     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6796     break 2
6797   fi
6798 done
6799 done
6800
6801 fi
6802 fi
6803 AR=$ac_cv_prog_AR
6804 if test -n "$AR"; then
6805   echo "$as_me:$LINENO: result: $AR" >&5
6806 echo "${ECHO_T}$AR" >&6
6807 else
6808   echo "$as_me:$LINENO: result: no" >&5
6809 echo "${ECHO_T}no" >&6
6810 fi
6811
6812   done
6813 fi
6814
6815 for ncn_progname in ar; do
6816   if test -n "$ncn_tool_prefix"; then
6817     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6818 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6819 echo "$as_me:$LINENO: checking for $ac_word" >&5
6820 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6821 if test "${ac_cv_prog_AR+set}" = set; then
6822   echo $ECHO_N "(cached) $ECHO_C" >&6
6823 else
6824   if test -n "$AR"; then
6825   ac_cv_prog_AR="$AR" # Let the user override the test.
6826 else
6827 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6828 for as_dir in $PATH
6829 do
6830   IFS=$as_save_IFS
6831   test -z "$as_dir" && as_dir=.
6832   for ac_exec_ext in '' $ac_executable_extensions; do
6833   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6834     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6835     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6836     break 2
6837   fi
6838 done
6839 done
6840
6841 fi
6842 fi
6843 AR=$ac_cv_prog_AR
6844 if test -n "$AR"; then
6845   echo "$as_me:$LINENO: result: $AR" >&5
6846 echo "${ECHO_T}$AR" >&6
6847 else
6848   echo "$as_me:$LINENO: result: no" >&5
6849 echo "${ECHO_T}no" >&6
6850 fi
6851
6852   fi
6853   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6854     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6855 set dummy ${ncn_progname}; ac_word=$2
6856 echo "$as_me:$LINENO: checking for $ac_word" >&5
6857 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6858 if test "${ac_cv_prog_AR+set}" = set; then
6859   echo $ECHO_N "(cached) $ECHO_C" >&6
6860 else
6861   if test -n "$AR"; then
6862   ac_cv_prog_AR="$AR" # Let the user override the test.
6863 else
6864 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6865 for as_dir in $PATH
6866 do
6867   IFS=$as_save_IFS
6868   test -z "$as_dir" && as_dir=.
6869   for ac_exec_ext in '' $ac_executable_extensions; do
6870   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6871     ac_cv_prog_AR="${ncn_progname}"
6872     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6873     break 2
6874   fi
6875 done
6876 done
6877
6878 fi
6879 fi
6880 AR=$ac_cv_prog_AR
6881 if test -n "$AR"; then
6882   echo "$as_me:$LINENO: result: $AR" >&5
6883 echo "${ECHO_T}$AR" >&6
6884 else
6885   echo "$as_me:$LINENO: result: no" >&5
6886 echo "${ECHO_T}no" >&6
6887 fi
6888
6889   fi
6890   test -n "$ac_cv_prog_AR" && break
6891 done
6892
6893 if test -z "$ac_cv_prog_AR" ; then
6894   set dummy ar
6895   if test $build = $host ; then
6896     AR="$2"
6897   else
6898     AR="${ncn_tool_prefix}$2"
6899   fi
6900 fi
6901
6902
6903
6904 if test -n "$AS"; then
6905   ac_cv_prog_AS=$AS
6906 elif test -n "$ac_cv_prog_AS"; then
6907   AS=$ac_cv_prog_AS
6908 fi
6909
6910 if test -n "$ac_cv_prog_AS"; then
6911   for ncn_progname in as; do
6912     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6913 set dummy ${ncn_progname}; ac_word=$2
6914 echo "$as_me:$LINENO: checking for $ac_word" >&5
6915 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6916 if test "${ac_cv_prog_AS+set}" = set; then
6917   echo $ECHO_N "(cached) $ECHO_C" >&6
6918 else
6919   if test -n "$AS"; then
6920   ac_cv_prog_AS="$AS" # Let the user override the test.
6921 else
6922 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6923 for as_dir in $PATH
6924 do
6925   IFS=$as_save_IFS
6926   test -z "$as_dir" && as_dir=.
6927   for ac_exec_ext in '' $ac_executable_extensions; do
6928   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6929     ac_cv_prog_AS="${ncn_progname}"
6930     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6931     break 2
6932   fi
6933 done
6934 done
6935
6936 fi
6937 fi
6938 AS=$ac_cv_prog_AS
6939 if test -n "$AS"; then
6940   echo "$as_me:$LINENO: result: $AS" >&5
6941 echo "${ECHO_T}$AS" >&6
6942 else
6943   echo "$as_me:$LINENO: result: no" >&5
6944 echo "${ECHO_T}no" >&6
6945 fi
6946
6947   done
6948 fi
6949
6950 for ncn_progname in as; do
6951   if test -n "$ncn_tool_prefix"; then
6952     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6953 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6954 echo "$as_me:$LINENO: checking for $ac_word" >&5
6955 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6956 if test "${ac_cv_prog_AS+set}" = set; then
6957   echo $ECHO_N "(cached) $ECHO_C" >&6
6958 else
6959   if test -n "$AS"; then
6960   ac_cv_prog_AS="$AS" # Let the user override the test.
6961 else
6962 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6963 for as_dir in $PATH
6964 do
6965   IFS=$as_save_IFS
6966   test -z "$as_dir" && as_dir=.
6967   for ac_exec_ext in '' $ac_executable_extensions; do
6968   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6969     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6970     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6971     break 2
6972   fi
6973 done
6974 done
6975
6976 fi
6977 fi
6978 AS=$ac_cv_prog_AS
6979 if test -n "$AS"; then
6980   echo "$as_me:$LINENO: result: $AS" >&5
6981 echo "${ECHO_T}$AS" >&6
6982 else
6983   echo "$as_me:$LINENO: result: no" >&5
6984 echo "${ECHO_T}no" >&6
6985 fi
6986
6987   fi
6988   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6989     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6990 set dummy ${ncn_progname}; ac_word=$2
6991 echo "$as_me:$LINENO: checking for $ac_word" >&5
6992 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6993 if test "${ac_cv_prog_AS+set}" = set; then
6994   echo $ECHO_N "(cached) $ECHO_C" >&6
6995 else
6996   if test -n "$AS"; then
6997   ac_cv_prog_AS="$AS" # Let the user override the test.
6998 else
6999 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7000 for as_dir in $PATH
7001 do
7002   IFS=$as_save_IFS
7003   test -z "$as_dir" && as_dir=.
7004   for ac_exec_ext in '' $ac_executable_extensions; do
7005   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7006     ac_cv_prog_AS="${ncn_progname}"
7007     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7008     break 2
7009   fi
7010 done
7011 done
7012
7013 fi
7014 fi
7015 AS=$ac_cv_prog_AS
7016 if test -n "$AS"; then
7017   echo "$as_me:$LINENO: result: $AS" >&5
7018 echo "${ECHO_T}$AS" >&6
7019 else
7020   echo "$as_me:$LINENO: result: no" >&5
7021 echo "${ECHO_T}no" >&6
7022 fi
7023
7024   fi
7025   test -n "$ac_cv_prog_AS" && break
7026 done
7027
7028 if test -z "$ac_cv_prog_AS" ; then
7029   set dummy as
7030   if test $build = $host ; then
7031     AS="$2"
7032   else
7033     AS="${ncn_tool_prefix}$2"
7034   fi
7035 fi
7036
7037
7038
7039 if test -n "$DLLTOOL"; then
7040   ac_cv_prog_DLLTOOL=$DLLTOOL
7041 elif test -n "$ac_cv_prog_DLLTOOL"; then
7042   DLLTOOL=$ac_cv_prog_DLLTOOL
7043 fi
7044
7045 if test -n "$ac_cv_prog_DLLTOOL"; then
7046   for ncn_progname in dlltool; do
7047     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7048 set dummy ${ncn_progname}; ac_word=$2
7049 echo "$as_me:$LINENO: checking for $ac_word" >&5
7050 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7051 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7052   echo $ECHO_N "(cached) $ECHO_C" >&6
7053 else
7054   if test -n "$DLLTOOL"; then
7055   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7056 else
7057 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7058 for as_dir in $PATH
7059 do
7060   IFS=$as_save_IFS
7061   test -z "$as_dir" && as_dir=.
7062   for ac_exec_ext in '' $ac_executable_extensions; do
7063   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7064     ac_cv_prog_DLLTOOL="${ncn_progname}"
7065     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7066     break 2
7067   fi
7068 done
7069 done
7070
7071 fi
7072 fi
7073 DLLTOOL=$ac_cv_prog_DLLTOOL
7074 if test -n "$DLLTOOL"; then
7075   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7076 echo "${ECHO_T}$DLLTOOL" >&6
7077 else
7078   echo "$as_me:$LINENO: result: no" >&5
7079 echo "${ECHO_T}no" >&6
7080 fi
7081
7082   done
7083 fi
7084
7085 for ncn_progname in dlltool; do
7086   if test -n "$ncn_tool_prefix"; then
7087     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7088 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7089 echo "$as_me:$LINENO: checking for $ac_word" >&5
7090 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7091 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7092   echo $ECHO_N "(cached) $ECHO_C" >&6
7093 else
7094   if test -n "$DLLTOOL"; then
7095   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7096 else
7097 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7098 for as_dir in $PATH
7099 do
7100   IFS=$as_save_IFS
7101   test -z "$as_dir" && as_dir=.
7102   for ac_exec_ext in '' $ac_executable_extensions; do
7103   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7104     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7105     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7106     break 2
7107   fi
7108 done
7109 done
7110
7111 fi
7112 fi
7113 DLLTOOL=$ac_cv_prog_DLLTOOL
7114 if test -n "$DLLTOOL"; then
7115   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7116 echo "${ECHO_T}$DLLTOOL" >&6
7117 else
7118   echo "$as_me:$LINENO: result: no" >&5
7119 echo "${ECHO_T}no" >&6
7120 fi
7121
7122   fi
7123   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7124     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7125 set dummy ${ncn_progname}; ac_word=$2
7126 echo "$as_me:$LINENO: checking for $ac_word" >&5
7127 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7128 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7129   echo $ECHO_N "(cached) $ECHO_C" >&6
7130 else
7131   if test -n "$DLLTOOL"; then
7132   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7133 else
7134 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7135 for as_dir in $PATH
7136 do
7137   IFS=$as_save_IFS
7138   test -z "$as_dir" && as_dir=.
7139   for ac_exec_ext in '' $ac_executable_extensions; do
7140   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7141     ac_cv_prog_DLLTOOL="${ncn_progname}"
7142     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7143     break 2
7144   fi
7145 done
7146 done
7147
7148 fi
7149 fi
7150 DLLTOOL=$ac_cv_prog_DLLTOOL
7151 if test -n "$DLLTOOL"; then
7152   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7153 echo "${ECHO_T}$DLLTOOL" >&6
7154 else
7155   echo "$as_me:$LINENO: result: no" >&5
7156 echo "${ECHO_T}no" >&6
7157 fi
7158
7159   fi
7160   test -n "$ac_cv_prog_DLLTOOL" && break
7161 done
7162
7163 if test -z "$ac_cv_prog_DLLTOOL" ; then
7164   set dummy dlltool
7165   if test $build = $host ; then
7166     DLLTOOL="$2"
7167   else
7168     DLLTOOL="${ncn_tool_prefix}$2"
7169   fi
7170 fi
7171
7172
7173
7174 if test -n "$LD"; then
7175   ac_cv_prog_LD=$LD
7176 elif test -n "$ac_cv_prog_LD"; then
7177   LD=$ac_cv_prog_LD
7178 fi
7179
7180 if test -n "$ac_cv_prog_LD"; then
7181   for ncn_progname in ld; do
7182     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7183 set dummy ${ncn_progname}; ac_word=$2
7184 echo "$as_me:$LINENO: checking for $ac_word" >&5
7185 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7186 if test "${ac_cv_prog_LD+set}" = set; then
7187   echo $ECHO_N "(cached) $ECHO_C" >&6
7188 else
7189   if test -n "$LD"; then
7190   ac_cv_prog_LD="$LD" # Let the user override the test.
7191 else
7192 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7193 for as_dir in $PATH
7194 do
7195   IFS=$as_save_IFS
7196   test -z "$as_dir" && as_dir=.
7197   for ac_exec_ext in '' $ac_executable_extensions; do
7198   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7199     ac_cv_prog_LD="${ncn_progname}"
7200     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7201     break 2
7202   fi
7203 done
7204 done
7205
7206 fi
7207 fi
7208 LD=$ac_cv_prog_LD
7209 if test -n "$LD"; then
7210   echo "$as_me:$LINENO: result: $LD" >&5
7211 echo "${ECHO_T}$LD" >&6
7212 else
7213   echo "$as_me:$LINENO: result: no" >&5
7214 echo "${ECHO_T}no" >&6
7215 fi
7216
7217   done
7218 fi
7219
7220 for ncn_progname in ld; do
7221   if test -n "$ncn_tool_prefix"; then
7222     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7223 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7224 echo "$as_me:$LINENO: checking for $ac_word" >&5
7225 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7226 if test "${ac_cv_prog_LD+set}" = set; then
7227   echo $ECHO_N "(cached) $ECHO_C" >&6
7228 else
7229   if test -n "$LD"; then
7230   ac_cv_prog_LD="$LD" # Let the user override the test.
7231 else
7232 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7233 for as_dir in $PATH
7234 do
7235   IFS=$as_save_IFS
7236   test -z "$as_dir" && as_dir=.
7237   for ac_exec_ext in '' $ac_executable_extensions; do
7238   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7239     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7240     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7241     break 2
7242   fi
7243 done
7244 done
7245
7246 fi
7247 fi
7248 LD=$ac_cv_prog_LD
7249 if test -n "$LD"; then
7250   echo "$as_me:$LINENO: result: $LD" >&5
7251 echo "${ECHO_T}$LD" >&6
7252 else
7253   echo "$as_me:$LINENO: result: no" >&5
7254 echo "${ECHO_T}no" >&6
7255 fi
7256
7257   fi
7258   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7259     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7260 set dummy ${ncn_progname}; ac_word=$2
7261 echo "$as_me:$LINENO: checking for $ac_word" >&5
7262 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7263 if test "${ac_cv_prog_LD+set}" = set; then
7264   echo $ECHO_N "(cached) $ECHO_C" >&6
7265 else
7266   if test -n "$LD"; then
7267   ac_cv_prog_LD="$LD" # Let the user override the test.
7268 else
7269 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7270 for as_dir in $PATH
7271 do
7272   IFS=$as_save_IFS
7273   test -z "$as_dir" && as_dir=.
7274   for ac_exec_ext in '' $ac_executable_extensions; do
7275   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7276     ac_cv_prog_LD="${ncn_progname}"
7277     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7278     break 2
7279   fi
7280 done
7281 done
7282
7283 fi
7284 fi
7285 LD=$ac_cv_prog_LD
7286 if test -n "$LD"; then
7287   echo "$as_me:$LINENO: result: $LD" >&5
7288 echo "${ECHO_T}$LD" >&6
7289 else
7290   echo "$as_me:$LINENO: result: no" >&5
7291 echo "${ECHO_T}no" >&6
7292 fi
7293
7294   fi
7295   test -n "$ac_cv_prog_LD" && break
7296 done
7297
7298 if test -z "$ac_cv_prog_LD" ; then
7299   set dummy ld
7300   if test $build = $host ; then
7301     LD="$2"
7302   else
7303     LD="${ncn_tool_prefix}$2"
7304   fi
7305 fi
7306
7307
7308
7309 if test -n "$LIPO"; then
7310   ac_cv_prog_LIPO=$LIPO
7311 elif test -n "$ac_cv_prog_LIPO"; then
7312   LIPO=$ac_cv_prog_LIPO
7313 fi
7314
7315 if test -n "$ac_cv_prog_LIPO"; then
7316   for ncn_progname in lipo; do
7317     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7318 set dummy ${ncn_progname}; ac_word=$2
7319 echo "$as_me:$LINENO: checking for $ac_word" >&5
7320 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7321 if test "${ac_cv_prog_LIPO+set}" = set; then
7322   echo $ECHO_N "(cached) $ECHO_C" >&6
7323 else
7324   if test -n "$LIPO"; then
7325   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7326 else
7327 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7328 for as_dir in $PATH
7329 do
7330   IFS=$as_save_IFS
7331   test -z "$as_dir" && as_dir=.
7332   for ac_exec_ext in '' $ac_executable_extensions; do
7333   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7334     ac_cv_prog_LIPO="${ncn_progname}"
7335     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7336     break 2
7337   fi
7338 done
7339 done
7340
7341 fi
7342 fi
7343 LIPO=$ac_cv_prog_LIPO
7344 if test -n "$LIPO"; then
7345   echo "$as_me:$LINENO: result: $LIPO" >&5
7346 echo "${ECHO_T}$LIPO" >&6
7347 else
7348   echo "$as_me:$LINENO: result: no" >&5
7349 echo "${ECHO_T}no" >&6
7350 fi
7351
7352   done
7353 fi
7354
7355 for ncn_progname in lipo; do
7356   if test -n "$ncn_tool_prefix"; then
7357     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7358 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7359 echo "$as_me:$LINENO: checking for $ac_word" >&5
7360 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7361 if test "${ac_cv_prog_LIPO+set}" = set; then
7362   echo $ECHO_N "(cached) $ECHO_C" >&6
7363 else
7364   if test -n "$LIPO"; then
7365   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7366 else
7367 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7368 for as_dir in $PATH
7369 do
7370   IFS=$as_save_IFS
7371   test -z "$as_dir" && as_dir=.
7372   for ac_exec_ext in '' $ac_executable_extensions; do
7373   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7374     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7375     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7376     break 2
7377   fi
7378 done
7379 done
7380
7381 fi
7382 fi
7383 LIPO=$ac_cv_prog_LIPO
7384 if test -n "$LIPO"; then
7385   echo "$as_me:$LINENO: result: $LIPO" >&5
7386 echo "${ECHO_T}$LIPO" >&6
7387 else
7388   echo "$as_me:$LINENO: result: no" >&5
7389 echo "${ECHO_T}no" >&6
7390 fi
7391
7392   fi
7393   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7394     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7395 set dummy ${ncn_progname}; ac_word=$2
7396 echo "$as_me:$LINENO: checking for $ac_word" >&5
7397 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7398 if test "${ac_cv_prog_LIPO+set}" = set; then
7399   echo $ECHO_N "(cached) $ECHO_C" >&6
7400 else
7401   if test -n "$LIPO"; then
7402   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7403 else
7404 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7405 for as_dir in $PATH
7406 do
7407   IFS=$as_save_IFS
7408   test -z "$as_dir" && as_dir=.
7409   for ac_exec_ext in '' $ac_executable_extensions; do
7410   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7411     ac_cv_prog_LIPO="${ncn_progname}"
7412     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7413     break 2
7414   fi
7415 done
7416 done
7417
7418 fi
7419 fi
7420 LIPO=$ac_cv_prog_LIPO
7421 if test -n "$LIPO"; then
7422   echo "$as_me:$LINENO: result: $LIPO" >&5
7423 echo "${ECHO_T}$LIPO" >&6
7424 else
7425   echo "$as_me:$LINENO: result: no" >&5
7426 echo "${ECHO_T}no" >&6
7427 fi
7428
7429   fi
7430   test -n "$ac_cv_prog_LIPO" && break
7431 done
7432
7433 if test -z "$ac_cv_prog_LIPO" ; then
7434   set dummy lipo
7435   if test $build = $host ; then
7436     LIPO="$2"
7437   else
7438     LIPO="${ncn_tool_prefix}$2"
7439   fi
7440 fi
7441
7442
7443
7444 if test -n "$NM"; then
7445   ac_cv_prog_NM=$NM
7446 elif test -n "$ac_cv_prog_NM"; then
7447   NM=$ac_cv_prog_NM
7448 fi
7449
7450 if test -n "$ac_cv_prog_NM"; then
7451   for ncn_progname in nm; do
7452     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7453 set dummy ${ncn_progname}; ac_word=$2
7454 echo "$as_me:$LINENO: checking for $ac_word" >&5
7455 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7456 if test "${ac_cv_prog_NM+set}" = set; then
7457   echo $ECHO_N "(cached) $ECHO_C" >&6
7458 else
7459   if test -n "$NM"; then
7460   ac_cv_prog_NM="$NM" # Let the user override the test.
7461 else
7462 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7463 for as_dir in $PATH
7464 do
7465   IFS=$as_save_IFS
7466   test -z "$as_dir" && as_dir=.
7467   for ac_exec_ext in '' $ac_executable_extensions; do
7468   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7469     ac_cv_prog_NM="${ncn_progname}"
7470     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7471     break 2
7472   fi
7473 done
7474 done
7475
7476 fi
7477 fi
7478 NM=$ac_cv_prog_NM
7479 if test -n "$NM"; then
7480   echo "$as_me:$LINENO: result: $NM" >&5
7481 echo "${ECHO_T}$NM" >&6
7482 else
7483   echo "$as_me:$LINENO: result: no" >&5
7484 echo "${ECHO_T}no" >&6
7485 fi
7486
7487   done
7488 fi
7489
7490 for ncn_progname in nm; do
7491   if test -n "$ncn_tool_prefix"; then
7492     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7493 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7494 echo "$as_me:$LINENO: checking for $ac_word" >&5
7495 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7496 if test "${ac_cv_prog_NM+set}" = set; then
7497   echo $ECHO_N "(cached) $ECHO_C" >&6
7498 else
7499   if test -n "$NM"; then
7500   ac_cv_prog_NM="$NM" # Let the user override the test.
7501 else
7502 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7503 for as_dir in $PATH
7504 do
7505   IFS=$as_save_IFS
7506   test -z "$as_dir" && as_dir=.
7507   for ac_exec_ext in '' $ac_executable_extensions; do
7508   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7509     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7510     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7511     break 2
7512   fi
7513 done
7514 done
7515
7516 fi
7517 fi
7518 NM=$ac_cv_prog_NM
7519 if test -n "$NM"; then
7520   echo "$as_me:$LINENO: result: $NM" >&5
7521 echo "${ECHO_T}$NM" >&6
7522 else
7523   echo "$as_me:$LINENO: result: no" >&5
7524 echo "${ECHO_T}no" >&6
7525 fi
7526
7527   fi
7528   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7529     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7530 set dummy ${ncn_progname}; ac_word=$2
7531 echo "$as_me:$LINENO: checking for $ac_word" >&5
7532 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7533 if test "${ac_cv_prog_NM+set}" = set; then
7534   echo $ECHO_N "(cached) $ECHO_C" >&6
7535 else
7536   if test -n "$NM"; then
7537   ac_cv_prog_NM="$NM" # Let the user override the test.
7538 else
7539 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7540 for as_dir in $PATH
7541 do
7542   IFS=$as_save_IFS
7543   test -z "$as_dir" && as_dir=.
7544   for ac_exec_ext in '' $ac_executable_extensions; do
7545   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7546     ac_cv_prog_NM="${ncn_progname}"
7547     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7548     break 2
7549   fi
7550 done
7551 done
7552
7553 fi
7554 fi
7555 NM=$ac_cv_prog_NM
7556 if test -n "$NM"; then
7557   echo "$as_me:$LINENO: result: $NM" >&5
7558 echo "${ECHO_T}$NM" >&6
7559 else
7560   echo "$as_me:$LINENO: result: no" >&5
7561 echo "${ECHO_T}no" >&6
7562 fi
7563
7564   fi
7565   test -n "$ac_cv_prog_NM" && break
7566 done
7567
7568 if test -z "$ac_cv_prog_NM" ; then
7569   set dummy nm
7570   if test $build = $host ; then
7571     NM="$2"
7572   else
7573     NM="${ncn_tool_prefix}$2"
7574   fi
7575 fi
7576
7577
7578
7579 if test -n "$RANLIB"; then
7580   ac_cv_prog_RANLIB=$RANLIB
7581 elif test -n "$ac_cv_prog_RANLIB"; then
7582   RANLIB=$ac_cv_prog_RANLIB
7583 fi
7584
7585 if test -n "$ac_cv_prog_RANLIB"; then
7586   for ncn_progname in ranlib; do
7587     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7588 set dummy ${ncn_progname}; ac_word=$2
7589 echo "$as_me:$LINENO: checking for $ac_word" >&5
7590 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7591 if test "${ac_cv_prog_RANLIB+set}" = set; then
7592   echo $ECHO_N "(cached) $ECHO_C" >&6
7593 else
7594   if test -n "$RANLIB"; then
7595   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7596 else
7597 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7598 for as_dir in $PATH
7599 do
7600   IFS=$as_save_IFS
7601   test -z "$as_dir" && as_dir=.
7602   for ac_exec_ext in '' $ac_executable_extensions; do
7603   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7604     ac_cv_prog_RANLIB="${ncn_progname}"
7605     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7606     break 2
7607   fi
7608 done
7609 done
7610
7611 fi
7612 fi
7613 RANLIB=$ac_cv_prog_RANLIB
7614 if test -n "$RANLIB"; then
7615   echo "$as_me:$LINENO: result: $RANLIB" >&5
7616 echo "${ECHO_T}$RANLIB" >&6
7617 else
7618   echo "$as_me:$LINENO: result: no" >&5
7619 echo "${ECHO_T}no" >&6
7620 fi
7621
7622   done
7623 fi
7624
7625 for ncn_progname in ranlib; do
7626   if test -n "$ncn_tool_prefix"; then
7627     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7628 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7629 echo "$as_me:$LINENO: checking for $ac_word" >&5
7630 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7631 if test "${ac_cv_prog_RANLIB+set}" = set; then
7632   echo $ECHO_N "(cached) $ECHO_C" >&6
7633 else
7634   if test -n "$RANLIB"; then
7635   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7636 else
7637 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7638 for as_dir in $PATH
7639 do
7640   IFS=$as_save_IFS
7641   test -z "$as_dir" && as_dir=.
7642   for ac_exec_ext in '' $ac_executable_extensions; do
7643   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7644     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7645     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7646     break 2
7647   fi
7648 done
7649 done
7650
7651 fi
7652 fi
7653 RANLIB=$ac_cv_prog_RANLIB
7654 if test -n "$RANLIB"; then
7655   echo "$as_me:$LINENO: result: $RANLIB" >&5
7656 echo "${ECHO_T}$RANLIB" >&6
7657 else
7658   echo "$as_me:$LINENO: result: no" >&5
7659 echo "${ECHO_T}no" >&6
7660 fi
7661
7662   fi
7663   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7664     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7665 set dummy ${ncn_progname}; ac_word=$2
7666 echo "$as_me:$LINENO: checking for $ac_word" >&5
7667 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7668 if test "${ac_cv_prog_RANLIB+set}" = set; then
7669   echo $ECHO_N "(cached) $ECHO_C" >&6
7670 else
7671   if test -n "$RANLIB"; then
7672   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7673 else
7674 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7675 for as_dir in $PATH
7676 do
7677   IFS=$as_save_IFS
7678   test -z "$as_dir" && as_dir=.
7679   for ac_exec_ext in '' $ac_executable_extensions; do
7680   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7681     ac_cv_prog_RANLIB="${ncn_progname}"
7682     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7683     break 2
7684   fi
7685 done
7686 done
7687
7688 fi
7689 fi
7690 RANLIB=$ac_cv_prog_RANLIB
7691 if test -n "$RANLIB"; then
7692   echo "$as_me:$LINENO: result: $RANLIB" >&5
7693 echo "${ECHO_T}$RANLIB" >&6
7694 else
7695   echo "$as_me:$LINENO: result: no" >&5
7696 echo "${ECHO_T}no" >&6
7697 fi
7698
7699   fi
7700   test -n "$ac_cv_prog_RANLIB" && break
7701 done
7702
7703 if test -z "$ac_cv_prog_RANLIB" ; then
7704   RANLIB=":"
7705 fi
7706
7707
7708
7709 if test -n "$STRIP"; then
7710   ac_cv_prog_STRIP=$STRIP
7711 elif test -n "$ac_cv_prog_STRIP"; then
7712   STRIP=$ac_cv_prog_STRIP
7713 fi
7714
7715 if test -n "$ac_cv_prog_STRIP"; then
7716   for ncn_progname in strip; do
7717     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7718 set dummy ${ncn_progname}; ac_word=$2
7719 echo "$as_me:$LINENO: checking for $ac_word" >&5
7720 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7721 if test "${ac_cv_prog_STRIP+set}" = set; then
7722   echo $ECHO_N "(cached) $ECHO_C" >&6
7723 else
7724   if test -n "$STRIP"; then
7725   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7726 else
7727 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7728 for as_dir in $PATH
7729 do
7730   IFS=$as_save_IFS
7731   test -z "$as_dir" && as_dir=.
7732   for ac_exec_ext in '' $ac_executable_extensions; do
7733   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7734     ac_cv_prog_STRIP="${ncn_progname}"
7735     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7736     break 2
7737   fi
7738 done
7739 done
7740
7741 fi
7742 fi
7743 STRIP=$ac_cv_prog_STRIP
7744 if test -n "$STRIP"; then
7745   echo "$as_me:$LINENO: result: $STRIP" >&5
7746 echo "${ECHO_T}$STRIP" >&6
7747 else
7748   echo "$as_me:$LINENO: result: no" >&5
7749 echo "${ECHO_T}no" >&6
7750 fi
7751
7752   done
7753 fi
7754
7755 for ncn_progname in strip; do
7756   if test -n "$ncn_tool_prefix"; then
7757     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7758 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7759 echo "$as_me:$LINENO: checking for $ac_word" >&5
7760 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7761 if test "${ac_cv_prog_STRIP+set}" = set; then
7762   echo $ECHO_N "(cached) $ECHO_C" >&6
7763 else
7764   if test -n "$STRIP"; then
7765   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7766 else
7767 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7768 for as_dir in $PATH
7769 do
7770   IFS=$as_save_IFS
7771   test -z "$as_dir" && as_dir=.
7772   for ac_exec_ext in '' $ac_executable_extensions; do
7773   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7774     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7775     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7776     break 2
7777   fi
7778 done
7779 done
7780
7781 fi
7782 fi
7783 STRIP=$ac_cv_prog_STRIP
7784 if test -n "$STRIP"; then
7785   echo "$as_me:$LINENO: result: $STRIP" >&5
7786 echo "${ECHO_T}$STRIP" >&6
7787 else
7788   echo "$as_me:$LINENO: result: no" >&5
7789 echo "${ECHO_T}no" >&6
7790 fi
7791
7792   fi
7793   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7794     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7795 set dummy ${ncn_progname}; ac_word=$2
7796 echo "$as_me:$LINENO: checking for $ac_word" >&5
7797 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7798 if test "${ac_cv_prog_STRIP+set}" = set; then
7799   echo $ECHO_N "(cached) $ECHO_C" >&6
7800 else
7801   if test -n "$STRIP"; then
7802   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7803 else
7804 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7805 for as_dir in $PATH
7806 do
7807   IFS=$as_save_IFS
7808   test -z "$as_dir" && as_dir=.
7809   for ac_exec_ext in '' $ac_executable_extensions; do
7810   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7811     ac_cv_prog_STRIP="${ncn_progname}"
7812     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7813     break 2
7814   fi
7815 done
7816 done
7817
7818 fi
7819 fi
7820 STRIP=$ac_cv_prog_STRIP
7821 if test -n "$STRIP"; then
7822   echo "$as_me:$LINENO: result: $STRIP" >&5
7823 echo "${ECHO_T}$STRIP" >&6
7824 else
7825   echo "$as_me:$LINENO: result: no" >&5
7826 echo "${ECHO_T}no" >&6
7827 fi
7828
7829   fi
7830   test -n "$ac_cv_prog_STRIP" && break
7831 done
7832
7833 if test -z "$ac_cv_prog_STRIP" ; then
7834   STRIP=":"
7835 fi
7836
7837
7838
7839 if test -n "$WINDRES"; then
7840   ac_cv_prog_WINDRES=$WINDRES
7841 elif test -n "$ac_cv_prog_WINDRES"; then
7842   WINDRES=$ac_cv_prog_WINDRES
7843 fi
7844
7845 if test -n "$ac_cv_prog_WINDRES"; then
7846   for ncn_progname in windres; do
7847     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7848 set dummy ${ncn_progname}; ac_word=$2
7849 echo "$as_me:$LINENO: checking for $ac_word" >&5
7850 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7851 if test "${ac_cv_prog_WINDRES+set}" = set; then
7852   echo $ECHO_N "(cached) $ECHO_C" >&6
7853 else
7854   if test -n "$WINDRES"; then
7855   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7856 else
7857 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7858 for as_dir in $PATH
7859 do
7860   IFS=$as_save_IFS
7861   test -z "$as_dir" && as_dir=.
7862   for ac_exec_ext in '' $ac_executable_extensions; do
7863   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7864     ac_cv_prog_WINDRES="${ncn_progname}"
7865     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7866     break 2
7867   fi
7868 done
7869 done
7870
7871 fi
7872 fi
7873 WINDRES=$ac_cv_prog_WINDRES
7874 if test -n "$WINDRES"; then
7875   echo "$as_me:$LINENO: result: $WINDRES" >&5
7876 echo "${ECHO_T}$WINDRES" >&6
7877 else
7878   echo "$as_me:$LINENO: result: no" >&5
7879 echo "${ECHO_T}no" >&6
7880 fi
7881
7882   done
7883 fi
7884
7885 for ncn_progname in windres; do
7886   if test -n "$ncn_tool_prefix"; then
7887     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7888 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7889 echo "$as_me:$LINENO: checking for $ac_word" >&5
7890 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7891 if test "${ac_cv_prog_WINDRES+set}" = set; then
7892   echo $ECHO_N "(cached) $ECHO_C" >&6
7893 else
7894   if test -n "$WINDRES"; then
7895   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7896 else
7897 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7898 for as_dir in $PATH
7899 do
7900   IFS=$as_save_IFS
7901   test -z "$as_dir" && as_dir=.
7902   for ac_exec_ext in '' $ac_executable_extensions; do
7903   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7904     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7905     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7906     break 2
7907   fi
7908 done
7909 done
7910
7911 fi
7912 fi
7913 WINDRES=$ac_cv_prog_WINDRES
7914 if test -n "$WINDRES"; then
7915   echo "$as_me:$LINENO: result: $WINDRES" >&5
7916 echo "${ECHO_T}$WINDRES" >&6
7917 else
7918   echo "$as_me:$LINENO: result: no" >&5
7919 echo "${ECHO_T}no" >&6
7920 fi
7921
7922   fi
7923   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7924     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7925 set dummy ${ncn_progname}; ac_word=$2
7926 echo "$as_me:$LINENO: checking for $ac_word" >&5
7927 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7928 if test "${ac_cv_prog_WINDRES+set}" = set; then
7929   echo $ECHO_N "(cached) $ECHO_C" >&6
7930 else
7931   if test -n "$WINDRES"; then
7932   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7933 else
7934 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7935 for as_dir in $PATH
7936 do
7937   IFS=$as_save_IFS
7938   test -z "$as_dir" && as_dir=.
7939   for ac_exec_ext in '' $ac_executable_extensions; do
7940   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7941     ac_cv_prog_WINDRES="${ncn_progname}"
7942     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7943     break 2
7944   fi
7945 done
7946 done
7947
7948 fi
7949 fi
7950 WINDRES=$ac_cv_prog_WINDRES
7951 if test -n "$WINDRES"; then
7952   echo "$as_me:$LINENO: result: $WINDRES" >&5
7953 echo "${ECHO_T}$WINDRES" >&6
7954 else
7955   echo "$as_me:$LINENO: result: no" >&5
7956 echo "${ECHO_T}no" >&6
7957 fi
7958
7959   fi
7960   test -n "$ac_cv_prog_WINDRES" && break
7961 done
7962
7963 if test -z "$ac_cv_prog_WINDRES" ; then
7964   set dummy windres
7965   if test $build = $host ; then
7966     WINDRES="$2"
7967   else
7968     WINDRES="${ncn_tool_prefix}$2"
7969   fi
7970 fi
7971
7972
7973
7974 if test -n "$WINDMC"; then
7975   ac_cv_prog_WINDMC=$WINDMC
7976 elif test -n "$ac_cv_prog_WINDMC"; then
7977   WINDMC=$ac_cv_prog_WINDMC
7978 fi
7979
7980 if test -n "$ac_cv_prog_WINDMC"; then
7981   for ncn_progname in windmc; do
7982     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7983 set dummy ${ncn_progname}; ac_word=$2
7984 echo "$as_me:$LINENO: checking for $ac_word" >&5
7985 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7986 if test "${ac_cv_prog_WINDMC+set}" = set; then
7987   echo $ECHO_N "(cached) $ECHO_C" >&6
7988 else
7989   if test -n "$WINDMC"; then
7990   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7991 else
7992 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7993 for as_dir in $PATH
7994 do
7995   IFS=$as_save_IFS
7996   test -z "$as_dir" && as_dir=.
7997   for ac_exec_ext in '' $ac_executable_extensions; do
7998   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7999     ac_cv_prog_WINDMC="${ncn_progname}"
8000     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8001     break 2
8002   fi
8003 done
8004 done
8005
8006 fi
8007 fi
8008 WINDMC=$ac_cv_prog_WINDMC
8009 if test -n "$WINDMC"; then
8010   echo "$as_me:$LINENO: result: $WINDMC" >&5
8011 echo "${ECHO_T}$WINDMC" >&6
8012 else
8013   echo "$as_me:$LINENO: result: no" >&5
8014 echo "${ECHO_T}no" >&6
8015 fi
8016
8017   done
8018 fi
8019
8020 for ncn_progname in windmc; do
8021   if test -n "$ncn_tool_prefix"; then
8022     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8023 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8024 echo "$as_me:$LINENO: checking for $ac_word" >&5
8025 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8026 if test "${ac_cv_prog_WINDMC+set}" = set; then
8027   echo $ECHO_N "(cached) $ECHO_C" >&6
8028 else
8029   if test -n "$WINDMC"; then
8030   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8031 else
8032 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8033 for as_dir in $PATH
8034 do
8035   IFS=$as_save_IFS
8036   test -z "$as_dir" && as_dir=.
8037   for ac_exec_ext in '' $ac_executable_extensions; do
8038   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8039     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8040     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8041     break 2
8042   fi
8043 done
8044 done
8045
8046 fi
8047 fi
8048 WINDMC=$ac_cv_prog_WINDMC
8049 if test -n "$WINDMC"; then
8050   echo "$as_me:$LINENO: result: $WINDMC" >&5
8051 echo "${ECHO_T}$WINDMC" >&6
8052 else
8053   echo "$as_me:$LINENO: result: no" >&5
8054 echo "${ECHO_T}no" >&6
8055 fi
8056
8057   fi
8058   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8059     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8060 set dummy ${ncn_progname}; ac_word=$2
8061 echo "$as_me:$LINENO: checking for $ac_word" >&5
8062 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8063 if test "${ac_cv_prog_WINDMC+set}" = set; then
8064   echo $ECHO_N "(cached) $ECHO_C" >&6
8065 else
8066   if test -n "$WINDMC"; then
8067   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8068 else
8069 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8070 for as_dir in $PATH
8071 do
8072   IFS=$as_save_IFS
8073   test -z "$as_dir" && as_dir=.
8074   for ac_exec_ext in '' $ac_executable_extensions; do
8075   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8076     ac_cv_prog_WINDMC="${ncn_progname}"
8077     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8078     break 2
8079   fi
8080 done
8081 done
8082
8083 fi
8084 fi
8085 WINDMC=$ac_cv_prog_WINDMC
8086 if test -n "$WINDMC"; then
8087   echo "$as_me:$LINENO: result: $WINDMC" >&5
8088 echo "${ECHO_T}$WINDMC" >&6
8089 else
8090   echo "$as_me:$LINENO: result: no" >&5
8091 echo "${ECHO_T}no" >&6
8092 fi
8093
8094   fi
8095   test -n "$ac_cv_prog_WINDMC" && break
8096 done
8097
8098 if test -z "$ac_cv_prog_WINDMC" ; then
8099   set dummy windmc
8100   if test $build = $host ; then
8101     WINDMC="$2"
8102   else
8103     WINDMC="${ncn_tool_prefix}$2"
8104   fi
8105 fi
8106
8107
8108
8109 if test -n "$OBJCOPY"; then
8110   ac_cv_prog_OBJCOPY=$OBJCOPY
8111 elif test -n "$ac_cv_prog_OBJCOPY"; then
8112   OBJCOPY=$ac_cv_prog_OBJCOPY
8113 fi
8114
8115 if test -n "$ac_cv_prog_OBJCOPY"; then
8116   for ncn_progname in objcopy; do
8117     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8118 set dummy ${ncn_progname}; ac_word=$2
8119 echo "$as_me:$LINENO: checking for $ac_word" >&5
8120 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8121 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8122   echo $ECHO_N "(cached) $ECHO_C" >&6
8123 else
8124   if test -n "$OBJCOPY"; then
8125   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8126 else
8127 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8128 for as_dir in $PATH
8129 do
8130   IFS=$as_save_IFS
8131   test -z "$as_dir" && as_dir=.
8132   for ac_exec_ext in '' $ac_executable_extensions; do
8133   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8134     ac_cv_prog_OBJCOPY="${ncn_progname}"
8135     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8136     break 2
8137   fi
8138 done
8139 done
8140
8141 fi
8142 fi
8143 OBJCOPY=$ac_cv_prog_OBJCOPY
8144 if test -n "$OBJCOPY"; then
8145   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8146 echo "${ECHO_T}$OBJCOPY" >&6
8147 else
8148   echo "$as_me:$LINENO: result: no" >&5
8149 echo "${ECHO_T}no" >&6
8150 fi
8151
8152   done
8153 fi
8154
8155 for ncn_progname in objcopy; do
8156   if test -n "$ncn_tool_prefix"; then
8157     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8158 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8159 echo "$as_me:$LINENO: checking for $ac_word" >&5
8160 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8161 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8162   echo $ECHO_N "(cached) $ECHO_C" >&6
8163 else
8164   if test -n "$OBJCOPY"; then
8165   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8166 else
8167 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8168 for as_dir in $PATH
8169 do
8170   IFS=$as_save_IFS
8171   test -z "$as_dir" && as_dir=.
8172   for ac_exec_ext in '' $ac_executable_extensions; do
8173   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8174     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8175     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8176     break 2
8177   fi
8178 done
8179 done
8180
8181 fi
8182 fi
8183 OBJCOPY=$ac_cv_prog_OBJCOPY
8184 if test -n "$OBJCOPY"; then
8185   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8186 echo "${ECHO_T}$OBJCOPY" >&6
8187 else
8188   echo "$as_me:$LINENO: result: no" >&5
8189 echo "${ECHO_T}no" >&6
8190 fi
8191
8192   fi
8193   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8194     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8195 set dummy ${ncn_progname}; ac_word=$2
8196 echo "$as_me:$LINENO: checking for $ac_word" >&5
8197 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8198 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8199   echo $ECHO_N "(cached) $ECHO_C" >&6
8200 else
8201   if test -n "$OBJCOPY"; then
8202   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8203 else
8204 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8205 for as_dir in $PATH
8206 do
8207   IFS=$as_save_IFS
8208   test -z "$as_dir" && as_dir=.
8209   for ac_exec_ext in '' $ac_executable_extensions; do
8210   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8211     ac_cv_prog_OBJCOPY="${ncn_progname}"
8212     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8213     break 2
8214   fi
8215 done
8216 done
8217
8218 fi
8219 fi
8220 OBJCOPY=$ac_cv_prog_OBJCOPY
8221 if test -n "$OBJCOPY"; then
8222   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8223 echo "${ECHO_T}$OBJCOPY" >&6
8224 else
8225   echo "$as_me:$LINENO: result: no" >&5
8226 echo "${ECHO_T}no" >&6
8227 fi
8228
8229   fi
8230   test -n "$ac_cv_prog_OBJCOPY" && break
8231 done
8232
8233 if test -z "$ac_cv_prog_OBJCOPY" ; then
8234   set dummy objcopy
8235   if test $build = $host ; then
8236     OBJCOPY="$2"
8237   else
8238     OBJCOPY="${ncn_tool_prefix}$2"
8239   fi
8240 fi
8241
8242
8243
8244 if test -n "$OBJDUMP"; then
8245   ac_cv_prog_OBJDUMP=$OBJDUMP
8246 elif test -n "$ac_cv_prog_OBJDUMP"; then
8247   OBJDUMP=$ac_cv_prog_OBJDUMP
8248 fi
8249
8250 if test -n "$ac_cv_prog_OBJDUMP"; then
8251   for ncn_progname in objdump; do
8252     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8253 set dummy ${ncn_progname}; ac_word=$2
8254 echo "$as_me:$LINENO: checking for $ac_word" >&5
8255 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8256 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8257   echo $ECHO_N "(cached) $ECHO_C" >&6
8258 else
8259   if test -n "$OBJDUMP"; then
8260   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8261 else
8262 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8263 for as_dir in $PATH
8264 do
8265   IFS=$as_save_IFS
8266   test -z "$as_dir" && as_dir=.
8267   for ac_exec_ext in '' $ac_executable_extensions; do
8268   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8269     ac_cv_prog_OBJDUMP="${ncn_progname}"
8270     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8271     break 2
8272   fi
8273 done
8274 done
8275
8276 fi
8277 fi
8278 OBJDUMP=$ac_cv_prog_OBJDUMP
8279 if test -n "$OBJDUMP"; then
8280   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8281 echo "${ECHO_T}$OBJDUMP" >&6
8282 else
8283   echo "$as_me:$LINENO: result: no" >&5
8284 echo "${ECHO_T}no" >&6
8285 fi
8286
8287   done
8288 fi
8289
8290 for ncn_progname in objdump; do
8291   if test -n "$ncn_tool_prefix"; then
8292     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8293 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8294 echo "$as_me:$LINENO: checking for $ac_word" >&5
8295 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8296 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8297   echo $ECHO_N "(cached) $ECHO_C" >&6
8298 else
8299   if test -n "$OBJDUMP"; then
8300   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8301 else
8302 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8303 for as_dir in $PATH
8304 do
8305   IFS=$as_save_IFS
8306   test -z "$as_dir" && as_dir=.
8307   for ac_exec_ext in '' $ac_executable_extensions; do
8308   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8309     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8310     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8311     break 2
8312   fi
8313 done
8314 done
8315
8316 fi
8317 fi
8318 OBJDUMP=$ac_cv_prog_OBJDUMP
8319 if test -n "$OBJDUMP"; then
8320   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8321 echo "${ECHO_T}$OBJDUMP" >&6
8322 else
8323   echo "$as_me:$LINENO: result: no" >&5
8324 echo "${ECHO_T}no" >&6
8325 fi
8326
8327   fi
8328   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8329     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8330 set dummy ${ncn_progname}; ac_word=$2
8331 echo "$as_me:$LINENO: checking for $ac_word" >&5
8332 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8333 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8334   echo $ECHO_N "(cached) $ECHO_C" >&6
8335 else
8336   if test -n "$OBJDUMP"; then
8337   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8338 else
8339 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8340 for as_dir in $PATH
8341 do
8342   IFS=$as_save_IFS
8343   test -z "$as_dir" && as_dir=.
8344   for ac_exec_ext in '' $ac_executable_extensions; do
8345   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8346     ac_cv_prog_OBJDUMP="${ncn_progname}"
8347     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8348     break 2
8349   fi
8350 done
8351 done
8352
8353 fi
8354 fi
8355 OBJDUMP=$ac_cv_prog_OBJDUMP
8356 if test -n "$OBJDUMP"; then
8357   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8358 echo "${ECHO_T}$OBJDUMP" >&6
8359 else
8360   echo "$as_me:$LINENO: result: no" >&5
8361 echo "${ECHO_T}no" >&6
8362 fi
8363
8364   fi
8365   test -n "$ac_cv_prog_OBJDUMP" && break
8366 done
8367
8368 if test -z "$ac_cv_prog_OBJDUMP" ; then
8369   set dummy objdump
8370   if test $build = $host ; then
8371     OBJDUMP="$2"
8372   else
8373     OBJDUMP="${ncn_tool_prefix}$2"
8374   fi
8375 fi
8376
8377
8378
8379
8380
8381
8382 # Target tools.
8383
8384 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8385 if test "${with_build_time_tools+set}" = set; then
8386   withval="$with_build_time_tools"
8387   case x"$withval" in
8388      x/*) ;;
8389      *)
8390        with_build_time_tools=
8391        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8392 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8393        ;;
8394    esac
8395 else
8396   with_build_time_tools=
8397 fi;
8398
8399
8400
8401 if test -n "$CC_FOR_TARGET"; then
8402   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8403 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8404   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8405 fi
8406
8407 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8408   for ncn_progname in cc gcc; do
8409     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8410 set dummy ${ncn_progname}; ac_word=$2
8411 echo "$as_me:$LINENO: checking for $ac_word" >&5
8412 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8413 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8414   echo $ECHO_N "(cached) $ECHO_C" >&6
8415 else
8416   if test -n "$CC_FOR_TARGET"; then
8417   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8418 else
8419 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8420 for as_dir in $PATH
8421 do
8422   IFS=$as_save_IFS
8423   test -z "$as_dir" && as_dir=.
8424   for ac_exec_ext in '' $ac_executable_extensions; do
8425   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8426     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8427     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8428     break 2
8429   fi
8430 done
8431 done
8432
8433 fi
8434 fi
8435 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8436 if test -n "$CC_FOR_TARGET"; then
8437   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8438 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8439 else
8440   echo "$as_me:$LINENO: result: no" >&5
8441 echo "${ECHO_T}no" >&6
8442 fi
8443
8444   done
8445 fi
8446
8447 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8448   for ncn_progname in cc gcc; do
8449     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8450 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8451     if test -x $with_build_time_tools/${ncn_progname}; then
8452       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8453       echo "$as_me:$LINENO: result: yes" >&5
8454 echo "${ECHO_T}yes" >&6
8455       break
8456     else
8457       echo "$as_me:$LINENO: result: no" >&5
8458 echo "${ECHO_T}no" >&6
8459     fi
8460   done
8461 fi
8462
8463 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8464   for ncn_progname in cc gcc; do
8465     if test -n "$ncn_target_tool_prefix"; then
8466       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8467 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8468 echo "$as_me:$LINENO: checking for $ac_word" >&5
8469 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8470 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8471   echo $ECHO_N "(cached) $ECHO_C" >&6
8472 else
8473   if test -n "$CC_FOR_TARGET"; then
8474   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8475 else
8476 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8477 for as_dir in $PATH
8478 do
8479   IFS=$as_save_IFS
8480   test -z "$as_dir" && as_dir=.
8481   for ac_exec_ext in '' $ac_executable_extensions; do
8482   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8483     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8484     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8485     break 2
8486   fi
8487 done
8488 done
8489
8490 fi
8491 fi
8492 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8493 if test -n "$CC_FOR_TARGET"; then
8494   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8495 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8496 else
8497   echo "$as_me:$LINENO: result: no" >&5
8498 echo "${ECHO_T}no" >&6
8499 fi
8500
8501     fi
8502     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8503       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8504 set dummy ${ncn_progname}; ac_word=$2
8505 echo "$as_me:$LINENO: checking for $ac_word" >&5
8506 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8507 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8508   echo $ECHO_N "(cached) $ECHO_C" >&6
8509 else
8510   if test -n "$CC_FOR_TARGET"; then
8511   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8512 else
8513 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8514 for as_dir in $PATH
8515 do
8516   IFS=$as_save_IFS
8517   test -z "$as_dir" && as_dir=.
8518   for ac_exec_ext in '' $ac_executable_extensions; do
8519   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8520     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8521     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8522     break 2
8523   fi
8524 done
8525 done
8526
8527 fi
8528 fi
8529 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8530 if test -n "$CC_FOR_TARGET"; then
8531   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8532 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8533 else
8534   echo "$as_me:$LINENO: result: no" >&5
8535 echo "${ECHO_T}no" >&6
8536 fi
8537
8538     fi
8539     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8540   done
8541 fi
8542
8543 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8544   set dummy cc gcc
8545   if test $build = $target ; then
8546     CC_FOR_TARGET="$2"
8547   else
8548     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8549   fi
8550 else
8551   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8552 fi
8553
8554
8555
8556 if test -n "$CXX_FOR_TARGET"; then
8557   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8558 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8559   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8560 fi
8561
8562 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8563   for ncn_progname in c++ g++ cxx gxx; do
8564     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8565 set dummy ${ncn_progname}; ac_word=$2
8566 echo "$as_me:$LINENO: checking for $ac_word" >&5
8567 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8568 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8569   echo $ECHO_N "(cached) $ECHO_C" >&6
8570 else
8571   if test -n "$CXX_FOR_TARGET"; then
8572   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8573 else
8574 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8575 for as_dir in $PATH
8576 do
8577   IFS=$as_save_IFS
8578   test -z "$as_dir" && as_dir=.
8579   for ac_exec_ext in '' $ac_executable_extensions; do
8580   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8581     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8582     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8583     break 2
8584   fi
8585 done
8586 done
8587
8588 fi
8589 fi
8590 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8591 if test -n "$CXX_FOR_TARGET"; then
8592   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8593 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8594 else
8595   echo "$as_me:$LINENO: result: no" >&5
8596 echo "${ECHO_T}no" >&6
8597 fi
8598
8599   done
8600 fi
8601
8602 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8603   for ncn_progname in c++ g++ cxx gxx; do
8604     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8605 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8606     if test -x $with_build_time_tools/${ncn_progname}; then
8607       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8608       echo "$as_me:$LINENO: result: yes" >&5
8609 echo "${ECHO_T}yes" >&6
8610       break
8611     else
8612       echo "$as_me:$LINENO: result: no" >&5
8613 echo "${ECHO_T}no" >&6
8614     fi
8615   done
8616 fi
8617
8618 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8619   for ncn_progname in c++ g++ cxx gxx; do
8620     if test -n "$ncn_target_tool_prefix"; then
8621       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8622 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8623 echo "$as_me:$LINENO: checking for $ac_word" >&5
8624 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8625 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8626   echo $ECHO_N "(cached) $ECHO_C" >&6
8627 else
8628   if test -n "$CXX_FOR_TARGET"; then
8629   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8630 else
8631 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8632 for as_dir in $PATH
8633 do
8634   IFS=$as_save_IFS
8635   test -z "$as_dir" && as_dir=.
8636   for ac_exec_ext in '' $ac_executable_extensions; do
8637   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8638     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8639     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8640     break 2
8641   fi
8642 done
8643 done
8644
8645 fi
8646 fi
8647 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8648 if test -n "$CXX_FOR_TARGET"; then
8649   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8650 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8651 else
8652   echo "$as_me:$LINENO: result: no" >&5
8653 echo "${ECHO_T}no" >&6
8654 fi
8655
8656     fi
8657     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8658       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8659 set dummy ${ncn_progname}; ac_word=$2
8660 echo "$as_me:$LINENO: checking for $ac_word" >&5
8661 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8662 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8663   echo $ECHO_N "(cached) $ECHO_C" >&6
8664 else
8665   if test -n "$CXX_FOR_TARGET"; then
8666   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8667 else
8668 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8669 for as_dir in $PATH
8670 do
8671   IFS=$as_save_IFS
8672   test -z "$as_dir" && as_dir=.
8673   for ac_exec_ext in '' $ac_executable_extensions; do
8674   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8675     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8676     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8677     break 2
8678   fi
8679 done
8680 done
8681
8682 fi
8683 fi
8684 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8685 if test -n "$CXX_FOR_TARGET"; then
8686   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8687 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8688 else
8689   echo "$as_me:$LINENO: result: no" >&5
8690 echo "${ECHO_T}no" >&6
8691 fi
8692
8693     fi
8694     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8695   done
8696 fi
8697
8698 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8699   set dummy c++ g++ cxx gxx
8700   if test $build = $target ; then
8701     CXX_FOR_TARGET="$2"
8702   else
8703     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8704   fi
8705 else
8706   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8707 fi
8708
8709
8710
8711 if test -n "$GCC_FOR_TARGET"; then
8712   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8713 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8714   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8715 fi
8716
8717 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8718   for ncn_progname in gcc; do
8719     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8720 set dummy ${ncn_progname}; ac_word=$2
8721 echo "$as_me:$LINENO: checking for $ac_word" >&5
8722 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8723 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8724   echo $ECHO_N "(cached) $ECHO_C" >&6
8725 else
8726   if test -n "$GCC_FOR_TARGET"; then
8727   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8728 else
8729 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8730 for as_dir in $PATH
8731 do
8732   IFS=$as_save_IFS
8733   test -z "$as_dir" && as_dir=.
8734   for ac_exec_ext in '' $ac_executable_extensions; do
8735   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8736     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8737     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8738     break 2
8739   fi
8740 done
8741 done
8742
8743 fi
8744 fi
8745 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8746 if test -n "$GCC_FOR_TARGET"; then
8747   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8748 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8749 else
8750   echo "$as_me:$LINENO: result: no" >&5
8751 echo "${ECHO_T}no" >&6
8752 fi
8753
8754   done
8755 fi
8756
8757 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8758   for ncn_progname in gcc; do
8759     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8760 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8761     if test -x $with_build_time_tools/${ncn_progname}; then
8762       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8763       echo "$as_me:$LINENO: result: yes" >&5
8764 echo "${ECHO_T}yes" >&6
8765       break
8766     else
8767       echo "$as_me:$LINENO: result: no" >&5
8768 echo "${ECHO_T}no" >&6
8769     fi
8770   done
8771 fi
8772
8773 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8774   for ncn_progname in gcc; do
8775     if test -n "$ncn_target_tool_prefix"; then
8776       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8777 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8778 echo "$as_me:$LINENO: checking for $ac_word" >&5
8779 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8780 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8781   echo $ECHO_N "(cached) $ECHO_C" >&6
8782 else
8783   if test -n "$GCC_FOR_TARGET"; then
8784   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8785 else
8786 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8787 for as_dir in $PATH
8788 do
8789   IFS=$as_save_IFS
8790   test -z "$as_dir" && as_dir=.
8791   for ac_exec_ext in '' $ac_executable_extensions; do
8792   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8793     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8794     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8795     break 2
8796   fi
8797 done
8798 done
8799
8800 fi
8801 fi
8802 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8803 if test -n "$GCC_FOR_TARGET"; then
8804   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8805 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8806 else
8807   echo "$as_me:$LINENO: result: no" >&5
8808 echo "${ECHO_T}no" >&6
8809 fi
8810
8811     fi
8812     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8813       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8814 set dummy ${ncn_progname}; ac_word=$2
8815 echo "$as_me:$LINENO: checking for $ac_word" >&5
8816 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8817 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8818   echo $ECHO_N "(cached) $ECHO_C" >&6
8819 else
8820   if test -n "$GCC_FOR_TARGET"; then
8821   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8822 else
8823 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8824 for as_dir in $PATH
8825 do
8826   IFS=$as_save_IFS
8827   test -z "$as_dir" && as_dir=.
8828   for ac_exec_ext in '' $ac_executable_extensions; do
8829   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8830     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8831     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8832     break 2
8833   fi
8834 done
8835 done
8836
8837 fi
8838 fi
8839 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8840 if test -n "$GCC_FOR_TARGET"; then
8841   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8842 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8843 else
8844   echo "$as_me:$LINENO: result: no" >&5
8845 echo "${ECHO_T}no" >&6
8846 fi
8847
8848     fi
8849     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8850   done
8851 fi
8852
8853 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8854   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8855 else
8856   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8857 fi
8858
8859
8860
8861 if test -n "$GCJ_FOR_TARGET"; then
8862   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8863 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8864   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8865 fi
8866
8867 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8868   for ncn_progname in gcj; do
8869     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8870 set dummy ${ncn_progname}; ac_word=$2
8871 echo "$as_me:$LINENO: checking for $ac_word" >&5
8872 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8873 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8874   echo $ECHO_N "(cached) $ECHO_C" >&6
8875 else
8876   if test -n "$GCJ_FOR_TARGET"; then
8877   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8878 else
8879 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8880 for as_dir in $PATH
8881 do
8882   IFS=$as_save_IFS
8883   test -z "$as_dir" && as_dir=.
8884   for ac_exec_ext in '' $ac_executable_extensions; do
8885   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8886     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8887     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8888     break 2
8889   fi
8890 done
8891 done
8892
8893 fi
8894 fi
8895 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8896 if test -n "$GCJ_FOR_TARGET"; then
8897   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8898 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8899 else
8900   echo "$as_me:$LINENO: result: no" >&5
8901 echo "${ECHO_T}no" >&6
8902 fi
8903
8904   done
8905 fi
8906
8907 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8908   for ncn_progname in gcj; do
8909     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8910 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8911     if test -x $with_build_time_tools/${ncn_progname}; then
8912       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8913       echo "$as_me:$LINENO: result: yes" >&5
8914 echo "${ECHO_T}yes" >&6
8915       break
8916     else
8917       echo "$as_me:$LINENO: result: no" >&5
8918 echo "${ECHO_T}no" >&6
8919     fi
8920   done
8921 fi
8922
8923 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8924   for ncn_progname in gcj; do
8925     if test -n "$ncn_target_tool_prefix"; then
8926       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8927 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8928 echo "$as_me:$LINENO: checking for $ac_word" >&5
8929 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8930 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8931   echo $ECHO_N "(cached) $ECHO_C" >&6
8932 else
8933   if test -n "$GCJ_FOR_TARGET"; then
8934   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8935 else
8936 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8937 for as_dir in $PATH
8938 do
8939   IFS=$as_save_IFS
8940   test -z "$as_dir" && as_dir=.
8941   for ac_exec_ext in '' $ac_executable_extensions; do
8942   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8943     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8944     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8945     break 2
8946   fi
8947 done
8948 done
8949
8950 fi
8951 fi
8952 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8953 if test -n "$GCJ_FOR_TARGET"; then
8954   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8955 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8956 else
8957   echo "$as_me:$LINENO: result: no" >&5
8958 echo "${ECHO_T}no" >&6
8959 fi
8960
8961     fi
8962     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8963       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8964 set dummy ${ncn_progname}; ac_word=$2
8965 echo "$as_me:$LINENO: checking for $ac_word" >&5
8966 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8967 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8968   echo $ECHO_N "(cached) $ECHO_C" >&6
8969 else
8970   if test -n "$GCJ_FOR_TARGET"; then
8971   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8972 else
8973 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8974 for as_dir in $PATH
8975 do
8976   IFS=$as_save_IFS
8977   test -z "$as_dir" && as_dir=.
8978   for ac_exec_ext in '' $ac_executable_extensions; do
8979   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8980     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8981     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8982     break 2
8983   fi
8984 done
8985 done
8986
8987 fi
8988 fi
8989 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8990 if test -n "$GCJ_FOR_TARGET"; then
8991   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8992 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8993 else
8994   echo "$as_me:$LINENO: result: no" >&5
8995 echo "${ECHO_T}no" >&6
8996 fi
8997
8998     fi
8999     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
9000   done
9001 fi
9002
9003 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
9004   set dummy gcj
9005   if test $build = $target ; then
9006     GCJ_FOR_TARGET="$2"
9007   else
9008     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9009   fi
9010 else
9011   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9012 fi
9013
9014
9015
9016 if test -n "$GFORTRAN_FOR_TARGET"; then
9017   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9018 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9019   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9020 fi
9021
9022 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9023   for ncn_progname in gfortran; do
9024     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9025 set dummy ${ncn_progname}; ac_word=$2
9026 echo "$as_me:$LINENO: checking for $ac_word" >&5
9027 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9028 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9029   echo $ECHO_N "(cached) $ECHO_C" >&6
9030 else
9031   if test -n "$GFORTRAN_FOR_TARGET"; then
9032   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9033 else
9034 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9035 for as_dir in $PATH
9036 do
9037   IFS=$as_save_IFS
9038   test -z "$as_dir" && as_dir=.
9039   for ac_exec_ext in '' $ac_executable_extensions; do
9040   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9041     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9042     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9043     break 2
9044   fi
9045 done
9046 done
9047
9048 fi
9049 fi
9050 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9051 if test -n "$GFORTRAN_FOR_TARGET"; then
9052   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9053 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9054 else
9055   echo "$as_me:$LINENO: result: no" >&5
9056 echo "${ECHO_T}no" >&6
9057 fi
9058
9059   done
9060 fi
9061
9062 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9063   for ncn_progname in gfortran; do
9064     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9065 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9066     if test -x $with_build_time_tools/${ncn_progname}; then
9067       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9068       echo "$as_me:$LINENO: result: yes" >&5
9069 echo "${ECHO_T}yes" >&6
9070       break
9071     else
9072       echo "$as_me:$LINENO: result: no" >&5
9073 echo "${ECHO_T}no" >&6
9074     fi
9075   done
9076 fi
9077
9078 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9079   for ncn_progname in gfortran; do
9080     if test -n "$ncn_target_tool_prefix"; then
9081       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9082 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9083 echo "$as_me:$LINENO: checking for $ac_word" >&5
9084 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9085 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9086   echo $ECHO_N "(cached) $ECHO_C" >&6
9087 else
9088   if test -n "$GFORTRAN_FOR_TARGET"; then
9089   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9090 else
9091 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9092 for as_dir in $PATH
9093 do
9094   IFS=$as_save_IFS
9095   test -z "$as_dir" && as_dir=.
9096   for ac_exec_ext in '' $ac_executable_extensions; do
9097   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9098     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9099     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9100     break 2
9101   fi
9102 done
9103 done
9104
9105 fi
9106 fi
9107 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9108 if test -n "$GFORTRAN_FOR_TARGET"; then
9109   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9110 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9111 else
9112   echo "$as_me:$LINENO: result: no" >&5
9113 echo "${ECHO_T}no" >&6
9114 fi
9115
9116     fi
9117     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9118       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9119 set dummy ${ncn_progname}; ac_word=$2
9120 echo "$as_me:$LINENO: checking for $ac_word" >&5
9121 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9122 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9123   echo $ECHO_N "(cached) $ECHO_C" >&6
9124 else
9125   if test -n "$GFORTRAN_FOR_TARGET"; then
9126   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9127 else
9128 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9129 for as_dir in $PATH
9130 do
9131   IFS=$as_save_IFS
9132   test -z "$as_dir" && as_dir=.
9133   for ac_exec_ext in '' $ac_executable_extensions; do
9134   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9135     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9136     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9137     break 2
9138   fi
9139 done
9140 done
9141
9142 fi
9143 fi
9144 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9145 if test -n "$GFORTRAN_FOR_TARGET"; then
9146   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9147 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9148 else
9149   echo "$as_me:$LINENO: result: no" >&5
9150 echo "${ECHO_T}no" >&6
9151 fi
9152
9153     fi
9154     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9155   done
9156 fi
9157
9158 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9159   set dummy gfortran
9160   if test $build = $target ; then
9161     GFORTRAN_FOR_TARGET="$2"
9162   else
9163     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9164   fi
9165 else
9166   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9167 fi
9168
9169
9170
9171 cat > conftest.c << \EOF
9172 #ifdef __GNUC__
9173   gcc_yay;
9174 #endif
9175 EOF
9176 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9177   have_gcc_for_target=yes
9178 else
9179   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9180   have_gcc_for_target=no
9181 fi
9182 rm conftest.c
9183
9184
9185
9186
9187 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9188   if test -n "$with_build_time_tools"; then
9189     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9190 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9191     if test -x $with_build_time_tools/ar; then
9192       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9193       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9194       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9195 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9196     else
9197       echo "$as_me:$LINENO: result: no" >&5
9198 echo "${ECHO_T}no" >&6
9199     fi
9200   elif test $build != $host && test $have_gcc_for_target = yes; then
9201     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9202     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9203     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9204   fi
9205 fi
9206 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9207   # Extract the first word of "ar", so it can be a program name with args.
9208 set dummy ar; ac_word=$2
9209 echo "$as_me:$LINENO: checking for $ac_word" >&5
9210 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9211 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9212   echo $ECHO_N "(cached) $ECHO_C" >&6
9213 else
9214   case $AR_FOR_TARGET in
9215   [\\/]* | ?:[\\/]*)
9216   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9217   ;;
9218   *)
9219   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9220 for as_dir in $gcc_cv_tool_dirs
9221 do
9222   IFS=$as_save_IFS
9223   test -z "$as_dir" && as_dir=.
9224   for ac_exec_ext in '' $ac_executable_extensions; do
9225   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9226     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9227     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9228     break 2
9229   fi
9230 done
9231 done
9232
9233   ;;
9234 esac
9235 fi
9236 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9237
9238 if test -n "$AR_FOR_TARGET"; then
9239   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9240 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9241 else
9242   echo "$as_me:$LINENO: result: no" >&5
9243 echo "${ECHO_T}no" >&6
9244 fi
9245
9246 fi
9247 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9248
9249
9250 if test -n "$AR_FOR_TARGET"; then
9251   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9252 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9253   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9254 fi
9255
9256 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9257   for ncn_progname in ar; do
9258     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9259 set dummy ${ncn_progname}; ac_word=$2
9260 echo "$as_me:$LINENO: checking for $ac_word" >&5
9261 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9262 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9263   echo $ECHO_N "(cached) $ECHO_C" >&6
9264 else
9265   if test -n "$AR_FOR_TARGET"; then
9266   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9267 else
9268 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9269 for as_dir in $PATH
9270 do
9271   IFS=$as_save_IFS
9272   test -z "$as_dir" && as_dir=.
9273   for ac_exec_ext in '' $ac_executable_extensions; do
9274   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9275     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9276     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9277     break 2
9278   fi
9279 done
9280 done
9281
9282 fi
9283 fi
9284 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9285 if test -n "$AR_FOR_TARGET"; then
9286   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9287 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9288 else
9289   echo "$as_me:$LINENO: result: no" >&5
9290 echo "${ECHO_T}no" >&6
9291 fi
9292
9293   done
9294 fi
9295
9296 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9297   for ncn_progname in ar; do
9298     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9299 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9300     if test -x $with_build_time_tools/${ncn_progname}; then
9301       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9302       echo "$as_me:$LINENO: result: yes" >&5
9303 echo "${ECHO_T}yes" >&6
9304       break
9305     else
9306       echo "$as_me:$LINENO: result: no" >&5
9307 echo "${ECHO_T}no" >&6
9308     fi
9309   done
9310 fi
9311
9312 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9313   for ncn_progname in ar; do
9314     if test -n "$ncn_target_tool_prefix"; then
9315       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9316 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9317 echo "$as_me:$LINENO: checking for $ac_word" >&5
9318 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9319 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9320   echo $ECHO_N "(cached) $ECHO_C" >&6
9321 else
9322   if test -n "$AR_FOR_TARGET"; then
9323   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9324 else
9325 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9326 for as_dir in $PATH
9327 do
9328   IFS=$as_save_IFS
9329   test -z "$as_dir" && as_dir=.
9330   for ac_exec_ext in '' $ac_executable_extensions; do
9331   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9332     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9333     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9334     break 2
9335   fi
9336 done
9337 done
9338
9339 fi
9340 fi
9341 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9342 if test -n "$AR_FOR_TARGET"; then
9343   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9344 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9345 else
9346   echo "$as_me:$LINENO: result: no" >&5
9347 echo "${ECHO_T}no" >&6
9348 fi
9349
9350     fi
9351     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9352       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9353 set dummy ${ncn_progname}; ac_word=$2
9354 echo "$as_me:$LINENO: checking for $ac_word" >&5
9355 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9356 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9357   echo $ECHO_N "(cached) $ECHO_C" >&6
9358 else
9359   if test -n "$AR_FOR_TARGET"; then
9360   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9361 else
9362 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9363 for as_dir in $PATH
9364 do
9365   IFS=$as_save_IFS
9366   test -z "$as_dir" && as_dir=.
9367   for ac_exec_ext in '' $ac_executable_extensions; do
9368   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9369     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9370     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9371     break 2
9372   fi
9373 done
9374 done
9375
9376 fi
9377 fi
9378 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9379 if test -n "$AR_FOR_TARGET"; then
9380   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9381 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9382 else
9383   echo "$as_me:$LINENO: result: no" >&5
9384 echo "${ECHO_T}no" >&6
9385 fi
9386
9387     fi
9388     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9389   done
9390 fi
9391
9392 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9393   set dummy ar
9394   if test $build = $target ; then
9395     AR_FOR_TARGET="$2"
9396   else
9397     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9398   fi
9399 else
9400   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9401 fi
9402
9403 else
9404   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9405 fi
9406
9407
9408
9409
9410 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9411   if test -n "$with_build_time_tools"; then
9412     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9413 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9414     if test -x $with_build_time_tools/as; then
9415       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9416       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9417       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9418 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9419     else
9420       echo "$as_me:$LINENO: result: no" >&5
9421 echo "${ECHO_T}no" >&6
9422     fi
9423   elif test $build != $host && test $have_gcc_for_target = yes; then
9424     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9425     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9426     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9427   fi
9428 fi
9429 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9430   # Extract the first word of "as", so it can be a program name with args.
9431 set dummy as; ac_word=$2
9432 echo "$as_me:$LINENO: checking for $ac_word" >&5
9433 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9434 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9435   echo $ECHO_N "(cached) $ECHO_C" >&6
9436 else
9437   case $AS_FOR_TARGET in
9438   [\\/]* | ?:[\\/]*)
9439   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9440   ;;
9441   *)
9442   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9443 for as_dir in $gcc_cv_tool_dirs
9444 do
9445   IFS=$as_save_IFS
9446   test -z "$as_dir" && as_dir=.
9447   for ac_exec_ext in '' $ac_executable_extensions; do
9448   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9449     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9450     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9451     break 2
9452   fi
9453 done
9454 done
9455
9456   ;;
9457 esac
9458 fi
9459 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9460
9461 if test -n "$AS_FOR_TARGET"; then
9462   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9463 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9464 else
9465   echo "$as_me:$LINENO: result: no" >&5
9466 echo "${ECHO_T}no" >&6
9467 fi
9468
9469 fi
9470 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9471
9472
9473 if test -n "$AS_FOR_TARGET"; then
9474   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9475 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9476   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9477 fi
9478
9479 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9480   for ncn_progname in as; do
9481     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9482 set dummy ${ncn_progname}; ac_word=$2
9483 echo "$as_me:$LINENO: checking for $ac_word" >&5
9484 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9485 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9486   echo $ECHO_N "(cached) $ECHO_C" >&6
9487 else
9488   if test -n "$AS_FOR_TARGET"; then
9489   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9490 else
9491 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9492 for as_dir in $PATH
9493 do
9494   IFS=$as_save_IFS
9495   test -z "$as_dir" && as_dir=.
9496   for ac_exec_ext in '' $ac_executable_extensions; do
9497   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9498     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9499     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9500     break 2
9501   fi
9502 done
9503 done
9504
9505 fi
9506 fi
9507 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9508 if test -n "$AS_FOR_TARGET"; then
9509   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9510 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9511 else
9512   echo "$as_me:$LINENO: result: no" >&5
9513 echo "${ECHO_T}no" >&6
9514 fi
9515
9516   done
9517 fi
9518
9519 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9520   for ncn_progname in as; do
9521     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9522 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9523     if test -x $with_build_time_tools/${ncn_progname}; then
9524       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9525       echo "$as_me:$LINENO: result: yes" >&5
9526 echo "${ECHO_T}yes" >&6
9527       break
9528     else
9529       echo "$as_me:$LINENO: result: no" >&5
9530 echo "${ECHO_T}no" >&6
9531     fi
9532   done
9533 fi
9534
9535 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9536   for ncn_progname in as; do
9537     if test -n "$ncn_target_tool_prefix"; then
9538       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9539 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9540 echo "$as_me:$LINENO: checking for $ac_word" >&5
9541 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9542 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9543   echo $ECHO_N "(cached) $ECHO_C" >&6
9544 else
9545   if test -n "$AS_FOR_TARGET"; then
9546   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9547 else
9548 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9549 for as_dir in $PATH
9550 do
9551   IFS=$as_save_IFS
9552   test -z "$as_dir" && as_dir=.
9553   for ac_exec_ext in '' $ac_executable_extensions; do
9554   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9555     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9556     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9557     break 2
9558   fi
9559 done
9560 done
9561
9562 fi
9563 fi
9564 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9565 if test -n "$AS_FOR_TARGET"; then
9566   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9567 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9568 else
9569   echo "$as_me:$LINENO: result: no" >&5
9570 echo "${ECHO_T}no" >&6
9571 fi
9572
9573     fi
9574     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9575       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9576 set dummy ${ncn_progname}; ac_word=$2
9577 echo "$as_me:$LINENO: checking for $ac_word" >&5
9578 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9579 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9580   echo $ECHO_N "(cached) $ECHO_C" >&6
9581 else
9582   if test -n "$AS_FOR_TARGET"; then
9583   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9584 else
9585 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9586 for as_dir in $PATH
9587 do
9588   IFS=$as_save_IFS
9589   test -z "$as_dir" && as_dir=.
9590   for ac_exec_ext in '' $ac_executable_extensions; do
9591   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9592     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9593     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9594     break 2
9595   fi
9596 done
9597 done
9598
9599 fi
9600 fi
9601 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9602 if test -n "$AS_FOR_TARGET"; then
9603   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9604 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9605 else
9606   echo "$as_me:$LINENO: result: no" >&5
9607 echo "${ECHO_T}no" >&6
9608 fi
9609
9610     fi
9611     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9612   done
9613 fi
9614
9615 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9616   set dummy as
9617   if test $build = $target ; then
9618     AS_FOR_TARGET="$2"
9619   else
9620     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9621   fi
9622 else
9623   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9624 fi
9625
9626 else
9627   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9628 fi
9629
9630
9631
9632
9633 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9634   if test -n "$with_build_time_tools"; then
9635     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9636 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9637     if test -x $with_build_time_tools/dlltool; then
9638       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9639       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9640       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9641 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9642     else
9643       echo "$as_me:$LINENO: result: no" >&5
9644 echo "${ECHO_T}no" >&6
9645     fi
9646   elif test $build != $host && test $have_gcc_for_target = yes; then
9647     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9648     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9649     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9650   fi
9651 fi
9652 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9653   # Extract the first word of "dlltool", so it can be a program name with args.
9654 set dummy dlltool; ac_word=$2
9655 echo "$as_me:$LINENO: checking for $ac_word" >&5
9656 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9657 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9658   echo $ECHO_N "(cached) $ECHO_C" >&6
9659 else
9660   case $DLLTOOL_FOR_TARGET in
9661   [\\/]* | ?:[\\/]*)
9662   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9663   ;;
9664   *)
9665   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9666 for as_dir in $gcc_cv_tool_dirs
9667 do
9668   IFS=$as_save_IFS
9669   test -z "$as_dir" && as_dir=.
9670   for ac_exec_ext in '' $ac_executable_extensions; do
9671   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9672     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9673     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9674     break 2
9675   fi
9676 done
9677 done
9678
9679   ;;
9680 esac
9681 fi
9682 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9683
9684 if test -n "$DLLTOOL_FOR_TARGET"; then
9685   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9686 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9687 else
9688   echo "$as_me:$LINENO: result: no" >&5
9689 echo "${ECHO_T}no" >&6
9690 fi
9691
9692 fi
9693 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9694
9695
9696 if test -n "$DLLTOOL_FOR_TARGET"; then
9697   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9698 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9699   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9700 fi
9701
9702 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9703   for ncn_progname in dlltool; do
9704     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9705 set dummy ${ncn_progname}; ac_word=$2
9706 echo "$as_me:$LINENO: checking for $ac_word" >&5
9707 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9708 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9709   echo $ECHO_N "(cached) $ECHO_C" >&6
9710 else
9711   if test -n "$DLLTOOL_FOR_TARGET"; then
9712   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9713 else
9714 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9715 for as_dir in $PATH
9716 do
9717   IFS=$as_save_IFS
9718   test -z "$as_dir" && as_dir=.
9719   for ac_exec_ext in '' $ac_executable_extensions; do
9720   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9721     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9722     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9723     break 2
9724   fi
9725 done
9726 done
9727
9728 fi
9729 fi
9730 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9731 if test -n "$DLLTOOL_FOR_TARGET"; then
9732   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9733 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9734 else
9735   echo "$as_me:$LINENO: result: no" >&5
9736 echo "${ECHO_T}no" >&6
9737 fi
9738
9739   done
9740 fi
9741
9742 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9743   for ncn_progname in dlltool; do
9744     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9745 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9746     if test -x $with_build_time_tools/${ncn_progname}; then
9747       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9748       echo "$as_me:$LINENO: result: yes" >&5
9749 echo "${ECHO_T}yes" >&6
9750       break
9751     else
9752       echo "$as_me:$LINENO: result: no" >&5
9753 echo "${ECHO_T}no" >&6
9754     fi
9755   done
9756 fi
9757
9758 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9759   for ncn_progname in dlltool; do
9760     if test -n "$ncn_target_tool_prefix"; then
9761       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9762 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9763 echo "$as_me:$LINENO: checking for $ac_word" >&5
9764 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9765 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9766   echo $ECHO_N "(cached) $ECHO_C" >&6
9767 else
9768   if test -n "$DLLTOOL_FOR_TARGET"; then
9769   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9770 else
9771 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9772 for as_dir in $PATH
9773 do
9774   IFS=$as_save_IFS
9775   test -z "$as_dir" && as_dir=.
9776   for ac_exec_ext in '' $ac_executable_extensions; do
9777   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9778     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9779     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9780     break 2
9781   fi
9782 done
9783 done
9784
9785 fi
9786 fi
9787 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9788 if test -n "$DLLTOOL_FOR_TARGET"; then
9789   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9790 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9791 else
9792   echo "$as_me:$LINENO: result: no" >&5
9793 echo "${ECHO_T}no" >&6
9794 fi
9795
9796     fi
9797     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9798       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9799 set dummy ${ncn_progname}; ac_word=$2
9800 echo "$as_me:$LINENO: checking for $ac_word" >&5
9801 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9802 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9803   echo $ECHO_N "(cached) $ECHO_C" >&6
9804 else
9805   if test -n "$DLLTOOL_FOR_TARGET"; then
9806   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9807 else
9808 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9809 for as_dir in $PATH
9810 do
9811   IFS=$as_save_IFS
9812   test -z "$as_dir" && as_dir=.
9813   for ac_exec_ext in '' $ac_executable_extensions; do
9814   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9815     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9816     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9817     break 2
9818   fi
9819 done
9820 done
9821
9822 fi
9823 fi
9824 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9825 if test -n "$DLLTOOL_FOR_TARGET"; then
9826   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9827 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9828 else
9829   echo "$as_me:$LINENO: result: no" >&5
9830 echo "${ECHO_T}no" >&6
9831 fi
9832
9833     fi
9834     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9835   done
9836 fi
9837
9838 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9839   set dummy dlltool
9840   if test $build = $target ; then
9841     DLLTOOL_FOR_TARGET="$2"
9842   else
9843     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9844   fi
9845 else
9846   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9847 fi
9848
9849 else
9850   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9851 fi
9852
9853
9854
9855
9856 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9857   if test -n "$with_build_time_tools"; then
9858     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9859 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9860     if test -x $with_build_time_tools/ld; then
9861       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9862       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9863       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9864 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9865     else
9866       echo "$as_me:$LINENO: result: no" >&5
9867 echo "${ECHO_T}no" >&6
9868     fi
9869   elif test $build != $host && test $have_gcc_for_target = yes; then
9870     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9871     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9872     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9873   fi
9874 fi
9875 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9876   # Extract the first word of "ld", so it can be a program name with args.
9877 set dummy ld; ac_word=$2
9878 echo "$as_me:$LINENO: checking for $ac_word" >&5
9879 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9880 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9881   echo $ECHO_N "(cached) $ECHO_C" >&6
9882 else
9883   case $LD_FOR_TARGET in
9884   [\\/]* | ?:[\\/]*)
9885   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9886   ;;
9887   *)
9888   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9889 for as_dir in $gcc_cv_tool_dirs
9890 do
9891   IFS=$as_save_IFS
9892   test -z "$as_dir" && as_dir=.
9893   for ac_exec_ext in '' $ac_executable_extensions; do
9894   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9895     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9896     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9897     break 2
9898   fi
9899 done
9900 done
9901
9902   ;;
9903 esac
9904 fi
9905 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9906
9907 if test -n "$LD_FOR_TARGET"; then
9908   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9909 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9910 else
9911   echo "$as_me:$LINENO: result: no" >&5
9912 echo "${ECHO_T}no" >&6
9913 fi
9914
9915 fi
9916 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9917
9918
9919 if test -n "$LD_FOR_TARGET"; then
9920   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9921 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9922   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9923 fi
9924
9925 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9926   for ncn_progname in ld; do
9927     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9928 set dummy ${ncn_progname}; ac_word=$2
9929 echo "$as_me:$LINENO: checking for $ac_word" >&5
9930 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9931 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9932   echo $ECHO_N "(cached) $ECHO_C" >&6
9933 else
9934   if test -n "$LD_FOR_TARGET"; then
9935   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9936 else
9937 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9938 for as_dir in $PATH
9939 do
9940   IFS=$as_save_IFS
9941   test -z "$as_dir" && as_dir=.
9942   for ac_exec_ext in '' $ac_executable_extensions; do
9943   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9944     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9945     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9946     break 2
9947   fi
9948 done
9949 done
9950
9951 fi
9952 fi
9953 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9954 if test -n "$LD_FOR_TARGET"; then
9955   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9956 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9957 else
9958   echo "$as_me:$LINENO: result: no" >&5
9959 echo "${ECHO_T}no" >&6
9960 fi
9961
9962   done
9963 fi
9964
9965 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9966   for ncn_progname in ld; do
9967     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9968 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9969     if test -x $with_build_time_tools/${ncn_progname}; then
9970       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9971       echo "$as_me:$LINENO: result: yes" >&5
9972 echo "${ECHO_T}yes" >&6
9973       break
9974     else
9975       echo "$as_me:$LINENO: result: no" >&5
9976 echo "${ECHO_T}no" >&6
9977     fi
9978   done
9979 fi
9980
9981 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9982   for ncn_progname in ld; do
9983     if test -n "$ncn_target_tool_prefix"; then
9984       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9985 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9986 echo "$as_me:$LINENO: checking for $ac_word" >&5
9987 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9988 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9989   echo $ECHO_N "(cached) $ECHO_C" >&6
9990 else
9991   if test -n "$LD_FOR_TARGET"; then
9992   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9993 else
9994 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9995 for as_dir in $PATH
9996 do
9997   IFS=$as_save_IFS
9998   test -z "$as_dir" && as_dir=.
9999   for ac_exec_ext in '' $ac_executable_extensions; do
10000   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10001     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10002     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10003     break 2
10004   fi
10005 done
10006 done
10007
10008 fi
10009 fi
10010 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10011 if test -n "$LD_FOR_TARGET"; then
10012   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10013 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10014 else
10015   echo "$as_me:$LINENO: result: no" >&5
10016 echo "${ECHO_T}no" >&6
10017 fi
10018
10019     fi
10020     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10021       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10022 set dummy ${ncn_progname}; ac_word=$2
10023 echo "$as_me:$LINENO: checking for $ac_word" >&5
10024 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10025 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10026   echo $ECHO_N "(cached) $ECHO_C" >&6
10027 else
10028   if test -n "$LD_FOR_TARGET"; then
10029   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10030 else
10031 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10032 for as_dir in $PATH
10033 do
10034   IFS=$as_save_IFS
10035   test -z "$as_dir" && as_dir=.
10036   for ac_exec_ext in '' $ac_executable_extensions; do
10037   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10038     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10039     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10040     break 2
10041   fi
10042 done
10043 done
10044
10045 fi
10046 fi
10047 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10048 if test -n "$LD_FOR_TARGET"; then
10049   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10050 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10051 else
10052   echo "$as_me:$LINENO: result: no" >&5
10053 echo "${ECHO_T}no" >&6
10054 fi
10055
10056     fi
10057     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10058   done
10059 fi
10060
10061 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10062   set dummy ld
10063   if test $build = $target ; then
10064     LD_FOR_TARGET="$2"
10065   else
10066     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10067   fi
10068 else
10069   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10070 fi
10071
10072 else
10073   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10074 fi
10075
10076
10077
10078
10079 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10080   if test -n "$with_build_time_tools"; then
10081     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10082 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10083     if test -x $with_build_time_tools/lipo; then
10084       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10085       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10086       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10087 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10088     else
10089       echo "$as_me:$LINENO: result: no" >&5
10090 echo "${ECHO_T}no" >&6
10091     fi
10092   elif test $build != $host && test $have_gcc_for_target = yes; then
10093     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10094     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10095     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10096   fi
10097 fi
10098 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10099   # Extract the first word of "lipo", so it can be a program name with args.
10100 set dummy lipo; ac_word=$2
10101 echo "$as_me:$LINENO: checking for $ac_word" >&5
10102 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10103 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10104   echo $ECHO_N "(cached) $ECHO_C" >&6
10105 else
10106   case $LIPO_FOR_TARGET in
10107   [\\/]* | ?:[\\/]*)
10108   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10109   ;;
10110   *)
10111   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10112 for as_dir in $gcc_cv_tool_dirs
10113 do
10114   IFS=$as_save_IFS
10115   test -z "$as_dir" && as_dir=.
10116   for ac_exec_ext in '' $ac_executable_extensions; do
10117   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10118     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10119     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10120     break 2
10121   fi
10122 done
10123 done
10124
10125   ;;
10126 esac
10127 fi
10128 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10129
10130 if test -n "$LIPO_FOR_TARGET"; then
10131   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10132 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10133 else
10134   echo "$as_me:$LINENO: result: no" >&5
10135 echo "${ECHO_T}no" >&6
10136 fi
10137
10138 fi
10139 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10140
10141
10142 if test -n "$LIPO_FOR_TARGET"; then
10143   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10144 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10145   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10146 fi
10147
10148 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10149   for ncn_progname in lipo; do
10150     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10151 set dummy ${ncn_progname}; ac_word=$2
10152 echo "$as_me:$LINENO: checking for $ac_word" >&5
10153 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10154 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10155   echo $ECHO_N "(cached) $ECHO_C" >&6
10156 else
10157   if test -n "$LIPO_FOR_TARGET"; then
10158   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10159 else
10160 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10161 for as_dir in $PATH
10162 do
10163   IFS=$as_save_IFS
10164   test -z "$as_dir" && as_dir=.
10165   for ac_exec_ext in '' $ac_executable_extensions; do
10166   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10167     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10168     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10169     break 2
10170   fi
10171 done
10172 done
10173
10174 fi
10175 fi
10176 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10177 if test -n "$LIPO_FOR_TARGET"; then
10178   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10179 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10180 else
10181   echo "$as_me:$LINENO: result: no" >&5
10182 echo "${ECHO_T}no" >&6
10183 fi
10184
10185   done
10186 fi
10187
10188 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10189   for ncn_progname in lipo; do
10190     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10191 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10192     if test -x $with_build_time_tools/${ncn_progname}; then
10193       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10194       echo "$as_me:$LINENO: result: yes" >&5
10195 echo "${ECHO_T}yes" >&6
10196       break
10197     else
10198       echo "$as_me:$LINENO: result: no" >&5
10199 echo "${ECHO_T}no" >&6
10200     fi
10201   done
10202 fi
10203
10204 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10205   for ncn_progname in lipo; do
10206     if test -n "$ncn_target_tool_prefix"; then
10207       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10208 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10209 echo "$as_me:$LINENO: checking for $ac_word" >&5
10210 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10211 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10212   echo $ECHO_N "(cached) $ECHO_C" >&6
10213 else
10214   if test -n "$LIPO_FOR_TARGET"; then
10215   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10216 else
10217 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10218 for as_dir in $PATH
10219 do
10220   IFS=$as_save_IFS
10221   test -z "$as_dir" && as_dir=.
10222   for ac_exec_ext in '' $ac_executable_extensions; do
10223   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10224     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10225     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10226     break 2
10227   fi
10228 done
10229 done
10230
10231 fi
10232 fi
10233 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10234 if test -n "$LIPO_FOR_TARGET"; then
10235   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10236 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10237 else
10238   echo "$as_me:$LINENO: result: no" >&5
10239 echo "${ECHO_T}no" >&6
10240 fi
10241
10242     fi
10243     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10244       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10245 set dummy ${ncn_progname}; ac_word=$2
10246 echo "$as_me:$LINENO: checking for $ac_word" >&5
10247 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10248 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10249   echo $ECHO_N "(cached) $ECHO_C" >&6
10250 else
10251   if test -n "$LIPO_FOR_TARGET"; then
10252   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10253 else
10254 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10255 for as_dir in $PATH
10256 do
10257   IFS=$as_save_IFS
10258   test -z "$as_dir" && as_dir=.
10259   for ac_exec_ext in '' $ac_executable_extensions; do
10260   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10261     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10262     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10263     break 2
10264   fi
10265 done
10266 done
10267
10268 fi
10269 fi
10270 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10271 if test -n "$LIPO_FOR_TARGET"; then
10272   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10273 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10274 else
10275   echo "$as_me:$LINENO: result: no" >&5
10276 echo "${ECHO_T}no" >&6
10277 fi
10278
10279     fi
10280     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10281   done
10282 fi
10283
10284 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10285   set dummy lipo
10286   if test $build = $target ; then
10287     LIPO_FOR_TARGET="$2"
10288   else
10289     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10290   fi
10291 else
10292   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10293 fi
10294
10295 else
10296   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10297 fi
10298
10299
10300
10301
10302 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10303   if test -n "$with_build_time_tools"; then
10304     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10305 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10306     if test -x $with_build_time_tools/nm; then
10307       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10308       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10309       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10310 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10311     else
10312       echo "$as_me:$LINENO: result: no" >&5
10313 echo "${ECHO_T}no" >&6
10314     fi
10315   elif test $build != $host && test $have_gcc_for_target = yes; then
10316     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10317     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10318     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10319   fi
10320 fi
10321 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10322   # Extract the first word of "nm", so it can be a program name with args.
10323 set dummy nm; ac_word=$2
10324 echo "$as_me:$LINENO: checking for $ac_word" >&5
10325 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10326 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10327   echo $ECHO_N "(cached) $ECHO_C" >&6
10328 else
10329   case $NM_FOR_TARGET in
10330   [\\/]* | ?:[\\/]*)
10331   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10332   ;;
10333   *)
10334   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10335 for as_dir in $gcc_cv_tool_dirs
10336 do
10337   IFS=$as_save_IFS
10338   test -z "$as_dir" && as_dir=.
10339   for ac_exec_ext in '' $ac_executable_extensions; do
10340   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10341     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10342     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10343     break 2
10344   fi
10345 done
10346 done
10347
10348   ;;
10349 esac
10350 fi
10351 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10352
10353 if test -n "$NM_FOR_TARGET"; then
10354   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10355 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10356 else
10357   echo "$as_me:$LINENO: result: no" >&5
10358 echo "${ECHO_T}no" >&6
10359 fi
10360
10361 fi
10362 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10363
10364
10365 if test -n "$NM_FOR_TARGET"; then
10366   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10367 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10368   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10369 fi
10370
10371 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10372   for ncn_progname in nm; do
10373     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10374 set dummy ${ncn_progname}; ac_word=$2
10375 echo "$as_me:$LINENO: checking for $ac_word" >&5
10376 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10377 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10378   echo $ECHO_N "(cached) $ECHO_C" >&6
10379 else
10380   if test -n "$NM_FOR_TARGET"; then
10381   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10382 else
10383 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10384 for as_dir in $PATH
10385 do
10386   IFS=$as_save_IFS
10387   test -z "$as_dir" && as_dir=.
10388   for ac_exec_ext in '' $ac_executable_extensions; do
10389   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10390     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10391     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10392     break 2
10393   fi
10394 done
10395 done
10396
10397 fi
10398 fi
10399 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10400 if test -n "$NM_FOR_TARGET"; then
10401   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10402 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10403 else
10404   echo "$as_me:$LINENO: result: no" >&5
10405 echo "${ECHO_T}no" >&6
10406 fi
10407
10408   done
10409 fi
10410
10411 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10412   for ncn_progname in nm; do
10413     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10414 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10415     if test -x $with_build_time_tools/${ncn_progname}; then
10416       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10417       echo "$as_me:$LINENO: result: yes" >&5
10418 echo "${ECHO_T}yes" >&6
10419       break
10420     else
10421       echo "$as_me:$LINENO: result: no" >&5
10422 echo "${ECHO_T}no" >&6
10423     fi
10424   done
10425 fi
10426
10427 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10428   for ncn_progname in nm; do
10429     if test -n "$ncn_target_tool_prefix"; then
10430       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10431 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10432 echo "$as_me:$LINENO: checking for $ac_word" >&5
10433 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10434 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10435   echo $ECHO_N "(cached) $ECHO_C" >&6
10436 else
10437   if test -n "$NM_FOR_TARGET"; then
10438   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10439 else
10440 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10441 for as_dir in $PATH
10442 do
10443   IFS=$as_save_IFS
10444   test -z "$as_dir" && as_dir=.
10445   for ac_exec_ext in '' $ac_executable_extensions; do
10446   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10447     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10448     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10449     break 2
10450   fi
10451 done
10452 done
10453
10454 fi
10455 fi
10456 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10457 if test -n "$NM_FOR_TARGET"; then
10458   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10459 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10460 else
10461   echo "$as_me:$LINENO: result: no" >&5
10462 echo "${ECHO_T}no" >&6
10463 fi
10464
10465     fi
10466     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10467       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10468 set dummy ${ncn_progname}; ac_word=$2
10469 echo "$as_me:$LINENO: checking for $ac_word" >&5
10470 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10471 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10472   echo $ECHO_N "(cached) $ECHO_C" >&6
10473 else
10474   if test -n "$NM_FOR_TARGET"; then
10475   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10476 else
10477 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10478 for as_dir in $PATH
10479 do
10480   IFS=$as_save_IFS
10481   test -z "$as_dir" && as_dir=.
10482   for ac_exec_ext in '' $ac_executable_extensions; do
10483   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10484     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10485     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10486     break 2
10487   fi
10488 done
10489 done
10490
10491 fi
10492 fi
10493 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10494 if test -n "$NM_FOR_TARGET"; then
10495   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10496 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10497 else
10498   echo "$as_me:$LINENO: result: no" >&5
10499 echo "${ECHO_T}no" >&6
10500 fi
10501
10502     fi
10503     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10504   done
10505 fi
10506
10507 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10508   set dummy nm
10509   if test $build = $target ; then
10510     NM_FOR_TARGET="$2"
10511   else
10512     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10513   fi
10514 else
10515   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10516 fi
10517
10518 else
10519   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10520 fi
10521
10522
10523
10524
10525 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10526   if test -n "$with_build_time_tools"; then
10527     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10528 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10529     if test -x $with_build_time_tools/objdump; then
10530       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10531       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10532       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10533 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10534     else
10535       echo "$as_me:$LINENO: result: no" >&5
10536 echo "${ECHO_T}no" >&6
10537     fi
10538   elif test $build != $host && test $have_gcc_for_target = yes; then
10539     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10540     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10541     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10542   fi
10543 fi
10544 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10545   # Extract the first word of "objdump", so it can be a program name with args.
10546 set dummy objdump; ac_word=$2
10547 echo "$as_me:$LINENO: checking for $ac_word" >&5
10548 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10549 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10550   echo $ECHO_N "(cached) $ECHO_C" >&6
10551 else
10552   case $OBJDUMP_FOR_TARGET in
10553   [\\/]* | ?:[\\/]*)
10554   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10555   ;;
10556   *)
10557   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10558 for as_dir in $gcc_cv_tool_dirs
10559 do
10560   IFS=$as_save_IFS
10561   test -z "$as_dir" && as_dir=.
10562   for ac_exec_ext in '' $ac_executable_extensions; do
10563   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10564     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10565     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10566     break 2
10567   fi
10568 done
10569 done
10570
10571   ;;
10572 esac
10573 fi
10574 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10575
10576 if test -n "$OBJDUMP_FOR_TARGET"; then
10577   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10578 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10579 else
10580   echo "$as_me:$LINENO: result: no" >&5
10581 echo "${ECHO_T}no" >&6
10582 fi
10583
10584 fi
10585 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10586
10587
10588 if test -n "$OBJDUMP_FOR_TARGET"; then
10589   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10590 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10591   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10592 fi
10593
10594 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10595   for ncn_progname in objdump; do
10596     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10597 set dummy ${ncn_progname}; ac_word=$2
10598 echo "$as_me:$LINENO: checking for $ac_word" >&5
10599 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10600 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10601   echo $ECHO_N "(cached) $ECHO_C" >&6
10602 else
10603   if test -n "$OBJDUMP_FOR_TARGET"; then
10604   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10605 else
10606 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10607 for as_dir in $PATH
10608 do
10609   IFS=$as_save_IFS
10610   test -z "$as_dir" && as_dir=.
10611   for ac_exec_ext in '' $ac_executable_extensions; do
10612   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10613     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10614     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10615     break 2
10616   fi
10617 done
10618 done
10619
10620 fi
10621 fi
10622 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10623 if test -n "$OBJDUMP_FOR_TARGET"; then
10624   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10625 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10626 else
10627   echo "$as_me:$LINENO: result: no" >&5
10628 echo "${ECHO_T}no" >&6
10629 fi
10630
10631   done
10632 fi
10633
10634 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10635   for ncn_progname in objdump; do
10636     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10637 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10638     if test -x $with_build_time_tools/${ncn_progname}; then
10639       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10640       echo "$as_me:$LINENO: result: yes" >&5
10641 echo "${ECHO_T}yes" >&6
10642       break
10643     else
10644       echo "$as_me:$LINENO: result: no" >&5
10645 echo "${ECHO_T}no" >&6
10646     fi
10647   done
10648 fi
10649
10650 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10651   for ncn_progname in objdump; do
10652     if test -n "$ncn_target_tool_prefix"; then
10653       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10654 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10655 echo "$as_me:$LINENO: checking for $ac_word" >&5
10656 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10657 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10658   echo $ECHO_N "(cached) $ECHO_C" >&6
10659 else
10660   if test -n "$OBJDUMP_FOR_TARGET"; then
10661   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10662 else
10663 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10664 for as_dir in $PATH
10665 do
10666   IFS=$as_save_IFS
10667   test -z "$as_dir" && as_dir=.
10668   for ac_exec_ext in '' $ac_executable_extensions; do
10669   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10670     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10671     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10672     break 2
10673   fi
10674 done
10675 done
10676
10677 fi
10678 fi
10679 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10680 if test -n "$OBJDUMP_FOR_TARGET"; then
10681   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10682 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10683 else
10684   echo "$as_me:$LINENO: result: no" >&5
10685 echo "${ECHO_T}no" >&6
10686 fi
10687
10688     fi
10689     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10690       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10691 set dummy ${ncn_progname}; ac_word=$2
10692 echo "$as_me:$LINENO: checking for $ac_word" >&5
10693 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10694 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10695   echo $ECHO_N "(cached) $ECHO_C" >&6
10696 else
10697   if test -n "$OBJDUMP_FOR_TARGET"; then
10698   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10699 else
10700 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10701 for as_dir in $PATH
10702 do
10703   IFS=$as_save_IFS
10704   test -z "$as_dir" && as_dir=.
10705   for ac_exec_ext in '' $ac_executable_extensions; do
10706   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10707     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10708     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10709     break 2
10710   fi
10711 done
10712 done
10713
10714 fi
10715 fi
10716 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10717 if test -n "$OBJDUMP_FOR_TARGET"; then
10718   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10719 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10720 else
10721   echo "$as_me:$LINENO: result: no" >&5
10722 echo "${ECHO_T}no" >&6
10723 fi
10724
10725     fi
10726     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10727   done
10728 fi
10729
10730 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10731   set dummy objdump
10732   if test $build = $target ; then
10733     OBJDUMP_FOR_TARGET="$2"
10734   else
10735     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10736   fi
10737 else
10738   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10739 fi
10740
10741 else
10742   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10743 fi
10744
10745
10746
10747
10748 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10749   if test -n "$with_build_time_tools"; then
10750     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10751 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10752     if test -x $with_build_time_tools/ranlib; then
10753       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10754       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10755       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10756 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10757     else
10758       echo "$as_me:$LINENO: result: no" >&5
10759 echo "${ECHO_T}no" >&6
10760     fi
10761   elif test $build != $host && test $have_gcc_for_target = yes; then
10762     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10763     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10764     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10765   fi
10766 fi
10767 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10768   # Extract the first word of "ranlib", so it can be a program name with args.
10769 set dummy ranlib; ac_word=$2
10770 echo "$as_me:$LINENO: checking for $ac_word" >&5
10771 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10772 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10773   echo $ECHO_N "(cached) $ECHO_C" >&6
10774 else
10775   case $RANLIB_FOR_TARGET in
10776   [\\/]* | ?:[\\/]*)
10777   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10778   ;;
10779   *)
10780   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10781 for as_dir in $gcc_cv_tool_dirs
10782 do
10783   IFS=$as_save_IFS
10784   test -z "$as_dir" && as_dir=.
10785   for ac_exec_ext in '' $ac_executable_extensions; do
10786   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10787     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10788     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10789     break 2
10790   fi
10791 done
10792 done
10793
10794   ;;
10795 esac
10796 fi
10797 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10798
10799 if test -n "$RANLIB_FOR_TARGET"; then
10800   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10801 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10802 else
10803   echo "$as_me:$LINENO: result: no" >&5
10804 echo "${ECHO_T}no" >&6
10805 fi
10806
10807 fi
10808 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10809
10810
10811 if test -n "$RANLIB_FOR_TARGET"; then
10812   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10813 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10814   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10815 fi
10816
10817 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10818   for ncn_progname in ranlib; do
10819     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10820 set dummy ${ncn_progname}; ac_word=$2
10821 echo "$as_me:$LINENO: checking for $ac_word" >&5
10822 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10823 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10824   echo $ECHO_N "(cached) $ECHO_C" >&6
10825 else
10826   if test -n "$RANLIB_FOR_TARGET"; then
10827   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10828 else
10829 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10830 for as_dir in $PATH
10831 do
10832   IFS=$as_save_IFS
10833   test -z "$as_dir" && as_dir=.
10834   for ac_exec_ext in '' $ac_executable_extensions; do
10835   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10836     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10837     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10838     break 2
10839   fi
10840 done
10841 done
10842
10843 fi
10844 fi
10845 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10846 if test -n "$RANLIB_FOR_TARGET"; then
10847   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10848 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10849 else
10850   echo "$as_me:$LINENO: result: no" >&5
10851 echo "${ECHO_T}no" >&6
10852 fi
10853
10854   done
10855 fi
10856
10857 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10858   for ncn_progname in ranlib; do
10859     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10860 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10861     if test -x $with_build_time_tools/${ncn_progname}; then
10862       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10863       echo "$as_me:$LINENO: result: yes" >&5
10864 echo "${ECHO_T}yes" >&6
10865       break
10866     else
10867       echo "$as_me:$LINENO: result: no" >&5
10868 echo "${ECHO_T}no" >&6
10869     fi
10870   done
10871 fi
10872
10873 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10874   for ncn_progname in ranlib; do
10875     if test -n "$ncn_target_tool_prefix"; then
10876       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10877 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10878 echo "$as_me:$LINENO: checking for $ac_word" >&5
10879 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10880 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10881   echo $ECHO_N "(cached) $ECHO_C" >&6
10882 else
10883   if test -n "$RANLIB_FOR_TARGET"; then
10884   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10885 else
10886 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10887 for as_dir in $PATH
10888 do
10889   IFS=$as_save_IFS
10890   test -z "$as_dir" && as_dir=.
10891   for ac_exec_ext in '' $ac_executable_extensions; do
10892   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10893     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10894     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10895     break 2
10896   fi
10897 done
10898 done
10899
10900 fi
10901 fi
10902 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10903 if test -n "$RANLIB_FOR_TARGET"; then
10904   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10905 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10906 else
10907   echo "$as_me:$LINENO: result: no" >&5
10908 echo "${ECHO_T}no" >&6
10909 fi
10910
10911     fi
10912     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10913       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10914 set dummy ${ncn_progname}; ac_word=$2
10915 echo "$as_me:$LINENO: checking for $ac_word" >&5
10916 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10917 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10918   echo $ECHO_N "(cached) $ECHO_C" >&6
10919 else
10920   if test -n "$RANLIB_FOR_TARGET"; then
10921   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10922 else
10923 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10924 for as_dir in $PATH
10925 do
10926   IFS=$as_save_IFS
10927   test -z "$as_dir" && as_dir=.
10928   for ac_exec_ext in '' $ac_executable_extensions; do
10929   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10930     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10931     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10932     break 2
10933   fi
10934 done
10935 done
10936
10937 fi
10938 fi
10939 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10940 if test -n "$RANLIB_FOR_TARGET"; then
10941   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10942 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10943 else
10944   echo "$as_me:$LINENO: result: no" >&5
10945 echo "${ECHO_T}no" >&6
10946 fi
10947
10948     fi
10949     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10950   done
10951 fi
10952
10953 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10954   set dummy ranlib
10955   if test $build = $target ; then
10956     RANLIB_FOR_TARGET="$2"
10957   else
10958     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10959   fi
10960 else
10961   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10962 fi
10963
10964 else
10965   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10966 fi
10967
10968
10969
10970
10971 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10972   if test -n "$with_build_time_tools"; then
10973     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10974 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10975     if test -x $with_build_time_tools/strip; then
10976       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10977       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10978       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10979 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10980     else
10981       echo "$as_me:$LINENO: result: no" >&5
10982 echo "${ECHO_T}no" >&6
10983     fi
10984   elif test $build != $host && test $have_gcc_for_target = yes; then
10985     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10986     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10987     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10988   fi
10989 fi
10990 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10991   # Extract the first word of "strip", so it can be a program name with args.
10992 set dummy strip; ac_word=$2
10993 echo "$as_me:$LINENO: checking for $ac_word" >&5
10994 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10995 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10996   echo $ECHO_N "(cached) $ECHO_C" >&6
10997 else
10998   case $STRIP_FOR_TARGET in
10999   [\\/]* | ?:[\\/]*)
11000   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
11001   ;;
11002   *)
11003   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11004 for as_dir in $gcc_cv_tool_dirs
11005 do
11006   IFS=$as_save_IFS
11007   test -z "$as_dir" && as_dir=.
11008   for ac_exec_ext in '' $ac_executable_extensions; do
11009   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11010     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11011     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11012     break 2
11013   fi
11014 done
11015 done
11016
11017   ;;
11018 esac
11019 fi
11020 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11021
11022 if test -n "$STRIP_FOR_TARGET"; then
11023   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11024 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11025 else
11026   echo "$as_me:$LINENO: result: no" >&5
11027 echo "${ECHO_T}no" >&6
11028 fi
11029
11030 fi
11031 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11032
11033
11034 if test -n "$STRIP_FOR_TARGET"; then
11035   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11036 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11037   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11038 fi
11039
11040 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11041   for ncn_progname in strip; do
11042     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11043 set dummy ${ncn_progname}; ac_word=$2
11044 echo "$as_me:$LINENO: checking for $ac_word" >&5
11045 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11046 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11047   echo $ECHO_N "(cached) $ECHO_C" >&6
11048 else
11049   if test -n "$STRIP_FOR_TARGET"; then
11050   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11051 else
11052 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11053 for as_dir in $PATH
11054 do
11055   IFS=$as_save_IFS
11056   test -z "$as_dir" && as_dir=.
11057   for ac_exec_ext in '' $ac_executable_extensions; do
11058   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11059     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11060     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11061     break 2
11062   fi
11063 done
11064 done
11065
11066 fi
11067 fi
11068 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11069 if test -n "$STRIP_FOR_TARGET"; then
11070   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11071 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11072 else
11073   echo "$as_me:$LINENO: result: no" >&5
11074 echo "${ECHO_T}no" >&6
11075 fi
11076
11077   done
11078 fi
11079
11080 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11081   for ncn_progname in strip; do
11082     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11083 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11084     if test -x $with_build_time_tools/${ncn_progname}; then
11085       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11086       echo "$as_me:$LINENO: result: yes" >&5
11087 echo "${ECHO_T}yes" >&6
11088       break
11089     else
11090       echo "$as_me:$LINENO: result: no" >&5
11091 echo "${ECHO_T}no" >&6
11092     fi
11093   done
11094 fi
11095
11096 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11097   for ncn_progname in strip; do
11098     if test -n "$ncn_target_tool_prefix"; then
11099       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11100 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11101 echo "$as_me:$LINENO: checking for $ac_word" >&5
11102 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11103 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11104   echo $ECHO_N "(cached) $ECHO_C" >&6
11105 else
11106   if test -n "$STRIP_FOR_TARGET"; then
11107   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11108 else
11109 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11110 for as_dir in $PATH
11111 do
11112   IFS=$as_save_IFS
11113   test -z "$as_dir" && as_dir=.
11114   for ac_exec_ext in '' $ac_executable_extensions; do
11115   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11116     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11117     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11118     break 2
11119   fi
11120 done
11121 done
11122
11123 fi
11124 fi
11125 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11126 if test -n "$STRIP_FOR_TARGET"; then
11127   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11128 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11129 else
11130   echo "$as_me:$LINENO: result: no" >&5
11131 echo "${ECHO_T}no" >&6
11132 fi
11133
11134     fi
11135     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11136       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11137 set dummy ${ncn_progname}; ac_word=$2
11138 echo "$as_me:$LINENO: checking for $ac_word" >&5
11139 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11140 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11141   echo $ECHO_N "(cached) $ECHO_C" >&6
11142 else
11143   if test -n "$STRIP_FOR_TARGET"; then
11144   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11145 else
11146 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11147 for as_dir in $PATH
11148 do
11149   IFS=$as_save_IFS
11150   test -z "$as_dir" && as_dir=.
11151   for ac_exec_ext in '' $ac_executable_extensions; do
11152   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11153     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11154     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11155     break 2
11156   fi
11157 done
11158 done
11159
11160 fi
11161 fi
11162 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11163 if test -n "$STRIP_FOR_TARGET"; then
11164   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11165 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11166 else
11167   echo "$as_me:$LINENO: result: no" >&5
11168 echo "${ECHO_T}no" >&6
11169 fi
11170
11171     fi
11172     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11173   done
11174 fi
11175
11176 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11177   set dummy strip
11178   if test $build = $target ; then
11179     STRIP_FOR_TARGET="$2"
11180   else
11181     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11182   fi
11183 else
11184   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11185 fi
11186
11187 else
11188   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11189 fi
11190
11191
11192
11193
11194 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11195   if test -n "$with_build_time_tools"; then
11196     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11197 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11198     if test -x $with_build_time_tools/windres; then
11199       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11200       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11201       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11202 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11203     else
11204       echo "$as_me:$LINENO: result: no" >&5
11205 echo "${ECHO_T}no" >&6
11206     fi
11207   elif test $build != $host && test $have_gcc_for_target = yes; then
11208     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11209     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11210     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11211   fi
11212 fi
11213 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11214   # Extract the first word of "windres", so it can be a program name with args.
11215 set dummy windres; ac_word=$2
11216 echo "$as_me:$LINENO: checking for $ac_word" >&5
11217 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11218 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11219   echo $ECHO_N "(cached) $ECHO_C" >&6
11220 else
11221   case $WINDRES_FOR_TARGET in
11222   [\\/]* | ?:[\\/]*)
11223   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11224   ;;
11225   *)
11226   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11227 for as_dir in $gcc_cv_tool_dirs
11228 do
11229   IFS=$as_save_IFS
11230   test -z "$as_dir" && as_dir=.
11231   for ac_exec_ext in '' $ac_executable_extensions; do
11232   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11233     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11234     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11235     break 2
11236   fi
11237 done
11238 done
11239
11240   ;;
11241 esac
11242 fi
11243 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11244
11245 if test -n "$WINDRES_FOR_TARGET"; then
11246   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11247 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11248 else
11249   echo "$as_me:$LINENO: result: no" >&5
11250 echo "${ECHO_T}no" >&6
11251 fi
11252
11253 fi
11254 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11255
11256
11257 if test -n "$WINDRES_FOR_TARGET"; then
11258   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11259 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11260   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11261 fi
11262
11263 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11264   for ncn_progname in windres; do
11265     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11266 set dummy ${ncn_progname}; ac_word=$2
11267 echo "$as_me:$LINENO: checking for $ac_word" >&5
11268 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11269 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11270   echo $ECHO_N "(cached) $ECHO_C" >&6
11271 else
11272   if test -n "$WINDRES_FOR_TARGET"; then
11273   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11274 else
11275 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11276 for as_dir in $PATH
11277 do
11278   IFS=$as_save_IFS
11279   test -z "$as_dir" && as_dir=.
11280   for ac_exec_ext in '' $ac_executable_extensions; do
11281   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11282     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11283     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11284     break 2
11285   fi
11286 done
11287 done
11288
11289 fi
11290 fi
11291 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11292 if test -n "$WINDRES_FOR_TARGET"; then
11293   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11294 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11295 else
11296   echo "$as_me:$LINENO: result: no" >&5
11297 echo "${ECHO_T}no" >&6
11298 fi
11299
11300   done
11301 fi
11302
11303 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11304   for ncn_progname in windres; do
11305     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11306 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11307     if test -x $with_build_time_tools/${ncn_progname}; then
11308       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11309       echo "$as_me:$LINENO: result: yes" >&5
11310 echo "${ECHO_T}yes" >&6
11311       break
11312     else
11313       echo "$as_me:$LINENO: result: no" >&5
11314 echo "${ECHO_T}no" >&6
11315     fi
11316   done
11317 fi
11318
11319 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11320   for ncn_progname in windres; do
11321     if test -n "$ncn_target_tool_prefix"; then
11322       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11323 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11324 echo "$as_me:$LINENO: checking for $ac_word" >&5
11325 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11326 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11327   echo $ECHO_N "(cached) $ECHO_C" >&6
11328 else
11329   if test -n "$WINDRES_FOR_TARGET"; then
11330   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11331 else
11332 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11333 for as_dir in $PATH
11334 do
11335   IFS=$as_save_IFS
11336   test -z "$as_dir" && as_dir=.
11337   for ac_exec_ext in '' $ac_executable_extensions; do
11338   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11339     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11340     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11341     break 2
11342   fi
11343 done
11344 done
11345
11346 fi
11347 fi
11348 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11349 if test -n "$WINDRES_FOR_TARGET"; then
11350   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11351 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11352 else
11353   echo "$as_me:$LINENO: result: no" >&5
11354 echo "${ECHO_T}no" >&6
11355 fi
11356
11357     fi
11358     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11359       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11360 set dummy ${ncn_progname}; ac_word=$2
11361 echo "$as_me:$LINENO: checking for $ac_word" >&5
11362 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11363 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11364   echo $ECHO_N "(cached) $ECHO_C" >&6
11365 else
11366   if test -n "$WINDRES_FOR_TARGET"; then
11367   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11368 else
11369 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11370 for as_dir in $PATH
11371 do
11372   IFS=$as_save_IFS
11373   test -z "$as_dir" && as_dir=.
11374   for ac_exec_ext in '' $ac_executable_extensions; do
11375   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11376     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11377     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11378     break 2
11379   fi
11380 done
11381 done
11382
11383 fi
11384 fi
11385 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11386 if test -n "$WINDRES_FOR_TARGET"; then
11387   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11388 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11389 else
11390   echo "$as_me:$LINENO: result: no" >&5
11391 echo "${ECHO_T}no" >&6
11392 fi
11393
11394     fi
11395     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11396   done
11397 fi
11398
11399 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11400   set dummy windres
11401   if test $build = $target ; then
11402     WINDRES_FOR_TARGET="$2"
11403   else
11404     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11405   fi
11406 else
11407   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11408 fi
11409
11410 else
11411   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11412 fi
11413
11414
11415
11416
11417 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11418   if test -n "$with_build_time_tools"; then
11419     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11420 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11421     if test -x $with_build_time_tools/windmc; then
11422       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11423       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11424       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11425 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11426     else
11427       echo "$as_me:$LINENO: result: no" >&5
11428 echo "${ECHO_T}no" >&6
11429     fi
11430   elif test $build != $host && test $have_gcc_for_target = yes; then
11431     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11432     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11433     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11434   fi
11435 fi
11436 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11437   # Extract the first word of "windmc", so it can be a program name with args.
11438 set dummy windmc; ac_word=$2
11439 echo "$as_me:$LINENO: checking for $ac_word" >&5
11440 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11441 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11442   echo $ECHO_N "(cached) $ECHO_C" >&6
11443 else
11444   case $WINDMC_FOR_TARGET in
11445   [\\/]* | ?:[\\/]*)
11446   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11447   ;;
11448   *)
11449   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11450 for as_dir in $gcc_cv_tool_dirs
11451 do
11452   IFS=$as_save_IFS
11453   test -z "$as_dir" && as_dir=.
11454   for ac_exec_ext in '' $ac_executable_extensions; do
11455   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11456     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11457     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11458     break 2
11459   fi
11460 done
11461 done
11462
11463   ;;
11464 esac
11465 fi
11466 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11467
11468 if test -n "$WINDMC_FOR_TARGET"; then
11469   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11470 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11471 else
11472   echo "$as_me:$LINENO: result: no" >&5
11473 echo "${ECHO_T}no" >&6
11474 fi
11475
11476 fi
11477 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11478
11479
11480 if test -n "$WINDMC_FOR_TARGET"; then
11481   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11482 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11483   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11484 fi
11485
11486 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11487   for ncn_progname in windmc; do
11488     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11489 set dummy ${ncn_progname}; ac_word=$2
11490 echo "$as_me:$LINENO: checking for $ac_word" >&5
11491 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11492 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11493   echo $ECHO_N "(cached) $ECHO_C" >&6
11494 else
11495   if test -n "$WINDMC_FOR_TARGET"; then
11496   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11497 else
11498 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11499 for as_dir in $PATH
11500 do
11501   IFS=$as_save_IFS
11502   test -z "$as_dir" && as_dir=.
11503   for ac_exec_ext in '' $ac_executable_extensions; do
11504   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11505     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11506     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11507     break 2
11508   fi
11509 done
11510 done
11511
11512 fi
11513 fi
11514 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11515 if test -n "$WINDMC_FOR_TARGET"; then
11516   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11517 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11518 else
11519   echo "$as_me:$LINENO: result: no" >&5
11520 echo "${ECHO_T}no" >&6
11521 fi
11522
11523   done
11524 fi
11525
11526 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11527   for ncn_progname in windmc; do
11528     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11529 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11530     if test -x $with_build_time_tools/${ncn_progname}; then
11531       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11532       echo "$as_me:$LINENO: result: yes" >&5
11533 echo "${ECHO_T}yes" >&6
11534       break
11535     else
11536       echo "$as_me:$LINENO: result: no" >&5
11537 echo "${ECHO_T}no" >&6
11538     fi
11539   done
11540 fi
11541
11542 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11543   for ncn_progname in windmc; do
11544     if test -n "$ncn_target_tool_prefix"; then
11545       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11546 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11547 echo "$as_me:$LINENO: checking for $ac_word" >&5
11548 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11549 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11550   echo $ECHO_N "(cached) $ECHO_C" >&6
11551 else
11552   if test -n "$WINDMC_FOR_TARGET"; then
11553   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11554 else
11555 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11556 for as_dir in $PATH
11557 do
11558   IFS=$as_save_IFS
11559   test -z "$as_dir" && as_dir=.
11560   for ac_exec_ext in '' $ac_executable_extensions; do
11561   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11562     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11563     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11564     break 2
11565   fi
11566 done
11567 done
11568
11569 fi
11570 fi
11571 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11572 if test -n "$WINDMC_FOR_TARGET"; then
11573   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11574 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11575 else
11576   echo "$as_me:$LINENO: result: no" >&5
11577 echo "${ECHO_T}no" >&6
11578 fi
11579
11580     fi
11581     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11582       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11583 set dummy ${ncn_progname}; ac_word=$2
11584 echo "$as_me:$LINENO: checking for $ac_word" >&5
11585 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11586 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11587   echo $ECHO_N "(cached) $ECHO_C" >&6
11588 else
11589   if test -n "$WINDMC_FOR_TARGET"; then
11590   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11591 else
11592 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11593 for as_dir in $PATH
11594 do
11595   IFS=$as_save_IFS
11596   test -z "$as_dir" && as_dir=.
11597   for ac_exec_ext in '' $ac_executable_extensions; do
11598   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11599     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11600     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11601     break 2
11602   fi
11603 done
11604 done
11605
11606 fi
11607 fi
11608 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11609 if test -n "$WINDMC_FOR_TARGET"; then
11610   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11611 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11612 else
11613   echo "$as_me:$LINENO: result: no" >&5
11614 echo "${ECHO_T}no" >&6
11615 fi
11616
11617     fi
11618     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11619   done
11620 fi
11621
11622 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11623   set dummy windmc
11624   if test $build = $target ; then
11625     WINDMC_FOR_TARGET="$2"
11626   else
11627     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11628   fi
11629 else
11630   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11631 fi
11632
11633 else
11634   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11635 fi
11636
11637
11638 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11639
11640 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11641 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11642 if test "x${build}" != "x${host}" ; then
11643   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11644     # We already found the complete path
11645     ac_dir=`dirname $AR_FOR_TARGET`
11646     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11647 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11648   else
11649     # Canadian cross, just use what we found
11650     echo "$as_me:$LINENO: result: pre-installed" >&5
11651 echo "${ECHO_T}pre-installed" >&6
11652   fi
11653 else
11654   ok=yes
11655   case " ${configdirs} " in
11656     *" binutils "*) ;;
11657     *) ok=no ;;
11658   esac
11659
11660   if test $ok = yes; then
11661     # An in-tree tool is available and we can use it
11662     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11663     echo "$as_me:$LINENO: result: just compiled" >&5
11664 echo "${ECHO_T}just compiled" >&6
11665   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11666     # We already found the complete path
11667     ac_dir=`dirname $AR_FOR_TARGET`
11668     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11669 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11670   elif test "x$target" = "x$host"; then
11671     # We can use an host tool
11672     AR_FOR_TARGET='$(AR)'
11673     echo "$as_me:$LINENO: result: host tool" >&5
11674 echo "${ECHO_T}host tool" >&6
11675   else
11676     # We need a cross tool
11677     echo "$as_me:$LINENO: result: pre-installed" >&5
11678 echo "${ECHO_T}pre-installed" >&6
11679   fi
11680 fi
11681
11682 echo "$as_me:$LINENO: checking where to find the target as" >&5
11683 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11684 if test "x${build}" != "x${host}" ; then
11685   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11686     # We already found the complete path
11687     ac_dir=`dirname $AS_FOR_TARGET`
11688     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11689 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11690   else
11691     # Canadian cross, just use what we found
11692     echo "$as_me:$LINENO: result: pre-installed" >&5
11693 echo "${ECHO_T}pre-installed" >&6
11694   fi
11695 else
11696   ok=yes
11697   case " ${configdirs} " in
11698     *" gas "*) ;;
11699     *) ok=no ;;
11700   esac
11701
11702   if test $ok = yes; then
11703     # An in-tree tool is available and we can use it
11704     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11705     echo "$as_me:$LINENO: result: just compiled" >&5
11706 echo "${ECHO_T}just compiled" >&6
11707   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11708     # We already found the complete path
11709     ac_dir=`dirname $AS_FOR_TARGET`
11710     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11711 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11712   elif test "x$target" = "x$host"; then
11713     # We can use an host tool
11714     AS_FOR_TARGET='$(AS)'
11715     echo "$as_me:$LINENO: result: host tool" >&5
11716 echo "${ECHO_T}host tool" >&6
11717   else
11718     # We need a cross tool
11719     echo "$as_me:$LINENO: result: pre-installed" >&5
11720 echo "${ECHO_T}pre-installed" >&6
11721   fi
11722 fi
11723
11724 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11725 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11726 if test "x${build}" != "x${host}" ; then
11727   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11728     # We already found the complete path
11729     ac_dir=`dirname $CC_FOR_TARGET`
11730     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11731 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11732   else
11733     # Canadian cross, just use what we found
11734     echo "$as_me:$LINENO: result: pre-installed" >&5
11735 echo "${ECHO_T}pre-installed" >&6
11736   fi
11737 else
11738   ok=yes
11739   case " ${configdirs} " in
11740     *" gcc "*) ;;
11741     *) ok=no ;;
11742   esac
11743
11744   if test $ok = yes; then
11745     # An in-tree tool is available and we can use it
11746     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11747     echo "$as_me:$LINENO: result: just compiled" >&5
11748 echo "${ECHO_T}just compiled" >&6
11749   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11750     # We already found the complete path
11751     ac_dir=`dirname $CC_FOR_TARGET`
11752     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11753 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11754   elif test "x$target" = "x$host"; then
11755     # We can use an host tool
11756     CC_FOR_TARGET='$(CC)'
11757     echo "$as_me:$LINENO: result: host tool" >&5
11758 echo "${ECHO_T}host tool" >&6
11759   else
11760     # We need a cross tool
11761     echo "$as_me:$LINENO: result: pre-installed" >&5
11762 echo "${ECHO_T}pre-installed" >&6
11763   fi
11764 fi
11765
11766 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11767 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11768 if test "x${build}" != "x${host}" ; then
11769   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11770     # We already found the complete path
11771     ac_dir=`dirname $CXX_FOR_TARGET`
11772     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11773 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11774   else
11775     # Canadian cross, just use what we found
11776     echo "$as_me:$LINENO: result: pre-installed" >&5
11777 echo "${ECHO_T}pre-installed" >&6
11778   fi
11779 else
11780   ok=yes
11781   case " ${configdirs} " in
11782     *" gcc "*) ;;
11783     *) ok=no ;;
11784   esac
11785   case ,${enable_languages}, in
11786     *,c++,*) ;;
11787     *) ok=no ;;
11788   esac
11789   if test $ok = yes; then
11790     # An in-tree tool is available and we can use it
11791     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'
11792     echo "$as_me:$LINENO: result: just compiled" >&5
11793 echo "${ECHO_T}just compiled" >&6
11794   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11795     # We already found the complete path
11796     ac_dir=`dirname $CXX_FOR_TARGET`
11797     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11798 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11799   elif test "x$target" = "x$host"; then
11800     # We can use an host tool
11801     CXX_FOR_TARGET='$(CXX)'
11802     echo "$as_me:$LINENO: result: host tool" >&5
11803 echo "${ECHO_T}host tool" >&6
11804   else
11805     # We need a cross tool
11806     echo "$as_me:$LINENO: result: pre-installed" >&5
11807 echo "${ECHO_T}pre-installed" >&6
11808   fi
11809 fi
11810
11811 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11812 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11813 if test "x${build}" != "x${host}" ; then
11814   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11815     # We already found the complete path
11816     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11817     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11818 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11819   else
11820     # Canadian cross, just use what we found
11821     echo "$as_me:$LINENO: result: pre-installed" >&5
11822 echo "${ECHO_T}pre-installed" >&6
11823   fi
11824 else
11825   ok=yes
11826   case " ${configdirs} " in
11827     *" gcc "*) ;;
11828     *) ok=no ;;
11829   esac
11830   case ,${enable_languages}, in
11831     *,c++,*) ;;
11832     *) ok=no ;;
11833   esac
11834   if test $ok = yes; then
11835     # An in-tree tool is available and we can use it
11836     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'
11837     echo "$as_me:$LINENO: result: just compiled" >&5
11838 echo "${ECHO_T}just compiled" >&6
11839   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11840     # We already found the complete path
11841     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11842     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11843 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11844   elif test "x$target" = "x$host"; then
11845     # We can use an host tool
11846     RAW_CXX_FOR_TARGET='$(CXX)'
11847     echo "$as_me:$LINENO: result: host tool" >&5
11848 echo "${ECHO_T}host tool" >&6
11849   else
11850     # We need a cross tool
11851     echo "$as_me:$LINENO: result: pre-installed" >&5
11852 echo "${ECHO_T}pre-installed" >&6
11853   fi
11854 fi
11855
11856 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11857 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11858 if test "x${build}" != "x${host}" ; then
11859   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11860     # We already found the complete path
11861     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11862     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11863 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11864   else
11865     # Canadian cross, just use what we found
11866     echo "$as_me:$LINENO: result: pre-installed" >&5
11867 echo "${ECHO_T}pre-installed" >&6
11868   fi
11869 else
11870   ok=yes
11871   case " ${configdirs} " in
11872     *" binutils "*) ;;
11873     *) ok=no ;;
11874   esac
11875
11876   if test $ok = yes; then
11877     # An in-tree tool is available and we can use it
11878     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11879     echo "$as_me:$LINENO: result: just compiled" >&5
11880 echo "${ECHO_T}just compiled" >&6
11881   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11882     # We already found the complete path
11883     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11884     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11885 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11886   elif test "x$target" = "x$host"; then
11887     # We can use an host tool
11888     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11889     echo "$as_me:$LINENO: result: host tool" >&5
11890 echo "${ECHO_T}host tool" >&6
11891   else
11892     # We need a cross tool
11893     echo "$as_me:$LINENO: result: pre-installed" >&5
11894 echo "${ECHO_T}pre-installed" >&6
11895   fi
11896 fi
11897
11898 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11899 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11900 if test "x${build}" != "x${host}" ; then
11901   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11902     # We already found the complete path
11903     ac_dir=`dirname $GCC_FOR_TARGET`
11904     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11905 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11906   else
11907     # Canadian cross, just use what we found
11908     echo "$as_me:$LINENO: result: pre-installed" >&5
11909 echo "${ECHO_T}pre-installed" >&6
11910   fi
11911 else
11912   ok=yes
11913   case " ${configdirs} " in
11914     *" gcc "*) ;;
11915     *) ok=no ;;
11916   esac
11917
11918   if test $ok = yes; then
11919     # An in-tree tool is available and we can use it
11920     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11921     echo "$as_me:$LINENO: result: just compiled" >&5
11922 echo "${ECHO_T}just compiled" >&6
11923   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11924     # We already found the complete path
11925     ac_dir=`dirname $GCC_FOR_TARGET`
11926     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11927 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11928   elif test "x$target" = "x$host"; then
11929     # We can use an host tool
11930     GCC_FOR_TARGET='$()'
11931     echo "$as_me:$LINENO: result: host tool" >&5
11932 echo "${ECHO_T}host tool" >&6
11933   else
11934     # We need a cross tool
11935     echo "$as_me:$LINENO: result: pre-installed" >&5
11936 echo "${ECHO_T}pre-installed" >&6
11937   fi
11938 fi
11939
11940 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11941 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11942 if test "x${build}" != "x${host}" ; then
11943   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11944     # We already found the complete path
11945     ac_dir=`dirname $GCJ_FOR_TARGET`
11946     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11947 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11948   else
11949     # Canadian cross, just use what we found
11950     echo "$as_me:$LINENO: result: pre-installed" >&5
11951 echo "${ECHO_T}pre-installed" >&6
11952   fi
11953 else
11954   ok=yes
11955   case " ${configdirs} " in
11956     *" gcc "*) ;;
11957     *) ok=no ;;
11958   esac
11959   case ,${enable_languages}, in
11960     *,java,*) ;;
11961     *) ok=no ;;
11962   esac
11963   if test $ok = yes; then
11964     # An in-tree tool is available and we can use it
11965     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11966     echo "$as_me:$LINENO: result: just compiled" >&5
11967 echo "${ECHO_T}just compiled" >&6
11968   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11969     # We already found the complete path
11970     ac_dir=`dirname $GCJ_FOR_TARGET`
11971     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11972 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11973   elif test "x$target" = "x$host"; then
11974     # We can use an host tool
11975     GCJ_FOR_TARGET='$(GCJ)'
11976     echo "$as_me:$LINENO: result: host tool" >&5
11977 echo "${ECHO_T}host tool" >&6
11978   else
11979     # We need a cross tool
11980     echo "$as_me:$LINENO: result: pre-installed" >&5
11981 echo "${ECHO_T}pre-installed" >&6
11982   fi
11983 fi
11984
11985 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11986 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11987 if test "x${build}" != "x${host}" ; then
11988   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11989     # We already found the complete path
11990     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11991     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11992 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11993   else
11994     # Canadian cross, just use what we found
11995     echo "$as_me:$LINENO: result: pre-installed" >&5
11996 echo "${ECHO_T}pre-installed" >&6
11997   fi
11998 else
11999   ok=yes
12000   case " ${configdirs} " in
12001     *" gcc "*) ;;
12002     *) ok=no ;;
12003   esac
12004   case ,${enable_languages}, in
12005     *,fortran,*) ;;
12006     *) ok=no ;;
12007   esac
12008   if test $ok = yes; then
12009     # An in-tree tool is available and we can use it
12010     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12011     echo "$as_me:$LINENO: result: just compiled" >&5
12012 echo "${ECHO_T}just compiled" >&6
12013   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12014     # We already found the complete path
12015     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12016     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12017 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12018   elif test "x$target" = "x$host"; then
12019     # We can use an host tool
12020     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12021     echo "$as_me:$LINENO: result: host tool" >&5
12022 echo "${ECHO_T}host tool" >&6
12023   else
12024     # We need a cross tool
12025     echo "$as_me:$LINENO: result: pre-installed" >&5
12026 echo "${ECHO_T}pre-installed" >&6
12027   fi
12028 fi
12029
12030 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12031 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12032 if test "x${build}" != "x${host}" ; then
12033   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12034     # We already found the complete path
12035     ac_dir=`dirname $LD_FOR_TARGET`
12036     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12037 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12038   else
12039     # Canadian cross, just use what we found
12040     echo "$as_me:$LINENO: result: pre-installed" >&5
12041 echo "${ECHO_T}pre-installed" >&6
12042   fi
12043 else
12044   ok=yes
12045   case " ${configdirs} " in
12046     *" ld "*) ;;
12047     *) ok=no ;;
12048   esac
12049
12050   if test $ok = yes; then
12051     # An in-tree tool is available and we can use it
12052     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12053     echo "$as_me:$LINENO: result: just compiled" >&5
12054 echo "${ECHO_T}just compiled" >&6
12055   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12056     # We already found the complete path
12057     ac_dir=`dirname $LD_FOR_TARGET`
12058     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12059 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12060   elif test "x$target" = "x$host"; then
12061     # We can use an host tool
12062     LD_FOR_TARGET='$(LD)'
12063     echo "$as_me:$LINENO: result: host tool" >&5
12064 echo "${ECHO_T}host tool" >&6
12065   else
12066     # We need a cross tool
12067     echo "$as_me:$LINENO: result: pre-installed" >&5
12068 echo "${ECHO_T}pre-installed" >&6
12069   fi
12070 fi
12071
12072 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12073 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12074 if test "x${build}" != "x${host}" ; then
12075   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12076     # We already found the complete path
12077     ac_dir=`dirname $LIPO_FOR_TARGET`
12078     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12079 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12080   else
12081     # Canadian cross, just use what we found
12082     echo "$as_me:$LINENO: result: pre-installed" >&5
12083 echo "${ECHO_T}pre-installed" >&6
12084   fi
12085 else
12086   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12087     # We already found the complete path
12088     ac_dir=`dirname $LIPO_FOR_TARGET`
12089     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12090 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12091   elif test "x$target" = "x$host"; then
12092     # We can use an host tool
12093     LIPO_FOR_TARGET='$(LIPO)'
12094     echo "$as_me:$LINENO: result: host tool" >&5
12095 echo "${ECHO_T}host tool" >&6
12096   else
12097     # We need a cross tool
12098     echo "$as_me:$LINENO: result: pre-installed" >&5
12099 echo "${ECHO_T}pre-installed" >&6
12100   fi
12101 fi
12102
12103 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12104 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12105 if test "x${build}" != "x${host}" ; then
12106   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12107     # We already found the complete path
12108     ac_dir=`dirname $NM_FOR_TARGET`
12109     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12110 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12111   else
12112     # Canadian cross, just use what we found
12113     echo "$as_me:$LINENO: result: pre-installed" >&5
12114 echo "${ECHO_T}pre-installed" >&6
12115   fi
12116 else
12117   ok=yes
12118   case " ${configdirs} " in
12119     *" binutils "*) ;;
12120     *) ok=no ;;
12121   esac
12122
12123   if test $ok = yes; then
12124     # An in-tree tool is available and we can use it
12125     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12126     echo "$as_me:$LINENO: result: just compiled" >&5
12127 echo "${ECHO_T}just compiled" >&6
12128   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12129     # We already found the complete path
12130     ac_dir=`dirname $NM_FOR_TARGET`
12131     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12132 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12133   elif test "x$target" = "x$host"; then
12134     # We can use an host tool
12135     NM_FOR_TARGET='$(NM)'
12136     echo "$as_me:$LINENO: result: host tool" >&5
12137 echo "${ECHO_T}host tool" >&6
12138   else
12139     # We need a cross tool
12140     echo "$as_me:$LINENO: result: pre-installed" >&5
12141 echo "${ECHO_T}pre-installed" >&6
12142   fi
12143 fi
12144
12145 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12146 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12147 if test "x${build}" != "x${host}" ; then
12148   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12149     # We already found the complete path
12150     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12151     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12152 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12153   else
12154     # Canadian cross, just use what we found
12155     echo "$as_me:$LINENO: result: pre-installed" >&5
12156 echo "${ECHO_T}pre-installed" >&6
12157   fi
12158 else
12159   ok=yes
12160   case " ${configdirs} " in
12161     *" binutils "*) ;;
12162     *) ok=no ;;
12163   esac
12164
12165   if test $ok = yes; then
12166     # An in-tree tool is available and we can use it
12167     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12168     echo "$as_me:$LINENO: result: just compiled" >&5
12169 echo "${ECHO_T}just compiled" >&6
12170   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12171     # We already found the complete path
12172     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12173     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12174 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12175   elif test "x$target" = "x$host"; then
12176     # We can use an host tool
12177     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12178     echo "$as_me:$LINENO: result: host tool" >&5
12179 echo "${ECHO_T}host tool" >&6
12180   else
12181     # We need a cross tool
12182     echo "$as_me:$LINENO: result: pre-installed" >&5
12183 echo "${ECHO_T}pre-installed" >&6
12184   fi
12185 fi
12186
12187 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12188 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12189 if test "x${build}" != "x${host}" ; then
12190   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12191     # We already found the complete path
12192     ac_dir=`dirname $RANLIB_FOR_TARGET`
12193     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12194 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12195   else
12196     # Canadian cross, just use what we found
12197     echo "$as_me:$LINENO: result: pre-installed" >&5
12198 echo "${ECHO_T}pre-installed" >&6
12199   fi
12200 else
12201   ok=yes
12202   case " ${configdirs} " in
12203     *" binutils "*) ;;
12204     *) ok=no ;;
12205   esac
12206
12207   if test $ok = yes; then
12208     # An in-tree tool is available and we can use it
12209     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12210     echo "$as_me:$LINENO: result: just compiled" >&5
12211 echo "${ECHO_T}just compiled" >&6
12212   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12213     # We already found the complete path
12214     ac_dir=`dirname $RANLIB_FOR_TARGET`
12215     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12216 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12217   elif test "x$target" = "x$host"; then
12218     # We can use an host tool
12219     RANLIB_FOR_TARGET='$(RANLIB)'
12220     echo "$as_me:$LINENO: result: host tool" >&5
12221 echo "${ECHO_T}host tool" >&6
12222   else
12223     # We need a cross tool
12224     echo "$as_me:$LINENO: result: pre-installed" >&5
12225 echo "${ECHO_T}pre-installed" >&6
12226   fi
12227 fi
12228
12229 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12230 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12231 if test "x${build}" != "x${host}" ; then
12232   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12233     # We already found the complete path
12234     ac_dir=`dirname $STRIP_FOR_TARGET`
12235     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12236 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12237   else
12238     # Canadian cross, just use what we found
12239     echo "$as_me:$LINENO: result: pre-installed" >&5
12240 echo "${ECHO_T}pre-installed" >&6
12241   fi
12242 else
12243   ok=yes
12244   case " ${configdirs} " in
12245     *" binutils "*) ;;
12246     *) ok=no ;;
12247   esac
12248
12249   if test $ok = yes; then
12250     # An in-tree tool is available and we can use it
12251     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12252     echo "$as_me:$LINENO: result: just compiled" >&5
12253 echo "${ECHO_T}just compiled" >&6
12254   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12255     # We already found the complete path
12256     ac_dir=`dirname $STRIP_FOR_TARGET`
12257     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12258 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12259   elif test "x$target" = "x$host"; then
12260     # We can use an host tool
12261     STRIP_FOR_TARGET='$(STRIP)'
12262     echo "$as_me:$LINENO: result: host tool" >&5
12263 echo "${ECHO_T}host tool" >&6
12264   else
12265     # We need a cross tool
12266     echo "$as_me:$LINENO: result: pre-installed" >&5
12267 echo "${ECHO_T}pre-installed" >&6
12268   fi
12269 fi
12270
12271 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12272 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12273 if test "x${build}" != "x${host}" ; then
12274   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12275     # We already found the complete path
12276     ac_dir=`dirname $WINDRES_FOR_TARGET`
12277     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12278 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12279   else
12280     # Canadian cross, just use what we found
12281     echo "$as_me:$LINENO: result: pre-installed" >&5
12282 echo "${ECHO_T}pre-installed" >&6
12283   fi
12284 else
12285   ok=yes
12286   case " ${configdirs} " in
12287     *" binutils "*) ;;
12288     *) ok=no ;;
12289   esac
12290
12291   if test $ok = yes; then
12292     # An in-tree tool is available and we can use it
12293     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12294     echo "$as_me:$LINENO: result: just compiled" >&5
12295 echo "${ECHO_T}just compiled" >&6
12296   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12297     # We already found the complete path
12298     ac_dir=`dirname $WINDRES_FOR_TARGET`
12299     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12300 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12301   elif test "x$target" = "x$host"; then
12302     # We can use an host tool
12303     WINDRES_FOR_TARGET='$(WINDRES)'
12304     echo "$as_me:$LINENO: result: host tool" >&5
12305 echo "${ECHO_T}host tool" >&6
12306   else
12307     # We need a cross tool
12308     echo "$as_me:$LINENO: result: pre-installed" >&5
12309 echo "${ECHO_T}pre-installed" >&6
12310   fi
12311 fi
12312
12313 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12314 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12315 if test "x${build}" != "x${host}" ; then
12316   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12317     # We already found the complete path
12318     ac_dir=`dirname $WINDMC_FOR_TARGET`
12319     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12320 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12321   else
12322     # Canadian cross, just use what we found
12323     echo "$as_me:$LINENO: result: pre-installed" >&5
12324 echo "${ECHO_T}pre-installed" >&6
12325   fi
12326 else
12327   ok=yes
12328   case " ${configdirs} " in
12329     *" binutils "*) ;;
12330     *) ok=no ;;
12331   esac
12332
12333   if test $ok = yes; then
12334     # An in-tree tool is available and we can use it
12335     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12336     echo "$as_me:$LINENO: result: just compiled" >&5
12337 echo "${ECHO_T}just compiled" >&6
12338   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12339     # We already found the complete path
12340     ac_dir=`dirname $WINDMC_FOR_TARGET`
12341     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12342 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12343   elif test "x$target" = "x$host"; then
12344     # We can use an host tool
12345     WINDMC_FOR_TARGET='$(WINDMC)'
12346     echo "$as_me:$LINENO: result: host tool" >&5
12347 echo "${ECHO_T}host tool" >&6
12348   else
12349     # We need a cross tool
12350     echo "$as_me:$LINENO: result: pre-installed" >&5
12351 echo "${ECHO_T}pre-installed" >&6
12352   fi
12353 fi
12354
12355
12356
12357
12358
12359 # Certain tools may need extra flags.
12360 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12361 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12362 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12363
12364 # When building target libraries, except in a Canadian cross, we use
12365 # the same toolchain as the compiler we just built.
12366 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12367 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12368 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12369 if test $host = $build; then
12370   case " $configdirs " in
12371     *" gcc "*)
12372       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12373       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12374       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12375       ;;
12376   esac
12377 fi
12378
12379
12380
12381
12382
12383 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12384 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12385 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12386 if test "${enable_maintainer_mode+set}" = set; then
12387   enableval="$enable_maintainer_mode"
12388   USE_MAINTAINER_MODE=$enableval
12389 else
12390   USE_MAINTAINER_MODE=no
12391 fi;
12392 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12393 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12394
12395
12396 if test "$USE_MAINTAINER_MODE" = yes; then
12397   MAINTAINER_MODE_TRUE=
12398   MAINTAINER_MODE_FALSE='#'
12399 else
12400   MAINTAINER_MODE_TRUE='#'
12401   MAINTAINER_MODE_FALSE=
12402 fi
12403 MAINT=$MAINTAINER_MODE_TRUE
12404
12405 # ---------------------
12406 # GCC bootstrap support
12407 # ---------------------
12408
12409 # Stage specific cflags for build.
12410 stage1_cflags="-g"
12411 case $build in
12412   vax-*-*)
12413     case ${GCC} in
12414       yes) stage1_cflags="-g -Wa,-J" ;;
12415       *) stage1_cflags="-g -J" ;;
12416     esac ;;
12417 esac
12418
12419 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12420 if test "$GCC" = yes; then
12421   saved_CFLAGS="$CFLAGS"
12422
12423   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12424   CFLAGS="$CFLAGS -fkeep-inline-functions"
12425   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12426 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12427   cat >conftest.$ac_ext <<_ACEOF
12428 /* confdefs.h.  */
12429 _ACEOF
12430 cat confdefs.h >>conftest.$ac_ext
12431 cat >>conftest.$ac_ext <<_ACEOF
12432 /* end confdefs.h.  */
12433
12434 #if (__GNUC__ < 3) \
12435     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12436                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12437 #error http://gcc.gnu.org/PR29382
12438 #endif
12439
12440 int
12441 main ()
12442 {
12443
12444   ;
12445   return 0;
12446 }
12447 _ACEOF
12448 rm -f conftest.$ac_objext
12449 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12450   (eval $ac_compile) 2>conftest.er1
12451   ac_status=$?
12452   grep -v '^ *+' conftest.er1 >conftest.err
12453   rm -f conftest.er1
12454   cat conftest.err >&5
12455   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12456   (exit $ac_status); } &&
12457          { ac_try='test -z "$ac_c_werror_flag"
12458                          || test ! -s conftest.err'
12459   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12460   (eval $ac_try) 2>&5
12461   ac_status=$?
12462   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12463   (exit $ac_status); }; } &&
12464          { ac_try='test -s conftest.$ac_objext'
12465   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12466   (eval $ac_try) 2>&5
12467   ac_status=$?
12468   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12469   (exit $ac_status); }; }; then
12470   echo "$as_me:$LINENO: result: yes" >&5
12471 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12472 else
12473   echo "$as_me: failed program was:" >&5
12474 sed 's/^/| /' conftest.$ac_ext >&5
12475
12476 echo "$as_me:$LINENO: result: no" >&5
12477 echo "${ECHO_T}no" >&6
12478 fi
12479 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12480
12481   CFLAGS="$saved_CFLAGS"
12482 fi
12483
12484
12485
12486 # Enable --enable-checking in stage1 of the compiler.
12487 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12488 if test "${enable_stage1_checking+set}" = set; then
12489   enableval="$enable_stage1_checking"
12490   stage1_checking=--enable-checking=${enable_stage1_checking}
12491 else
12492   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12493   stage1_checking=--enable-checking=yes,types
12494 else
12495   stage1_checking=--enable-checking=$enable_checking,types
12496 fi
12497 fi;
12498
12499
12500 # Enable -Werror in bootstrap stage2 and later.
12501 # Check whether --enable-werror or --disable-werror was given.
12502 if test "${enable_werror+set}" = set; then
12503   enableval="$enable_werror"
12504
12505 else
12506   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12507   enable_werror=yes
12508 else
12509   enable_werror=no
12510 fi
12511 fi;
12512 case ${enable_werror} in
12513   yes) stage2_werror_flag="--enable-werror-always" ;;
12514   *) stage2_werror_flag="" ;;
12515 esac
12516
12517
12518 # Flags needed to enable html installing and building
12519
12520 # Check whether --with-datarootdir or --without-datarootdir was given.
12521 if test "${with_datarootdir+set}" = set; then
12522   withval="$with_datarootdir"
12523   datarootdir="\${prefix}/${withval}"
12524 else
12525   datarootdir="\${prefix}/share"
12526 fi;
12527
12528
12529 # Check whether --with-docdir or --without-docdir was given.
12530 if test "${with_docdir+set}" = set; then
12531   withval="$with_docdir"
12532   docdir="\${prefix}/${withval}"
12533 else
12534   docdir="\${datarootdir}/doc"
12535 fi;
12536
12537
12538 # Check whether --with-pdfdir or --without-pdfdir was given.
12539 if test "${with_pdfdir+set}" = set; then
12540   withval="$with_pdfdir"
12541   pdfdir="\${prefix}/${withval}"
12542 else
12543   pdfdir="\${docdir}"
12544 fi;
12545
12546
12547 # Check whether --with-htmldir or --without-htmldir was given.
12548 if test "${with_htmldir+set}" = set; then
12549   withval="$with_htmldir"
12550   htmldir="\${prefix}/${withval}"
12551 else
12552   htmldir="\${docdir}"
12553 fi;
12554
12555
12556
12557
12558
12559
12560           ac_config_files="$ac_config_files Makefile"
12561 cat >confcache <<\_ACEOF
12562 # This file is a shell script that caches the results of configure
12563 # tests run on this system so they can be shared between configure
12564 # scripts and configure runs, see configure's option --config-cache.
12565 # It is not useful on other systems.  If it contains results you don't
12566 # want to keep, you may remove or edit it.
12567 #
12568 # config.status only pays attention to the cache file if you give it
12569 # the --recheck option to rerun configure.
12570 #
12571 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12572 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12573 # following values.
12574
12575 _ACEOF
12576
12577 # The following way of writing the cache mishandles newlines in values,
12578 # but we know of no workaround that is simple, portable, and efficient.
12579 # So, don't put newlines in cache variables' values.
12580 # Ultrix sh set writes to stderr and can't be redirected directly,
12581 # and sets the high bit in the cache file unless we assign to the vars.
12582 {
12583   (set) 2>&1 |
12584     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12585     *ac_space=\ *)
12586       # `set' does not quote correctly, so add quotes (double-quote
12587       # substitution turns \\\\ into \\, and sed turns \\ into \).
12588       sed -n \
12589         "s/'/'\\\\''/g;
12590           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12591       ;;
12592     *)
12593       # `set' quotes correctly as required by POSIX, so do not add quotes.
12594       sed -n \
12595         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12596       ;;
12597     esac;
12598 } |
12599   sed '
12600      t clear
12601      : clear
12602      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12603      t end
12604      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12605      : end' >>confcache
12606 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12607   if test -w $cache_file; then
12608     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12609     cat confcache >$cache_file
12610   else
12611     echo "not updating unwritable cache $cache_file"
12612   fi
12613 fi
12614 rm -f confcache
12615
12616 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12617 # Let make expand exec_prefix.
12618 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12619
12620 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12621 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12622 # trailing colons and then remove the whole line if VPATH becomes empty
12623 # (actually we leave an empty line to preserve line numbers).
12624 if test "x$srcdir" = x.; then
12625   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12626 s/:*\$(srcdir):*/:/;
12627 s/:*\${srcdir}:*/:/;
12628 s/:*@srcdir@:*/:/;
12629 s/^\([^=]*=[     ]*\):*/\1/;
12630 s/:*$//;
12631 s/^[^=]*=[       ]*$//;
12632 }'
12633 fi
12634
12635 # Transform confdefs.h into DEFS.
12636 # Protect against shell expansion while executing Makefile rules.
12637 # Protect against Makefile macro expansion.
12638 #
12639 # If the first sed substitution is executed (which looks for macros that
12640 # take arguments), then we branch to the quote section.  Otherwise,
12641 # look for a macro that doesn't take arguments.
12642 cat >confdef2opt.sed <<\_ACEOF
12643 t clear
12644 : clear
12645 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12646 t quote
12647 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12648 t quote
12649 d
12650 : quote
12651 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12652 s,\[,\\&,g
12653 s,\],\\&,g
12654 s,\$,$$,g
12655 p
12656 _ACEOF
12657 # We use echo to avoid assuming a particular line-breaking character.
12658 # The extra dot is to prevent the shell from consuming trailing
12659 # line-breaks from the sub-command output.  A line-break within
12660 # single-quotes doesn't work because, if this script is created in a
12661 # platform that uses two characters for line-breaks (e.g., DOS), tr
12662 # would break.
12663 ac_LF_and_DOT=`echo; echo .`
12664 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12665 rm -f confdef2opt.sed
12666
12667
12668 ac_libobjs=
12669 ac_ltlibobjs=
12670 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12671   # 1. Remove the extension, and $U if already installed.
12672   ac_i=`echo "$ac_i" |
12673          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12674   # 2. Add them.
12675   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12676   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12677 done
12678 LIBOBJS=$ac_libobjs
12679
12680 LTLIBOBJS=$ac_ltlibobjs
12681
12682
12683
12684 : ${CONFIG_STATUS=./config.status}
12685 ac_clean_files_save=$ac_clean_files
12686 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12687 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12688 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12689 cat >$CONFIG_STATUS <<_ACEOF
12690 #! $SHELL
12691 # Generated by $as_me.
12692 # Run this file to recreate the current configuration.
12693 # Compiler output produced by configure, useful for debugging
12694 # configure, is in config.log if it exists.
12695
12696 debug=false
12697 ac_cs_recheck=false
12698 ac_cs_silent=false
12699 SHELL=\${CONFIG_SHELL-$SHELL}
12700 _ACEOF
12701
12702 cat >>$CONFIG_STATUS <<\_ACEOF
12703 ## --------------------- ##
12704 ## M4sh Initialization.  ##
12705 ## --------------------- ##
12706
12707 # Be Bourne compatible
12708 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12709   emulate sh
12710   NULLCMD=:
12711   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12712   # is contrary to our usage.  Disable this feature.
12713   alias -g '${1+"$@"}'='"$@"'
12714 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12715   set -o posix
12716 fi
12717 DUALCASE=1; export DUALCASE # for MKS sh
12718
12719 # Support unset when possible.
12720 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12721   as_unset=unset
12722 else
12723   as_unset=false
12724 fi
12725
12726
12727 # Work around bugs in pre-3.0 UWIN ksh.
12728 $as_unset ENV MAIL MAILPATH
12729 PS1='$ '
12730 PS2='> '
12731 PS4='+ '
12732
12733 # NLS nuisances.
12734 for as_var in \
12735   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12736   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12737   LC_TELEPHONE LC_TIME
12738 do
12739   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12740     eval $as_var=C; export $as_var
12741   else
12742     $as_unset $as_var
12743   fi
12744 done
12745
12746 # Required to use basename.
12747 if expr a : '\(a\)' >/dev/null 2>&1; then
12748   as_expr=expr
12749 else
12750   as_expr=false
12751 fi
12752
12753 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12754   as_basename=basename
12755 else
12756   as_basename=false
12757 fi
12758
12759
12760 # Name of the executable.
12761 as_me=`$as_basename "$0" ||
12762 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12763          X"$0" : 'X\(//\)$' \| \
12764          X"$0" : 'X\(/\)$' \| \
12765          .     : '\(.\)' 2>/dev/null ||
12766 echo X/"$0" |
12767     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12768           /^X\/\(\/\/\)$/{ s//\1/; q; }
12769           /^X\/\(\/\).*/{ s//\1/; q; }
12770           s/.*/./; q'`
12771
12772
12773 # PATH needs CR, and LINENO needs CR and PATH.
12774 # Avoid depending upon Character Ranges.
12775 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12776 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12777 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12778 as_cr_digits='0123456789'
12779 as_cr_alnum=$as_cr_Letters$as_cr_digits
12780
12781 # The user is always right.
12782 if test "${PATH_SEPARATOR+set}" != set; then
12783   echo "#! /bin/sh" >conf$$.sh
12784   echo  "exit 0"   >>conf$$.sh
12785   chmod +x conf$$.sh
12786   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12787     PATH_SEPARATOR=';'
12788   else
12789     PATH_SEPARATOR=:
12790   fi
12791   rm -f conf$$.sh
12792 fi
12793
12794
12795   as_lineno_1=$LINENO
12796   as_lineno_2=$LINENO
12797   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12798   test "x$as_lineno_1" != "x$as_lineno_2" &&
12799   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12800   # Find who we are.  Look in the path if we contain no path at all
12801   # relative or not.
12802   case $0 in
12803     *[\\/]* ) as_myself=$0 ;;
12804     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12805 for as_dir in $PATH
12806 do
12807   IFS=$as_save_IFS
12808   test -z "$as_dir" && as_dir=.
12809   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12810 done
12811
12812        ;;
12813   esac
12814   # We did not find ourselves, most probably we were run as `sh COMMAND'
12815   # in which case we are not to be found in the path.
12816   if test "x$as_myself" = x; then
12817     as_myself=$0
12818   fi
12819   if test ! -f "$as_myself"; then
12820     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12821 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12822    { (exit 1); exit 1; }; }
12823   fi
12824   case $CONFIG_SHELL in
12825   '')
12826     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12827 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12828 do
12829   IFS=$as_save_IFS
12830   test -z "$as_dir" && as_dir=.
12831   for as_base in sh bash ksh sh5; do
12832          case $as_dir in
12833          /*)
12834            if ("$as_dir/$as_base" -c '
12835   as_lineno_1=$LINENO
12836   as_lineno_2=$LINENO
12837   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12838   test "x$as_lineno_1" != "x$as_lineno_2" &&
12839   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12840              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12841              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12842              CONFIG_SHELL=$as_dir/$as_base
12843              export CONFIG_SHELL
12844              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12845            fi;;
12846          esac
12847        done
12848 done
12849 ;;
12850   esac
12851
12852   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12853   # uniformly replaced by the line number.  The first 'sed' inserts a
12854   # line-number line before each line; the second 'sed' does the real
12855   # work.  The second script uses 'N' to pair each line-number line
12856   # with the numbered line, and appends trailing '-' during
12857   # substitution so that $LINENO is not a special case at line end.
12858   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12859   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12860   sed '=' <$as_myself |
12861     sed '
12862       N
12863       s,$,-,
12864       : loop
12865       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12866       t loop
12867       s,-$,,
12868       s,^['$as_cr_digits']*\n,,
12869     ' >$as_me.lineno &&
12870   chmod +x $as_me.lineno ||
12871     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12872 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12873    { (exit 1); exit 1; }; }
12874
12875   # Don't try to exec as it changes $[0], causing all sort of problems
12876   # (the dirname of $[0] is not the place where we might find the
12877   # original and so on.  Autoconf is especially sensible to this).
12878   . ./$as_me.lineno
12879   # Exit status is that of the last command.
12880   exit
12881 }
12882
12883
12884 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12885   *c*,-n*) ECHO_N= ECHO_C='
12886 ' ECHO_T='      ' ;;
12887   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12888   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12889 esac
12890
12891 if expr a : '\(a\)' >/dev/null 2>&1; then
12892   as_expr=expr
12893 else
12894   as_expr=false
12895 fi
12896
12897 rm -f conf$$ conf$$.exe conf$$.file
12898 echo >conf$$.file
12899 if ln -s conf$$.file conf$$ 2>/dev/null; then
12900   # We could just check for DJGPP; but this test a) works b) is more generic
12901   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12902   if test -f conf$$.exe; then
12903     # Don't use ln at all; we don't have any links
12904     as_ln_s='cp -p'
12905   else
12906     as_ln_s='ln -s'
12907   fi
12908 elif ln conf$$.file conf$$ 2>/dev/null; then
12909   as_ln_s=ln
12910 else
12911   as_ln_s='cp -p'
12912 fi
12913 rm -f conf$$ conf$$.exe conf$$.file
12914
12915 if mkdir -p . 2>/dev/null; then
12916   as_mkdir_p=:
12917 else
12918   test -d ./-p && rmdir ./-p
12919   as_mkdir_p=false
12920 fi
12921
12922 as_executable_p="test -f"
12923
12924 # Sed expression to map a string onto a valid CPP name.
12925 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12926
12927 # Sed expression to map a string onto a valid variable name.
12928 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12929
12930
12931 # IFS
12932 # We need space, tab and new line, in precisely that order.
12933 as_nl='
12934 '
12935 IFS="   $as_nl"
12936
12937 # CDPATH.
12938 $as_unset CDPATH
12939
12940 exec 6>&1
12941
12942 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12943 # report actual input values of CONFIG_FILES etc. instead of their
12944 # values after options handling.  Logging --version etc. is OK.
12945 exec 5>>config.log
12946 {
12947   echo
12948   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12949 ## Running $as_me. ##
12950 _ASBOX
12951 } >&5
12952 cat >&5 <<_CSEOF
12953
12954 This file was extended by $as_me, which was
12955 generated by GNU Autoconf 2.59.  Invocation command line was
12956
12957   CONFIG_FILES    = $CONFIG_FILES
12958   CONFIG_HEADERS  = $CONFIG_HEADERS
12959   CONFIG_LINKS    = $CONFIG_LINKS
12960   CONFIG_COMMANDS = $CONFIG_COMMANDS
12961   $ $0 $@
12962
12963 _CSEOF
12964 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12965 echo >&5
12966 _ACEOF
12967
12968 # Files that config.status was made for.
12969 if test -n "$ac_config_files"; then
12970   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12971 fi
12972
12973 if test -n "$ac_config_headers"; then
12974   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12975 fi
12976
12977 if test -n "$ac_config_links"; then
12978   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12979 fi
12980
12981 if test -n "$ac_config_commands"; then
12982   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12983 fi
12984
12985 cat >>$CONFIG_STATUS <<\_ACEOF
12986
12987 ac_cs_usage="\
12988 \`$as_me' instantiates files from templates according to the
12989 current configuration.
12990
12991 Usage: $0 [OPTIONS] [FILE]...
12992
12993   -h, --help       print this help, then exit
12994   -V, --version    print version number, then exit
12995   -q, --quiet      do not print progress messages
12996   -d, --debug      don't remove temporary files
12997       --recheck    update $as_me by reconfiguring in the same conditions
12998   --file=FILE[:TEMPLATE]
12999                    instantiate the configuration file FILE
13000
13001 Configuration files:
13002 $config_files
13003
13004 Report bugs to <bug-autoconf@gnu.org>."
13005 _ACEOF
13006
13007 cat >>$CONFIG_STATUS <<_ACEOF
13008 ac_cs_version="\\
13009 config.status
13010 configured by $0, generated by GNU Autoconf 2.59,
13011   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13012
13013 Copyright (C) 2003 Free Software Foundation, Inc.
13014 This config.status script is free software; the Free Software Foundation
13015 gives unlimited permission to copy, distribute and modify it."
13016 srcdir=$srcdir
13017 INSTALL="$INSTALL"
13018 _ACEOF
13019
13020 cat >>$CONFIG_STATUS <<\_ACEOF
13021 # If no file are specified by the user, then we need to provide default
13022 # value.  By we need to know if files were specified by the user.
13023 ac_need_defaults=:
13024 while test $# != 0
13025 do
13026   case $1 in
13027   --*=*)
13028     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13029     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13030     ac_shift=:
13031     ;;
13032   -*)
13033     ac_option=$1
13034     ac_optarg=$2
13035     ac_shift=shift
13036     ;;
13037   *) # This is not an option, so the user has probably given explicit
13038      # arguments.
13039      ac_option=$1
13040      ac_need_defaults=false;;
13041   esac
13042
13043   case $ac_option in
13044   # Handling of the options.
13045 _ACEOF
13046 cat >>$CONFIG_STATUS <<\_ACEOF
13047   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13048     ac_cs_recheck=: ;;
13049   --version | --vers* | -V )
13050     echo "$ac_cs_version"; exit 0 ;;
13051   --he | --h)
13052     # Conflict between --help and --header
13053     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13054 Try \`$0 --help' for more information." >&5
13055 echo "$as_me: error: ambiguous option: $1
13056 Try \`$0 --help' for more information." >&2;}
13057    { (exit 1); exit 1; }; };;
13058   --help | --hel | -h )
13059     echo "$ac_cs_usage"; exit 0 ;;
13060   --debug | --d* | -d )
13061     debug=: ;;
13062   --file | --fil | --fi | --f )
13063     $ac_shift
13064     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13065     ac_need_defaults=false;;
13066   --header | --heade | --head | --hea )
13067     $ac_shift
13068     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13069     ac_need_defaults=false;;
13070   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13071   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13072     ac_cs_silent=: ;;
13073
13074   # This is an error.
13075   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13076 Try \`$0 --help' for more information." >&5
13077 echo "$as_me: error: unrecognized option: $1
13078 Try \`$0 --help' for more information." >&2;}
13079    { (exit 1); exit 1; }; } ;;
13080
13081   *) ac_config_targets="$ac_config_targets $1" ;;
13082
13083   esac
13084   shift
13085 done
13086
13087 ac_configure_extra_args=
13088
13089 if $ac_cs_silent; then
13090   exec 6>/dev/null
13091   ac_configure_extra_args="$ac_configure_extra_args --silent"
13092 fi
13093
13094 _ACEOF
13095 cat >>$CONFIG_STATUS <<_ACEOF
13096 if \$ac_cs_recheck; then
13097   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13098   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13099 fi
13100
13101 _ACEOF
13102
13103
13104
13105
13106
13107 cat >>$CONFIG_STATUS <<\_ACEOF
13108 for ac_config_target in $ac_config_targets
13109 do
13110   case "$ac_config_target" in
13111   # Handling of arguments.
13112   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13113   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13114 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13115    { (exit 1); exit 1; }; };;
13116   esac
13117 done
13118
13119 # If the user did not use the arguments to specify the items to instantiate,
13120 # then the envvar interface is used.  Set only those that are not.
13121 # We use the long form for the default assignment because of an extremely
13122 # bizarre bug on SunOS 4.1.3.
13123 if $ac_need_defaults; then
13124   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13125 fi
13126
13127 # Have a temporary directory for convenience.  Make it in the build tree
13128 # simply because there is no reason to put it here, and in addition,
13129 # creating and moving files from /tmp can sometimes cause problems.
13130 # Create a temporary directory, and hook for its removal unless debugging.
13131 $debug ||
13132 {
13133   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13134   trap '{ (exit 1); exit 1; }' 1 2 13 15
13135 }
13136
13137 # Create a (secure) tmp directory for tmp files.
13138
13139 {
13140   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13141   test -n "$tmp" && test -d "$tmp"
13142 }  ||
13143 {
13144   tmp=./confstat$$-$RANDOM
13145   (umask 077 && mkdir $tmp)
13146 } ||
13147 {
13148    echo "$me: cannot create a temporary directory in ." >&2
13149    { (exit 1); exit 1; }
13150 }
13151
13152 _ACEOF
13153
13154 cat >>$CONFIG_STATUS <<_ACEOF
13155
13156 #
13157 # CONFIG_FILES section.
13158 #
13159
13160 # No need to generate the scripts if there are no CONFIG_FILES.
13161 # This happens for instance when ./config.status config.h
13162 if test -n "\$CONFIG_FILES"; then
13163   # Protect against being on the right side of a sed subst in config.status.
13164   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13165    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13166 s,@SHELL@,$SHELL,;t t
13167 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13168 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13169 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13170 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13171 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13172 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13173 s,@exec_prefix@,$exec_prefix,;t t
13174 s,@prefix@,$prefix,;t t
13175 s,@program_transform_name@,$program_transform_name,;t t
13176 s,@bindir@,$bindir,;t t
13177 s,@sbindir@,$sbindir,;t t
13178 s,@libexecdir@,$libexecdir,;t t
13179 s,@datadir@,$datadir,;t t
13180 s,@sysconfdir@,$sysconfdir,;t t
13181 s,@sharedstatedir@,$sharedstatedir,;t t
13182 s,@localstatedir@,$localstatedir,;t t
13183 s,@libdir@,$libdir,;t t
13184 s,@includedir@,$includedir,;t t
13185 s,@oldincludedir@,$oldincludedir,;t t
13186 s,@infodir@,$infodir,;t t
13187 s,@mandir@,$mandir,;t t
13188 s,@build_alias@,$build_alias,;t t
13189 s,@host_alias@,$host_alias,;t t
13190 s,@target_alias@,$target_alias,;t t
13191 s,@DEFS@,$DEFS,;t t
13192 s,@ECHO_C@,$ECHO_C,;t t
13193 s,@ECHO_N@,$ECHO_N,;t t
13194 s,@ECHO_T@,$ECHO_T,;t t
13195 s,@LIBS@,$LIBS,;t t
13196 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13197 s,@build@,$build,;t t
13198 s,@build_cpu@,$build_cpu,;t t
13199 s,@build_vendor@,$build_vendor,;t t
13200 s,@build_os@,$build_os,;t t
13201 s,@build_noncanonical@,$build_noncanonical,;t t
13202 s,@host_noncanonical@,$host_noncanonical,;t t
13203 s,@target_noncanonical@,$target_noncanonical,;t t
13204 s,@host@,$host,;t t
13205 s,@host_cpu@,$host_cpu,;t t
13206 s,@host_vendor@,$host_vendor,;t t
13207 s,@host_os@,$host_os,;t t
13208 s,@target@,$target,;t t
13209 s,@target_cpu@,$target_cpu,;t t
13210 s,@target_vendor@,$target_vendor,;t t
13211 s,@target_os@,$target_os,;t t
13212 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13213 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13214 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13215 s,@LN@,$LN,;t t
13216 s,@LN_S@,$LN_S,;t t
13217 s,@build_libsubdir@,$build_libsubdir,;t t
13218 s,@build_subdir@,$build_subdir,;t t
13219 s,@host_subdir@,$host_subdir,;t t
13220 s,@target_subdir@,$target_subdir,;t t
13221 s,@CC@,$CC,;t t
13222 s,@CFLAGS@,$CFLAGS,;t t
13223 s,@LDFLAGS@,$LDFLAGS,;t t
13224 s,@CPPFLAGS@,$CPPFLAGS,;t t
13225 s,@ac_ct_CC@,$ac_ct_CC,;t t
13226 s,@EXEEXT@,$EXEEXT,;t t
13227 s,@OBJEXT@,$OBJEXT,;t t
13228 s,@CXX@,$CXX,;t t
13229 s,@CXXFLAGS@,$CXXFLAGS,;t t
13230 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13231 s,@GNATBIND@,$GNATBIND,;t t
13232 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13233 s,@GNATMAKE@,$GNATMAKE,;t t
13234 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13235 s,@do_compare@,$do_compare,;t t
13236 s,@gmplibs@,$gmplibs,;t t
13237 s,@gmpinc@,$gmpinc,;t t
13238 s,@ppllibs@,$ppllibs,;t t
13239 s,@pplinc@,$pplinc,;t t
13240 s,@clooglibs@,$clooglibs,;t t
13241 s,@clooginc@,$clooginc,;t t
13242 s,@stage1_languages@,$stage1_languages,;t t
13243 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13244 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13245 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13246 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13247 s,@CPPFLAGS_FOR_TARGET@,$CPPFLAGS_FOR_TARGET,;t t
13248 s,@LDFLAGS_FOR_TARGET@,$LDFLAGS_FOR_TARGET,;t t
13249 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13250 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13251 s,@tooldir@,$tooldir,;t t
13252 s,@build_tooldir@,$build_tooldir,;t t
13253 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13254 s,@GDB_TK@,$GDB_TK,;t t
13255 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13256 s,@build_configargs@,$build_configargs,;t t
13257 s,@build_configdirs@,$build_configdirs,;t t
13258 s,@host_configargs@,$host_configargs,;t t
13259 s,@configdirs@,$configdirs,;t t
13260 s,@target_configargs@,$target_configargs,;t t
13261 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13262 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13263 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13264 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13265 s,@CPPFLAGS_FOR_BUILD@,$CPPFLAGS_FOR_BUILD,;t t
13266 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13267 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13268 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13269 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13270 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13271 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13272 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13273 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13274 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13275 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13276 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13277 s,@config_shell@,$config_shell,;t t
13278 s,@YACC@,$YACC,;t t
13279 s,@BISON@,$BISON,;t t
13280 s,@M4@,$M4,;t t
13281 s,@LEX@,$LEX,;t t
13282 s,@FLEX@,$FLEX,;t t
13283 s,@MAKEINFO@,$MAKEINFO,;t t
13284 s,@EXPECT@,$EXPECT,;t t
13285 s,@RUNTEST@,$RUNTEST,;t t
13286 s,@AR@,$AR,;t t
13287 s,@AS@,$AS,;t t
13288 s,@DLLTOOL@,$DLLTOOL,;t t
13289 s,@LD@,$LD,;t t
13290 s,@LIPO@,$LIPO,;t t
13291 s,@NM@,$NM,;t t
13292 s,@RANLIB@,$RANLIB,;t t
13293 s,@STRIP@,$STRIP,;t t
13294 s,@WINDRES@,$WINDRES,;t t
13295 s,@WINDMC@,$WINDMC,;t t
13296 s,@OBJCOPY@,$OBJCOPY,;t t
13297 s,@OBJDUMP@,$OBJDUMP,;t t
13298 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13299 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13300 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13301 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13302 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13303 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13304 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13305 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13306 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13307 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13308 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13309 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13310 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13311 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13312 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13313 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13314 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13315 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13316 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13317 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13318 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13319 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13320 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13321 s,@MAINT@,$MAINT,;t t
13322 s,@stage1_cflags@,$stage1_cflags,;t t
13323 s,@stage1_checking@,$stage1_checking,;t t
13324 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13325 s,@datarootdir@,$datarootdir,;t t
13326 s,@docdir@,$docdir,;t t
13327 s,@pdfdir@,$pdfdir,;t t
13328 s,@htmldir@,$htmldir,;t t
13329 s,@LIBOBJS@,$LIBOBJS,;t t
13330 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13331 /@serialization_dependencies@/r $serialization_dependencies
13332 s,@serialization_dependencies@,,;t t
13333 /@host_makefile_frag@/r $host_makefile_frag
13334 s,@host_makefile_frag@,,;t t
13335 /@target_makefile_frag@/r $target_makefile_frag
13336 s,@target_makefile_frag@,,;t t
13337 /@alphaieee_frag@/r $alphaieee_frag
13338 s,@alphaieee_frag@,,;t t
13339 /@ospace_frag@/r $ospace_frag
13340 s,@ospace_frag@,,;t t
13341 CEOF
13342
13343 _ACEOF
13344
13345   cat >>$CONFIG_STATUS <<\_ACEOF
13346   # Split the substitutions into bite-sized pieces for seds with
13347   # small command number limits, like on Digital OSF/1 and HP-UX.
13348   ac_max_sed_lines=48
13349   ac_sed_frag=1 # Number of current file.
13350   ac_beg=1 # First line for current file.
13351   ac_end=$ac_max_sed_lines # Line after last line for current file.
13352   ac_more_lines=:
13353   ac_sed_cmds=
13354   while $ac_more_lines; do
13355     if test $ac_beg -gt 1; then
13356       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13357     else
13358       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13359     fi
13360     if test ! -s $tmp/subs.frag; then
13361       ac_more_lines=false
13362     else
13363       # The purpose of the label and of the branching condition is to
13364       # speed up the sed processing (if there are no `@' at all, there
13365       # is no need to browse any of the substitutions).
13366       # These are the two extra sed commands mentioned above.
13367       (echo ':t
13368   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13369       if test -z "$ac_sed_cmds"; then
13370         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13371       else
13372         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13373       fi
13374       ac_sed_frag=`expr $ac_sed_frag + 1`
13375       ac_beg=$ac_end
13376       ac_end=`expr $ac_end + $ac_max_sed_lines`
13377     fi
13378   done
13379   if test -z "$ac_sed_cmds"; then
13380     ac_sed_cmds=cat
13381   fi
13382 fi # test -n "$CONFIG_FILES"
13383
13384 _ACEOF
13385 cat >>$CONFIG_STATUS <<\_ACEOF
13386 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13387   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13388   case $ac_file in
13389   - | *:- | *:-:* ) # input from stdin
13390         cat >$tmp/stdin
13391         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13392         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13393   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13394         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13395   * )   ac_file_in=$ac_file.in ;;
13396   esac
13397
13398   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13399   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13400 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13401          X"$ac_file" : 'X\(//\)[^/]' \| \
13402          X"$ac_file" : 'X\(//\)$' \| \
13403          X"$ac_file" : 'X\(/\)' \| \
13404          .     : '\(.\)' 2>/dev/null ||
13405 echo X"$ac_file" |
13406     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13407           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13408           /^X\(\/\/\)$/{ s//\1/; q; }
13409           /^X\(\/\).*/{ s//\1/; q; }
13410           s/.*/./; q'`
13411   { if $as_mkdir_p; then
13412     mkdir -p "$ac_dir"
13413   else
13414     as_dir="$ac_dir"
13415     as_dirs=
13416     while test ! -d "$as_dir"; do
13417       as_dirs="$as_dir $as_dirs"
13418       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13419 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13420          X"$as_dir" : 'X\(//\)[^/]' \| \
13421          X"$as_dir" : 'X\(//\)$' \| \
13422          X"$as_dir" : 'X\(/\)' \| \
13423          .     : '\(.\)' 2>/dev/null ||
13424 echo X"$as_dir" |
13425     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13426           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13427           /^X\(\/\/\)$/{ s//\1/; q; }
13428           /^X\(\/\).*/{ s//\1/; q; }
13429           s/.*/./; q'`
13430     done
13431     test ! -n "$as_dirs" || mkdir $as_dirs
13432   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13433 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13434    { (exit 1); exit 1; }; }; }
13435
13436   ac_builddir=.
13437
13438 if test "$ac_dir" != .; then
13439   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13440   # A "../" for each directory in $ac_dir_suffix.
13441   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13442 else
13443   ac_dir_suffix= ac_top_builddir=
13444 fi
13445
13446 case $srcdir in
13447   .)  # No --srcdir option.  We are building in place.
13448     ac_srcdir=.
13449     if test -z "$ac_top_builddir"; then
13450        ac_top_srcdir=.
13451     else
13452        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13453     fi ;;
13454   [\\/]* | ?:[\\/]* )  # Absolute path.
13455     ac_srcdir=$srcdir$ac_dir_suffix;
13456     ac_top_srcdir=$srcdir ;;
13457   *) # Relative path.
13458     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13459     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13460 esac
13461
13462 # Do not use `cd foo && pwd` to compute absolute paths, because
13463 # the directories may not exist.
13464 case `pwd` in
13465 .) ac_abs_builddir="$ac_dir";;
13466 *)
13467   case "$ac_dir" in
13468   .) ac_abs_builddir=`pwd`;;
13469   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13470   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13471   esac;;
13472 esac
13473 case $ac_abs_builddir in
13474 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13475 *)
13476   case ${ac_top_builddir}. in
13477   .) ac_abs_top_builddir=$ac_abs_builddir;;
13478   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13479   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13480   esac;;
13481 esac
13482 case $ac_abs_builddir in
13483 .) ac_abs_srcdir=$ac_srcdir;;
13484 *)
13485   case $ac_srcdir in
13486   .) ac_abs_srcdir=$ac_abs_builddir;;
13487   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13488   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13489   esac;;
13490 esac
13491 case $ac_abs_builddir in
13492 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13493 *)
13494   case $ac_top_srcdir in
13495   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13496   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13497   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13498   esac;;
13499 esac
13500
13501
13502   case $INSTALL in
13503   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13504   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13505   esac
13506
13507   if test x"$ac_file" != x-; then
13508     { echo "$as_me:$LINENO: creating $ac_file" >&5
13509 echo "$as_me: creating $ac_file" >&6;}
13510     rm -f "$ac_file"
13511   fi
13512   # Let's still pretend it is `configure' which instantiates (i.e., don't
13513   # use $as_me), people would be surprised to read:
13514   #    /* config.h.  Generated by config.status.  */
13515   if test x"$ac_file" = x-; then
13516     configure_input=
13517   else
13518     configure_input="$ac_file.  "
13519   fi
13520   configure_input=$configure_input"Generated from `echo $ac_file_in |
13521                                      sed 's,.*/,,'` by configure."
13522
13523   # First look for the input files in the build tree, otherwise in the
13524   # src tree.
13525   ac_file_inputs=`IFS=:
13526     for f in $ac_file_in; do
13527       case $f in
13528       -) echo $tmp/stdin ;;
13529       [\\/$]*)
13530          # Absolute (can't be DOS-style, as IFS=:)
13531          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13532 echo "$as_me: error: cannot find input file: $f" >&2;}
13533    { (exit 1); exit 1; }; }
13534          echo "$f";;
13535       *) # Relative
13536          if test -f "$f"; then
13537            # Build tree
13538            echo "$f"
13539          elif test -f "$srcdir/$f"; then
13540            # Source tree
13541            echo "$srcdir/$f"
13542          else
13543            # /dev/null tree
13544            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13545 echo "$as_me: error: cannot find input file: $f" >&2;}
13546    { (exit 1); exit 1; }; }
13547          fi;;
13548       esac
13549     done` || { (exit 1); exit 1; }
13550 _ACEOF
13551 cat >>$CONFIG_STATUS <<_ACEOF
13552   sed "$ac_vpsub
13553 $extrasub
13554 _ACEOF
13555 cat >>$CONFIG_STATUS <<\_ACEOF
13556 :t
13557 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13558 s,@configure_input@,$configure_input,;t t
13559 s,@srcdir@,$ac_srcdir,;t t
13560 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13561 s,@top_srcdir@,$ac_top_srcdir,;t t
13562 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13563 s,@builddir@,$ac_builddir,;t t
13564 s,@abs_builddir@,$ac_abs_builddir,;t t
13565 s,@top_builddir@,$ac_top_builddir,;t t
13566 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13567 s,@INSTALL@,$ac_INSTALL,;t t
13568 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13569   rm -f $tmp/stdin
13570   if test x"$ac_file" != x-; then
13571     mv $tmp/out $ac_file
13572   else
13573     cat $tmp/out
13574     rm -f $tmp/out
13575   fi
13576
13577 done
13578 _ACEOF
13579
13580 cat >>$CONFIG_STATUS <<\_ACEOF
13581
13582 { (exit 0); exit 0; }
13583 _ACEOF
13584 chmod +x $CONFIG_STATUS
13585 ac_clean_files=$ac_clean_files_save
13586
13587
13588 # configure is writing to config.log, and then calls config.status.
13589 # config.status does its own redirection, appending to config.log.
13590 # Unfortunately, on DOS this fails, as config.log is still kept open
13591 # by configure, so config.status won't be able to write to it; its
13592 # output is simply discarded.  So we exec the FD to /dev/null,
13593 # effectively closing config.log, so it can be properly (re)opened and
13594 # appended to by config.status.  When coming back to configure, we
13595 # need to make the FD available again.
13596 if test "$no_create" != yes; then
13597   ac_cs_success=:
13598   ac_config_status_args=
13599   test "$silent" = yes &&
13600     ac_config_status_args="$ac_config_status_args --quiet"
13601   exec 5>/dev/null
13602   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13603   exec 5>>config.log
13604   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13605   # would make configure fail if this is the last instruction.
13606   $ac_cs_success || { (exit 1); exit 1; }
13607 fi
13608