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 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 TOPLEVEL_CONFIGURE_ARGUMENTS 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 stage1_languages SYSROOT_CFLAGS_FOR_TARGET RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs CC_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES OBJCOPY OBJDUMP CFLAGS_FOR_BUILD 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 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 htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277
 278 # Initialize some variables set by options.
 279 ac_init_help=
 280 ac_init_version=false
 281 # The variables have the same names as the options, with
 282 # dashes changed to underlines.
 283 cache_file=/dev/null
 284 exec_prefix=NONE
 285 no_create=
 286 no_recursion=
 287 prefix=NONE
 288 program_prefix=NONE
 289 program_suffix=NONE
 290 program_transform_name=s,x,x,
 291 silent=
 292 site=
 293 srcdir=
 294 verbose=
 295 x_includes=NONE
 296 x_libraries=NONE
 297
 298 # Installation directory options.
 299 # These are left unexpanded so users can "make install exec_prefix=/foo"
 300 # and all the variables that are supposed to be based on exec_prefix
 301 # by default will actually change.
 302 # Use braces instead of parens because sh, perl, etc. also accept them.
 303 bindir='${exec_prefix}/bin'
 304 sbindir='${exec_prefix}/sbin'
 305 libexecdir='${exec_prefix}/libexec'
 306 datadir='${prefix}/share'
 307 sysconfdir='${prefix}/etc'
 308 sharedstatedir='${prefix}/com'
 309 localstatedir='${prefix}/var'
 310 libdir='${exec_prefix}/lib'
 311 includedir='${prefix}/include'
 312 oldincludedir='/usr/include'
 313 infodir='${prefix}/info'
 314 mandir='${prefix}/man'
 315
 316 ac_prev=
 317 for ac_option
 318 do
 319   # If the previous option needs an argument, assign it.
 320   if test -n "$ac_prev"; then
 321     eval "$ac_prev=\$ac_option"
 322     ac_prev=
 323     continue
 324   fi
 325
 326   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 327
 328   # Accept the important Cygnus configure options, so we can diagnose typos.
 329
 330   case $ac_option in
 331
 332   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 333     ac_prev=bindir ;;
 334   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 335     bindir=$ac_optarg ;;
 336
 337   -build | --build | --buil | --bui | --bu)
 338     ac_prev=build_alias ;;
 339   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 340     build_alias=$ac_optarg ;;
 341
 342   -cache-file | --cache-file | --cache-fil | --cache-fi \
 343   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 344     ac_prev=cache_file ;;
 345   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 346   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 347     cache_file=$ac_optarg ;;
 348
 349   --config-cache | -C)
 350     cache_file=config.cache ;;
 351
 352   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 353     ac_prev=datadir ;;
 354   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 355   | --da=*)
 356     datadir=$ac_optarg ;;
 357
 358   -disable-* | --disable-*)
 359     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 360     # Reject names that are not valid shell variable names.
 361     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 362       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 363    { (exit 1); exit 1; }; }
 364     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 365     eval "enable_$ac_feature=no" ;;
 366
 367   -enable-* | --enable-*)
 368     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 369     # Reject names that are not valid shell variable names.
 370     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 371       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 372    { (exit 1); exit 1; }; }
 373     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 374     case $ac_option in
 375       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 376       *) ac_optarg=yes ;;
 377     esac
 378     eval "enable_$ac_feature='$ac_optarg'" ;;
 379
 380   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 381   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 382   | --exec | --exe | --ex)
 383     ac_prev=exec_prefix ;;
 384   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 385   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 386   | --exec=* | --exe=* | --ex=*)
 387     exec_prefix=$ac_optarg ;;
 388
 389   -gas | --gas | --ga | --g)
 390     # Obsolete; use --with-gas.
 391     with_gas=yes ;;
 392
 393   -help | --help | --hel | --he | -h)
 394     ac_init_help=long ;;
 395   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 396     ac_init_help=recursive ;;
 397   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 398     ac_init_help=short ;;
 399
 400   -host | --host | --hos | --ho)
 401     ac_prev=host_alias ;;
 402   -host=* | --host=* | --hos=* | --ho=*)
 403     host_alias=$ac_optarg ;;
 404
 405   -includedir | --includedir | --includedi | --included | --include \
 406   | --includ | --inclu | --incl | --inc)
 407     ac_prev=includedir ;;
 408   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 409   | --includ=* | --inclu=* | --incl=* | --inc=*)
 410     includedir=$ac_optarg ;;
 411
 412   -infodir | --infodir | --infodi | --infod | --info | --inf)
 413     ac_prev=infodir ;;
 414   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 415     infodir=$ac_optarg ;;
 416
 417   -libdir | --libdir | --libdi | --libd)
 418     ac_prev=libdir ;;
 419   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 420     libdir=$ac_optarg ;;
 421
 422   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 423   | --libexe | --libex | --libe)
 424     ac_prev=libexecdir ;;
 425   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 426   | --libexe=* | --libex=* | --libe=*)
 427     libexecdir=$ac_optarg ;;
 428
 429   -localstatedir | --localstatedir | --localstatedi | --localstated \
 430   | --localstate | --localstat | --localsta | --localst \
 431   | --locals | --local | --loca | --loc | --lo)
 432     ac_prev=localstatedir ;;
 433   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 434   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 435   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 436     localstatedir=$ac_optarg ;;
 437
 438   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 439     ac_prev=mandir ;;
 440   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 441     mandir=$ac_optarg ;;
 442
 443   -nfp | --nfp | --nf)
 444     # Obsolete; use --without-fp.
 445     with_fp=no ;;
 446
 447   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 448   | --no-cr | --no-c | -n)
 449     no_create=yes ;;
 450
 451   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 452   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 453     no_recursion=yes ;;
 454
 455   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 456   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 457   | --oldin | --oldi | --old | --ol | --o)
 458     ac_prev=oldincludedir ;;
 459   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 460   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 461   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 462     oldincludedir=$ac_optarg ;;
 463
 464   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 465     ac_prev=prefix ;;
 466   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 467     prefix=$ac_optarg ;;
 468
 469   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 470   | --program-pre | --program-pr | --program-p)
 471     ac_prev=program_prefix ;;
 472   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 473   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 474     program_prefix=$ac_optarg ;;
 475
 476   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 477   | --program-suf | --program-su | --program-s)
 478     ac_prev=program_suffix ;;
 479   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 480   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 481     program_suffix=$ac_optarg ;;
 482
 483   -program-transform-name | --program-transform-name \
 484   | --program-transform-nam | --program-transform-na \
 485   | --program-transform-n | --program-transform- \
 486   | --program-transform | --program-transfor \
 487   | --program-transfo | --program-transf \
 488   | --program-trans | --program-tran \
 489   | --progr-tra | --program-tr | --program-t)
 490     ac_prev=program_transform_name ;;
 491   -program-transform-name=* | --program-transform-name=* \
 492   | --program-transform-nam=* | --program-transform-na=* \
 493   | --program-transform-n=* | --program-transform-=* \
 494   | --program-transform=* | --program-transfor=* \
 495   | --program-transfo=* | --program-transf=* \
 496   | --program-trans=* | --program-tran=* \
 497   | --progr-tra=* | --program-tr=* | --program-t=*)
 498     program_transform_name=$ac_optarg ;;
 499
 500   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 501   | -silent | --silent | --silen | --sile | --sil)
 502     silent=yes ;;
 503
 504   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 505     ac_prev=sbindir ;;
 506   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 507   | --sbi=* | --sb=*)
 508     sbindir=$ac_optarg ;;
 509
 510   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 511   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 512   | --sharedst | --shareds | --shared | --share | --shar \
 513   | --sha | --sh)
 514     ac_prev=sharedstatedir ;;
 515   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 516   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 517   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 518   | --sha=* | --sh=*)
 519     sharedstatedir=$ac_optarg ;;
 520
 521   -site | --site | --sit)
 522     ac_prev=site ;;
 523   -site=* | --site=* | --sit=*)
 524     site=$ac_optarg ;;
 525
 526   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 527     ac_prev=srcdir ;;
 528   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 529     srcdir=$ac_optarg ;;
 530
 531   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 532   | --syscon | --sysco | --sysc | --sys | --sy)
 533     ac_prev=sysconfdir ;;
 534   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 535   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 536     sysconfdir=$ac_optarg ;;
 537
 538   -target | --target | --targe | --targ | --tar | --ta | --t)
 539     ac_prev=target_alias ;;
 540   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 541     target_alias=$ac_optarg ;;
 542
 543   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 544     verbose=yes ;;
 545
 546   -version | --version | --versio | --versi | --vers | -V)
 547     ac_init_version=: ;;
 548
 549   -with-* | --with-*)
 550     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 551     # Reject names that are not valid shell variable names.
 552     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 553       { echo "$as_me: error: invalid package name: $ac_package" >&2
 554    { (exit 1); exit 1; }; }
 555     ac_package=`echo $ac_package| sed 's/-/_/g'`
 556     case $ac_option in
 557       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 558       *) ac_optarg=yes ;;
 559     esac
 560     eval "with_$ac_package='$ac_optarg'" ;;
 561
 562   -without-* | --without-*)
 563     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 564     # Reject names that are not valid shell variable names.
 565     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 566       { echo "$as_me: error: invalid package name: $ac_package" >&2
 567    { (exit 1); exit 1; }; }
 568     ac_package=`echo $ac_package | sed 's/-/_/g'`
 569     eval "with_$ac_package=no" ;;
 570
 571   --x)
 572     # Obsolete; use --with-x.
 573     with_x=yes ;;
 574
 575   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 576   | --x-incl | --x-inc | --x-in | --x-i)
 577     ac_prev=x_includes ;;
 578   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 579   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 580     x_includes=$ac_optarg ;;
 581
 582   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 583   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 584     ac_prev=x_libraries ;;
 585   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 586   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 587     x_libraries=$ac_optarg ;;
 588
 589   -*) { echo "$as_me: error: unrecognized option: $ac_option
 590 Try \`$0 --help' for more information." >&2
 591    { (exit 1); exit 1; }; }
 592     ;;
 593
 594   *=*)
 595     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 596     # Reject names that are not valid shell variable names.
 597     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 598       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 599    { (exit 1); exit 1; }; }
 600     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 601     eval "$ac_envvar='$ac_optarg'"
 602     export $ac_envvar ;;
 603
 604   *)
 605     # FIXME: should be removed in autoconf 3.0.
 606     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 607     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 608       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 609     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 610     ;;
 611
 612   esac
 613 done
 614
 615 if test -n "$ac_prev"; then
 616   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 617   { echo "$as_me: error: missing argument to $ac_option" >&2
 618    { (exit 1); exit 1; }; }
 619 fi
 620
 621 # Be sure to have absolute paths.
 622 for ac_var in exec_prefix prefix
 623 do
 624   eval ac_val=$`echo $ac_var`
 625   case $ac_val in
 626     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 627     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 628    { (exit 1); exit 1; }; };;
 629   esac
 630 done
 631
 632 # Be sure to have absolute paths.
 633 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 634               localstatedir libdir includedir oldincludedir infodir mandir
 635 do
 636   eval ac_val=$`echo $ac_var`
 637   case $ac_val in
 638     [\\/$]* | ?:[\\/]* ) ;;
 639     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 640    { (exit 1); exit 1; }; };;
 641   esac
 642 done
 643
 644 # There might be people who depend on the old broken behavior: `$host'
 645 # used to hold the argument of --host etc.
 646 # FIXME: To remove some day.
 647 build=$build_alias
 648 host=$host_alias
 649 target=$target_alias
 650
 651 # FIXME: To remove some day.
 652 if test "x$host_alias" != x; then
 653   if test "x$build_alias" = x; then
 654     cross_compiling=maybe
 655     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 656     If a cross compiler is detected then cross compile mode will be used." >&2
 657   elif test "x$build_alias" != "x$host_alias"; then
 658     cross_compiling=yes
 659   fi
 660 fi
 661
 662 ac_tool_prefix=
 663 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 664
 665 test "$silent" = yes && exec 6>/dev/null
 666
 667
 668 # Find the source files, if location was not specified.
 669 if test -z "$srcdir"; then
 670   ac_srcdir_defaulted=yes
 671   # Try the directory containing this script, then its parent.
 672   ac_confdir=`(dirname "$0") 2>/dev/null ||
 673 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 674          X"$0" : 'X\(//\)[^/]' \| \
 675          X"$0" : 'X\(//\)$' \| \
 676          X"$0" : 'X\(/\)' \| \
 677          .     : '\(.\)' 2>/dev/null ||
 678 echo X"$0" |
 679     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 680           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 681           /^X\(\/\/\)$/{ s//\1/; q; }
 682           /^X\(\/\).*/{ s//\1/; q; }
 683           s/.*/./; q'`
 684   srcdir=$ac_confdir
 685   if test ! -r $srcdir/$ac_unique_file; then
 686     srcdir=..
 687   fi
 688 else
 689   ac_srcdir_defaulted=no
 690 fi
 691 if test ! -r $srcdir/$ac_unique_file; then
 692   if test "$ac_srcdir_defaulted" = yes; then
 693     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 694    { (exit 1); exit 1; }; }
 695   else
 696     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 697    { (exit 1); exit 1; }; }
 698   fi
 699 fi
 700 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 701   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 702    { (exit 1); exit 1; }; }
 703 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 704 ac_env_build_alias_set=${build_alias+set}
 705 ac_env_build_alias_value=$build_alias
 706 ac_cv_env_build_alias_set=${build_alias+set}
 707 ac_cv_env_build_alias_value=$build_alias
 708 ac_env_host_alias_set=${host_alias+set}
 709 ac_env_host_alias_value=$host_alias
 710 ac_cv_env_host_alias_set=${host_alias+set}
 711 ac_cv_env_host_alias_value=$host_alias
 712 ac_env_target_alias_set=${target_alias+set}
 713 ac_env_target_alias_value=$target_alias
 714 ac_cv_env_target_alias_set=${target_alias+set}
 715 ac_cv_env_target_alias_value=$target_alias
 716 ac_env_CC_set=${CC+set}
 717 ac_env_CC_value=$CC
 718 ac_cv_env_CC_set=${CC+set}
 719 ac_cv_env_CC_value=$CC
 720 ac_env_CFLAGS_set=${CFLAGS+set}
 721 ac_env_CFLAGS_value=$CFLAGS
 722 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 723 ac_cv_env_CFLAGS_value=$CFLAGS
 724 ac_env_LDFLAGS_set=${LDFLAGS+set}
 725 ac_env_LDFLAGS_value=$LDFLAGS
 726 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 727 ac_cv_env_LDFLAGS_value=$LDFLAGS
 728 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 729 ac_env_CPPFLAGS_value=$CPPFLAGS
 730 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 731 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 732 ac_env_CXX_set=${CXX+set}
 733 ac_env_CXX_value=$CXX
 734 ac_cv_env_CXX_set=${CXX+set}
 735 ac_cv_env_CXX_value=$CXX
 736 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 737 ac_env_CXXFLAGS_value=$CXXFLAGS
 738 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 739 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 740 ac_env_AR_set=${AR+set}
 741 ac_env_AR_value=$AR
 742 ac_cv_env_AR_set=${AR+set}
 743 ac_cv_env_AR_value=$AR
 744 ac_env_AS_set=${AS+set}
 745 ac_env_AS_value=$AS
 746 ac_cv_env_AS_set=${AS+set}
 747 ac_cv_env_AS_value=$AS
 748 ac_env_DLLTOOL_set=${DLLTOOL+set}
 749 ac_env_DLLTOOL_value=$DLLTOOL
 750 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 751 ac_cv_env_DLLTOOL_value=$DLLTOOL
 752 ac_env_LD_set=${LD+set}
 753 ac_env_LD_value=$LD
 754 ac_cv_env_LD_set=${LD+set}
 755 ac_cv_env_LD_value=$LD
 756 ac_env_LIPO_set=${LIPO+set}
 757 ac_env_LIPO_value=$LIPO
 758 ac_cv_env_LIPO_set=${LIPO+set}
 759 ac_cv_env_LIPO_value=$LIPO
 760 ac_env_NM_set=${NM+set}
 761 ac_env_NM_value=$NM
 762 ac_cv_env_NM_set=${NM+set}
 763 ac_cv_env_NM_value=$NM
 764 ac_env_RANLIB_set=${RANLIB+set}
 765 ac_env_RANLIB_value=$RANLIB
 766 ac_cv_env_RANLIB_set=${RANLIB+set}
 767 ac_cv_env_RANLIB_value=$RANLIB
 768 ac_env_STRIP_set=${STRIP+set}
 769 ac_env_STRIP_value=$STRIP
 770 ac_cv_env_STRIP_set=${STRIP+set}
 771 ac_cv_env_STRIP_value=$STRIP
 772 ac_env_WINDRES_set=${WINDRES+set}
 773 ac_env_WINDRES_value=$WINDRES
 774 ac_cv_env_WINDRES_set=${WINDRES+set}
 775 ac_cv_env_WINDRES_value=$WINDRES
 776 ac_env_OBJCOPY_set=${OBJCOPY+set}
 777 ac_env_OBJCOPY_value=$OBJCOPY
 778 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 779 ac_cv_env_OBJCOPY_value=$OBJCOPY
 780 ac_env_OBJDUMP_set=${OBJDUMP+set}
 781 ac_env_OBJDUMP_value=$OBJDUMP
 782 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 783 ac_cv_env_OBJDUMP_value=$OBJDUMP
 784 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 785 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 786 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 787 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 788 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 789 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 790 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 791 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 792 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 793 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 794 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 795 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 796 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 797 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 798 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 799 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 800 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 801 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 802 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 803 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 804 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 805 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 806 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 807 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 808 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 809 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 810 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 811 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 812 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 813 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 814 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 815 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 816 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 817 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 818 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 819 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 820 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 821 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 822 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 823 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 824 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 825 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 826 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 827 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 828 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 829 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 830 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 831 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 832 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 833 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 834 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 835 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 836 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 837 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 838 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 839 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 840 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 841 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 842 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 843 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 844
 845 #
 846 # Report the --help message.
 847 #
 848 if test "$ac_init_help" = "long"; then
 849   # Omit some internal or obsolete options to make the list less imposing.
 850   # This message is too long to be a string in the A/UX 3.1 sh.
 851   cat <<_ACEOF
 852 \`configure' configures this package to adapt to many kinds of systems.
 853
 854 Usage: $0 [OPTION]... [VAR=VALUE]...
 855
 856 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 857 VAR=VALUE.  See below for descriptions of some of the useful variables.
 858
 859 Defaults for the options are specified in brackets.
 860
 861 Configuration:
 862   -h, --help              display this help and exit
 863       --help=short        display options specific to this package
 864       --help=recursive    display the short help of all the included packages
 865   -V, --version           display version information and exit
 866   -q, --quiet, --silent   do not print \`checking...' messages
 867       --cache-file=FILE   cache test results in FILE [disabled]
 868   -C, --config-cache      alias for \`--cache-file=config.cache'
 869   -n, --no-create         do not create output files
 870       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 871
 872 _ACEOF
 873
 874   cat <<_ACEOF
 875 Installation directories:
 876   --prefix=PREFIX         install architecture-independent files in PREFIX
 877                           [$ac_default_prefix]
 878   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 879                           [PREFIX]
 880
 881 By default, \`make install' will install all the files in
 882 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 883 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 884 for instance \`--prefix=\$HOME'.
 885
 886 For better control, use the options below.
 887
 888 Fine tuning of the installation directories:
 889   --bindir=DIR           user executables [EPREFIX/bin]
 890   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 891   --libexecdir=DIR       program executables [EPREFIX/libexec]
 892   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 893   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 894   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 895   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 896   --libdir=DIR           object code libraries [EPREFIX/lib]
 897   --includedir=DIR       C header files [PREFIX/include]
 898   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 899   --infodir=DIR          info documentation [PREFIX/info]
 900   --mandir=DIR           man documentation [PREFIX/man]
 901 _ACEOF
 902
 903   cat <<\_ACEOF
 904
 905 Program names:
 906   --program-prefix=PREFIX            prepend PREFIX to installed program names
 907   --program-suffix=SUFFIX            append SUFFIX to installed program names
 908   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 909
 910 System types:
 911   --build=BUILD     configure for building on BUILD [guessed]
 912   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 913   --target=TARGET   configure for building compilers for TARGET [HOST]
 914 _ACEOF
 915 fi
 916
 917 if test -n "$ac_init_help"; then
 918
 919   cat <<\_ACEOF
 920
 921 Optional Features:
 922   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 923   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 924   --enable-libada        Builds libada directory
 925   --enable-libssp        Builds libssp directory
 926   --enable-stage1-languages=all   choose additional languages to build during
 927                           stage1.  Mostly useful for compiler development.
 928   --enable-objc-gc       enable the use of Boehm's garbage collector with
 929                           the GNU Objective-C runtime.
 930   --enable-bootstrap           Enable bootstrapping yes if native build
 931   --enable-serial-{host,target,build}-configure
 932                           Force sequential configuration of
 933                           sub-packages for the host, target or build
 934                           machine, or all sub-packages
 935   --enable-maintainer-mode enable make rules and dependencies not useful
 936                           (and sometimes confusing) to the casual installer
 937   --enable-stage1-checking=all   choose additional checking for stage1
 938                           of the compiler.
 939   --enable-werror         enable -Werror in bootstrap stage2 and later
 940
 941 Optional Packages:
 942   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 943   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 944   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 945   --with-mpfr-dir=PATH    This option has been REMOVED
 946   --with-mpfr=PATH        Specify prefix directory for installed MPFR package
 947                           Equivalent to --with-mpfr-include=PATH/include
 948                           plus --with-mpfr-lib=PATH/lib
 949   --with-mpfr-include=PATH
 950                           Specify directory for installed MPFR include files
 951   --with-mpfr-lib=PATH    Specify the directory for the installed MPFR library
 952   --with-gmp-dir=PATH     This option has been REMOVED
 953   --with-gmp=PATH         Specify prefix directory for the installed GMP package
 954                           Equivalent to --with-gmp-include=PATH/include
 955                           plus --with-gmp-lib=PATH/lib
 956   --with-gmp-include=PATH Specify directory for installed GMP include files
 957   --with-gmp-lib=PATH     Specify the directory for the installed GMP library
 958   --with-build-sysroot=sysroot
 959                           use sysroot as the system root during the build
 960   --with-build-time-tools=path
 961                           use given path to find target tools during the build
 962   --with-datarootdir    Use datarootdir as the data root directory.
 963   --with-docdir Install documentation in this directory.
 964   --with-htmldir        Install html in this directory.
 965
 966 Some influential environment variables:
 967   CC          C compiler command
 968   CFLAGS      C compiler flags
 969   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 970               nonstandard directory <lib dir>
 971   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 972               headers in a nonstandard directory <include dir>
 973   CXX         C++ compiler command
 974   CXXFLAGS    C++ compiler flags
 975   AR          AR for the host
 976   AS          AS for the host
 977   DLLTOOL     DLLTOOL for the host
 978   LD          LD for the host
 979   LIPO        LIPO for the host
 980   NM          NM for the host
 981   RANLIB      RANLIB for the host
 982   STRIP       STRIP for the host
 983   WINDRES     WINDRES for the host
 984   OBJCOPY     OBJCOPY for the host
 985   OBJDUMP     OBJDUMP for the host
 986   CC_FOR_TARGET
 987               CC for the target
 988   CXX_FOR_TARGET
 989               CXX for the target
 990   GCC_FOR_TARGET
 991               GCC for the target
 992   GCJ_FOR_TARGET
 993               GCJ for the target
 994   GFORTRAN_FOR_TARGET
 995               GFORTRAN for the target
 996   AR_FOR_TARGET
 997               AR for the target
 998   AS_FOR_TARGET
 999               AS for the target
1000   DLLTOOL_FOR_TARGET
1001               DLLTOOL for the target
1002   LD_FOR_TARGET
1003               LD for the target
1004   LIPO_FOR_TARGET
1005               LIPO for the target
1006   NM_FOR_TARGET
1007               NM for the target
1008   OBJDUMP_FOR_TARGET
1009               OBJDUMP for the target
1010   RANLIB_FOR_TARGET
1011               RANLIB for the target
1012   STRIP_FOR_TARGET
1013               STRIP for the target
1014   WINDRES_FOR_TARGET
1015               WINDRES for the target
1016
1017 Use these variables to override the choices made by `configure' or to help
1018 it to find libraries and programs with nonstandard names/locations.
1019
1020 _ACEOF
1021 fi
1022
1023 if test "$ac_init_help" = "recursive"; then
1024   # If there are subdirs, report their specific --help.
1025   ac_popdir=`pwd`
1026   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1027     test -d $ac_dir || continue
1028     ac_builddir=.
1029
1030 if test "$ac_dir" != .; then
1031   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1032   # A "../" for each directory in $ac_dir_suffix.
1033   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1034 else
1035   ac_dir_suffix= ac_top_builddir=
1036 fi
1037
1038 case $srcdir in
1039   .)  # No --srcdir option.  We are building in place.
1040     ac_srcdir=.
1041     if test -z "$ac_top_builddir"; then
1042        ac_top_srcdir=.
1043     else
1044        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1045     fi ;;
1046   [\\/]* | ?:[\\/]* )  # Absolute path.
1047     ac_srcdir=$srcdir$ac_dir_suffix;
1048     ac_top_srcdir=$srcdir ;;
1049   *) # Relative path.
1050     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1051     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1052 esac
1053
1054 # Do not use `cd foo && pwd` to compute absolute paths, because
1055 # the directories may not exist.
1056 case `pwd` in
1057 .) ac_abs_builddir="$ac_dir";;
1058 *)
1059   case "$ac_dir" in
1060   .) ac_abs_builddir=`pwd`;;
1061   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1062   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1063   esac;;
1064 esac
1065 case $ac_abs_builddir in
1066 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1067 *)
1068   case ${ac_top_builddir}. in
1069   .) ac_abs_top_builddir=$ac_abs_builddir;;
1070   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1071   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1072   esac;;
1073 esac
1074 case $ac_abs_builddir in
1075 .) ac_abs_srcdir=$ac_srcdir;;
1076 *)
1077   case $ac_srcdir in
1078   .) ac_abs_srcdir=$ac_abs_builddir;;
1079   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1080   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1081   esac;;
1082 esac
1083 case $ac_abs_builddir in
1084 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1085 *)
1086   case $ac_top_srcdir in
1087   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1088   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1089   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1090   esac;;
1091 esac
1092
1093     cd $ac_dir
1094     # Check for guested configure; otherwise get Cygnus style configure.
1095     if test -f $ac_srcdir/configure.gnu; then
1096       echo
1097       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1098     elif test -f $ac_srcdir/configure; then
1099       echo
1100       $SHELL $ac_srcdir/configure  --help=recursive
1101     elif test -f $ac_srcdir/configure.ac ||
1102            test -f $ac_srcdir/configure.in; then
1103       echo
1104       $ac_configure --help
1105     else
1106       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1107     fi
1108     cd $ac_popdir
1109   done
1110 fi
1111
1112 test -n "$ac_init_help" && exit 0
1113 if $ac_init_version; then
1114   cat <<\_ACEOF
1115
1116 Copyright (C) 2003 Free Software Foundation, Inc.
1117 This configure script is free software; the Free Software Foundation
1118 gives unlimited permission to copy, distribute and modify it.
1119 _ACEOF
1120   exit 0
1121 fi
1122 exec 5>config.log
1123 cat >&5 <<_ACEOF
1124 This file contains any messages produced by compilers while
1125 running configure, to aid debugging if configure makes a mistake.
1126
1127 It was created by $as_me, which was
1128 generated by GNU Autoconf 2.59.  Invocation command line was
1129
1130   $ $0 $@
1131
1132 _ACEOF
1133 {
1134 cat <<_ASUNAME
1135 ## --------- ##
1136 ## Platform. ##
1137 ## --------- ##
1138
1139 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1140 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1141 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1142 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1143 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1144
1145 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1146 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1147
1148 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1149 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1150 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1151 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1152 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1153 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1154 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1155
1156 _ASUNAME
1157
1158 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1159 for as_dir in $PATH
1160 do
1161   IFS=$as_save_IFS
1162   test -z "$as_dir" && as_dir=.
1163   echo "PATH: $as_dir"
1164 done
1165
1166 } >&5
1167
1168 cat >&5 <<_ACEOF
1169
1170
1171 ## ----------- ##
1172 ## Core tests. ##
1173 ## ----------- ##
1174
1175 _ACEOF
1176
1177
1178 # Keep a trace of the command line.
1179 # Strip out --no-create and --no-recursion so they do not pile up.
1180 # Strip out --silent because we don't want to record it for future runs.
1181 # Also quote any args containing shell meta-characters.
1182 # Make two passes to allow for proper duplicate-argument suppression.
1183 ac_configure_args=
1184 ac_configure_args0=
1185 ac_configure_args1=
1186 ac_sep=
1187 ac_must_keep_next=false
1188 for ac_pass in 1 2
1189 do
1190   for ac_arg
1191   do
1192     case $ac_arg in
1193     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1194     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1195     | -silent | --silent | --silen | --sile | --sil)
1196       continue ;;
1197     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1198       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1199     esac
1200     case $ac_pass in
1201     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1202     2)
1203       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1204       if test $ac_must_keep_next = true; then
1205         ac_must_keep_next=false # Got value, back to normal.
1206       else
1207         case $ac_arg in
1208           *=* | --config-cache | -C | -disable-* | --disable-* \
1209           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1210           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1211           | -with-* | --with-* | -without-* | --without-* | --x)
1212             case "$ac_configure_args0 " in
1213               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1214             esac
1215             ;;
1216           -* ) ac_must_keep_next=true ;;
1217         esac
1218       fi
1219       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1220       # Get rid of the leading space.
1221       ac_sep=" "
1222       ;;
1223     esac
1224   done
1225 done
1226 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1227 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1228
1229 # When interrupted or exit'd, cleanup temporary files, and complete
1230 # config.log.  We remove comments because anyway the quotes in there
1231 # would cause problems or look ugly.
1232 # WARNING: Be sure not to use single quotes in there, as some shells,
1233 # such as our DU 5.0 friend, will then `close' the trap.
1234 trap 'exit_status=$?
1235   # Save into config.log some information that might help in debugging.
1236   {
1237     echo
1238
1239     cat <<\_ASBOX
1240 ## ---------------- ##
1241 ## Cache variables. ##
1242 ## ---------------- ##
1243 _ASBOX
1244     echo
1245     # The following way of writing the cache mishandles newlines in values,
1246 {
1247   (set) 2>&1 |
1248     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1249     *ac_space=\ *)
1250       sed -n \
1251         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1252           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1253       ;;
1254     *)
1255       sed -n \
1256         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1257       ;;
1258     esac;
1259 }
1260     echo
1261
1262     cat <<\_ASBOX
1263 ## ----------------- ##
1264 ## Output variables. ##
1265 ## ----------------- ##
1266 _ASBOX
1267     echo
1268     for ac_var in $ac_subst_vars
1269     do
1270       eval ac_val=$`echo $ac_var`
1271       echo "$ac_var='"'"'$ac_val'"'"'"
1272     done | sort
1273     echo
1274
1275     if test -n "$ac_subst_files"; then
1276       cat <<\_ASBOX
1277 ## ------------- ##
1278 ## Output files. ##
1279 ## ------------- ##
1280 _ASBOX
1281       echo
1282       for ac_var in $ac_subst_files
1283       do
1284         eval ac_val=$`echo $ac_var`
1285         echo "$ac_var='"'"'$ac_val'"'"'"
1286       done | sort
1287       echo
1288     fi
1289
1290     if test -s confdefs.h; then
1291       cat <<\_ASBOX
1292 ## ----------- ##
1293 ## confdefs.h. ##
1294 ## ----------- ##
1295 _ASBOX
1296       echo
1297       sed "/^$/d" confdefs.h | sort
1298       echo
1299     fi
1300     test "$ac_signal" != 0 &&
1301       echo "$as_me: caught signal $ac_signal"
1302     echo "$as_me: exit $exit_status"
1303   } >&5
1304   rm -f core *.core &&
1305   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1306     exit $exit_status
1307      ' 0
1308 for ac_signal in 1 2 13 15; do
1309   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1310 done
1311 ac_signal=0
1312
1313 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1314 rm -rf conftest* confdefs.h
1315 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1316 echo >confdefs.h
1317
1318 # Predefined preprocessor variables.
1319
1320 cat >>confdefs.h <<_ACEOF
1321 #define PACKAGE_NAME "$PACKAGE_NAME"
1322 _ACEOF
1323
1324
1325 cat >>confdefs.h <<_ACEOF
1326 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1327 _ACEOF
1328
1329
1330 cat >>confdefs.h <<_ACEOF
1331 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1332 _ACEOF
1333
1334
1335 cat >>confdefs.h <<_ACEOF
1336 #define PACKAGE_STRING "$PACKAGE_STRING"
1337 _ACEOF
1338
1339
1340 cat >>confdefs.h <<_ACEOF
1341 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1342 _ACEOF
1343
1344
1345 # Let the site file select an alternate cache file if it wants to.
1346 # Prefer explicitly selected file to automatically selected ones.
1347 if test -z "$CONFIG_SITE"; then
1348   if test "x$prefix" != xNONE; then
1349     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1350   else
1351     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1352   fi
1353 fi
1354 for ac_site_file in $CONFIG_SITE; do
1355   if test -r "$ac_site_file"; then
1356     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1357 echo "$as_me: loading site script $ac_site_file" >&6;}
1358     sed 's/^/| /' "$ac_site_file" >&5
1359     . "$ac_site_file"
1360   fi
1361 done
1362
1363 if test -r "$cache_file"; then
1364   # Some versions of bash will fail to source /dev/null (special
1365   # files actually), so we avoid doing that.
1366   if test -f "$cache_file"; then
1367     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1368 echo "$as_me: loading cache $cache_file" >&6;}
1369     case $cache_file in
1370       [\\/]* | ?:[\\/]* ) . $cache_file;;
1371       *)                      . ./$cache_file;;
1372     esac
1373   fi
1374 else
1375   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1376 echo "$as_me: creating cache $cache_file" >&6;}
1377   >$cache_file
1378 fi
1379
1380 # Check that the precious variables saved in the cache have kept the same
1381 # value.
1382 ac_cache_corrupted=false
1383 for ac_var in `(set) 2>&1 |
1384                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1385   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1386   eval ac_new_set=\$ac_env_${ac_var}_set
1387   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1388   eval ac_new_val="\$ac_env_${ac_var}_value"
1389   case $ac_old_set,$ac_new_set in
1390     set,)
1391       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1392 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1393       ac_cache_corrupted=: ;;
1394     ,set)
1395       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1396 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1397       ac_cache_corrupted=: ;;
1398     ,);;
1399     *)
1400       if test "x$ac_old_val" != "x$ac_new_val"; then
1401         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1402 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1403         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1404 echo "$as_me:   former value:  $ac_old_val" >&2;}
1405         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1406 echo "$as_me:   current value: $ac_new_val" >&2;}
1407         ac_cache_corrupted=:
1408       fi;;
1409   esac
1410   # Pass precious variables to config.status.
1411   if test "$ac_new_set" = set; then
1412     case $ac_new_val in
1413     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1414       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1415     *) ac_arg=$ac_var=$ac_new_val ;;
1416     esac
1417     case " $ac_configure_args " in
1418       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1419       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1420     esac
1421   fi
1422 done
1423 if $ac_cache_corrupted; then
1424   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1425 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1426   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1427 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1428    { (exit 1); exit 1; }; }
1429 fi
1430
1431 ac_ext=c
1432 ac_cpp='$CPP $CPPFLAGS'
1433 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1434 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1435 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457 # Find the build, host, and target systems.
1458 ac_aux_dir=
1459 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1460   if test -f $ac_dir/install-sh; then
1461     ac_aux_dir=$ac_dir
1462     ac_install_sh="$ac_aux_dir/install-sh -c"
1463     break
1464   elif test -f $ac_dir/install.sh; then
1465     ac_aux_dir=$ac_dir
1466     ac_install_sh="$ac_aux_dir/install.sh -c"
1467     break
1468   elif test -f $ac_dir/shtool; then
1469     ac_aux_dir=$ac_dir
1470     ac_install_sh="$ac_aux_dir/shtool install -c"
1471     break
1472   fi
1473 done
1474 if test -z "$ac_aux_dir"; then
1475   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1476 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1477    { (exit 1); exit 1; }; }
1478 fi
1479 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1480 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1481 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1482
1483 # Make sure we can run config.sub.
1484 $ac_config_sub sun4 >/dev/null 2>&1 ||
1485   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1486 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1487    { (exit 1); exit 1; }; }
1488
1489 echo "$as_me:$LINENO: checking build system type" >&5
1490 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1491 if test "${ac_cv_build+set}" = set; then
1492   echo $ECHO_N "(cached) $ECHO_C" >&6
1493 else
1494   ac_cv_build_alias=$build_alias
1495 test -z "$ac_cv_build_alias" &&
1496   ac_cv_build_alias=`$ac_config_guess`
1497 test -z "$ac_cv_build_alias" &&
1498   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1499 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1500    { (exit 1); exit 1; }; }
1501 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1502   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1503 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1504    { (exit 1); exit 1; }; }
1505
1506 fi
1507 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1508 echo "${ECHO_T}$ac_cv_build" >&6
1509 build=$ac_cv_build
1510 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1511 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1512 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1513
1514
1515  case ${build_alias} in
1516   "") build_noncanonical=${build} ;;
1517   *) build_noncanonical=${build_alias} ;;
1518 esac
1519
1520
1521
1522  case ${host_alias} in
1523   "") host_noncanonical=${build_noncanonical} ;;
1524   *) host_noncanonical=${host_alias} ;;
1525 esac
1526
1527
1528
1529  case ${target_alias} in
1530   "") target_noncanonical=${host_noncanonical} ;;
1531   *) target_noncanonical=${target_alias} ;;
1532 esac
1533
1534
1535
1536
1537 test "$host_noncanonical" = "$target_noncanonical" &&
1538   test "$program_prefix$program_suffix$program_transform_name" = \
1539     NONENONEs,x,x, &&
1540   program_transform_name=s,y,y,
1541
1542 echo "$as_me:$LINENO: checking host system type" >&5
1543 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1544 if test "${ac_cv_host+set}" = set; then
1545   echo $ECHO_N "(cached) $ECHO_C" >&6
1546 else
1547   ac_cv_host_alias=$host_alias
1548 test -z "$ac_cv_host_alias" &&
1549   ac_cv_host_alias=$ac_cv_build_alias
1550 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1551   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1552 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1553    { (exit 1); exit 1; }; }
1554
1555 fi
1556 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1557 echo "${ECHO_T}$ac_cv_host" >&6
1558 host=$ac_cv_host
1559 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1560 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1561 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1562
1563
1564 echo "$as_me:$LINENO: checking target system type" >&5
1565 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1566 if test "${ac_cv_target+set}" = set; then
1567   echo $ECHO_N "(cached) $ECHO_C" >&6
1568 else
1569   ac_cv_target_alias=$target_alias
1570 test "x$ac_cv_target_alias" = "x" &&
1571   ac_cv_target_alias=$ac_cv_host_alias
1572 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1573   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1574 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1575    { (exit 1); exit 1; }; }
1576
1577 fi
1578 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1579 echo "${ECHO_T}$ac_cv_target" >&6
1580 target=$ac_cv_target
1581 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1582 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1583 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1584
1585
1586 # The aliases save the names the user supplied, while $host etc.
1587 # will get canonicalized.
1588 test -n "$target_alias" &&
1589   test "$program_prefix$program_suffix$program_transform_name" = \
1590     NONENONEs,x,x, &&
1591   program_prefix=${target_alias}-
1592 test "$program_prefix" != NONE &&
1593   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1594 # Use a double $ so make ignores it.
1595 test "$program_suffix" != NONE &&
1596   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1597 # Double any \ or $.  echo might interpret backslashes.
1598 # By default was `s,x,x', remove it if useless.
1599 cat <<\_ACEOF >conftest.sed
1600 s/[\\$]/&&/g;s/;s,x,x,$//
1601 _ACEOF
1602 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1603 rm conftest.sed
1604
1605
1606
1607 # Get 'install' or 'install-sh' and its variants.
1608 # Find a good install program.  We prefer a C program (faster),
1609 # so one script is as good as another.  But avoid the broken or
1610 # incompatible versions:
1611 # SysV /etc/install, /usr/sbin/install
1612 # SunOS /usr/etc/install
1613 # IRIX /sbin/install
1614 # AIX /bin/install
1615 # AmigaOS /C/install, which installs bootblocks on floppy discs
1616 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1617 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1618 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1619 # OS/2's system install, which has a completely different semantic
1620 # ./install, which can be erroneously created by make from ./install.sh.
1621 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1622 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1623 if test -z "$INSTALL"; then
1624 if test "${ac_cv_path_install+set}" = set; then
1625   echo $ECHO_N "(cached) $ECHO_C" >&6
1626 else
1627   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1628 for as_dir in $PATH
1629 do
1630   IFS=$as_save_IFS
1631   test -z "$as_dir" && as_dir=.
1632   # Account for people who put trailing slashes in PATH elements.
1633 case $as_dir/ in
1634   ./ | .// | /cC/* | \
1635   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1636   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1637   /usr/ucb/* ) ;;
1638   *)
1639     # OSF1 and SCO ODT 3.0 have their own names for install.
1640     # Don't use installbsd from OSF since it installs stuff as root
1641     # by default.
1642     for ac_prog in ginstall scoinst install; do
1643       for ac_exec_ext in '' $ac_executable_extensions; do
1644         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1645           if test $ac_prog = install &&
1646             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1647             # AIX install.  It has an incompatible calling convention.
1648             :
1649           elif test $ac_prog = install &&
1650             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1651             # program-specific install script used by HP pwplus--don't use.
1652             :
1653           else
1654             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1655             break 3
1656           fi
1657         fi
1658       done
1659     done
1660     ;;
1661 esac
1662 done
1663
1664
1665 fi
1666   if test "${ac_cv_path_install+set}" = set; then
1667     INSTALL=$ac_cv_path_install
1668   else
1669     # As a last resort, use the slow shell script.  We don't cache a
1670     # path for INSTALL within a source directory, because that will
1671     # break other packages using the cache if that directory is
1672     # removed, or if the path is relative.
1673     INSTALL=$ac_install_sh
1674   fi
1675 fi
1676 echo "$as_me:$LINENO: result: $INSTALL" >&5
1677 echo "${ECHO_T}$INSTALL" >&6
1678
1679 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1680 # It thinks the first close brace ends the variable substitution.
1681 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1682
1683 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1684
1685 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1686
1687 echo "$as_me:$LINENO: checking whether ln works" >&5
1688 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1689 if test "${acx_cv_prog_LN+set}" = set; then
1690   echo $ECHO_N "(cached) $ECHO_C" >&6
1691 else
1692   rm -f conftestdata_t
1693 echo >conftestdata_f
1694 if ln conftestdata_f conftestdata_t 2>/dev/null
1695 then
1696   acx_cv_prog_LN=ln
1697 else
1698   acx_cv_prog_LN=no
1699 fi
1700 rm -f conftestdata_f conftestdata_t
1701
1702 fi
1703 if test $acx_cv_prog_LN = no; then
1704   LN="cp"
1705   echo "$as_me:$LINENO: result: no, using $LN" >&5
1706 echo "${ECHO_T}no, using $LN" >&6
1707 else
1708   LN="$acx_cv_prog_LN"
1709   echo "$as_me:$LINENO: result: yes" >&5
1710 echo "${ECHO_T}yes" >&6
1711 fi
1712
1713 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1714 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1715 LN_S=$as_ln_s
1716 if test "$LN_S" = "ln -s"; then
1717   echo "$as_me:$LINENO: result: yes" >&5
1718 echo "${ECHO_T}yes" >&6
1719 else
1720   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1721 echo "${ECHO_T}no, using $LN_S" >&6
1722 fi
1723
1724
1725 ### we might need to use some other shell than /bin/sh for running subshells
1726 ### If we are on Windows, search for the shell.  This will permit people
1727 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1728 ### without also having to set CONFIG_SHELL.  This code will work when
1729 ### using bash, which sets OSTYPE.
1730 case "${OSTYPE}" in
1731 *win32*)
1732   if test x${CONFIG_SHELL} = x ; then
1733     if test ! -f /bin/sh ; then
1734       if test x${SHELL} != x && test -f ${SHELL} ; then
1735         CONFIG_SHELL=${SHELL}
1736         export CONFIG_SHELL
1737       else
1738         for prog in sh sh.exe bash bash.exe; do
1739           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1740           for dir in $PATH; do
1741             test -z "$dir" && dir=.
1742             if test -f $dir/$prog; then
1743               CONFIG_SHELL=$dir/$prog
1744               export CONFIG_SHELL
1745               break
1746             fi
1747           done
1748           IFS="$save_ifs"
1749           test -n "${CONFIG_SHELL}" && break
1750         done
1751       fi
1752     fi
1753   fi
1754   ;;
1755 esac
1756
1757 config_shell=${CONFIG_SHELL-/bin/sh}
1758
1759 progname=$0
1760 # if PWD already has a value, it is probably wrong.
1761 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1762
1763 # Export original configure arguments for use by sub-configures.
1764 # Quote arguments with shell meta charatcers.
1765 TOPLEVEL_CONFIGURE_ARGUMENTS=
1766 set -- "$progname" "$@"
1767 for ac_arg; do
1768   case "$ac_arg" in
1769   *" "*|*"      "*|*\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?*)
1770     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1771     # if the argument is of the form -foo=baz, quote the baz part only
1772     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1773   *) ;;
1774   esac
1775   # Add the quoted argument to the list.
1776   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1777 done
1778 # Remove the initial space we just introduced and, as these will be
1779 # expanded by make, quote '$'.
1780 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1781
1782
1783 moveifchange=${srcdir}/move-if-change
1784
1785 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1786
1787 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1788 # a relative path.
1789 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1790   INSTALL="${srcpwd}/install-sh -c"
1791 fi
1792
1793 # Set srcdir to "." if that's what it is.
1794 # This is important for multilib support.
1795 pwd=`${PWDCMD-pwd}`
1796 if test "${pwd}" = "${srcpwd}" ; then
1797   srcdir=.
1798 fi
1799
1800 topsrcdir=$srcpwd
1801
1802 extra_host_args=
1803
1804 ### To add a new directory to the tree, first choose whether it is a target
1805 ### or a host dependent tool.  Then put it into the appropriate list
1806 ### (library or tools, host or target), doing a dependency sort.
1807
1808 # Subdirs will be configured in the order listed in build_configdirs,
1809 # configdirs, or target_configdirs; see the serialization section below.
1810
1811 # Dependency sorting is only needed when *configuration* must be done in
1812 # a particular order.  In all cases a dependency should be specified in
1813 # the Makefile, whether or not it's implicitly specified here.
1814
1815 # Double entries in build_configdirs, configdirs, or target_configdirs may
1816 # cause circular dependencies and break everything horribly.
1817
1818 # these library is used by various programs built for the build
1819 # environment
1820 #
1821 build_libs="build-libiberty"
1822
1823 # these tools are built for the build environment
1824 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1825
1826 # these libraries are used by various programs built for the host environment
1827 #
1828 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1829
1830 # these tools are built for the host environment
1831 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1832 # know that we are building the simulator.
1833 # binutils, gas and ld appear in that order because it makes sense to run
1834 # "make check" in that particular order.
1835 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"
1836
1837 # libgcj represents the runtime libraries only used by gcj.
1838 libgcj="target-libffi \
1839         target-zlib \
1840         target-qthreads \
1841         target-libjava"
1842
1843 # these libraries are built for the target environment, and are built after
1844 # the host libraries and the host tools (which may be a cross compiler)
1845 #
1846 target_libraries="target-libgcc \
1847                 target-libiberty \
1848                 target-libgloss \
1849                 target-newlib \
1850                 target-libstdc++-v3 \
1851                 target-libmudflap \
1852                 target-libssp \
1853                 target-libgfortran \
1854                 target-boehm-gc \
1855                 ${libgcj} \
1856                 target-libobjc \
1857                 target-libada \
1858                 target-libgomp"
1859
1860 # these tools are built using the target libraries, and are intended to
1861 # run only in the target environment
1862 #
1863 # note: any program that *uses* libraries that are in the "target_libraries"
1864 # list belongs in this list.  those programs are also very likely
1865 # candidates for the "native_only" list which follows
1866 #
1867 target_tools="target-examples target-groff target-gperf target-rda"
1868
1869 ################################################################################
1870
1871 ## All tools belong in one of the four categories, and are assigned above
1872 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1873 ## is important because configure will choke if they ever get through.
1874 ## ${configdirs} is directories we build using the host tools.
1875 ## ${target_configdirs} is directories we build using the target tools.
1876 configdirs=`echo ${host_libs} ${host_tools}`
1877 target_configdirs=`echo ${target_libraries} ${target_tools}`
1878 build_configdirs=`echo ${build_libs} ${build_tools}`
1879
1880 ################################################################################
1881
1882 srcname="gnu development package"
1883
1884 # This gets set non-empty for some net releases of packages.
1885 appdirs=""
1886
1887 # Define is_cross_compiler to save on calls to 'test'.
1888 is_cross_compiler=
1889 if test x"${host}" = x"${target}" ; then
1890   is_cross_compiler=no
1891 else
1892   is_cross_compiler=yes
1893 fi
1894
1895 # Find the build and target subdir names.
1896
1897 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1898 # have matching libraries, they should use host libraries: Makefile.tpl
1899 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1900 # However, they still use the build modules, because the corresponding
1901 # host modules (e.g. bison) are only built for the host when bootstrap
1902 # finishes. So:
1903 # - build_subdir is where we find build modules, and never changes.
1904 # - build_libsubdir is where we find build libraries, and can be overridden.
1905
1906 # Prefix 'build-' so this never conflicts with target_subdir.
1907 build_subdir="build-${build_noncanonical}"
1908
1909 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1910 if test "${with_build_libsubdir+set}" = set; then
1911   withval="$with_build_libsubdir"
1912   build_libsubdir="$withval"
1913 else
1914   build_libsubdir="$build_subdir"
1915 fi;
1916 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1917 if ( test $srcdir = . && test -d gcc ) \
1918    || test -d $srcdir/../host-${host_noncanonical}; then
1919   host_subdir="host-${host_noncanonical}"
1920 else
1921   host_subdir=.
1922 fi
1923 # No prefix.
1924 target_subdir=${target_noncanonical}
1925
1926
1927 # Skipdirs are removed silently.
1928 skipdirs=
1929 # Noconfigdirs are removed loudly.
1930 noconfigdirs=""
1931
1932 use_gnu_ld=
1933 # Make sure we don't let GNU ld be added if we didn't want it.
1934 if test x$with_gnu_ld = xno ; then
1935   use_gnu_ld=no
1936   noconfigdirs="$noconfigdirs ld"
1937 fi
1938
1939 use_gnu_as=
1940 # Make sure we don't let GNU as be added if we didn't want it.
1941 if test x$with_gnu_as = xno ; then
1942   use_gnu_as=no
1943   noconfigdirs="$noconfigdirs gas"
1944 fi
1945
1946 # some tools are so dependent upon X11 that if we're not building with X,
1947 # it's not even worth trying to configure, much less build, that tool.
1948
1949 case ${with_x} in
1950   yes | "") ;; # the default value for this tree is that X11 is available
1951   no)
1952     skipdirs="${skipdirs} tk itcl libgui"
1953     # We won't be able to build gdbtk without X.
1954     enable_gdbtk=no
1955     ;;
1956   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1957 esac
1958
1959 # Some tools are only suitable for building in a "native" situation.
1960 # Remove these if host!=target.
1961 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"
1962
1963 # Similarly, some are only suitable for cross toolchains.
1964 # Remove these if host=target.
1965 cross_only="target-libgloss target-newlib target-opcodes"
1966
1967 case $is_cross_compiler in
1968   no) skipdirs="${skipdirs} ${cross_only}" ;;
1969   yes) skipdirs="${skipdirs} ${native_only}" ;;
1970 esac
1971
1972 # If both --with-headers and --with-libs are specified, default to
1973 # --without-newlib.
1974 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
1975    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
1976   if test x"${with_newlib}" = x ; then
1977     with_newlib=no
1978   fi
1979 fi
1980
1981 # Recognize --with-newlib/--without-newlib.
1982 case ${with_newlib} in
1983   no) skipdirs="${skipdirs} target-newlib" ;;
1984   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
1985 esac
1986
1987 # Configure extra directories which are host specific
1988
1989 case "${host}" in
1990   *-cygwin*)
1991     configdirs="$configdirs libtermcap" ;;
1992 esac
1993
1994 # A target can indicate whether a language isn't supported for some reason.
1995 # Only spaces may be used in this macro; not newlines or tabs.
1996 unsupported_languages=
1997
1998 # Remove more programs from consideration, based on the host or
1999 # target this usually means that a port of the program doesn't
2000 # exist yet.
2001
2002 case "${host}" in
2003   hppa*64*-*-*)
2004     noconfigdirs="$noconfigdirs byacc"
2005     ;;
2006   i[3456789]86-*-vsta)
2007     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2008     ;;
2009   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2010     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2011     ;;
2012   x86_64-*-mingw*)
2013     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2014     ;;
2015   i[3456789]86-*-mingw32*)
2016     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2017     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2018     ;;
2019   i[3456789]86-*-beos*)
2020     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2021     ;;
2022   *-*-cygwin*)
2023     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2024     ;;
2025   *-*-netbsd*)
2026     noconfigdirs="$noconfigdirs rcs"
2027     ;;
2028   ppc*-*-pe)
2029     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2030     ;;
2031   powerpc-*-beos*)
2032     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2033     ;;
2034 esac
2035
2036
2037 # Check whether --enable-libada or --disable-libada was given.
2038 if test "${enable_libada+set}" = set; then
2039   enableval="$enable_libada"
2040   ENABLE_LIBADA=$enableval
2041 else
2042   ENABLE_LIBADA=yes
2043 fi;
2044 if test "${ENABLE_LIBADA}" != "yes" ; then
2045   noconfigdirs="$noconfigdirs gnattools"
2046 fi
2047
2048 # Check whether --enable-libssp or --disable-libssp was given.
2049 if test "${enable_libssp+set}" = set; then
2050   enableval="$enable_libssp"
2051   ENABLE_LIBSSP=$enableval
2052 else
2053   ENABLE_LIBSSP=yes
2054 fi;
2055
2056 # Save it here so that, even in case of --enable-libgcj, if the Java
2057 # front-end isn't enabled, we still get libgcj disabled.
2058 libgcj_saved=$libgcj
2059 case $enable_libgcj in
2060 yes)
2061   # If we reset it here, it won't get added to noconfigdirs in the
2062   # target-specific build rules, so it will be forcibly enabled
2063   # (unless the Java language itself isn't enabled).
2064   libgcj=
2065   ;;
2066 no)
2067   # Make sure we get it printed in the list of not supported target libs.
2068   noconfigdirs="$noconfigdirs ${libgcj}"
2069   ;;
2070 esac
2071
2072
2073 # Disable libmudflap on some systems.
2074 if test x$enable_libmudflap = x ; then
2075     case "${target}" in
2076     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2077         # Enable libmudflap by default in GNU and friends.
2078         ;;
2079     *-*-freebsd*)
2080         # Enable libmudflap by default in FreeBSD.
2081         ;;
2082     *)
2083         # Disable it by default everywhere else.
2084         noconfigdirs="$noconfigdirs target-libmudflap"
2085         ;;
2086     esac
2087 fi
2088
2089 # Disable libgomp on non POSIX hosted systems.
2090 if test x$enable_libgomp = x ; then
2091     # Enable libgomp by default on hosted POSIX systems.
2092     case "${target}" in
2093     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2094         ;;
2095     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2096         ;;
2097     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2098         ;;
2099     *-*-darwin* | *-*-aix*)
2100         ;;
2101     *)
2102         noconfigdirs="$noconfigdirs target-libgomp"
2103         ;;
2104     esac
2105 fi
2106
2107
2108 case "${target}" in
2109   *-*-chorusos)
2110     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2111     ;;
2112   powerpc-*-darwin* | i[3456789]86-*-darwin*)
2113     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2114     noconfigdirs="$noconfigdirs sim target-rda"
2115     ;;
2116   *-*-darwin*)
2117     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2118     noconfigdirs="$noconfigdirs sim target-rda"
2119     noconfigdirs="$noconfigdirs ${libgcj}"
2120     ;;
2121   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2122     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2123     ;;
2124   *-*-freebsd*)
2125     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2126     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2127         && test -f /usr/local/include/gmp.h; then
2128       with_gmp=/usr/local
2129     fi
2130
2131     # Skip some stuff that's unsupported on some FreeBSD configurations.
2132     case "${target}" in
2133       i*86-*-*) ;;
2134       alpha*-*-*) ;;
2135       *)
2136         noconfigdirs="$noconfigdirs ${libgcj}"
2137         ;;
2138     esac
2139     ;;
2140   *-*-kaos*)
2141     # Remove unsupported stuff on all kaOS configurations.
2142     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2143     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2144     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2145     noconfigdirs="$noconfigdirs target-libgloss"
2146     ;;
2147   *-*-netbsd*)
2148     # Skip some stuff on all NetBSD configurations.
2149     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2150
2151     # Skip some stuff that's unsupported on some NetBSD configurations.
2152     case "${target}" in
2153       i*86-*-netbsdelf*) ;;
2154       arm*-*-netbsdelf*) ;;
2155       *)
2156         noconfigdirs="$noconfigdirs ${libgcj}"
2157         ;;
2158     esac
2159     ;;
2160   *-*-netware*)
2161     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2162     ;;
2163   *-*-rtems*)
2164     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2165     ;;
2166     # The tpf target doesn't support gdb yet.
2167   *-*-tpf*)
2168     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2169     ;;
2170   *-*-uclinux*)
2171     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2172     ;;
2173   *-*-vxworks*)
2174     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2175     ;;
2176   alpha*-dec-osf*)
2177     # ld works, but does not support shared libraries.
2178     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2179     # gas doesn't generate exception information.
2180     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2181     ;;
2182   alpha*-*-*vms*)
2183     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2184     ;;
2185   alpha*-*-linux*)
2186     # newlib is not 64 bit ready
2187     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2188     ;;
2189   alpha*-*-*)
2190     # newlib is not 64 bit ready
2191     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2192     ;;
2193   am33_2.0-*-linux*)
2194     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2195     ;;
2196   sh-*-linux*)
2197     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2198     ;;
2199   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2200     noconfigdirs="$noconfigdirs ${libgcj}"
2201     noconfigdirs="$noconfigdirs target-examples"
2202     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2203     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2204     noconfigdirs="$noconfigdirs expect dejagnu"
2205     # the C++ libraries don't build on top of CE's C libraries
2206     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2207     noconfigdirs="$noconfigdirs target-newlib"
2208     case "${host}" in
2209       *-*-cygwin*) ;; # keep gdb and readline
2210       *) noconfigdirs="$noconfigdirs gdb readline"
2211          ;;
2212     esac
2213     ;;
2214   arc-*-*)
2215     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2216     ;;
2217   arm-semi-aof )
2218     ;;
2219   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2220     noconfigdirs="$noconfigdirs ${libgcj}"
2221     ;;
2222   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2223     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2224     ;;
2225   arm*-*-linux-gnueabi)
2226     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2227     noconfigdirs="$noconfigdirs target-libjava target-libobjc"
2228     ;;
2229   arm*-*-symbianelf*)
2230     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2231     ;;
2232   arm-*-pe*)
2233     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2234     ;;
2235   thumb-*-coff)
2236     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2237     ;;
2238   thumb-*-elf)
2239     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2240     ;;
2241   thumb-*-pe)
2242     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2243     ;;
2244   arm-*-riscix*)
2245     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2246     ;;
2247   avr-*-*)
2248     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2249     ;;
2250   bfin-*-*)
2251     noconfigdirs="$noconfigdirs gdb"
2252     if test x${is_cross_compiler} != xno ; then
2253       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2254     fi
2255     ;;
2256   c4x-*-* | tic4x-*-*)
2257     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2258     ;;
2259   c54x*-*-* | tic54x-*-*)
2260     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2261     ;;
2262   cris-*-* | crisv32-*-*)
2263     unsupported_languages="$unsupported_languages java"
2264     case "${target}" in
2265       *-*-aout)
2266         unsupported_languages="$unsupported_languages fortran"
2267         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2268       *-*-elf)
2269         unsupported_languages="$unsupported_languages fortran"
2270         noconfigdirs="$noconfigdirs target-boehm-gc";;
2271       *-*-linux*)
2272         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2273       *)
2274         unsupported_languages="$unsupported_languages fortran"
2275         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2276     esac
2277     ;;
2278   crx-*-*)
2279     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2280     ;;
2281   d10v-*-*)
2282     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2283     ;;
2284   d30v-*-*)
2285     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2286     ;;
2287   fr30-*-elf*)
2288     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2289     ;;
2290   frv-*-*)
2291     noconfigdirs="$noconfigdirs ${libgcj}"
2292     ;;
2293   h8300*-*-*)
2294     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2295     ;;
2296   h8500-*-*)
2297     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2298     ;;
2299   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2300     ;;
2301   hppa*64*-*-linux* | parisc*64*-*-linux*)
2302     # In this case, it's because the hppa64-linux target is for
2303     # the kernel only at this point and has no libc, and thus no
2304     # headers, crt*.o, etc., all of which are needed by these.
2305     noconfigdirs="$noconfigdirs target-zlib"
2306     ;;
2307   parisc*-*-linux* | hppa*-*-linux*)
2308     ;;
2309   hppa*-*-*elf* | \
2310   hppa*-*-lites* | \
2311   hppa*-*-openbsd* | \
2312   hppa*64*-*-*)
2313     noconfigdirs="$noconfigdirs ${libgcj}"
2314     ;;
2315   hppa*-hp-hpux11*)
2316     noconfigdirs="$noconfigdirs ld shellutils"
2317     ;;
2318   hppa*-*-*)
2319     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2320     # build on HP-UX 10.20.
2321     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2322     ;;
2323   i960-*-*)
2324     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2325     ;;
2326   ia64*-*-elf*)
2327     # No gdb support yet.
2328     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2329     ;;
2330   ia64*-**-hpux*)
2331     # No gdb or ld support yet.
2332     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2333     ;;
2334   i370-*-opened*)
2335     ;;
2336   i[3456789]86-*-coff | i[3456789]86-*-elf)
2337     noconfigdirs="$noconfigdirs ${libgcj}"
2338     ;;
2339   i[3456789]86-*-linux*)
2340     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2341     # not build java stuff by default.
2342     case "${target}" in
2343       *-*-*libc1*)
2344         noconfigdirs="$noconfigdirs ${libgcj}";;
2345     esac
2346
2347     # This section makes it possible to build newlib natively on linux.
2348     # If we are using a cross compiler then don't configure newlib.
2349     if test x${is_cross_compiler} != xno ; then
2350       noconfigdirs="$noconfigdirs target-newlib"
2351     fi
2352     noconfigdirs="$noconfigdirs target-libgloss"
2353     # If we are not using a cross compiler, do configure newlib.
2354     # Note however, that newlib will only be configured in this situation
2355     # if the --with-newlib option has been given, because otherwise
2356     # 'target-newlib' will appear in skipdirs.
2357     ;;
2358   i[3456789]86-*-mingw32*)
2359     target_configdirs="$target_configdirs target-winsup"
2360     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2361     ;;
2362   x86_64-*-mingw*)
2363     target_configdirs="$target_configdirs target-winsup"
2364     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2365     ;;
2366   *-*-cygwin*)
2367     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2368     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2369     # always build newlib if winsup directory is present.
2370     if test -d "$srcdir/winsup/cygwin"; then
2371       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2372     elif test -d "$srcdir/newlib"; then
2373       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2374     fi
2375     ;;
2376   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2377   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2378     ;;
2379   i[3456789]86-*-pe)
2380     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2381     ;;
2382   i[3456789]86-*-sco3.2v5*)
2383     # The linker does not yet know about weak symbols in COFF,
2384     # and is not configured to handle mixed ELF and COFF.
2385     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2386     ;;
2387   i[3456789]86-*-sco*)
2388     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2389     ;;
2390   i[3456789]86-*-solaris2*)
2391     noconfigdirs="$noconfigdirs target-libgloss"
2392     ;;
2393   i[3456789]86-*-sysv4*)
2394     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2395     ;;
2396   i[3456789]86-*-beos*)
2397     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2398     ;;
2399   i[3456789]86-*-rdos*)
2400     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2401     ;;
2402   m32r-*-*)
2403     noconfigdirs="$noconfigdirs ${libgcj}"
2404     ;;
2405   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2406     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2407     ;;
2408   m68k-*-elf*)
2409     noconfigdirs="$noconfigdirs ${libgcj}"
2410     ;;
2411   m68k-*-coff*)
2412     noconfigdirs="$noconfigdirs ${libgcj}"
2413     ;;
2414   mcore-*-pe*)
2415   # The EPOC C++ environment does not support exceptions or rtti,
2416   # and so building libstdc++-v3 tends not to always work.
2417     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2418     ;;
2419   mmix-*-*)
2420     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2421     unsupported_languages="$unsupported_languages fortran java"
2422     ;;
2423   mn10200-*-*)
2424     noconfigdirs="$noconfigdirs ${libgcj}"
2425     ;;
2426   mn10300-*-*)
2427     noconfigdirs="$noconfigdirs ${libgcj}"
2428     ;;
2429   mt-*-*)
2430     noconfigdirs="$noconfigdirs sim"
2431     ;;
2432   powerpc-*-aix*)
2433     # copied from rs6000-*-* entry
2434     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2435     ;;
2436   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2437     target_configdirs="$target_configdirs target-winsup"
2438     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2439     # always build newlib.
2440     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2441     ;;
2442     # This is temporary until we can link against shared libraries
2443   powerpcle-*-solaris*)
2444     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2445     ;;
2446   powerpc-*-beos*)
2447     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2448     ;;
2449   powerpc-*-eabi)
2450     noconfigdirs="$noconfigdirs ${libgcj}"
2451     ;;
2452   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2453     ;;
2454   rs6000-*-lynxos*)
2455     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2456     ;;
2457   rs6000-*-aix*)
2458     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2459     ;;
2460   rs6000-*-*)
2461     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2462     ;;
2463   m68k-apollo-*)
2464     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2465     ;;
2466   mips*-*-irix5*)
2467     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2468     ;;
2469   mips*-*-irix6*)
2470     # Linking libjava exceeds command-line length limits on at least
2471     # IRIX 6.2, but not on IRIX 6.5.
2472     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2473     # <oldham@codesourcery.com>
2474     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2475     ;;
2476   mips*-*-bsd*)
2477     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2478     ;;
2479   mips64*-*-linux*)
2480     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2481     ;;
2482   mips*-*-linux*)
2483     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2484     ;;
2485   mips*-*-*)
2486     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2487     ;;
2488   romp-*-*)
2489     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2490     ;;
2491   sh-*-* | sh64-*-*)
2492     case "${host}" in
2493       i[3456789]86-*-vsta) ;; # don't add gprof back in
2494       i[3456789]86-*-go32*) ;; # don't add gprof back in
2495       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2496       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2497     esac
2498     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2499     ;;
2500   sparc-*-elf*)
2501     noconfigdirs="$noconfigdirs ${libgcj}"
2502     ;;
2503   sparc64-*-elf*)
2504     noconfigdirs="$noconfigdirs ${libgcj}"
2505     ;;
2506   sparclite-*-*)
2507     noconfigdirs="$noconfigdirs ${libgcj}"
2508     ;;
2509   sparc-*-sunos4*)
2510     noconfigdirs="$noconfigdirs ${libgcj}"
2511     if test x${is_cross_compiler} != xno ; then
2512            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2513     else
2514            use_gnu_ld=no
2515     fi
2516     ;;
2517   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2518     noconfigdirs="$noconfigdirs ${libgcj}"
2519     ;;
2520   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2521     ;;
2522   spu-*-*)
2523     skipdirs="target-libssp"
2524     ;;
2525   v810-*-*)
2526     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2527     ;;
2528   v850-*-*)
2529     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2530     ;;
2531   v850e-*-*)
2532     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2533     ;;
2534   v850ea-*-*)
2535     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2536     ;;
2537   vax-*-vms)
2538     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2539     ;;
2540   vax-*-*)
2541     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2542     ;;
2543   xtensa-*-*)
2544     noconfigdirs="$noconfigdirs ${libgcj}"
2545     ;;
2546   ip2k-*-*)
2547     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2548     ;;
2549   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2550     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2551     ;;
2552   *-*-lynxos*)
2553     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2554     ;;
2555   *-*-*)
2556     noconfigdirs="$noconfigdirs ${libgcj}"
2557     ;;
2558 esac
2559
2560 # If we aren't building newlib, then don't build libgloss, since libgloss
2561 # depends upon some newlib header files.
2562 case "${noconfigdirs}" in
2563   *target-libgloss*) ;;
2564   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2565 esac
2566
2567 # Work in distributions that contain no compiler tools, like Autoconf.
2568 tentative_cc=""
2569 host_makefile_frag=/dev/null
2570 if test -d ${srcdir}/config ; then
2571 case "${host}" in
2572   m68k-hp-hpux*)
2573     # Avoid "too much defining" errors from HPUX compiler.
2574     tentative_cc="cc -Wp,-H256000"
2575     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2576     # If it's HP/UX ar, this should be harmless.
2577     RANLIB="ar ts"
2578     ;;
2579   m68k-apollo-sysv*)
2580     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2581     ;;
2582   m68k-apollo-bsd*)
2583     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2584     # chokes on bfd, the compiler won't let you assign integers to enums, and
2585     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2586     # the apollo compiler" (the preferred version of GCC could be called cc,
2587     # or whatever), but I'm not sure leaving CC as cc is any better...
2588     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2589     # Used to have BISON=yacc.
2590     tentative_cc=gcc
2591     ;;
2592   m88k-dg-dgux*)
2593     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2594     ;;
2595   m88k-harris-cxux*)
2596     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2597     tentative_cc="cc -Xa"
2598     host_makefile_frag="config/mh-cxux"
2599     ;;
2600   m88k-motorola-sysv*)
2601     ;;
2602   mips*-dec-ultrix*)
2603     tentative_cc="cc -Wf,-XNg1000"
2604     host_makefile_frag="config/mh-decstation"
2605     ;;
2606   mips*-nec-sysv4*)
2607     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2608     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2609     host_makefile_frag="config/mh-necv4"
2610     ;;
2611   mips*-sgi-irix4*)
2612     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2613     # environment.  Also bump switch table size so that cp-parse will
2614     # compile.  Bump string length limit so linker builds.
2615     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2616     ;;
2617   mips*-*-sysv4*)
2618     host_makefile_frag="config/mh-sysv4"
2619     ;;
2620   mips*-*-sysv*)
2621     # This is for a MIPS running RISC/os 4.52C.
2622
2623     # This is needed for GDB, but needs to be in the top-level make because
2624     # if a library is compiled with the bsd headers and gets linked with the
2625     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2626     # a different size).
2627     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2628     # known except to select the sysv environment.  Could we use /proc instead?
2629     # These "sysv environments" and "bsd environments" often end up being a pain.
2630     #
2631     # This is not part of CFLAGS because perhaps not all C compilers have this
2632     # option.
2633     tentative_cc="cc -systype sysv"
2634     ;;
2635   i370-ibm-opened*)
2636     tentative_cc="c89"
2637     ;;
2638   i[3456789]86-*-sysv5*)
2639     host_makefile_frag="config/mh-sysv5"
2640     ;;
2641   i[3456789]86-*-dgux*)
2642     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2643     host_makefile_frag="config/mh-dgux386"
2644     ;;
2645   i[3456789]86-ncr-sysv4.3*)
2646     # The MetaWare compiler will generate a copyright message unless you
2647     # turn it off by adding the -Hnocopyr flag.
2648     tentative_cc="cc -Hnocopyr"
2649     ;;
2650   i[3456789]86-ncr-sysv4*)
2651     # for an NCR 3000 (i486/SVR4) system.
2652     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2653     # This compiler not only emits obnoxious copyright messages every time
2654     # you run it, but it chokes and dies on a whole bunch of GNU source
2655     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2656     tentative_cc="/usr/ccs/ATT/cc"
2657     host_makefile_frag="config/mh-ncr3000"
2658     ;;
2659   i[3456789]86-*-sco3.2v5*)
2660     ;;
2661   i[3456789]86-*-sco*)
2662     # The native C compiler botches some simple uses of const.  Unfortunately,
2663     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2664     tentative_cc="cc -Dconst="
2665     host_makefile_frag="config/mh-sco"
2666     ;;
2667   i[3456789]86-*-udk*)
2668     host_makefile_frag="config/mh-sysv5"
2669     ;;
2670   i[3456789]86-*-solaris2*)
2671     host_makefile_frag="config/mh-sysv4"
2672     ;;
2673   i[3456789]86-*-msdosdjgpp*)
2674     host_makefile_frag="config/mh-djgpp"
2675     ;;
2676   *-cygwin*)
2677     host_makefile_frag="config/mh-cygwin"
2678     ;;
2679   *-mingw32*)
2680     ;;
2681   *-mingw64*)
2682     ;;
2683   *-interix*)
2684     host_makefile_frag="config/mh-interix"
2685     ;;
2686   vax-*-ultrix2*)
2687     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2688     tentative_cc=gcc
2689     ;;
2690   *-*-solaris2*)
2691     host_makefile_frag="config/mh-solaris"
2692     ;;
2693   m68k-sun-sunos*)
2694     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2695     # without overflowing the jump tables (-J says to use a 32 bit table)
2696     tentative_cc="cc -J"
2697     ;;
2698   *-hp-hpux*)
2699     tentative_cc="cc -Wp,-H256000"
2700     ;;
2701   *-*-hiux*)
2702     tentative_cc="cc -Wp,-H256000"
2703     ;;
2704   rs6000-*-lynxos*)
2705     # /bin/cc is less than useful for our purposes.  Always use GCC
2706     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2707     host_makefile_frag="config/mh-lynxrs6k"
2708     ;;
2709   powerpc-*-darwin*)
2710     host_makefile_frag="config/mh-ppc-darwin"
2711     ;;
2712   powerpc-*-aix*)
2713     host_makefile_frag="config/mh-ppc-aix"
2714     ;;
2715   rs6000-*-aix*)
2716     host_makefile_frag="config/mh-ppc-aix"
2717     ;;
2718   *-*-lynxos*)
2719     # /bin/cc is less than useful for our purposes.  Always use GCC
2720     tentative_cc="/bin/gcc"
2721     ;;
2722   *-*-sysv4*)
2723     host_makefile_frag="config/mh-sysv4"
2724     ;;
2725   # This is placed last to prevent interfering with the cases above.
2726   i[3456789]86-*-*)
2727     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2728     host_makefile_frag="config/mh-x86omitfp"
2729     ;;
2730 esac
2731 fi
2732
2733 # If we aren't going to be using gcc, see if we can extract a definition
2734 # of CC from the fragment.
2735 # Actually, use the 'pre-extracted' version above.
2736 if test -z "${CC}" && test "${build}" = "${host}" ; then
2737   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2738   found=
2739   for dir in $PATH; do
2740     test -z "$dir" && dir=.
2741     if test -f $dir/gcc; then
2742       found=yes
2743       break
2744     fi
2745   done
2746   IFS="$save_ifs"
2747   if test -z "${found}" && test -n "${tentative_cc}" ; then
2748     CC=$tentative_cc
2749   fi
2750 fi
2751
2752 if test "${build}" != "${host}" ; then
2753   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2754 else
2755   CC_FOR_BUILD="\$(CC)"
2756 fi
2757
2758 ac_ext=c
2759 ac_cpp='$CPP $CPPFLAGS'
2760 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2761 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2762 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2763 if test -n "$ac_tool_prefix"; then
2764   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2765 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2766 echo "$as_me:$LINENO: checking for $ac_word" >&5
2767 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2768 if test "${ac_cv_prog_CC+set}" = set; then
2769   echo $ECHO_N "(cached) $ECHO_C" >&6
2770 else
2771   if test -n "$CC"; then
2772   ac_cv_prog_CC="$CC" # Let the user override the test.
2773 else
2774 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2775 for as_dir in $PATH
2776 do
2777   IFS=$as_save_IFS
2778   test -z "$as_dir" && as_dir=.
2779   for ac_exec_ext in '' $ac_executable_extensions; do
2780   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2781     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2782     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2783     break 2
2784   fi
2785 done
2786 done
2787
2788 fi
2789 fi
2790 CC=$ac_cv_prog_CC
2791 if test -n "$CC"; then
2792   echo "$as_me:$LINENO: result: $CC" >&5
2793 echo "${ECHO_T}$CC" >&6
2794 else
2795   echo "$as_me:$LINENO: result: no" >&5
2796 echo "${ECHO_T}no" >&6
2797 fi
2798
2799 fi
2800 if test -z "$ac_cv_prog_CC"; then
2801   ac_ct_CC=$CC
2802   # Extract the first word of "gcc", so it can be a program name with args.
2803 set dummy gcc; ac_word=$2
2804 echo "$as_me:$LINENO: checking for $ac_word" >&5
2805 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2806 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2807   echo $ECHO_N "(cached) $ECHO_C" >&6
2808 else
2809   if test -n "$ac_ct_CC"; then
2810   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2811 else
2812 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2813 for as_dir in $PATH
2814 do
2815   IFS=$as_save_IFS
2816   test -z "$as_dir" && as_dir=.
2817   for ac_exec_ext in '' $ac_executable_extensions; do
2818   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2819     ac_cv_prog_ac_ct_CC="gcc"
2820     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2821     break 2
2822   fi
2823 done
2824 done
2825
2826 fi
2827 fi
2828 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2829 if test -n "$ac_ct_CC"; then
2830   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2831 echo "${ECHO_T}$ac_ct_CC" >&6
2832 else
2833   echo "$as_me:$LINENO: result: no" >&5
2834 echo "${ECHO_T}no" >&6
2835 fi
2836
2837   CC=$ac_ct_CC
2838 else
2839   CC="$ac_cv_prog_CC"
2840 fi
2841
2842 if test -z "$CC"; then
2843   if test -n "$ac_tool_prefix"; then
2844   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2845 set dummy ${ac_tool_prefix}cc; ac_word=$2
2846 echo "$as_me:$LINENO: checking for $ac_word" >&5
2847 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2848 if test "${ac_cv_prog_CC+set}" = set; then
2849   echo $ECHO_N "(cached) $ECHO_C" >&6
2850 else
2851   if test -n "$CC"; then
2852   ac_cv_prog_CC="$CC" # Let the user override the test.
2853 else
2854 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2855 for as_dir in $PATH
2856 do
2857   IFS=$as_save_IFS
2858   test -z "$as_dir" && as_dir=.
2859   for ac_exec_ext in '' $ac_executable_extensions; do
2860   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2861     ac_cv_prog_CC="${ac_tool_prefix}cc"
2862     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2863     break 2
2864   fi
2865 done
2866 done
2867
2868 fi
2869 fi
2870 CC=$ac_cv_prog_CC
2871 if test -n "$CC"; then
2872   echo "$as_me:$LINENO: result: $CC" >&5
2873 echo "${ECHO_T}$CC" >&6
2874 else
2875   echo "$as_me:$LINENO: result: no" >&5
2876 echo "${ECHO_T}no" >&6
2877 fi
2878
2879 fi
2880 if test -z "$ac_cv_prog_CC"; then
2881   ac_ct_CC=$CC
2882   # Extract the first word of "cc", so it can be a program name with args.
2883 set dummy cc; ac_word=$2
2884 echo "$as_me:$LINENO: checking for $ac_word" >&5
2885 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2886 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2887   echo $ECHO_N "(cached) $ECHO_C" >&6
2888 else
2889   if test -n "$ac_ct_CC"; then
2890   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2891 else
2892 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2893 for as_dir in $PATH
2894 do
2895   IFS=$as_save_IFS
2896   test -z "$as_dir" && as_dir=.
2897   for ac_exec_ext in '' $ac_executable_extensions; do
2898   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2899     ac_cv_prog_ac_ct_CC="cc"
2900     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2901     break 2
2902   fi
2903 done
2904 done
2905
2906 fi
2907 fi
2908 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2909 if test -n "$ac_ct_CC"; then
2910   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2911 echo "${ECHO_T}$ac_ct_CC" >&6
2912 else
2913   echo "$as_me:$LINENO: result: no" >&5
2914 echo "${ECHO_T}no" >&6
2915 fi
2916
2917   CC=$ac_ct_CC
2918 else
2919   CC="$ac_cv_prog_CC"
2920 fi
2921
2922 fi
2923 if test -z "$CC"; then
2924   # Extract the first word of "cc", so it can be a program name with args.
2925 set dummy cc; ac_word=$2
2926 echo "$as_me:$LINENO: checking for $ac_word" >&5
2927 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2928 if test "${ac_cv_prog_CC+set}" = set; then
2929   echo $ECHO_N "(cached) $ECHO_C" >&6
2930 else
2931   if test -n "$CC"; then
2932   ac_cv_prog_CC="$CC" # Let the user override the test.
2933 else
2934   ac_prog_rejected=no
2935 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2936 for as_dir in $PATH
2937 do
2938   IFS=$as_save_IFS
2939   test -z "$as_dir" && as_dir=.
2940   for ac_exec_ext in '' $ac_executable_extensions; do
2941   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2942     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2943        ac_prog_rejected=yes
2944        continue
2945      fi
2946     ac_cv_prog_CC="cc"
2947     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2948     break 2
2949   fi
2950 done
2951 done
2952
2953 if test $ac_prog_rejected = yes; then
2954   # We found a bogon in the path, so make sure we never use it.
2955   set dummy $ac_cv_prog_CC
2956   shift
2957   if test $# != 0; then
2958     # We chose a different compiler from the bogus one.
2959     # However, it has the same basename, so the bogon will be chosen
2960     # first if we set CC to just the basename; use the full file name.
2961     shift
2962     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
2963   fi
2964 fi
2965 fi
2966 fi
2967 CC=$ac_cv_prog_CC
2968 if test -n "$CC"; then
2969   echo "$as_me:$LINENO: result: $CC" >&5
2970 echo "${ECHO_T}$CC" >&6
2971 else
2972   echo "$as_me:$LINENO: result: no" >&5
2973 echo "${ECHO_T}no" >&6
2974 fi
2975
2976 fi
2977 if test -z "$CC"; then
2978   if test -n "$ac_tool_prefix"; then
2979   for ac_prog in cl
2980   do
2981     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2982 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2983 echo "$as_me:$LINENO: checking for $ac_word" >&5
2984 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2985 if test "${ac_cv_prog_CC+set}" = set; then
2986   echo $ECHO_N "(cached) $ECHO_C" >&6
2987 else
2988   if test -n "$CC"; then
2989   ac_cv_prog_CC="$CC" # Let the user override the test.
2990 else
2991 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2992 for as_dir in $PATH
2993 do
2994   IFS=$as_save_IFS
2995   test -z "$as_dir" && as_dir=.
2996   for ac_exec_ext in '' $ac_executable_extensions; do
2997   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2998     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2999     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3000     break 2
3001   fi
3002 done
3003 done
3004
3005 fi
3006 fi
3007 CC=$ac_cv_prog_CC
3008 if test -n "$CC"; then
3009   echo "$as_me:$LINENO: result: $CC" >&5
3010 echo "${ECHO_T}$CC" >&6
3011 else
3012   echo "$as_me:$LINENO: result: no" >&5
3013 echo "${ECHO_T}no" >&6
3014 fi
3015
3016     test -n "$CC" && break
3017   done
3018 fi
3019 if test -z "$CC"; then
3020   ac_ct_CC=$CC
3021   for ac_prog in cl
3022 do
3023   # Extract the first word of "$ac_prog", so it can be a program name with args.
3024 set dummy $ac_prog; ac_word=$2
3025 echo "$as_me:$LINENO: checking for $ac_word" >&5
3026 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3027 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3028   echo $ECHO_N "(cached) $ECHO_C" >&6
3029 else
3030   if test -n "$ac_ct_CC"; then
3031   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3032 else
3033 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3034 for as_dir in $PATH
3035 do
3036   IFS=$as_save_IFS
3037   test -z "$as_dir" && as_dir=.
3038   for ac_exec_ext in '' $ac_executable_extensions; do
3039   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3040     ac_cv_prog_ac_ct_CC="$ac_prog"
3041     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3042     break 2
3043   fi
3044 done
3045 done
3046
3047 fi
3048 fi
3049 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3050 if test -n "$ac_ct_CC"; then
3051   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3052 echo "${ECHO_T}$ac_ct_CC" >&6
3053 else
3054   echo "$as_me:$LINENO: result: no" >&5
3055 echo "${ECHO_T}no" >&6
3056 fi
3057
3058   test -n "$ac_ct_CC" && break
3059 done
3060
3061   CC=$ac_ct_CC
3062 fi
3063
3064 fi
3065
3066
3067 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3068 See \`config.log' for more details." >&5
3069 echo "$as_me: error: no acceptable C compiler found in \$PATH
3070 See \`config.log' for more details." >&2;}
3071    { (exit 1); exit 1; }; }
3072
3073 # Provide some information about the compiler.
3074 echo "$as_me:$LINENO:" \
3075      "checking for C compiler version" >&5
3076 ac_compiler=`set X $ac_compile; echo $2`
3077 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3078   (eval $ac_compiler --version </dev/null >&5) 2>&5
3079   ac_status=$?
3080   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3081   (exit $ac_status); }
3082 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3083   (eval $ac_compiler -v </dev/null >&5) 2>&5
3084   ac_status=$?
3085   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3086   (exit $ac_status); }
3087 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3088   (eval $ac_compiler -V </dev/null >&5) 2>&5
3089   ac_status=$?
3090   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3091   (exit $ac_status); }
3092
3093 cat >conftest.$ac_ext <<_ACEOF
3094 /* confdefs.h.  */
3095 _ACEOF
3096 cat confdefs.h >>conftest.$ac_ext
3097 cat >>conftest.$ac_ext <<_ACEOF
3098 /* end confdefs.h.  */
3099
3100 int
3101 main ()
3102 {
3103
3104   ;
3105   return 0;
3106 }
3107 _ACEOF
3108 ac_clean_files_save=$ac_clean_files
3109 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3110 # Try to create an executable without -o first, disregard a.out.
3111 # It will help us diagnose broken compilers, and finding out an intuition
3112 # of exeext.
3113 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3114 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3115 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3116 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3117   (eval $ac_link_default) 2>&5
3118   ac_status=$?
3119   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3120   (exit $ac_status); }; then
3121   # Find the output, starting from the most likely.  This scheme is
3122 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3123 # resort.
3124
3125 # Be careful to initialize this variable, since it used to be cached.
3126 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3127 ac_cv_exeext=
3128 # b.out is created by i960 compilers.
3129 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3130 do
3131   test -f "$ac_file" || continue
3132   case $ac_file in
3133     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3134         ;;
3135     conftest.$ac_ext )
3136         # This is the source file.
3137         ;;
3138     [ab].out )
3139         # We found the default executable, but exeext='' is most
3140         # certainly right.
3141         break;;
3142     *.* )
3143         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3144         # FIXME: I believe we export ac_cv_exeext for Libtool,
3145         # but it would be cool to find out if it's true.  Does anybody
3146         # maintain Libtool? --akim.
3147         export ac_cv_exeext
3148         break;;
3149     * )
3150         break;;
3151   esac
3152 done
3153 else
3154   echo "$as_me: failed program was:" >&5
3155 sed 's/^/| /' conftest.$ac_ext >&5
3156
3157 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3158 See \`config.log' for more details." >&5
3159 echo "$as_me: error: C compiler cannot create executables
3160 See \`config.log' for more details." >&2;}
3161    { (exit 77); exit 77; }; }
3162 fi
3163
3164 ac_exeext=$ac_cv_exeext
3165 echo "$as_me:$LINENO: result: $ac_file" >&5
3166 echo "${ECHO_T}$ac_file" >&6
3167
3168 # Check the compiler produces executables we can run.  If not, either
3169 # the compiler is broken, or we cross compile.
3170 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3171 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3172 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3173 # If not cross compiling, check that we can run a simple program.
3174 if test "$cross_compiling" != yes; then
3175   if { ac_try='./$ac_file'
3176   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3177   (eval $ac_try) 2>&5
3178   ac_status=$?
3179   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3180   (exit $ac_status); }; }; then
3181     cross_compiling=no
3182   else
3183     if test "$cross_compiling" = maybe; then
3184         cross_compiling=yes
3185     else
3186         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3187 If you meant to cross compile, use \`--host'.
3188 See \`config.log' for more details." >&5
3189 echo "$as_me: error: cannot run C compiled programs.
3190 If you meant to cross compile, use \`--host'.
3191 See \`config.log' for more details." >&2;}
3192    { (exit 1); exit 1; }; }
3193     fi
3194   fi
3195 fi
3196 echo "$as_me:$LINENO: result: yes" >&5
3197 echo "${ECHO_T}yes" >&6
3198
3199 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3200 ac_clean_files=$ac_clean_files_save
3201 # Check the compiler produces executables we can run.  If not, either
3202 # the compiler is broken, or we cross compile.
3203 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3204 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3205 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3206 echo "${ECHO_T}$cross_compiling" >&6
3207
3208 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3209 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3210 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3211   (eval $ac_link) 2>&5
3212   ac_status=$?
3213   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3214   (exit $ac_status); }; then
3215   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3216 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3217 # work properly (i.e., refer to `conftest.exe'), while it won't with
3218 # `rm'.
3219 for ac_file in conftest.exe conftest conftest.*; do
3220   test -f "$ac_file" || continue
3221   case $ac_file in
3222     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3223     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3224           export ac_cv_exeext
3225           break;;
3226     * ) break;;
3227   esac
3228 done
3229 else
3230   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3231 See \`config.log' for more details." >&5
3232 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3233 See \`config.log' for more details." >&2;}
3234    { (exit 1); exit 1; }; }
3235 fi
3236
3237 rm -f conftest$ac_cv_exeext
3238 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3239 echo "${ECHO_T}$ac_cv_exeext" >&6
3240
3241 rm -f conftest.$ac_ext
3242 EXEEXT=$ac_cv_exeext
3243 ac_exeext=$EXEEXT
3244 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3245 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3246 if test "${ac_cv_objext+set}" = set; then
3247   echo $ECHO_N "(cached) $ECHO_C" >&6
3248 else
3249   cat >conftest.$ac_ext <<_ACEOF
3250 /* confdefs.h.  */
3251 _ACEOF
3252 cat confdefs.h >>conftest.$ac_ext
3253 cat >>conftest.$ac_ext <<_ACEOF
3254 /* end confdefs.h.  */
3255
3256 int
3257 main ()
3258 {
3259
3260   ;
3261   return 0;
3262 }
3263 _ACEOF
3264 rm -f conftest.o conftest.obj
3265 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3266   (eval $ac_compile) 2>&5
3267   ac_status=$?
3268   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3269   (exit $ac_status); }; then
3270   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3271   case $ac_file in
3272     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3273     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3274        break;;
3275   esac
3276 done
3277 else
3278   echo "$as_me: failed program was:" >&5
3279 sed 's/^/| /' conftest.$ac_ext >&5
3280
3281 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3282 See \`config.log' for more details." >&5
3283 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3284 See \`config.log' for more details." >&2;}
3285    { (exit 1); exit 1; }; }
3286 fi
3287
3288 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3289 fi
3290 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3291 echo "${ECHO_T}$ac_cv_objext" >&6
3292 OBJEXT=$ac_cv_objext
3293 ac_objext=$OBJEXT
3294 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3295 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3296 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3297   echo $ECHO_N "(cached) $ECHO_C" >&6
3298 else
3299   cat >conftest.$ac_ext <<_ACEOF
3300 /* confdefs.h.  */
3301 _ACEOF
3302 cat confdefs.h >>conftest.$ac_ext
3303 cat >>conftest.$ac_ext <<_ACEOF
3304 /* end confdefs.h.  */
3305
3306 int
3307 main ()
3308 {
3309 #ifndef __GNUC__
3310        choke me
3311 #endif
3312
3313   ;
3314   return 0;
3315 }
3316 _ACEOF
3317 rm -f conftest.$ac_objext
3318 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3319   (eval $ac_compile) 2>conftest.er1
3320   ac_status=$?
3321   grep -v '^ *+' conftest.er1 >conftest.err
3322   rm -f conftest.er1
3323   cat conftest.err >&5
3324   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3325   (exit $ac_status); } &&
3326          { ac_try='test -z "$ac_c_werror_flag"
3327                          || test ! -s conftest.err'
3328   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3329   (eval $ac_try) 2>&5
3330   ac_status=$?
3331   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3332   (exit $ac_status); }; } &&
3333          { ac_try='test -s conftest.$ac_objext'
3334   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3335   (eval $ac_try) 2>&5
3336   ac_status=$?
3337   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3338   (exit $ac_status); }; }; then
3339   ac_compiler_gnu=yes
3340 else
3341   echo "$as_me: failed program was:" >&5
3342 sed 's/^/| /' conftest.$ac_ext >&5
3343
3344 ac_compiler_gnu=no
3345 fi
3346 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3347 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3348
3349 fi
3350 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3351 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3352 GCC=`test $ac_compiler_gnu = yes && echo yes`
3353 ac_test_CFLAGS=${CFLAGS+set}
3354 ac_save_CFLAGS=$CFLAGS
3355 CFLAGS="-g"
3356 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3357 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3358 if test "${ac_cv_prog_cc_g+set}" = set; then
3359   echo $ECHO_N "(cached) $ECHO_C" >&6
3360 else
3361   cat >conftest.$ac_ext <<_ACEOF
3362 /* confdefs.h.  */
3363 _ACEOF
3364 cat confdefs.h >>conftest.$ac_ext
3365 cat >>conftest.$ac_ext <<_ACEOF
3366 /* end confdefs.h.  */
3367
3368 int
3369 main ()
3370 {
3371
3372   ;
3373   return 0;
3374 }
3375 _ACEOF
3376 rm -f conftest.$ac_objext
3377 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3378   (eval $ac_compile) 2>conftest.er1
3379   ac_status=$?
3380   grep -v '^ *+' conftest.er1 >conftest.err
3381   rm -f conftest.er1
3382   cat conftest.err >&5
3383   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3384   (exit $ac_status); } &&
3385          { ac_try='test -z "$ac_c_werror_flag"
3386                          || test ! -s conftest.err'
3387   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3388   (eval $ac_try) 2>&5
3389   ac_status=$?
3390   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3391   (exit $ac_status); }; } &&
3392          { ac_try='test -s conftest.$ac_objext'
3393   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3394   (eval $ac_try) 2>&5
3395   ac_status=$?
3396   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3397   (exit $ac_status); }; }; then
3398   ac_cv_prog_cc_g=yes
3399 else
3400   echo "$as_me: failed program was:" >&5
3401 sed 's/^/| /' conftest.$ac_ext >&5
3402
3403 ac_cv_prog_cc_g=no
3404 fi
3405 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3406 fi
3407 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3408 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3409 if test "$ac_test_CFLAGS" = set; then
3410   CFLAGS=$ac_save_CFLAGS
3411 elif test $ac_cv_prog_cc_g = yes; then
3412   if test "$GCC" = yes; then
3413     CFLAGS="-g -O2"
3414   else
3415     CFLAGS="-g"
3416   fi
3417 else
3418   if test "$GCC" = yes; then
3419     CFLAGS="-O2"
3420   else
3421     CFLAGS=
3422   fi
3423 fi
3424 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3425 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3426 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3427   echo $ECHO_N "(cached) $ECHO_C" >&6
3428 else
3429   ac_cv_prog_cc_stdc=no
3430 ac_save_CC=$CC
3431 cat >conftest.$ac_ext <<_ACEOF
3432 /* confdefs.h.  */
3433 _ACEOF
3434 cat confdefs.h >>conftest.$ac_ext
3435 cat >>conftest.$ac_ext <<_ACEOF
3436 /* end confdefs.h.  */
3437 #include <stdarg.h>
3438 #include <stdio.h>
3439 #include <sys/types.h>
3440 #include <sys/stat.h>
3441 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3442 struct buf { int x; };
3443 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3444 static char *e (p, i)
3445      char **p;
3446      int i;
3447 {
3448   return p[i];
3449 }
3450 static char *f (char * (*g) (char **, int), char **p, ...)
3451 {
3452   char *s;
3453   va_list v;
3454   va_start (v,p);
3455   s = g (p, va_arg (v,int));
3456   va_end (v);
3457   return s;
3458 }
3459
3460 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3461    function prototypes and stuff, but not '\xHH' hex character constants.
3462    These don't provoke an error unfortunately, instead are silently treated
3463    as 'x'.  The following induces an error, until -std1 is added to get
3464    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3465    array size at least.  It's necessary to write '\x00'==0 to get something
3466    that's true only with -std1.  */
3467 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3468
3469 int test (int i, double x);
3470 struct s1 {int (*f) (int a);};
3471 struct s2 {int (*f) (double a);};
3472 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3473 int argc;
3474 char **argv;
3475 int
3476 main ()
3477 {
3478 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3479   ;
3480   return 0;
3481 }
3482 _ACEOF
3483 # Don't try gcc -ansi; that turns off useful extensions and
3484 # breaks some systems' header files.
3485 # AIX                   -qlanglvl=ansi
3486 # Ultrix and OSF/1      -std1
3487 # HP-UX 10.20 and later -Ae
3488 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3489 # SVR4                  -Xc -D__EXTENSIONS__
3490 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3491 do
3492   CC="$ac_save_CC $ac_arg"
3493   rm -f conftest.$ac_objext
3494 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3495   (eval $ac_compile) 2>conftest.er1
3496   ac_status=$?
3497   grep -v '^ *+' conftest.er1 >conftest.err
3498   rm -f conftest.er1
3499   cat conftest.err >&5
3500   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3501   (exit $ac_status); } &&
3502          { ac_try='test -z "$ac_c_werror_flag"
3503                          || test ! -s conftest.err'
3504   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3505   (eval $ac_try) 2>&5
3506   ac_status=$?
3507   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3508   (exit $ac_status); }; } &&
3509          { ac_try='test -s conftest.$ac_objext'
3510   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3511   (eval $ac_try) 2>&5
3512   ac_status=$?
3513   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3514   (exit $ac_status); }; }; then
3515   ac_cv_prog_cc_stdc=$ac_arg
3516 break
3517 else
3518   echo "$as_me: failed program was:" >&5
3519 sed 's/^/| /' conftest.$ac_ext >&5
3520
3521 fi
3522 rm -f conftest.err conftest.$ac_objext
3523 done
3524 rm -f conftest.$ac_ext conftest.$ac_objext
3525 CC=$ac_save_CC
3526
3527 fi
3528
3529 case "x$ac_cv_prog_cc_stdc" in
3530   x|xno)
3531     echo "$as_me:$LINENO: result: none needed" >&5
3532 echo "${ECHO_T}none needed" >&6 ;;
3533   *)
3534     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3535 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3536     CC="$CC $ac_cv_prog_cc_stdc" ;;
3537 esac
3538
3539 # Some people use a C++ compiler to compile C.  Since we use `exit',
3540 # in C++ we need to declare it.  In case someone uses the same compiler
3541 # for both compiling C and C++ we need to have the C++ compiler decide
3542 # the declaration of exit, since it's the most demanding environment.
3543 cat >conftest.$ac_ext <<_ACEOF
3544 #ifndef __cplusplus
3545   choke me
3546 #endif
3547 _ACEOF
3548 rm -f conftest.$ac_objext
3549 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3550   (eval $ac_compile) 2>conftest.er1
3551   ac_status=$?
3552   grep -v '^ *+' conftest.er1 >conftest.err
3553   rm -f conftest.er1
3554   cat conftest.err >&5
3555   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3556   (exit $ac_status); } &&
3557          { ac_try='test -z "$ac_c_werror_flag"
3558                          || test ! -s conftest.err'
3559   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3560   (eval $ac_try) 2>&5
3561   ac_status=$?
3562   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3563   (exit $ac_status); }; } &&
3564          { ac_try='test -s conftest.$ac_objext'
3565   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3566   (eval $ac_try) 2>&5
3567   ac_status=$?
3568   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3569   (exit $ac_status); }; }; then
3570   for ac_declaration in \
3571    '' \
3572    'extern "C" void std::exit (int) throw (); using std::exit;' \
3573    'extern "C" void std::exit (int); using std::exit;' \
3574    'extern "C" void exit (int) throw ();' \
3575    'extern "C" void exit (int);' \
3576    'void exit (int);'
3577 do
3578   cat >conftest.$ac_ext <<_ACEOF
3579 /* confdefs.h.  */
3580 _ACEOF
3581 cat confdefs.h >>conftest.$ac_ext
3582 cat >>conftest.$ac_ext <<_ACEOF
3583 /* end confdefs.h.  */
3584 $ac_declaration
3585 #include <stdlib.h>
3586 int
3587 main ()
3588 {
3589 exit (42);
3590   ;
3591   return 0;
3592 }
3593 _ACEOF
3594 rm -f conftest.$ac_objext
3595 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3596   (eval $ac_compile) 2>conftest.er1
3597   ac_status=$?
3598   grep -v '^ *+' conftest.er1 >conftest.err
3599   rm -f conftest.er1
3600   cat conftest.err >&5
3601   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3602   (exit $ac_status); } &&
3603          { ac_try='test -z "$ac_c_werror_flag"
3604                          || test ! -s conftest.err'
3605   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3606   (eval $ac_try) 2>&5
3607   ac_status=$?
3608   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3609   (exit $ac_status); }; } &&
3610          { ac_try='test -s conftest.$ac_objext'
3611   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3612   (eval $ac_try) 2>&5
3613   ac_status=$?
3614   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3615   (exit $ac_status); }; }; then
3616   :
3617 else
3618   echo "$as_me: failed program was:" >&5
3619 sed 's/^/| /' conftest.$ac_ext >&5
3620
3621 continue
3622 fi
3623 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3624   cat >conftest.$ac_ext <<_ACEOF
3625 /* confdefs.h.  */
3626 _ACEOF
3627 cat confdefs.h >>conftest.$ac_ext
3628 cat >>conftest.$ac_ext <<_ACEOF
3629 /* end confdefs.h.  */
3630 $ac_declaration
3631 int
3632 main ()
3633 {
3634 exit (42);
3635   ;
3636   return 0;
3637 }
3638 _ACEOF
3639 rm -f conftest.$ac_objext
3640 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3641   (eval $ac_compile) 2>conftest.er1
3642   ac_status=$?
3643   grep -v '^ *+' conftest.er1 >conftest.err
3644   rm -f conftest.er1
3645   cat conftest.err >&5
3646   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3647   (exit $ac_status); } &&
3648          { ac_try='test -z "$ac_c_werror_flag"
3649                          || test ! -s conftest.err'
3650   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3651   (eval $ac_try) 2>&5
3652   ac_status=$?
3653   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3654   (exit $ac_status); }; } &&
3655          { ac_try='test -s conftest.$ac_objext'
3656   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3657   (eval $ac_try) 2>&5
3658   ac_status=$?
3659   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3660   (exit $ac_status); }; }; then
3661   break
3662 else
3663   echo "$as_me: failed program was:" >&5
3664 sed 's/^/| /' conftest.$ac_ext >&5
3665
3666 fi
3667 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3668 done
3669 rm -f conftest*
3670 if test -n "$ac_declaration"; then
3671   echo '#ifdef __cplusplus' >>confdefs.h
3672   echo $ac_declaration      >>confdefs.h
3673   echo '#endif'             >>confdefs.h
3674 fi
3675
3676 else
3677   echo "$as_me: failed program was:" >&5
3678 sed 's/^/| /' conftest.$ac_ext >&5
3679
3680 fi
3681 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3682 ac_ext=c
3683 ac_cpp='$CPP $CPPFLAGS'
3684 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3685 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3686 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3687
3688 ac_ext=cc
3689 ac_cpp='$CXXCPP $CPPFLAGS'
3690 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3691 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3692 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3693 if test -n "$ac_tool_prefix"; then
3694   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3695   do
3696     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3697 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3698 echo "$as_me:$LINENO: checking for $ac_word" >&5
3699 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3700 if test "${ac_cv_prog_CXX+set}" = set; then
3701   echo $ECHO_N "(cached) $ECHO_C" >&6
3702 else
3703   if test -n "$CXX"; then
3704   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3705 else
3706 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3707 for as_dir in $PATH
3708 do
3709   IFS=$as_save_IFS
3710   test -z "$as_dir" && as_dir=.
3711   for ac_exec_ext in '' $ac_executable_extensions; do
3712   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3713     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3714     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3715     break 2
3716   fi
3717 done
3718 done
3719
3720 fi
3721 fi
3722 CXX=$ac_cv_prog_CXX
3723 if test -n "$CXX"; then
3724   echo "$as_me:$LINENO: result: $CXX" >&5
3725 echo "${ECHO_T}$CXX" >&6
3726 else
3727   echo "$as_me:$LINENO: result: no" >&5
3728 echo "${ECHO_T}no" >&6
3729 fi
3730
3731     test -n "$CXX" && break
3732   done
3733 fi
3734 if test -z "$CXX"; then
3735   ac_ct_CXX=$CXX
3736   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3737 do
3738   # Extract the first word of "$ac_prog", so it can be a program name with args.
3739 set dummy $ac_prog; ac_word=$2
3740 echo "$as_me:$LINENO: checking for $ac_word" >&5
3741 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3742 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3743   echo $ECHO_N "(cached) $ECHO_C" >&6
3744 else
3745   if test -n "$ac_ct_CXX"; then
3746   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3747 else
3748 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3749 for as_dir in $PATH
3750 do
3751   IFS=$as_save_IFS
3752   test -z "$as_dir" && as_dir=.
3753   for ac_exec_ext in '' $ac_executable_extensions; do
3754   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3755     ac_cv_prog_ac_ct_CXX="$ac_prog"
3756     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3757     break 2
3758   fi
3759 done
3760 done
3761
3762 fi
3763 fi
3764 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3765 if test -n "$ac_ct_CXX"; then
3766   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3767 echo "${ECHO_T}$ac_ct_CXX" >&6
3768 else
3769   echo "$as_me:$LINENO: result: no" >&5
3770 echo "${ECHO_T}no" >&6
3771 fi
3772
3773   test -n "$ac_ct_CXX" && break
3774 done
3775 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3776
3777   CXX=$ac_ct_CXX
3778 fi
3779
3780
3781 # Provide some information about the compiler.
3782 echo "$as_me:$LINENO:" \
3783      "checking for C++ compiler version" >&5
3784 ac_compiler=`set X $ac_compile; echo $2`
3785 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3786   (eval $ac_compiler --version </dev/null >&5) 2>&5
3787   ac_status=$?
3788   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3789   (exit $ac_status); }
3790 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3791   (eval $ac_compiler -v </dev/null >&5) 2>&5
3792   ac_status=$?
3793   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3794   (exit $ac_status); }
3795 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3796   (eval $ac_compiler -V </dev/null >&5) 2>&5
3797   ac_status=$?
3798   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3799   (exit $ac_status); }
3800
3801 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3802 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3803 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3804   echo $ECHO_N "(cached) $ECHO_C" >&6
3805 else
3806   cat >conftest.$ac_ext <<_ACEOF
3807 /* confdefs.h.  */
3808 _ACEOF
3809 cat confdefs.h >>conftest.$ac_ext
3810 cat >>conftest.$ac_ext <<_ACEOF
3811 /* end confdefs.h.  */
3812
3813 int
3814 main ()
3815 {
3816 #ifndef __GNUC__
3817        choke me
3818 #endif
3819
3820   ;
3821   return 0;
3822 }
3823 _ACEOF
3824 rm -f conftest.$ac_objext
3825 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3826   (eval $ac_compile) 2>conftest.er1
3827   ac_status=$?
3828   grep -v '^ *+' conftest.er1 >conftest.err
3829   rm -f conftest.er1
3830   cat conftest.err >&5
3831   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3832   (exit $ac_status); } &&
3833          { ac_try='test -z "$ac_cxx_werror_flag"
3834                          || test ! -s conftest.err'
3835   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3836   (eval $ac_try) 2>&5
3837   ac_status=$?
3838   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3839   (exit $ac_status); }; } &&
3840          { ac_try='test -s conftest.$ac_objext'
3841   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3842   (eval $ac_try) 2>&5
3843   ac_status=$?
3844   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3845   (exit $ac_status); }; }; then
3846   ac_compiler_gnu=yes
3847 else
3848   echo "$as_me: failed program was:" >&5
3849 sed 's/^/| /' conftest.$ac_ext >&5
3850
3851 ac_compiler_gnu=no
3852 fi
3853 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3854 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3855
3856 fi
3857 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3858 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3859 GXX=`test $ac_compiler_gnu = yes && echo yes`
3860 ac_test_CXXFLAGS=${CXXFLAGS+set}
3861 ac_save_CXXFLAGS=$CXXFLAGS
3862 CXXFLAGS="-g"
3863 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3864 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3865 if test "${ac_cv_prog_cxx_g+set}" = set; then
3866   echo $ECHO_N "(cached) $ECHO_C" >&6
3867 else
3868   cat >conftest.$ac_ext <<_ACEOF
3869 /* confdefs.h.  */
3870 _ACEOF
3871 cat confdefs.h >>conftest.$ac_ext
3872 cat >>conftest.$ac_ext <<_ACEOF
3873 /* end confdefs.h.  */
3874
3875 int
3876 main ()
3877 {
3878
3879   ;
3880   return 0;
3881 }
3882 _ACEOF
3883 rm -f conftest.$ac_objext
3884 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3885   (eval $ac_compile) 2>conftest.er1
3886   ac_status=$?
3887   grep -v '^ *+' conftest.er1 >conftest.err
3888   rm -f conftest.er1
3889   cat conftest.err >&5
3890   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3891   (exit $ac_status); } &&
3892          { ac_try='test -z "$ac_cxx_werror_flag"
3893                          || test ! -s conftest.err'
3894   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3895   (eval $ac_try) 2>&5
3896   ac_status=$?
3897   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3898   (exit $ac_status); }; } &&
3899          { ac_try='test -s conftest.$ac_objext'
3900   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3901   (eval $ac_try) 2>&5
3902   ac_status=$?
3903   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3904   (exit $ac_status); }; }; then
3905   ac_cv_prog_cxx_g=yes
3906 else
3907   echo "$as_me: failed program was:" >&5
3908 sed 's/^/| /' conftest.$ac_ext >&5
3909
3910 ac_cv_prog_cxx_g=no
3911 fi
3912 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3913 fi
3914 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3915 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
3916 if test "$ac_test_CXXFLAGS" = set; then
3917   CXXFLAGS=$ac_save_CXXFLAGS
3918 elif test $ac_cv_prog_cxx_g = yes; then
3919   if test "$GXX" = yes; then
3920     CXXFLAGS="-g -O2"
3921   else
3922     CXXFLAGS="-g"
3923   fi
3924 else
3925   if test "$GXX" = yes; then
3926     CXXFLAGS="-O2"
3927   else
3928     CXXFLAGS=
3929   fi
3930 fi
3931 for ac_declaration in \
3932    '' \
3933    'extern "C" void std::exit (int) throw (); using std::exit;' \
3934    'extern "C" void std::exit (int); using std::exit;' \
3935    'extern "C" void exit (int) throw ();' \
3936    'extern "C" void exit (int);' \
3937    'void exit (int);'
3938 do
3939   cat >conftest.$ac_ext <<_ACEOF
3940 /* confdefs.h.  */
3941 _ACEOF
3942 cat confdefs.h >>conftest.$ac_ext
3943 cat >>conftest.$ac_ext <<_ACEOF
3944 /* end confdefs.h.  */
3945 $ac_declaration
3946 #include <stdlib.h>
3947 int
3948 main ()
3949 {
3950 exit (42);
3951   ;
3952   return 0;
3953 }
3954 _ACEOF
3955 rm -f conftest.$ac_objext
3956 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3957   (eval $ac_compile) 2>conftest.er1
3958   ac_status=$?
3959   grep -v '^ *+' conftest.er1 >conftest.err
3960   rm -f conftest.er1
3961   cat conftest.err >&5
3962   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3963   (exit $ac_status); } &&
3964          { ac_try='test -z "$ac_cxx_werror_flag"
3965                          || test ! -s conftest.err'
3966   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3967   (eval $ac_try) 2>&5
3968   ac_status=$?
3969   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3970   (exit $ac_status); }; } &&
3971          { ac_try='test -s conftest.$ac_objext'
3972   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3973   (eval $ac_try) 2>&5
3974   ac_status=$?
3975   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3976   (exit $ac_status); }; }; then
3977   :
3978 else
3979   echo "$as_me: failed program was:" >&5
3980 sed 's/^/| /' conftest.$ac_ext >&5
3981
3982 continue
3983 fi
3984 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3985   cat >conftest.$ac_ext <<_ACEOF
3986 /* confdefs.h.  */
3987 _ACEOF
3988 cat confdefs.h >>conftest.$ac_ext
3989 cat >>conftest.$ac_ext <<_ACEOF
3990 /* end confdefs.h.  */
3991 $ac_declaration
3992 int
3993 main ()
3994 {
3995 exit (42);
3996   ;
3997   return 0;
3998 }
3999 _ACEOF
4000 rm -f conftest.$ac_objext
4001 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4002   (eval $ac_compile) 2>conftest.er1
4003   ac_status=$?
4004   grep -v '^ *+' conftest.er1 >conftest.err
4005   rm -f conftest.er1
4006   cat conftest.err >&5
4007   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4008   (exit $ac_status); } &&
4009          { ac_try='test -z "$ac_cxx_werror_flag"
4010                          || test ! -s conftest.err'
4011   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4012   (eval $ac_try) 2>&5
4013   ac_status=$?
4014   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4015   (exit $ac_status); }; } &&
4016          { ac_try='test -s conftest.$ac_objext'
4017   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4018   (eval $ac_try) 2>&5
4019   ac_status=$?
4020   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4021   (exit $ac_status); }; }; then
4022   break
4023 else
4024   echo "$as_me: failed program was:" >&5
4025 sed 's/^/| /' conftest.$ac_ext >&5
4026
4027 fi
4028 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4029 done
4030 rm -f conftest*
4031 if test -n "$ac_declaration"; then
4032   echo '#ifdef __cplusplus' >>confdefs.h
4033   echo $ac_declaration      >>confdefs.h
4034   echo '#endif'             >>confdefs.h
4035 fi
4036
4037 ac_ext=c
4038 ac_cpp='$CPP $CPPFLAGS'
4039 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4040 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4041 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4042
4043
4044 # We must set the default linker to the linker used by gcc for the correct
4045 # operation of libtool.  If LD is not defined and we are using gcc, try to
4046 # set the LD default to the ld used by gcc.
4047 if test -z "$LD"; then
4048   if test "$GCC" = yes; then
4049     case $build in
4050     *-*-mingw*)
4051       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4052     *)
4053       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4054     esac
4055     case $gcc_prog_ld in
4056     # Accept absolute paths.
4057     [\\/]* | [A-Za-z]:[\\/]*)
4058       LD="$gcc_prog_ld" ;;
4059     esac
4060   fi
4061 fi
4062
4063
4064
4065
4066 if test -n "$ac_tool_prefix"; then
4067   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4068 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4069 echo "$as_me:$LINENO: checking for $ac_word" >&5
4070 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4071 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4072   echo $ECHO_N "(cached) $ECHO_C" >&6
4073 else
4074   if test -n "$GNATBIND"; then
4075   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4076 else
4077 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4078 for as_dir in $PATH
4079 do
4080   IFS=$as_save_IFS
4081   test -z "$as_dir" && as_dir=.
4082   for ac_exec_ext in '' $ac_executable_extensions; do
4083   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4084     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4085     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4086     break 2
4087   fi
4088 done
4089 done
4090
4091 fi
4092 fi
4093 GNATBIND=$ac_cv_prog_GNATBIND
4094 if test -n "$GNATBIND"; then
4095   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4096 echo "${ECHO_T}$GNATBIND" >&6
4097 else
4098   echo "$as_me:$LINENO: result: no" >&5
4099 echo "${ECHO_T}no" >&6
4100 fi
4101
4102 fi
4103 if test -z "$ac_cv_prog_GNATBIND"; then
4104   ac_ct_GNATBIND=$GNATBIND
4105   # Extract the first word of "gnatbind", so it can be a program name with args.
4106 set dummy gnatbind; ac_word=$2
4107 echo "$as_me:$LINENO: checking for $ac_word" >&5
4108 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4109 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4110   echo $ECHO_N "(cached) $ECHO_C" >&6
4111 else
4112   if test -n "$ac_ct_GNATBIND"; then
4113   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4114 else
4115 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4116 for as_dir in $PATH
4117 do
4118   IFS=$as_save_IFS
4119   test -z "$as_dir" && as_dir=.
4120   for ac_exec_ext in '' $ac_executable_extensions; do
4121   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4122     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4123     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4124     break 2
4125   fi
4126 done
4127 done
4128
4129   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4130 fi
4131 fi
4132 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4133 if test -n "$ac_ct_GNATBIND"; then
4134   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4135 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4136 else
4137   echo "$as_me:$LINENO: result: no" >&5
4138 echo "${ECHO_T}no" >&6
4139 fi
4140
4141   GNATBIND=$ac_ct_GNATBIND
4142 else
4143   GNATBIND="$ac_cv_prog_GNATBIND"
4144 fi
4145
4146 if test -n "$ac_tool_prefix"; then
4147   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4148 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4149 echo "$as_me:$LINENO: checking for $ac_word" >&5
4150 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4151 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4152   echo $ECHO_N "(cached) $ECHO_C" >&6
4153 else
4154   if test -n "$GNATMAKE"; then
4155   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4156 else
4157 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4158 for as_dir in $PATH
4159 do
4160   IFS=$as_save_IFS
4161   test -z "$as_dir" && as_dir=.
4162   for ac_exec_ext in '' $ac_executable_extensions; do
4163   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4164     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4165     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4166     break 2
4167   fi
4168 done
4169 done
4170
4171 fi
4172 fi
4173 GNATMAKE=$ac_cv_prog_GNATMAKE
4174 if test -n "$GNATMAKE"; then
4175   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4176 echo "${ECHO_T}$GNATMAKE" >&6
4177 else
4178   echo "$as_me:$LINENO: result: no" >&5
4179 echo "${ECHO_T}no" >&6
4180 fi
4181
4182 fi
4183 if test -z "$ac_cv_prog_GNATMAKE"; then
4184   ac_ct_GNATMAKE=$GNATMAKE
4185   # Extract the first word of "gnatmake", so it can be a program name with args.
4186 set dummy gnatmake; ac_word=$2
4187 echo "$as_me:$LINENO: checking for $ac_word" >&5
4188 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4189 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4190   echo $ECHO_N "(cached) $ECHO_C" >&6
4191 else
4192   if test -n "$ac_ct_GNATMAKE"; then
4193   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4194 else
4195 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4196 for as_dir in $PATH
4197 do
4198   IFS=$as_save_IFS
4199   test -z "$as_dir" && as_dir=.
4200   for ac_exec_ext in '' $ac_executable_extensions; do
4201   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4202     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4203     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4204     break 2
4205   fi
4206 done
4207 done
4208
4209   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4210 fi
4211 fi
4212 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4213 if test -n "$ac_ct_GNATMAKE"; then
4214   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4215 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4216 else
4217   echo "$as_me:$LINENO: result: no" >&5
4218 echo "${ECHO_T}no" >&6
4219 fi
4220
4221   GNATMAKE=$ac_ct_GNATMAKE
4222 else
4223   GNATMAKE="$ac_cv_prog_GNATMAKE"
4224 fi
4225
4226 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4227 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4228 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4229   echo $ECHO_N "(cached) $ECHO_C" >&6
4230 else
4231   cat >conftest.adb <<EOF
4232 procedure conftest is begin null; end conftest;
4233 EOF
4234 acx_cv_cc_gcc_supports_ada=no
4235 # There is a bug in old released versions of GCC which causes the
4236 # driver to exit successfully when the appropriate language module
4237 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4238 # Therefore we must check for the error message as well as an
4239 # unsuccessful exit.
4240 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4241 # given a .adb file, but produce no object file.  So we must check
4242 # if an object file was really produced to guard against this.
4243 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4244 if test x"$errors" = x && test -f conftest.$ac_objext; then
4245   acx_cv_cc_gcc_supports_ada=yes
4246 fi
4247 rm -f conftest.*
4248 fi
4249 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4250 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4251
4252 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4253   have_gnat=yes
4254 else
4255   have_gnat=no
4256 fi
4257
4258 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4259 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4260 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4261   echo $ECHO_N "(cached) $ECHO_C" >&6
4262 else
4263    echo abfoo >t1
4264   echo cdfoo >t2
4265   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4266   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4267     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4268       :
4269     else
4270       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4271     fi
4272   fi
4273   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4274     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4275       :
4276     else
4277       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4278     fi
4279   fi
4280   rm t1 t2
4281
4282 fi
4283 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4284 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4285 do_compare="$gcc_cv_prog_cmp_skip"
4286
4287
4288
4289 # Check for GMP and MPFR
4290 gmplibs="-lmpfr -lgmp"
4291 gmpinc=
4292 have_gmp=no
4293
4294 # Specify a location for mpfr
4295 # check for this first so it ends up on the link line before gmp.
4296
4297 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4298 if test "${with_mpfr_dir+set}" = set; then
4299   withval="$with_mpfr_dir"
4300   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4301 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4302 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4303 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4304    { (exit 1); exit 1; }; }
4305 fi;
4306
4307
4308 # Check whether --with-mpfr or --without-mpfr was given.
4309 if test "${with_mpfr+set}" = set; then
4310   withval="$with_mpfr"
4311
4312 fi;
4313
4314 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4315 if test "${with_mpfr_include+set}" = set; then
4316   withval="$with_mpfr_include"
4317
4318 fi;
4319
4320 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4321 if test "${with_mpfr_lib+set}" = set; then
4322   withval="$with_mpfr_lib"
4323
4324 fi;
4325
4326 if test "x$with_mpfr" != x; then
4327   gmplibs="-L$with_mpfr/lib $gmplibs"
4328   gmpinc="-I$with_mpfr/include"
4329 fi
4330 if test "x$with_mpfr_include" != x; then
4331   gmpinc="-I$with_mpfr_include"
4332 fi
4333 if test "x$with_mpfr_lib" != x; then
4334   gmplibs="-L$with_mpfr_lib $gmplibs"
4335 fi
4336 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4337   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4338   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4339   # Do not test the mpfr version.  Assume that it is sufficient, since
4340   # it is in the source tree, and the library has not been built yet
4341   # but it would be included on the link line in the version check below
4342   # hence making the test fail.
4343   have_gmp=yes
4344 fi
4345
4346 # Specify a location for gmp
4347
4348 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4349 if test "${with_gmp_dir+set}" = set; then
4350   withval="$with_gmp_dir"
4351   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4352 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4353 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4354 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4355    { (exit 1); exit 1; }; }
4356 fi;
4357
4358
4359 # Check whether --with-gmp or --without-gmp was given.
4360 if test "${with_gmp+set}" = set; then
4361   withval="$with_gmp"
4362
4363 fi;
4364
4365 # Check whether --with-gmp_include or --without-gmp_include was given.
4366 if test "${with_gmp_include+set}" = set; then
4367   withval="$with_gmp_include"
4368
4369 fi;
4370
4371 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4372 if test "${with_gmp_lib+set}" = set; then
4373   withval="$with_gmp_lib"
4374
4375 fi;
4376
4377
4378 if test "x$with_gmp" != x; then
4379   gmplibs="-L$with_gmp/lib $gmplibs"
4380   gmpinc="-I$with_gmp/include $gmpinc"
4381 fi
4382 if test "x$with_gmp_include" != x; then
4383   gmpinc="-I$with_gmp_include $gmpinc"
4384 fi
4385 if test "x$with_gmp_lib" != x; then
4386   gmplibs="-L$with_gmp_lib $gmplibs"
4387 fi
4388 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4389   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4390   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4391   # Do not test the gmp version.  Assume that it is sufficient, since
4392   # it is in the source tree, and the library has not been built yet
4393   # but it would be included on the link line in the version check below
4394   # hence making the test fail.
4395   have_gmp=yes
4396 fi
4397
4398 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4399   have_gmp=yes
4400   saved_CFLAGS="$CFLAGS"
4401   CFLAGS="$CFLAGS $gmpinc"
4402   # Check GMP actually works
4403   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4404 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4405
4406 cat >conftest.$ac_ext <<_ACEOF
4407 /* confdefs.h.  */
4408 _ACEOF
4409 cat confdefs.h >>conftest.$ac_ext
4410 cat >>conftest.$ac_ext <<_ACEOF
4411 /* end confdefs.h.  */
4412 #include "gmp.h"
4413 int
4414 main ()
4415 {
4416
4417   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4418   choke me
4419   #endif
4420
4421   ;
4422   return 0;
4423 }
4424 _ACEOF
4425 rm -f conftest.$ac_objext
4426 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4427   (eval $ac_compile) 2>conftest.er1
4428   ac_status=$?
4429   grep -v '^ *+' conftest.er1 >conftest.err
4430   rm -f conftest.er1
4431   cat conftest.err >&5
4432   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4433   (exit $ac_status); } &&
4434          { ac_try='test -z "$ac_c_werror_flag"
4435                          || test ! -s conftest.err'
4436   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4437   (eval $ac_try) 2>&5
4438   ac_status=$?
4439   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4440   (exit $ac_status); }; } &&
4441          { ac_try='test -s conftest.$ac_objext'
4442   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4443   (eval $ac_try) 2>&5
4444   ac_status=$?
4445   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4446   (exit $ac_status); }; }; then
4447   echo "$as_me:$LINENO: result: yes" >&5
4448 echo "${ECHO_T}yes" >&6
4449 else
4450   echo "$as_me: failed program was:" >&5
4451 sed 's/^/| /' conftest.$ac_ext >&5
4452
4453 echo "$as_me:$LINENO: result: no" >&5
4454 echo "${ECHO_T}no" >&6; have_gmp=no
4455 fi
4456 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4457
4458   if test x"$have_gmp" = xyes; then
4459     saved_LIBS="$LIBS"
4460     LIBS="$LIBS $gmplibs"
4461         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4462 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4463     cat >conftest.$ac_ext <<_ACEOF
4464 /* confdefs.h.  */
4465 _ACEOF
4466 cat confdefs.h >>conftest.$ac_ext
4467 cat >>conftest.$ac_ext <<_ACEOF
4468 /* end confdefs.h.  */
4469 #include <gmp.h>
4470     #include <mpfr.h>
4471 int
4472 main ()
4473 {
4474
4475     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,0)
4476     choke me
4477     #endif
4478     mpfr_t n; mpfr_init(n);
4479     mpfr_t x; mpfr_init(x);
4480     int t;
4481     mpfr_atan2 (n, n, x, GMP_RNDN);
4482     mpfr_erfc (n, x, GMP_RNDN);
4483     mpfr_subnormalize (x, t, GMP_RNDN);
4484
4485   ;
4486   return 0;
4487 }
4488 _ACEOF
4489 rm -f conftest.$ac_objext conftest$ac_exeext
4490 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4491   (eval $ac_link) 2>conftest.er1
4492   ac_status=$?
4493   grep -v '^ *+' conftest.er1 >conftest.err
4494   rm -f conftest.er1
4495   cat conftest.err >&5
4496   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4497   (exit $ac_status); } &&
4498          { ac_try='test -z "$ac_c_werror_flag"
4499                          || test ! -s conftest.err'
4500   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4501   (eval $ac_try) 2>&5
4502   ac_status=$?
4503   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4504   (exit $ac_status); }; } &&
4505          { ac_try='test -s conftest$ac_exeext'
4506   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4507   (eval $ac_try) 2>&5
4508   ac_status=$?
4509   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4510   (exit $ac_status); }; }; then
4511   cat >conftest.$ac_ext <<_ACEOF
4512 /* confdefs.h.  */
4513 _ACEOF
4514 cat confdefs.h >>conftest.$ac_ext
4515 cat >>conftest.$ac_ext <<_ACEOF
4516 /* end confdefs.h.  */
4517 #include <gmp.h>
4518     #include <mpfr.h>
4519 int
4520 main ()
4521 {
4522
4523     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4524     choke me
4525     #endif
4526     mpfr_t n; mpfr_init(n);
4527
4528   ;
4529   return 0;
4530 }
4531 _ACEOF
4532 rm -f conftest.$ac_objext conftest$ac_exeext
4533 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4534   (eval $ac_link) 2>conftest.er1
4535   ac_status=$?
4536   grep -v '^ *+' conftest.er1 >conftest.err
4537   rm -f conftest.er1
4538   cat conftest.err >&5
4539   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4540   (exit $ac_status); } &&
4541          { ac_try='test -z "$ac_c_werror_flag"
4542                          || test ! -s conftest.err'
4543   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4544   (eval $ac_try) 2>&5
4545   ac_status=$?
4546   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4547   (exit $ac_status); }; } &&
4548          { ac_try='test -s conftest$ac_exeext'
4549   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4550   (eval $ac_try) 2>&5
4551   ac_status=$?
4552   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4553   (exit $ac_status); }; }; then
4554   echo "$as_me:$LINENO: result: yes" >&5
4555 echo "${ECHO_T}yes" >&6
4556 else
4557   echo "$as_me: failed program was:" >&5
4558 sed 's/^/| /' conftest.$ac_ext >&5
4559
4560 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4561 echo "${ECHO_T}buggy but acceptable" >&6
4562 fi
4563 rm -f conftest.err conftest.$ac_objext \
4564       conftest$ac_exeext conftest.$ac_ext
4565 else
4566   echo "$as_me: failed program was:" >&5
4567 sed 's/^/| /' conftest.$ac_ext >&5
4568
4569 echo "$as_me:$LINENO: result: no" >&5
4570 echo "${ECHO_T}no" >&6; have_gmp=no
4571 fi
4572 rm -f conftest.err conftest.$ac_objext \
4573       conftest$ac_exeext conftest.$ac_ext
4574       LIBS="$saved_LIBS"
4575   fi
4576   CFLAGS="$saved_CFLAGS"
4577
4578   if test x$have_gmp != xyes; then
4579     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4580 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4581 Copies of these libraries' source code can be found at their respective
4582 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4583 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4584 If you obtained GMP and/or MPFR from a vendor distribution package, make
4585 sure that you have installed both the libraries and the header files.
4586 They may be located in separate packages." >&5
4587 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4588 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4589 Copies of these libraries' source code can be found at their respective
4590 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4591 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4592 If you obtained GMP and/or MPFR from a vendor distribution package, make
4593 sure that you have installed both the libraries and the header files.
4594 They may be located in separate packages." >&2;}
4595    { (exit 1); exit 1; }; }
4596   fi
4597 fi
4598
4599 # Flags needed for both GMP and/or MPFR
4600
4601
4602
4603 # By default, C is the only stage 1 language.
4604 stage1_languages=,c,
4605
4606 # Figure out what language subdirectories are present.
4607 # Look if the user specified --enable-languages="..."; if not, use
4608 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4609 # go away some day.
4610 # NB:  embedded tabs in this IF block -- do not untabify
4611 if test -d ${srcdir}/gcc; then
4612   if test x"${enable_languages+set}" != xset; then
4613     if test x"${LANGUAGES+set}" = xset; then
4614       enable_languages="${LANGUAGES}"
4615         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4616     else
4617       enable_languages=all
4618     fi
4619   else
4620     if test x"${enable_languages}" = x ||
4621        test x"${enable_languages}" = xyes;
4622        then
4623       echo configure.in: --enable-languages needs at least one language argument 1>&2
4624       exit 1
4625     fi
4626   fi
4627   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4628
4629   # 'f95' is the old name for the 'fortran' language. We issue a warning
4630   # and make the substitution.
4631   case ,${enable_languages}, in
4632     *,f95,*)
4633       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4634       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4635       ;;
4636   esac
4637
4638   # First scan to see if an enabled language requires some other language.
4639   # We assume that a given config-lang.in will list all the language
4640   # front ends it requires, even if some are required indirectly.
4641   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4642     case ${lang_frag} in
4643       ..) ;;
4644       # The odd quoting in the next line works around
4645       # an apparent bug in bash 1.12 on linux.
4646       ${srcdir}/gcc/[*]/config-lang.in) ;;
4647       *)
4648         # From the config-lang.in, get $language, $lang_requires
4649         language=
4650         lang_requires=
4651         . ${lang_frag}
4652         for other in ${lang_requires} ; do
4653           case ,${enable_languages}, in
4654             *,$other,*) ;;
4655             *,all,*) ;;
4656             *,$language,*)
4657               echo " \`$other' language required by \`$language'; enabling" 1>&2
4658               enable_languages="${enable_languages},${other}"
4659               ;;
4660           esac
4661         done
4662         ;;
4663     esac
4664   done
4665
4666   new_enable_languages=,c,
4667   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4668   potential_languages=,c,
4669
4670   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4671     case ${lang_frag} in
4672       ..) ;;
4673       # The odd quoting in the next line works around
4674       # an apparent bug in bash 1.12 on linux.
4675       ${srcdir}/gcc/[*]/config-lang.in) ;;
4676       *)
4677         # From the config-lang.in, get $language, $target_libs,
4678         # $lang_dirs, $boot_language, and $build_by_default
4679         language=
4680         target_libs=
4681         lang_dirs=
4682         subdir_requires=
4683         boot_language=no
4684         build_by_default=yes
4685         . ${lang_frag}
4686         if test x${language} = x; then
4687           echo "${lang_frag} doesn't set \$language." 1>&2
4688           exit 1
4689         fi
4690
4691         case ,${enable_languages}, in
4692           *,${language},*)
4693             # Language was explicitly selected; include it.
4694             add_this_lang=yes
4695             ;;
4696           *,all,*)
4697             # 'all' was selected, select it if it is a default language
4698             add_this_lang=${build_by_default}
4699             ;;
4700           *)
4701             add_this_lang=no
4702             ;;
4703         esac
4704
4705         # Disable languages that need other directories if these aren't available.
4706         for i in $subdir_requires; do
4707           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4708           case ,${enable_languages}, in
4709             *,${language},*)
4710               # Specifically requested language; tell them.
4711               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4712 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4713    { (exit 1); exit 1; }; }
4714               ;;
4715             *)
4716               # Silently disable.
4717               add_this_lang=unsupported
4718               ;;
4719           esac
4720         done
4721
4722         # Disable Ada if no preexisting GNAT is available.
4723         case ,${enable_languages},:${language}:${have_gnat} in
4724           *,${language},*:ada:no)
4725             # Specifically requested language; tell them.
4726             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4727 echo "$as_me: error: GNAT is required to build $language" >&2;}
4728    { (exit 1); exit 1; }; }
4729             ;;
4730           *:ada:no)
4731             # Silently disable.
4732             add_this_lang=unsupported
4733             ;;
4734         esac
4735
4736         # Disable a language that is unsupported by the target.
4737         case " $unsupported_languages " in
4738           *" $language "*)
4739             add_this_lang=unsupported
4740             ;;
4741         esac
4742
4743         case $add_this_lang in
4744           unsupported)
4745             # Remove language-dependent dirs.
4746             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4747             ;;
4748           no)
4749             # Remove language-dependent dirs; still show language as supported.
4750             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4751             potential_languages="${potential_languages}${language},"
4752             ;;
4753           yes)
4754             new_enable_languages="${new_enable_languages}${language},"
4755             potential_languages="${potential_languages}${language},"
4756             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4757             case ${boot_language} in
4758               yes)
4759                 # Add to (comma-separated) list of stage 1 languages.
4760                 stage1_languages="${stage1_languages}${language},"
4761                 ;;
4762             esac
4763             ;;
4764         esac
4765         ;;
4766     esac
4767   done
4768
4769   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4770 if test "${enable_stage1_languages+set}" = set; then
4771   enableval="$enable_stage1_languages"
4772   case ,${enable_stage1_languages}, in
4773     ,no,|,,)
4774       # Set it to something that will have no effect in the loop below
4775       enable_stage1_languages=c ;;
4776     ,yes,)
4777       enable_stage1_languages=`echo $new_enable_languages | \
4778         sed -e "s/^,//" -e "s/,$//" ` ;;
4779     *,all,*)
4780       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4781         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4782   esac
4783
4784   # Add "good" languages from enable_stage1_languages to stage1_languages,
4785   # while "bad" languages go in missing_languages.  Leave no duplicates.
4786   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4787     case $potential_languages in
4788       *,$i,*)
4789         case $stage1_languages in
4790           *,$i,*) ;;
4791           *) stage1_languages="$stage1_languages$i," ;;
4792         esac ;;
4793       *)
4794         case $missing_languages in
4795           *,$i,*) ;;
4796           *) missing_languages="$missing_languages$i," ;;
4797         esac ;;
4798      esac
4799   done
4800 fi;
4801
4802   # Remove leading/trailing commas that were added for simplicity
4803   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4804   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4805   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4806   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4807
4808   if test "x$missing_languages" != x; then
4809     { { echo "$as_me:$LINENO: error:
4810 The following requested languages could not be built: ${missing_languages}
4811 Supported languages are: ${potential_languages}" >&5
4812 echo "$as_me: error:
4813 The following requested languages could not be built: ${missing_languages}
4814 Supported languages are: ${potential_languages}" >&2;}
4815    { (exit 1); exit 1; }; }
4816   fi
4817   if test "x$new_enable_languages" != "x$enable_languages"; then
4818     echo The following languages will be built: ${new_enable_languages}
4819     enable_languages="$new_enable_languages"
4820   fi
4821
4822
4823   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4824 fi
4825
4826 # Handle --disable-<component> generically.
4827 for dir in $configdirs $build_configdirs $target_configdirs ; do
4828   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4829   if eval test x\${enable_${dirname}} "=" xno ; then
4830     noconfigdirs="$noconfigdirs $dir"
4831   fi
4832 done
4833
4834 # Check for Boehm's garbage collector
4835 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4836 if test "${enable_objc_gc+set}" = set; then
4837   enableval="$enable_objc_gc"
4838   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4839   *,objc,*:*:yes:*target-boehm-gc*)
4840     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4841 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4842    { (exit 1); exit 1; }; }
4843     ;;
4844 esac
4845 fi;
4846
4847 # Make sure we only build Boehm's garbage collector if required.
4848 case ,${enable_languages},:${enable_objc_gc} in
4849   *,objc,*:yes)
4850     # Keep target-boehm-gc if requested for Objective-C.
4851     ;;
4852   *)
4853     # Otherwise remove target-boehm-gc depending on target-libjava.
4854     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4855       noconfigdirs="$noconfigdirs target-boehm-gc"
4856     fi
4857     ;;
4858 esac
4859
4860 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4861 # $build_configdirs and $target_configdirs.
4862 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4863
4864 notsupp=""
4865 for dir in . $skipdirs $noconfigdirs ; do
4866   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4867   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4868     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4869     if test -r $srcdir/$dirname/configure ; then
4870       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4871         true
4872       else
4873         notsupp="$notsupp $dir"
4874       fi
4875     fi
4876   fi
4877   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4878     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4879     if test -r $srcdir/$dirname/configure ; then
4880       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4881         true
4882       else
4883         notsupp="$notsupp $dir"
4884       fi
4885     fi
4886   fi
4887   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4888     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4889     if test -r $srcdir/$dirname/configure ; then
4890       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4891         true
4892       else
4893         notsupp="$notsupp $dir"
4894       fi
4895     fi
4896   fi
4897 done
4898
4899 # Sometimes the tools are distributed with libiberty but with no other
4900 # libraries.  In that case, we don't want to build target-libiberty.
4901 # Don't let libgcc imply libiberty either.
4902 if test -n "${target_configdirs}" ; then
4903   libgcc=
4904   others=
4905   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
4906     if test "$i" = "libgcc"; then
4907       libgcc=target-libgcc
4908     elif test "$i" != "libiberty" ; then
4909       if test -r $srcdir/$i/configure ; then
4910         others=yes;
4911         break;
4912       fi
4913     fi
4914   done
4915   if test -z "${others}" ; then
4916     target_configdirs=$libgcc
4917   fi
4918 fi
4919
4920 # Quietly strip out all directories which aren't configurable in this tree.
4921 # This relies on all configurable subdirectories being autoconfiscated, which
4922 # is now the case.
4923 build_configdirs_all="$build_configdirs"
4924 build_configdirs=
4925 for i in ${build_configdirs_all} ; do
4926   j=`echo $i | sed -e s/build-//g`
4927   if test -f ${srcdir}/$j/configure ; then
4928     build_configdirs="${build_configdirs} $i"
4929   fi
4930 done
4931
4932 configdirs_all="$configdirs"
4933 configdirs=
4934 for i in ${configdirs_all} ; do
4935   if test -f ${srcdir}/$i/configure ; then
4936     configdirs="${configdirs} $i"
4937   fi
4938 done
4939
4940 target_configdirs_all="$target_configdirs"
4941 target_configdirs=
4942 for i in ${target_configdirs_all} ; do
4943   j=`echo $i | sed -e s/target-//g`
4944   if test -f ${srcdir}/$j/configure ; then
4945     target_configdirs="${target_configdirs} $i"
4946   fi
4947 done
4948
4949 # Produce a warning message for the subdirs we can't configure.
4950 # This isn't especially interesting in the Cygnus tree, but in the individual
4951 # FSF releases, it's important to let people know when their machine isn't
4952 # supported by the one or two programs in a package.
4953
4954 if test -n "${notsupp}" && test -z "${norecursion}" ; then
4955   # If $appdirs is non-empty, at least one of those directories must still
4956   # be configured, or we error out.  (E.g., if the gas release supports a
4957   # specified target in some subdirs but not the gas subdir, we shouldn't
4958   # pretend that all is well.)
4959   if test -n "$appdirs" ; then
4960     for dir in $appdirs ; do
4961       if test -r $dir/Makefile.in ; then
4962         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4963           appdirs=""
4964           break
4965         fi
4966         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
4967           appdirs=""
4968           break
4969         fi
4970       fi
4971     done
4972     if test -n "$appdirs" ; then
4973       echo "*** This configuration is not supported by this package." 1>&2
4974       exit 1
4975     fi
4976   fi
4977   # Okay, some application will build, or we don't care to check.  Still
4978   # notify of subdirs not getting built.
4979   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
4980   echo "    ${notsupp}" 1>&2
4981   echo "    (Any other directories should still work fine.)" 1>&2
4982 fi
4983
4984 case "$host" in
4985   *msdosdjgpp*)
4986     enable_gdbtk=no ;;
4987 esac
4988
4989 # To find our prefix, in gcc_cv_tool_prefix.
4990
4991 # The user is always right.
4992 if test "${PATH_SEPARATOR+set}" != set; then
4993   echo "#! /bin/sh" >conf$$.sh
4994   echo  "exit 0"   >>conf$$.sh
4995   chmod +x conf$$.sh
4996   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
4997     PATH_SEPARATOR=';'
4998   else
4999     PATH_SEPARATOR=:
5000   fi
5001   rm -f conf$$.sh
5002 fi
5003
5004
5005
5006 if test "x$exec_prefix" = xNONE; then
5007         if test "x$prefix" = xNONE; then
5008                 gcc_cv_tool_prefix=$ac_default_prefix
5009         else
5010                 gcc_cv_tool_prefix=$prefix
5011         fi
5012 else
5013         gcc_cv_tool_prefix=$exec_prefix
5014 fi
5015
5016 # If there is no compiler in the tree, use the PATH only.  In any
5017 # case, if there is no compiler in the tree nobody should use
5018 # AS_FOR_TARGET and LD_FOR_TARGET.
5019 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5020     gcc_version=`cat $srcdir/gcc/BASE-VER`
5021     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5022     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5023     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5024     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5025     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5026     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5027 else
5028     gcc_cv_tool_dirs=
5029 fi
5030
5031 if test x$build = x$target && test -n "$md_exec_prefix"; then
5032         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5033 fi
5034
5035
5036
5037 copy_dirs=
5038
5039
5040 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5041 if test "${with_build_sysroot+set}" = set; then
5042   withval="$with_build_sysroot"
5043   if test x"$withval" != x ; then
5044      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5045    fi
5046 else
5047   SYSROOT_CFLAGS_FOR_TARGET=
5048 fi;
5049
5050
5051 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5052 # the named directory are copied to $(tooldir)/sys-include.
5053 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5054   if test x${is_cross_compiler} = xno ; then
5055     echo 1>&2 '***' --with-headers is only supported when cross compiling
5056     exit 1
5057   fi
5058   if test x"${with_headers}" != xyes ; then
5059     x=${gcc_cv_tool_prefix}
5060     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5061   fi
5062 fi
5063
5064 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5065 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5066 # are permitted.
5067 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5068   if test x${is_cross_compiler} = xno ; then
5069     echo 1>&2 '***' --with-libs is only supported when cross compiling
5070     exit 1
5071   fi
5072   if test x"${with_libs}" != xyes ; then
5073     # Copy the libraries in reverse order, so that files in the first named
5074     # library override files in subsequent libraries.
5075     x=${gcc_cv_tool_prefix}
5076     for l in ${with_libs}; do
5077       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5078     done
5079   fi
5080 fi
5081
5082 # Set with_gnu_as and with_gnu_ld as appropriate.
5083 #
5084 # This is done by determining whether or not the appropriate directory
5085 # is available, and by checking whether or not specific configurations
5086 # have requested that this magic not happen.
5087 #
5088 # The command line options always override the explicit settings in
5089 # configure.in, and the settings in configure.in override this magic.
5090 #
5091 # If the default for a toolchain is to use GNU as and ld, and you don't
5092 # want to do that, then you should use the --without-gnu-as and
5093 # --without-gnu-ld options for the configure script.
5094
5095 if test x${use_gnu_as} = x &&
5096    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5097   with_gnu_as=yes
5098   extra_host_args="$extra_host_args --with-gnu-as"
5099 fi
5100
5101 if test x${use_gnu_ld} = x &&
5102    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5103   with_gnu_ld=yes
5104   extra_host_args="$extra_host_args --with-gnu-ld"
5105 fi
5106
5107 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5108 # can detect this case.
5109
5110 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5111   with_newlib=yes
5112   extra_host_args="$extra_host_args --with-newlib"
5113 fi
5114
5115 # Handle ${copy_dirs}
5116 set fnord ${copy_dirs}
5117 shift
5118 while test $# != 0 ; do
5119   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5120     :
5121   else
5122     echo Copying $1 to $2
5123
5124     # Use the install script to create the directory and all required
5125     # parent directories.
5126     if test -d $2 ; then
5127       :
5128     else
5129       echo >config.temp
5130       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5131     fi
5132
5133     # Copy the directory, assuming we have tar.
5134     # FIXME: Should we use B in the second tar?  Not all systems support it.
5135     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5136
5137     # It is the responsibility of the user to correctly adjust all
5138     # symlinks.  If somebody can figure out how to handle them correctly
5139     # here, feel free to add the code.
5140
5141     echo $1 > $2/COPIED
5142   fi
5143   shift; shift
5144 done
5145
5146 # Determine a target-dependent exec_prefix that the installed
5147 # gcc will search in.  Keep this list sorted by triplet, with
5148 # the *-*-osname triplets last.
5149 md_exec_prefix=
5150 case "${target}" in
5151   alpha*-*-*vms*)
5152     md_exec_prefix=/gnu/lib/gcc-lib
5153     ;;
5154   i3456786-pc-msdosdjgpp*)
5155     md_exec_prefix=/dev/env/DJDIR/bin
5156     ;;
5157   i3456786-*-sco3.2v5*)
5158     if test $with_gnu_as = yes; then
5159       md_exec_prefix=/usr/gnu/bin
5160     else
5161       md_exec_prefix=/usr/ccs/bin/elf
5162     fi
5163     ;;
5164
5165   mn10300-*-* | \
5166   powerpc-*-chorusos* | \
5167   powerpc*-*-eabi* | \
5168   powerpc*-*-sysv* | \
5169   powerpc*-*-kaos* | \
5170   s390x-ibm-tpf*)
5171     md_exec_prefix=/usr/ccs/bin
5172     ;;
5173   sparc64-*-elf*)
5174     ;;
5175   v850*-*-*)
5176     md_exec_prefix=/usr/ccs/bin
5177     ;;
5178   xtensa-*-elf*)
5179     ;;
5180
5181   *-*-beos* | \
5182   *-*-elf* | \
5183   *-*-hpux* | \
5184   *-*-netware* | \
5185   *-*-nto-qnx* | \
5186   *-*-rtems* | \
5187   *-*-solaris2* | \
5188   *-*-sysv45* | \
5189   *-*-vxworks* | \
5190   *-wrs-windiss)
5191     md_exec_prefix=/usr/ccs/bin
5192     ;;
5193 esac
5194
5195 extra_arflags_for_target=
5196 extra_nmflags_for_target=
5197 extra_ranlibflags_for_target=
5198 target_makefile_frag=/dev/null
5199 case "${target}" in
5200   mep*-*-*)
5201     target_makefile_frag="config/mt-mep"
5202     ;;
5203   spu-*-*)
5204     target_makefile_frag="config/mt-spu"
5205     ;;
5206   *-*-netware*)
5207     target_makefile_frag="config/mt-netware"
5208     ;;
5209   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5210     target_makefile_frag="config/mt-gnu"
5211     ;;
5212   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5213     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5214     # commands to handle both 32-bit and 64-bit objects.  These flags are
5215     # harmless if we're using GNU nm or ar.
5216     extra_arflags_for_target=" -X32_64"
5217     extra_nmflags_for_target=" -B -X32_64"
5218     ;;
5219   *-*-darwin*)
5220     # ranlib from Darwin requires the -c flag to look at common symbols.
5221     extra_ranlibflags_for_target=" -c"
5222     ;;
5223   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5224     target_makefile_frag="config/mt-wince"
5225     ;;
5226 esac
5227
5228 alphaieee_frag=/dev/null
5229 case $target in
5230   alpha*-*-*)
5231     # This just makes sure to use the -mieee option to build target libs.
5232     # This should probably be set individually by each library.
5233     alphaieee_frag="config/mt-alphaieee"
5234     ;;
5235 esac
5236
5237 # If --enable-target-optspace always use -Os instead of -O2 to build
5238 # the target libraries, similarly if it is not specified, use -Os
5239 # on selected platforms.
5240 ospace_frag=/dev/null
5241 case "${enable_target_optspace}:${target}" in
5242   yes:*)
5243     ospace_frag="config/mt-ospace"
5244     ;;
5245   :d30v-*)
5246     ospace_frag="config/mt-d30v"
5247     ;;
5248   :m32r-* | :d10v-* | :fr30-*)
5249     ospace_frag="config/mt-ospace"
5250     ;;
5251   no:* | :*)
5252     ;;
5253   *)
5254     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5255     ;;
5256 esac
5257
5258 # Default to using --with-stabs for certain targets.
5259 if test x${with_stabs} = x ; then
5260   case "${target}" in
5261   mips*-*-irix[56]*)
5262     ;;
5263   mips*-*-* | alpha*-*-osf*)
5264     with_stabs=yes;
5265     extra_host_args="${extra_host_args} --with-stabs"
5266     ;;
5267   esac
5268 fi
5269
5270 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5271 # them automatically.
5272 case "${host}" in
5273   hppa*64*-*-hpux11*)
5274     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5275     ;;
5276 esac
5277
5278 # Some systems (e.g., one of the i386-aix systems the gas testers are
5279 # using) don't handle "\$" correctly, so don't use it here.
5280 tooldir='${exec_prefix}'/${target_noncanonical}
5281 build_tooldir=${tooldir}
5282
5283 # Create a .gdbinit file which runs the one in srcdir
5284 # and tells GDB to look there for source files.
5285
5286 if test -r ${srcdir}/.gdbinit ; then
5287   case ${srcdir} in
5288     .) ;;
5289     *) cat > ./.gdbinit <<EOF
5290 # ${NO_EDIT}
5291 dir ${srcdir}
5292 dir .
5293 source ${srcdir}/.gdbinit
5294 EOF
5295     ;;
5296   esac
5297 fi
5298
5299 # Make sure that the compiler is able to generate an executable.  If it
5300 # can't, we are probably in trouble.  We don't care whether we can run the
5301 # executable--we might be using a cross compiler--we only care whether it
5302 # can be created.  At this point the main configure script has set CC.
5303 we_are_ok=no
5304 echo "int main () { return 0; }" > conftest.c
5305 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5306 if test $? = 0 ; then
5307   if test -s conftest || test -s conftest.exe ; then
5308     we_are_ok=yes
5309   fi
5310 fi
5311 case $we_are_ok in
5312   no)
5313     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5314     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5315     rm -f conftest*
5316     exit 1
5317     ;;
5318 esac
5319 rm -f conftest*
5320
5321 # The Solaris /usr/ucb/cc compiler does not appear to work.
5322 case "${host}" in
5323   sparc-sun-solaris2*)
5324       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5325       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5326           could_use=
5327           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5328           if test -d /opt/cygnus/bin ; then
5329               if test "$could_use" = "" ; then
5330                   could_use="/opt/cygnus/bin"
5331               else
5332                   could_use="$could_use or /opt/cygnus/bin"
5333               fi
5334           fi
5335         if test "$could_use" = "" ; then
5336             echo "Warning: compilation may fail because you're using"
5337             echo "/usr/ucb/cc.  You should change your PATH or CC "
5338             echo "variable and rerun configure."
5339         else
5340             echo "Warning: compilation may fail because you're using"
5341             echo "/usr/ucb/cc, when you should use the C compiler from"
5342             echo "$could_use.  You should change your"
5343             echo "PATH or CC variable and rerun configure."
5344         fi
5345       fi
5346   ;;
5347 esac
5348
5349 case "${host}" in
5350   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5351   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5352   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5353 esac
5354
5355 # Record target_configdirs and the configure arguments for target and
5356 # build configuration in Makefile.
5357 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5358 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5359
5360 # Determine whether gdb needs tk/tcl or not.
5361 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5362 # and in that case we want gdb to be built without tk.  Ugh!
5363 # In fact I believe gdb is the *only* package directly dependent on tk,
5364 # so we should be able to put the 'maybe's in unconditionally and
5365 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5366 # 100% sure that that's safe though.
5367
5368 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5369 case "$enable_gdbtk" in
5370   no)
5371     GDB_TK="" ;;
5372   yes)
5373     GDB_TK="${gdb_tk}" ;;
5374   *)
5375     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5376     # distro.  Eventually someone will fix this and move Insight, nee
5377     # gdbtk to a separate directory.
5378     if test -d ${srcdir}/gdb/gdbtk ; then
5379       GDB_TK="${gdb_tk}"
5380     else
5381       GDB_TK=""
5382     fi
5383     ;;
5384 esac
5385 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5386 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5387
5388 # Strip out unwanted targets.
5389
5390 # While at that, we remove Makefiles if we were started for recursive
5391 # configuration, so that the top-level Makefile reconfigures them,
5392 # like we used to do when configure itself was recursive.
5393
5394 # Loop over modules.  $extrasub must be used with care, limiting as
5395 # much as possible the usage of range addresses.  That's because autoconf
5396 # splits the sed script to overcome limits in the number of commands,
5397 # and relying on carefully-timed sed passes may turn out to be very hard
5398 # to maintain later.  In this particular case, you just have to be careful
5399 # not to nest @if/@endif pairs, because configure will not warn you at all.
5400
5401 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5402 if test "${enable_bootstrap+set}" = set; then
5403   enableval="$enable_bootstrap"
5404
5405 else
5406   enable_bootstrap=default
5407 fi;
5408
5409 # Issue errors and warnings for invalid/strange bootstrap combinations.
5410 case "$configdirs" in
5411   *gcc*) have_compiler=yes ;;
5412   *) have_compiler=no ;;
5413 esac
5414
5415 case "$have_compiler:$host:$target:$enable_bootstrap" in
5416   *:*:*:no) ;;
5417
5418   # Default behavior.  Enable bootstrap if we have a compiler
5419   # and we are in a native configuration.
5420   yes:$build:$build:default)
5421     enable_bootstrap=yes ;;
5422
5423   *:*:*:default)
5424     enable_bootstrap=no ;;
5425
5426   # We have a compiler and we are in a native configuration, bootstrap is ok
5427   yes:$build:$build:yes)
5428     ;;
5429
5430   # Other configurations, but we have a compiler.  Assume the user knows
5431   # what he's doing.
5432   yes:*:*:yes)
5433     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5434 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5435     ;;
5436
5437   # No compiler: if they passed --enable-bootstrap explicitly, fail
5438   no:*:*:yes)
5439     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5440 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5441    { (exit 1); exit 1; }; } ;;
5442
5443   # Fail if wrong command line
5444   *)
5445     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5446 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5447    { (exit 1); exit 1; }; }
5448     ;;
5449 esac
5450
5451 # Adjust the toplevel makefile according to whether bootstrap was selected.
5452 case "$enable_bootstrap" in
5453   yes)
5454     bootstrap_suffix=bootstrap ;;
5455   no)
5456     bootstrap_suffix=no-bootstrap ;;
5457 esac
5458
5459 for module in ${build_configdirs} ; do
5460   if test -z "${no_recursion}" \
5461      && test -f ${build_subdir}/${module}/Makefile; then
5462     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5463     rm -f ${build_subdir}/${module}/Makefile
5464   fi
5465   extrasub="$extrasub
5466 /^@if build-$module\$/d
5467 /^@endif build-$module\$/d
5468 /^@if build-$module-$bootstrap_suffix\$/d
5469 /^@endif build-$module-$bootstrap_suffix\$/d"
5470 done
5471 for module in ${configdirs} ; do
5472   if test -z "${no_recursion}"; then
5473     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5474       if test -f ${file}; then
5475         echo 1>&2 "*** removing ${file} to force reconfigure"
5476         rm -f ${file}
5477       fi
5478     done
5479   fi
5480   extrasub="$extrasub
5481 /^@if $module\$/d
5482 /^@endif $module\$/d
5483 /^@if $module-$bootstrap_suffix\$/d
5484 /^@endif $module-$bootstrap_suffix\$/d"
5485 done
5486 for module in ${target_configdirs} ; do
5487   if test -z "${no_recursion}" \
5488      && test -f ${target_subdir}/${module}/Makefile; then
5489     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5490     rm -f ${target_subdir}/${module}/Makefile
5491   fi
5492   extrasub="$extrasub
5493 /^@if target-$module\$/d
5494 /^@endif target-$module\$/d
5495 /^@if target-$module-$bootstrap_suffix\$/d
5496 /^@endif target-$module-$bootstrap_suffix\$/d"
5497 done
5498
5499 extrasub="$extrasub
5500 /^@if /,/^@endif /d"
5501
5502 # Create the serialization dependencies.  This uses a temporary file.
5503
5504 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5505 if test "${enable_serial_configure+set}" = set; then
5506   enableval="$enable_serial_configure"
5507
5508 fi;
5509
5510 case ${enable_serial_configure} in
5511   yes)
5512     enable_serial_build_configure=yes
5513     enable_serial_host_configure=yes
5514     enable_serial_target_configure=yes
5515     ;;
5516 esac
5517
5518 # These force 'configure's to be done one at a time, to avoid problems
5519 # with contention over a shared config.cache.
5520 rm -f serdep.tmp
5521 echo '# serdep.tmp' > serdep.tmp
5522 olditem=
5523 test "x${enable_serial_build_configure}" = xyes &&
5524 for item in ${build_configdirs} ; do
5525   case ${olditem} in
5526     "") ;;
5527     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5528   esac
5529   olditem=${item}
5530 done
5531 olditem=
5532 test "x${enable_serial_host_configure}" = xyes &&
5533 for item in ${configdirs} ; do
5534   case ${olditem} in
5535     "") ;;
5536     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5537   esac
5538   olditem=${item}
5539 done
5540 olditem=
5541 test "x${enable_serial_target_configure}" = xyes &&
5542 for item in ${target_configdirs} ; do
5543   case ${olditem} in
5544     "") ;;
5545     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5546   esac
5547   olditem=${item}
5548 done
5549 serialization_dependencies=serdep.tmp
5550
5551
5552 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5553 # target, nonopt, and variable assignments.  These are the ones we
5554 # might not want to pass down to subconfigures.  Also strip
5555 # program-prefix, program-suffix, and program-transform-name, so that
5556 # we can pass down a consistent program-transform-name.
5557 baseargs=
5558 keep_next=no
5559 skip_next=no
5560 eval "set -- $ac_configure_args"
5561 for ac_arg
5562 do
5563   if test X"$skip_next" = X"yes"; then
5564     skip_next=no
5565     continue
5566   fi
5567   if test X"$keep_next" = X"yes"; then
5568     case $ac_arg in
5569       *\'*)
5570         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5571     esac
5572     baseargs="$baseargs '$ac_arg'"
5573     keep_next=no
5574     continue
5575   fi
5576
5577   # Handle separated arguments.  Based on the logic generated by
5578   # autoconf 2.59.
5579   case $ac_arg in
5580     *=* | --config-cache | -C | -disable-* | --disable-* \
5581       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5582       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5583       | -with-* | --with-* | -without-* | --without-* | --x)
5584       separate_arg=no
5585       ;;
5586     -*)
5587       separate_arg=yes
5588       ;;
5589     *)
5590       separate_arg=no
5591       ;;
5592   esac
5593
5594   case "$ac_arg" in
5595     --no*)
5596       continue
5597       ;;
5598     --c* | \
5599     --sr* | \
5600     --ho* | \
5601     --bu* | \
5602     --t* | \
5603     --program-* | \
5604     -cache_file* | \
5605     -srcdir* | \
5606     -host* | \
5607     -build* | \
5608     -target* | \
5609     -program-prefix* | \
5610     -program-suffix* | \
5611     -program-transform-name* )
5612       skip_next=$separate_arg
5613       continue
5614       ;;
5615     -*)
5616       # An option.  Add it.
5617       case $ac_arg in
5618         *\'*)
5619           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5620       esac
5621       baseargs="$baseargs '$ac_arg'"
5622       keep_next=$separate_arg
5623       ;;
5624     *)
5625       # Either a variable assignment, or a nonopt (triplet).  Don't
5626       # pass it down; let the Makefile handle this.
5627       continue
5628       ;;
5629   esac
5630 done
5631 # Remove the initial space we just introduced and, as these will be
5632 # expanded by make, quote '$'.
5633 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5634
5635 # Add in --program-transform-name, after --program-prefix and
5636 # --program-suffix have been applied to it.  Autoconf has already
5637 # doubled dollar signs and backslashes in program_transform_name; we want
5638 # the backslashes un-doubled, and then the entire thing wrapped in single
5639 # quotes, because this will be expanded first by make and then by the shell.
5640 # Also, because we want to override the logic in subdir configure scripts to
5641 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5642 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5643 ${program_transform_name}
5644 EOF_SED
5645 gcc_transform_name=`cat conftestsed.out`
5646 rm -f conftestsed.out
5647 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5648
5649 # For the build-side libraries, we just need to pretend we're native,
5650 # and not use the same cache file.  Multilibs are neither needed nor
5651 # desired.
5652 build_configargs="--cache-file=../config.cache ${baseargs}"
5653
5654 # For host modules, accept cache file option, or specification as blank.
5655 case "${cache_file}" in
5656 "") # empty
5657   cache_file_option="" ;;
5658 /* | [A-Za-z]:[\\/]* ) # absolute path
5659   cache_file_option="--cache-file=${cache_file}" ;;
5660 *) # relative path
5661   cache_file_option="--cache-file=../${cache_file}" ;;
5662 esac
5663
5664 # Host dirs don't like to share a cache file either, horribly enough.
5665 # This seems to be due to autoconf 2.5x stupidity.
5666 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5667
5668 target_configargs=${baseargs}
5669
5670 # Passing a --with-cross-host argument lets the target libraries know
5671 # whether they are being built with a cross-compiler or being built
5672 # native.  However, it would be better to use other mechanisms to make the
5673 # sorts of decisions they want to make on this basis.  Please consider
5674 # this option to be deprecated.  FIXME.
5675 if test x${is_cross_compiler} = xyes ; then
5676   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5677 fi
5678
5679 # Default to --enable-multilib.
5680 if test x${enable_multilib} = x ; then
5681   target_configargs="--enable-multilib ${target_configargs}"
5682 fi
5683
5684 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5685 # changed from the earlier setting of with_newlib.
5686 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5687   target_configargs="--with-newlib ${target_configargs}"
5688 fi
5689
5690 # Different target subdirs use different values of certain variables
5691 # (notably CXX).  Worse, multilibs use *lots* of different values.
5692 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5693 # it doesn't automatically accept command-line overrides of them.
5694 # This means it's not safe for target subdirs to share a cache file,
5695 # which is disgusting, but there you have it.  Hopefully this can be
5696 # fixed in future.  It's still worthwhile to use a cache file for each
5697 # directory.  I think.
5698
5699 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5700 # We need to pass --target, as newer autoconf's requires consistency
5701 # for target_alias and gcc doesn't manage it consistently.
5702 target_configargs="--cache-file=./config.cache ${target_configargs}"
5703
5704 FLAGS_FOR_TARGET=
5705 case " $target_configdirs " in
5706  *" newlib "*)
5707   case " $target_configargs " in
5708   *" --with-newlib "*)
5709    case "$target" in
5710    *-cygwin*)
5711      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' ;;
5712    esac
5713
5714    # If we're not building GCC, don't discard standard headers.
5715    if test -d ${srcdir}/gcc; then
5716      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5717
5718      if test "${build}" != "${host}"; then
5719        # On Canadian crosses, CC_FOR_TARGET will have already been set
5720        # by `configure', so we won't have an opportunity to add -Bgcc/
5721        # to it.  This is right: we don't want to search that directory
5722        # for binaries, but we want the header files in there, so add
5723        # them explicitly.
5724        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5725
5726        # Someone might think of using the pre-installed headers on
5727        # Canadian crosses, in case the installed compiler is not fully
5728        # compatible with the compiler being built.  In this case, it
5729        # would be better to flag an error than risking having
5730        # incompatible object files being constructed.  We can't
5731        # guarantee that an error will be flagged, but let's hope the
5732        # compiler will do it, when presented with incompatible header
5733        # files.
5734      fi
5735    fi
5736
5737    case "${target}-${is_cross_compiler}" in
5738    i[3456789]86-*-linux*-no)
5739       # Here host == target, so we don't need to build gcc,
5740       # so we don't want to discard standard headers.
5741       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5742       ;;
5743    *)
5744       # If we're building newlib, use its generic headers last, but search
5745       # for any libc-related directories first (so make it the last -B
5746       # switch).
5747       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5748       ;;
5749    esac
5750    ;;
5751   esac
5752   ;;
5753 esac
5754 case "$target" in
5755 *-mingw*)
5756   # Can't be handled as Cygwin above since Mingw does not use newlib.
5757   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' ;;
5758 esac
5759
5760 # Allow the user to override the flags for
5761 # our build compiler if desired.
5762 CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5763
5764 # On Canadian crosses, we'll be searching the right directories for
5765 # the previously-installed cross compiler, so don't bother to add
5766 # flags for directories within the install tree of the compiler
5767 # being built; programs in there won't even run.
5768 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5769   # Search for pre-installed headers if nothing else fits.
5770   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5771 fi
5772
5773 if test "x${use_gnu_ld}" = x &&
5774    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5775   # Arrange for us to find uninstalled linker scripts.
5776   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5777 fi
5778
5779 # Search for other target-specific linker scripts and such.
5780 case "${target}" in
5781   m32c-*-* )
5782     if test -d ${srcdir}/libgloss/m32c; then
5783       # This is for crt0.o
5784       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5785       # This is for r8c.ld
5786       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5787       # This is for libnosys.a
5788       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5789     fi
5790     ;;
5791   mep*)
5792     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5793     ;;
5794 esac
5795
5796 # Makefile fragments.
5797 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5798 do
5799   eval fragval=\$$frag
5800   if test $fragval != /dev/null; then
5801     eval $frag=${srcdir}/$fragval
5802   fi
5803 done
5804
5805
5806
5807
5808
5809 # Miscellanea: directories, flags, etc.
5810
5811
5812
5813
5814
5815
5816
5817 # Build module lists & subconfigure args.
5818
5819
5820
5821 # Host module lists & subconfigure args.
5822
5823
5824
5825 # Target module lists & subconfigure args.
5826
5827
5828
5829 # Build tools.
5830
5831
5832
5833 # Generate default definitions for YACC, M4, LEX and other programs that run
5834 # on the build machine.  These are used if the Makefile can't locate these
5835 # programs in objdir.
5836 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5837
5838 for ac_prog in 'bison -y' byacc yacc
5839 do
5840   # Extract the first word of "$ac_prog", so it can be a program name with args.
5841 set dummy $ac_prog; ac_word=$2
5842 echo "$as_me:$LINENO: checking for $ac_word" >&5
5843 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5844 if test "${ac_cv_prog_YACC+set}" = set; then
5845   echo $ECHO_N "(cached) $ECHO_C" >&6
5846 else
5847   if test -n "$YACC"; then
5848   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5849 else
5850 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5851 for as_dir in $PATH
5852 do
5853   IFS=$as_save_IFS
5854   test -z "$as_dir" && as_dir=.
5855   for ac_exec_ext in '' $ac_executable_extensions; do
5856   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5857     ac_cv_prog_YACC="$ac_prog"
5858     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5859     break 2
5860   fi
5861 done
5862 done
5863
5864 fi
5865 fi
5866 YACC=$ac_cv_prog_YACC
5867 if test -n "$YACC"; then
5868   echo "$as_me:$LINENO: result: $YACC" >&5
5869 echo "${ECHO_T}$YACC" >&6
5870 else
5871   echo "$as_me:$LINENO: result: no" >&5
5872 echo "${ECHO_T}no" >&6
5873 fi
5874
5875   test -n "$YACC" && break
5876 done
5877 test -n "$YACC" || YACC="$MISSING bison -y"
5878
5879 case " $build_configdirs " in
5880   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
5881   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
5882 esac
5883
5884 for ac_prog in bison
5885 do
5886   # Extract the first word of "$ac_prog", so it can be a program name with args.
5887 set dummy $ac_prog; ac_word=$2
5888 echo "$as_me:$LINENO: checking for $ac_word" >&5
5889 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5890 if test "${ac_cv_prog_BISON+set}" = set; then
5891   echo $ECHO_N "(cached) $ECHO_C" >&6
5892 else
5893   if test -n "$BISON"; then
5894   ac_cv_prog_BISON="$BISON" # Let the user override the test.
5895 else
5896 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5897 for as_dir in $PATH
5898 do
5899   IFS=$as_save_IFS
5900   test -z "$as_dir" && as_dir=.
5901   for ac_exec_ext in '' $ac_executable_extensions; do
5902   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5903     ac_cv_prog_BISON="$ac_prog"
5904     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5905     break 2
5906   fi
5907 done
5908 done
5909
5910 fi
5911 fi
5912 BISON=$ac_cv_prog_BISON
5913 if test -n "$BISON"; then
5914   echo "$as_me:$LINENO: result: $BISON" >&5
5915 echo "${ECHO_T}$BISON" >&6
5916 else
5917   echo "$as_me:$LINENO: result: no" >&5
5918 echo "${ECHO_T}no" >&6
5919 fi
5920
5921   test -n "$BISON" && break
5922 done
5923 test -n "$BISON" || BISON="$MISSING bison"
5924
5925 case " $build_configdirs " in
5926   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
5927 esac
5928
5929 for ac_prog in gm4 gnum4 m4
5930 do
5931   # Extract the first word of "$ac_prog", so it can be a program name with args.
5932 set dummy $ac_prog; ac_word=$2
5933 echo "$as_me:$LINENO: checking for $ac_word" >&5
5934 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5935 if test "${ac_cv_prog_M4+set}" = set; then
5936   echo $ECHO_N "(cached) $ECHO_C" >&6
5937 else
5938   if test -n "$M4"; then
5939   ac_cv_prog_M4="$M4" # Let the user override the test.
5940 else
5941 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5942 for as_dir in $PATH
5943 do
5944   IFS=$as_save_IFS
5945   test -z "$as_dir" && as_dir=.
5946   for ac_exec_ext in '' $ac_executable_extensions; do
5947   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5948     ac_cv_prog_M4="$ac_prog"
5949     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5950     break 2
5951   fi
5952 done
5953 done
5954
5955 fi
5956 fi
5957 M4=$ac_cv_prog_M4
5958 if test -n "$M4"; then
5959   echo "$as_me:$LINENO: result: $M4" >&5
5960 echo "${ECHO_T}$M4" >&6
5961 else
5962   echo "$as_me:$LINENO: result: no" >&5
5963 echo "${ECHO_T}no" >&6
5964 fi
5965
5966   test -n "$M4" && break
5967 done
5968 test -n "$M4" || M4="$MISSING m4"
5969
5970 case " $build_configdirs " in
5971   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
5972 esac
5973
5974 for ac_prog in flex lex
5975 do
5976   # Extract the first word of "$ac_prog", so it can be a program name with args.
5977 set dummy $ac_prog; ac_word=$2
5978 echo "$as_me:$LINENO: checking for $ac_word" >&5
5979 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5980 if test "${ac_cv_prog_LEX+set}" = set; then
5981   echo $ECHO_N "(cached) $ECHO_C" >&6
5982 else
5983   if test -n "$LEX"; then
5984   ac_cv_prog_LEX="$LEX" # Let the user override the test.
5985 else
5986 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5987 for as_dir in $PATH
5988 do
5989   IFS=$as_save_IFS
5990   test -z "$as_dir" && as_dir=.
5991   for ac_exec_ext in '' $ac_executable_extensions; do
5992   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5993     ac_cv_prog_LEX="$ac_prog"
5994     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5995     break 2
5996   fi
5997 done
5998 done
5999
6000 fi
6001 fi
6002 LEX=$ac_cv_prog_LEX
6003 if test -n "$LEX"; then
6004   echo "$as_me:$LINENO: result: $LEX" >&5
6005 echo "${ECHO_T}$LEX" >&6
6006 else
6007   echo "$as_me:$LINENO: result: no" >&5
6008 echo "${ECHO_T}no" >&6
6009 fi
6010
6011   test -n "$LEX" && break
6012 done
6013 test -n "$LEX" || LEX="$MISSING flex"
6014
6015 case " $build_configdirs " in
6016   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6017   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6018 esac
6019
6020 for ac_prog in flex
6021 do
6022   # Extract the first word of "$ac_prog", so it can be a program name with args.
6023 set dummy $ac_prog; ac_word=$2
6024 echo "$as_me:$LINENO: checking for $ac_word" >&5
6025 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6026 if test "${ac_cv_prog_FLEX+set}" = set; then
6027   echo $ECHO_N "(cached) $ECHO_C" >&6
6028 else
6029   if test -n "$FLEX"; then
6030   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6031 else
6032 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6033 for as_dir in $PATH
6034 do
6035   IFS=$as_save_IFS
6036   test -z "$as_dir" && as_dir=.
6037   for ac_exec_ext in '' $ac_executable_extensions; do
6038   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6039     ac_cv_prog_FLEX="$ac_prog"
6040     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6041     break 2
6042   fi
6043 done
6044 done
6045
6046 fi
6047 fi
6048 FLEX=$ac_cv_prog_FLEX
6049 if test -n "$FLEX"; then
6050   echo "$as_me:$LINENO: result: $FLEX" >&5
6051 echo "${ECHO_T}$FLEX" >&6
6052 else
6053   echo "$as_me:$LINENO: result: no" >&5
6054 echo "${ECHO_T}no" >&6
6055 fi
6056
6057   test -n "$FLEX" && break
6058 done
6059 test -n "$FLEX" || FLEX="$MISSING flex"
6060
6061 case " $build_configdirs " in
6062   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6063 esac
6064
6065 for ac_prog in makeinfo
6066 do
6067   # Extract the first word of "$ac_prog", so it can be a program name with args.
6068 set dummy $ac_prog; ac_word=$2
6069 echo "$as_me:$LINENO: checking for $ac_word" >&5
6070 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6071 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6072   echo $ECHO_N "(cached) $ECHO_C" >&6
6073 else
6074   if test -n "$MAKEINFO"; then
6075   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6076 else
6077 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6078 for as_dir in $PATH
6079 do
6080   IFS=$as_save_IFS
6081   test -z "$as_dir" && as_dir=.
6082   for ac_exec_ext in '' $ac_executable_extensions; do
6083   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6084     ac_cv_prog_MAKEINFO="$ac_prog"
6085     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6086     break 2
6087   fi
6088 done
6089 done
6090
6091 fi
6092 fi
6093 MAKEINFO=$ac_cv_prog_MAKEINFO
6094 if test -n "$MAKEINFO"; then
6095   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6096 echo "${ECHO_T}$MAKEINFO" >&6
6097 else
6098   echo "$as_me:$LINENO: result: no" >&5
6099 echo "${ECHO_T}no" >&6
6100 fi
6101
6102   test -n "$MAKEINFO" && break
6103 done
6104 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6105
6106 case " $build_configdirs " in
6107   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6108   *)
6109
6110     # For an installed makeinfo, we require it to be from texinfo 4.4 or
6111     # higher, else we use the "missing" dummy.
6112     if ${MAKEINFO} --version \
6113        | egrep 'texinfo[^0-9]*([1-3][0-9]|4\.[4-9]|[5-9])' >/dev/null 2>&1; then
6114       :
6115     else
6116       MAKEINFO="$MISSING makeinfo"
6117     fi
6118     ;;
6119
6120 esac
6121
6122 # FIXME: expect and dejagnu may become build tools?
6123
6124 for ac_prog in expect
6125 do
6126   # Extract the first word of "$ac_prog", so it can be a program name with args.
6127 set dummy $ac_prog; ac_word=$2
6128 echo "$as_me:$LINENO: checking for $ac_word" >&5
6129 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6130 if test "${ac_cv_prog_EXPECT+set}" = set; then
6131   echo $ECHO_N "(cached) $ECHO_C" >&6
6132 else
6133   if test -n "$EXPECT"; then
6134   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6135 else
6136 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6137 for as_dir in $PATH
6138 do
6139   IFS=$as_save_IFS
6140   test -z "$as_dir" && as_dir=.
6141   for ac_exec_ext in '' $ac_executable_extensions; do
6142   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6143     ac_cv_prog_EXPECT="$ac_prog"
6144     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6145     break 2
6146   fi
6147 done
6148 done
6149
6150 fi
6151 fi
6152 EXPECT=$ac_cv_prog_EXPECT
6153 if test -n "$EXPECT"; then
6154   echo "$as_me:$LINENO: result: $EXPECT" >&5
6155 echo "${ECHO_T}$EXPECT" >&6
6156 else
6157   echo "$as_me:$LINENO: result: no" >&5
6158 echo "${ECHO_T}no" >&6
6159 fi
6160
6161   test -n "$EXPECT" && break
6162 done
6163 test -n "$EXPECT" || EXPECT="expect"
6164
6165 case " $configdirs " in
6166   *" expect "*)
6167     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6168     ;;
6169 esac
6170
6171 for ac_prog in runtest
6172 do
6173   # Extract the first word of "$ac_prog", so it can be a program name with args.
6174 set dummy $ac_prog; ac_word=$2
6175 echo "$as_me:$LINENO: checking for $ac_word" >&5
6176 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6177 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6178   echo $ECHO_N "(cached) $ECHO_C" >&6
6179 else
6180   if test -n "$RUNTEST"; then
6181   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6182 else
6183 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6184 for as_dir in $PATH
6185 do
6186   IFS=$as_save_IFS
6187   test -z "$as_dir" && as_dir=.
6188   for ac_exec_ext in '' $ac_executable_extensions; do
6189   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6190     ac_cv_prog_RUNTEST="$ac_prog"
6191     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6192     break 2
6193   fi
6194 done
6195 done
6196
6197 fi
6198 fi
6199 RUNTEST=$ac_cv_prog_RUNTEST
6200 if test -n "$RUNTEST"; then
6201   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6202 echo "${ECHO_T}$RUNTEST" >&6
6203 else
6204   echo "$as_me:$LINENO: result: no" >&5
6205 echo "${ECHO_T}no" >&6
6206 fi
6207
6208   test -n "$RUNTEST" && break
6209 done
6210 test -n "$RUNTEST" || RUNTEST="runtest"
6211
6212 case " $configdirs " in
6213   *" dejagnu "*)
6214     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6215     ;;
6216 esac
6217
6218
6219 # Host tools.
6220 ncn_tool_prefix=
6221 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6222 ncn_target_tool_prefix=
6223 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6224
6225
6226
6227 if test -n "$AR"; then
6228   ac_cv_prog_AR=$AR
6229 elif test -n "$ac_cv_prog_AR"; then
6230   AR=$ac_cv_prog_AR
6231 fi
6232
6233 if test -n "$ac_cv_prog_AR"; then
6234   for ncn_progname in ar; do
6235     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6236 set dummy ${ncn_progname}; ac_word=$2
6237 echo "$as_me:$LINENO: checking for $ac_word" >&5
6238 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6239 if test "${ac_cv_prog_AR+set}" = set; then
6240   echo $ECHO_N "(cached) $ECHO_C" >&6
6241 else
6242   if test -n "$AR"; then
6243   ac_cv_prog_AR="$AR" # Let the user override the test.
6244 else
6245 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6246 for as_dir in $PATH
6247 do
6248   IFS=$as_save_IFS
6249   test -z "$as_dir" && as_dir=.
6250   for ac_exec_ext in '' $ac_executable_extensions; do
6251   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6252     ac_cv_prog_AR="${ncn_progname}"
6253     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6254     break 2
6255   fi
6256 done
6257 done
6258
6259 fi
6260 fi
6261 AR=$ac_cv_prog_AR
6262 if test -n "$AR"; then
6263   echo "$as_me:$LINENO: result: $AR" >&5
6264 echo "${ECHO_T}$AR" >&6
6265 else
6266   echo "$as_me:$LINENO: result: no" >&5
6267 echo "${ECHO_T}no" >&6
6268 fi
6269
6270   done
6271 fi
6272
6273 for ncn_progname in ar; do
6274   if test -n "$ncn_tool_prefix"; then
6275     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6276 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6277 echo "$as_me:$LINENO: checking for $ac_word" >&5
6278 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6279 if test "${ac_cv_prog_AR+set}" = set; then
6280   echo $ECHO_N "(cached) $ECHO_C" >&6
6281 else
6282   if test -n "$AR"; then
6283   ac_cv_prog_AR="$AR" # Let the user override the test.
6284 else
6285 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6286 for as_dir in $PATH
6287 do
6288   IFS=$as_save_IFS
6289   test -z "$as_dir" && as_dir=.
6290   for ac_exec_ext in '' $ac_executable_extensions; do
6291   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6292     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6293     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6294     break 2
6295   fi
6296 done
6297 done
6298
6299 fi
6300 fi
6301 AR=$ac_cv_prog_AR
6302 if test -n "$AR"; then
6303   echo "$as_me:$LINENO: result: $AR" >&5
6304 echo "${ECHO_T}$AR" >&6
6305 else
6306   echo "$as_me:$LINENO: result: no" >&5
6307 echo "${ECHO_T}no" >&6
6308 fi
6309
6310   fi
6311   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6312     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6313 set dummy ${ncn_progname}; ac_word=$2
6314 echo "$as_me:$LINENO: checking for $ac_word" >&5
6315 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6316 if test "${ac_cv_prog_AR+set}" = set; then
6317   echo $ECHO_N "(cached) $ECHO_C" >&6
6318 else
6319   if test -n "$AR"; then
6320   ac_cv_prog_AR="$AR" # Let the user override the test.
6321 else
6322 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6323 for as_dir in $PATH
6324 do
6325   IFS=$as_save_IFS
6326   test -z "$as_dir" && as_dir=.
6327   for ac_exec_ext in '' $ac_executable_extensions; do
6328   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6329     ac_cv_prog_AR="${ncn_progname}"
6330     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6331     break 2
6332   fi
6333 done
6334 done
6335
6336 fi
6337 fi
6338 AR=$ac_cv_prog_AR
6339 if test -n "$AR"; then
6340   echo "$as_me:$LINENO: result: $AR" >&5
6341 echo "${ECHO_T}$AR" >&6
6342 else
6343   echo "$as_me:$LINENO: result: no" >&5
6344 echo "${ECHO_T}no" >&6
6345 fi
6346
6347   fi
6348   test -n "$ac_cv_prog_AR" && break
6349 done
6350
6351 if test -z "$ac_cv_prog_AR" ; then
6352   set dummy ar
6353   if test $build = $host ; then
6354     AR="$2"
6355   else
6356     AR="${ncn_tool_prefix}$2"
6357   fi
6358 fi
6359
6360
6361
6362 if test -n "$AS"; then
6363   ac_cv_prog_AS=$AS
6364 elif test -n "$ac_cv_prog_AS"; then
6365   AS=$ac_cv_prog_AS
6366 fi
6367
6368 if test -n "$ac_cv_prog_AS"; then
6369   for ncn_progname in as; do
6370     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6371 set dummy ${ncn_progname}; ac_word=$2
6372 echo "$as_me:$LINENO: checking for $ac_word" >&5
6373 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6374 if test "${ac_cv_prog_AS+set}" = set; then
6375   echo $ECHO_N "(cached) $ECHO_C" >&6
6376 else
6377   if test -n "$AS"; then
6378   ac_cv_prog_AS="$AS" # Let the user override the test.
6379 else
6380 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6381 for as_dir in $PATH
6382 do
6383   IFS=$as_save_IFS
6384   test -z "$as_dir" && as_dir=.
6385   for ac_exec_ext in '' $ac_executable_extensions; do
6386   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6387     ac_cv_prog_AS="${ncn_progname}"
6388     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6389     break 2
6390   fi
6391 done
6392 done
6393
6394 fi
6395 fi
6396 AS=$ac_cv_prog_AS
6397 if test -n "$AS"; then
6398   echo "$as_me:$LINENO: result: $AS" >&5
6399 echo "${ECHO_T}$AS" >&6
6400 else
6401   echo "$as_me:$LINENO: result: no" >&5
6402 echo "${ECHO_T}no" >&6
6403 fi
6404
6405   done
6406 fi
6407
6408 for ncn_progname in as; do
6409   if test -n "$ncn_tool_prefix"; then
6410     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6411 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6412 echo "$as_me:$LINENO: checking for $ac_word" >&5
6413 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6414 if test "${ac_cv_prog_AS+set}" = set; then
6415   echo $ECHO_N "(cached) $ECHO_C" >&6
6416 else
6417   if test -n "$AS"; then
6418   ac_cv_prog_AS="$AS" # Let the user override the test.
6419 else
6420 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6421 for as_dir in $PATH
6422 do
6423   IFS=$as_save_IFS
6424   test -z "$as_dir" && as_dir=.
6425   for ac_exec_ext in '' $ac_executable_extensions; do
6426   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6427     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6428     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6429     break 2
6430   fi
6431 done
6432 done
6433
6434 fi
6435 fi
6436 AS=$ac_cv_prog_AS
6437 if test -n "$AS"; then
6438   echo "$as_me:$LINENO: result: $AS" >&5
6439 echo "${ECHO_T}$AS" >&6
6440 else
6441   echo "$as_me:$LINENO: result: no" >&5
6442 echo "${ECHO_T}no" >&6
6443 fi
6444
6445   fi
6446   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6447     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6448 set dummy ${ncn_progname}; ac_word=$2
6449 echo "$as_me:$LINENO: checking for $ac_word" >&5
6450 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6451 if test "${ac_cv_prog_AS+set}" = set; then
6452   echo $ECHO_N "(cached) $ECHO_C" >&6
6453 else
6454   if test -n "$AS"; then
6455   ac_cv_prog_AS="$AS" # Let the user override the test.
6456 else
6457 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6458 for as_dir in $PATH
6459 do
6460   IFS=$as_save_IFS
6461   test -z "$as_dir" && as_dir=.
6462   for ac_exec_ext in '' $ac_executable_extensions; do
6463   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6464     ac_cv_prog_AS="${ncn_progname}"
6465     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6466     break 2
6467   fi
6468 done
6469 done
6470
6471 fi
6472 fi
6473 AS=$ac_cv_prog_AS
6474 if test -n "$AS"; then
6475   echo "$as_me:$LINENO: result: $AS" >&5
6476 echo "${ECHO_T}$AS" >&6
6477 else
6478   echo "$as_me:$LINENO: result: no" >&5
6479 echo "${ECHO_T}no" >&6
6480 fi
6481
6482   fi
6483   test -n "$ac_cv_prog_AS" && break
6484 done
6485
6486 if test -z "$ac_cv_prog_AS" ; then
6487   set dummy as
6488   if test $build = $host ; then
6489     AS="$2"
6490   else
6491     AS="${ncn_tool_prefix}$2"
6492   fi
6493 fi
6494
6495
6496
6497 if test -n "$DLLTOOL"; then
6498   ac_cv_prog_DLLTOOL=$DLLTOOL
6499 elif test -n "$ac_cv_prog_DLLTOOL"; then
6500   DLLTOOL=$ac_cv_prog_DLLTOOL
6501 fi
6502
6503 if test -n "$ac_cv_prog_DLLTOOL"; then
6504   for ncn_progname in dlltool; do
6505     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6506 set dummy ${ncn_progname}; ac_word=$2
6507 echo "$as_me:$LINENO: checking for $ac_word" >&5
6508 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6509 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6510   echo $ECHO_N "(cached) $ECHO_C" >&6
6511 else
6512   if test -n "$DLLTOOL"; then
6513   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6514 else
6515 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6516 for as_dir in $PATH
6517 do
6518   IFS=$as_save_IFS
6519   test -z "$as_dir" && as_dir=.
6520   for ac_exec_ext in '' $ac_executable_extensions; do
6521   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6522     ac_cv_prog_DLLTOOL="${ncn_progname}"
6523     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6524     break 2
6525   fi
6526 done
6527 done
6528
6529 fi
6530 fi
6531 DLLTOOL=$ac_cv_prog_DLLTOOL
6532 if test -n "$DLLTOOL"; then
6533   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6534 echo "${ECHO_T}$DLLTOOL" >&6
6535 else
6536   echo "$as_me:$LINENO: result: no" >&5
6537 echo "${ECHO_T}no" >&6
6538 fi
6539
6540   done
6541 fi
6542
6543 for ncn_progname in dlltool; do
6544   if test -n "$ncn_tool_prefix"; then
6545     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6546 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6547 echo "$as_me:$LINENO: checking for $ac_word" >&5
6548 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6549 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6550   echo $ECHO_N "(cached) $ECHO_C" >&6
6551 else
6552   if test -n "$DLLTOOL"; then
6553   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6554 else
6555 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6556 for as_dir in $PATH
6557 do
6558   IFS=$as_save_IFS
6559   test -z "$as_dir" && as_dir=.
6560   for ac_exec_ext in '' $ac_executable_extensions; do
6561   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6562     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6563     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6564     break 2
6565   fi
6566 done
6567 done
6568
6569 fi
6570 fi
6571 DLLTOOL=$ac_cv_prog_DLLTOOL
6572 if test -n "$DLLTOOL"; then
6573   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6574 echo "${ECHO_T}$DLLTOOL" >&6
6575 else
6576   echo "$as_me:$LINENO: result: no" >&5
6577 echo "${ECHO_T}no" >&6
6578 fi
6579
6580   fi
6581   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6582     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6583 set dummy ${ncn_progname}; ac_word=$2
6584 echo "$as_me:$LINENO: checking for $ac_word" >&5
6585 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6586 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6587   echo $ECHO_N "(cached) $ECHO_C" >&6
6588 else
6589   if test -n "$DLLTOOL"; then
6590   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6591 else
6592 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6593 for as_dir in $PATH
6594 do
6595   IFS=$as_save_IFS
6596   test -z "$as_dir" && as_dir=.
6597   for ac_exec_ext in '' $ac_executable_extensions; do
6598   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6599     ac_cv_prog_DLLTOOL="${ncn_progname}"
6600     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6601     break 2
6602   fi
6603 done
6604 done
6605
6606 fi
6607 fi
6608 DLLTOOL=$ac_cv_prog_DLLTOOL
6609 if test -n "$DLLTOOL"; then
6610   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6611 echo "${ECHO_T}$DLLTOOL" >&6
6612 else
6613   echo "$as_me:$LINENO: result: no" >&5
6614 echo "${ECHO_T}no" >&6
6615 fi
6616
6617   fi
6618   test -n "$ac_cv_prog_DLLTOOL" && break
6619 done
6620
6621 if test -z "$ac_cv_prog_DLLTOOL" ; then
6622   set dummy dlltool
6623   if test $build = $host ; then
6624     DLLTOOL="$2"
6625   else
6626     DLLTOOL="${ncn_tool_prefix}$2"
6627   fi
6628 fi
6629
6630
6631
6632 if test -n "$LD"; then
6633   ac_cv_prog_LD=$LD
6634 elif test -n "$ac_cv_prog_LD"; then
6635   LD=$ac_cv_prog_LD
6636 fi
6637
6638 if test -n "$ac_cv_prog_LD"; then
6639   for ncn_progname in ld; do
6640     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6641 set dummy ${ncn_progname}; ac_word=$2
6642 echo "$as_me:$LINENO: checking for $ac_word" >&5
6643 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6644 if test "${ac_cv_prog_LD+set}" = set; then
6645   echo $ECHO_N "(cached) $ECHO_C" >&6
6646 else
6647   if test -n "$LD"; then
6648   ac_cv_prog_LD="$LD" # Let the user override the test.
6649 else
6650 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6651 for as_dir in $PATH
6652 do
6653   IFS=$as_save_IFS
6654   test -z "$as_dir" && as_dir=.
6655   for ac_exec_ext in '' $ac_executable_extensions; do
6656   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6657     ac_cv_prog_LD="${ncn_progname}"
6658     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6659     break 2
6660   fi
6661 done
6662 done
6663
6664 fi
6665 fi
6666 LD=$ac_cv_prog_LD
6667 if test -n "$LD"; then
6668   echo "$as_me:$LINENO: result: $LD" >&5
6669 echo "${ECHO_T}$LD" >&6
6670 else
6671   echo "$as_me:$LINENO: result: no" >&5
6672 echo "${ECHO_T}no" >&6
6673 fi
6674
6675   done
6676 fi
6677
6678 for ncn_progname in ld; do
6679   if test -n "$ncn_tool_prefix"; then
6680     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6681 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6682 echo "$as_me:$LINENO: checking for $ac_word" >&5
6683 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6684 if test "${ac_cv_prog_LD+set}" = set; then
6685   echo $ECHO_N "(cached) $ECHO_C" >&6
6686 else
6687   if test -n "$LD"; then
6688   ac_cv_prog_LD="$LD" # Let the user override the test.
6689 else
6690 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6691 for as_dir in $PATH
6692 do
6693   IFS=$as_save_IFS
6694   test -z "$as_dir" && as_dir=.
6695   for ac_exec_ext in '' $ac_executable_extensions; do
6696   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6697     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6698     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6699     break 2
6700   fi
6701 done
6702 done
6703
6704 fi
6705 fi
6706 LD=$ac_cv_prog_LD
6707 if test -n "$LD"; then
6708   echo "$as_me:$LINENO: result: $LD" >&5
6709 echo "${ECHO_T}$LD" >&6
6710 else
6711   echo "$as_me:$LINENO: result: no" >&5
6712 echo "${ECHO_T}no" >&6
6713 fi
6714
6715   fi
6716   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6717     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6718 set dummy ${ncn_progname}; ac_word=$2
6719 echo "$as_me:$LINENO: checking for $ac_word" >&5
6720 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6721 if test "${ac_cv_prog_LD+set}" = set; then
6722   echo $ECHO_N "(cached) $ECHO_C" >&6
6723 else
6724   if test -n "$LD"; then
6725   ac_cv_prog_LD="$LD" # Let the user override the test.
6726 else
6727 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6728 for as_dir in $PATH
6729 do
6730   IFS=$as_save_IFS
6731   test -z "$as_dir" && as_dir=.
6732   for ac_exec_ext in '' $ac_executable_extensions; do
6733   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6734     ac_cv_prog_LD="${ncn_progname}"
6735     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6736     break 2
6737   fi
6738 done
6739 done
6740
6741 fi
6742 fi
6743 LD=$ac_cv_prog_LD
6744 if test -n "$LD"; then
6745   echo "$as_me:$LINENO: result: $LD" >&5
6746 echo "${ECHO_T}$LD" >&6
6747 else
6748   echo "$as_me:$LINENO: result: no" >&5
6749 echo "${ECHO_T}no" >&6
6750 fi
6751
6752   fi
6753   test -n "$ac_cv_prog_LD" && break
6754 done
6755
6756 if test -z "$ac_cv_prog_LD" ; then
6757   set dummy ld
6758   if test $build = $host ; then
6759     LD="$2"
6760   else
6761     LD="${ncn_tool_prefix}$2"
6762   fi
6763 fi
6764
6765
6766
6767 if test -n "$LIPO"; then
6768   ac_cv_prog_LIPO=$LIPO
6769 elif test -n "$ac_cv_prog_LIPO"; then
6770   LIPO=$ac_cv_prog_LIPO
6771 fi
6772
6773 if test -n "$ac_cv_prog_LIPO"; then
6774   for ncn_progname in lipo; do
6775     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6776 set dummy ${ncn_progname}; ac_word=$2
6777 echo "$as_me:$LINENO: checking for $ac_word" >&5
6778 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6779 if test "${ac_cv_prog_LIPO+set}" = set; then
6780   echo $ECHO_N "(cached) $ECHO_C" >&6
6781 else
6782   if test -n "$LIPO"; then
6783   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6784 else
6785 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6786 for as_dir in $PATH
6787 do
6788   IFS=$as_save_IFS
6789   test -z "$as_dir" && as_dir=.
6790   for ac_exec_ext in '' $ac_executable_extensions; do
6791   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6792     ac_cv_prog_LIPO="${ncn_progname}"
6793     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6794     break 2
6795   fi
6796 done
6797 done
6798
6799 fi
6800 fi
6801 LIPO=$ac_cv_prog_LIPO
6802 if test -n "$LIPO"; then
6803   echo "$as_me:$LINENO: result: $LIPO" >&5
6804 echo "${ECHO_T}$LIPO" >&6
6805 else
6806   echo "$as_me:$LINENO: result: no" >&5
6807 echo "${ECHO_T}no" >&6
6808 fi
6809
6810   done
6811 fi
6812
6813 for ncn_progname in lipo; do
6814   if test -n "$ncn_tool_prefix"; then
6815     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6816 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6817 echo "$as_me:$LINENO: checking for $ac_word" >&5
6818 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6819 if test "${ac_cv_prog_LIPO+set}" = set; then
6820   echo $ECHO_N "(cached) $ECHO_C" >&6
6821 else
6822   if test -n "$LIPO"; then
6823   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6824 else
6825 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6826 for as_dir in $PATH
6827 do
6828   IFS=$as_save_IFS
6829   test -z "$as_dir" && as_dir=.
6830   for ac_exec_ext in '' $ac_executable_extensions; do
6831   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6832     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6833     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6834     break 2
6835   fi
6836 done
6837 done
6838
6839 fi
6840 fi
6841 LIPO=$ac_cv_prog_LIPO
6842 if test -n "$LIPO"; then
6843   echo "$as_me:$LINENO: result: $LIPO" >&5
6844 echo "${ECHO_T}$LIPO" >&6
6845 else
6846   echo "$as_me:$LINENO: result: no" >&5
6847 echo "${ECHO_T}no" >&6
6848 fi
6849
6850   fi
6851   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6852     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6853 set dummy ${ncn_progname}; ac_word=$2
6854 echo "$as_me:$LINENO: checking for $ac_word" >&5
6855 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6856 if test "${ac_cv_prog_LIPO+set}" = set; then
6857   echo $ECHO_N "(cached) $ECHO_C" >&6
6858 else
6859   if test -n "$LIPO"; then
6860   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6861 else
6862 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6863 for as_dir in $PATH
6864 do
6865   IFS=$as_save_IFS
6866   test -z "$as_dir" && as_dir=.
6867   for ac_exec_ext in '' $ac_executable_extensions; do
6868   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6869     ac_cv_prog_LIPO="${ncn_progname}"
6870     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6871     break 2
6872   fi
6873 done
6874 done
6875
6876 fi
6877 fi
6878 LIPO=$ac_cv_prog_LIPO
6879 if test -n "$LIPO"; then
6880   echo "$as_me:$LINENO: result: $LIPO" >&5
6881 echo "${ECHO_T}$LIPO" >&6
6882 else
6883   echo "$as_me:$LINENO: result: no" >&5
6884 echo "${ECHO_T}no" >&6
6885 fi
6886
6887   fi
6888   test -n "$ac_cv_prog_LIPO" && break
6889 done
6890
6891 if test -z "$ac_cv_prog_LIPO" ; then
6892   set dummy lipo
6893   if test $build = $host ; then
6894     LIPO="$2"
6895   else
6896     LIPO="${ncn_tool_prefix}$2"
6897   fi
6898 fi
6899
6900
6901
6902 if test -n "$NM"; then
6903   ac_cv_prog_NM=$NM
6904 elif test -n "$ac_cv_prog_NM"; then
6905   NM=$ac_cv_prog_NM
6906 fi
6907
6908 if test -n "$ac_cv_prog_NM"; then
6909   for ncn_progname in nm; do
6910     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6911 set dummy ${ncn_progname}; ac_word=$2
6912 echo "$as_me:$LINENO: checking for $ac_word" >&5
6913 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6914 if test "${ac_cv_prog_NM+set}" = set; then
6915   echo $ECHO_N "(cached) $ECHO_C" >&6
6916 else
6917   if test -n "$NM"; then
6918   ac_cv_prog_NM="$NM" # Let the user override the test.
6919 else
6920 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6921 for as_dir in $PATH
6922 do
6923   IFS=$as_save_IFS
6924   test -z "$as_dir" && as_dir=.
6925   for ac_exec_ext in '' $ac_executable_extensions; do
6926   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6927     ac_cv_prog_NM="${ncn_progname}"
6928     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6929     break 2
6930   fi
6931 done
6932 done
6933
6934 fi
6935 fi
6936 NM=$ac_cv_prog_NM
6937 if test -n "$NM"; then
6938   echo "$as_me:$LINENO: result: $NM" >&5
6939 echo "${ECHO_T}$NM" >&6
6940 else
6941   echo "$as_me:$LINENO: result: no" >&5
6942 echo "${ECHO_T}no" >&6
6943 fi
6944
6945   done
6946 fi
6947
6948 for ncn_progname in nm; do
6949   if test -n "$ncn_tool_prefix"; then
6950     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6951 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6952 echo "$as_me:$LINENO: checking for $ac_word" >&5
6953 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6954 if test "${ac_cv_prog_NM+set}" = set; then
6955   echo $ECHO_N "(cached) $ECHO_C" >&6
6956 else
6957   if test -n "$NM"; then
6958   ac_cv_prog_NM="$NM" # Let the user override the test.
6959 else
6960 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6961 for as_dir in $PATH
6962 do
6963   IFS=$as_save_IFS
6964   test -z "$as_dir" && as_dir=.
6965   for ac_exec_ext in '' $ac_executable_extensions; do
6966   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6967     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
6968     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6969     break 2
6970   fi
6971 done
6972 done
6973
6974 fi
6975 fi
6976 NM=$ac_cv_prog_NM
6977 if test -n "$NM"; then
6978   echo "$as_me:$LINENO: result: $NM" >&5
6979 echo "${ECHO_T}$NM" >&6
6980 else
6981   echo "$as_me:$LINENO: result: no" >&5
6982 echo "${ECHO_T}no" >&6
6983 fi
6984
6985   fi
6986   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
6987     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6988 set dummy ${ncn_progname}; ac_word=$2
6989 echo "$as_me:$LINENO: checking for $ac_word" >&5
6990 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6991 if test "${ac_cv_prog_NM+set}" = set; then
6992   echo $ECHO_N "(cached) $ECHO_C" >&6
6993 else
6994   if test -n "$NM"; then
6995   ac_cv_prog_NM="$NM" # Let the user override the test.
6996 else
6997 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6998 for as_dir in $PATH
6999 do
7000   IFS=$as_save_IFS
7001   test -z "$as_dir" && as_dir=.
7002   for ac_exec_ext in '' $ac_executable_extensions; do
7003   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7004     ac_cv_prog_NM="${ncn_progname}"
7005     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7006     break 2
7007   fi
7008 done
7009 done
7010
7011 fi
7012 fi
7013 NM=$ac_cv_prog_NM
7014 if test -n "$NM"; then
7015   echo "$as_me:$LINENO: result: $NM" >&5
7016 echo "${ECHO_T}$NM" >&6
7017 else
7018   echo "$as_me:$LINENO: result: no" >&5
7019 echo "${ECHO_T}no" >&6
7020 fi
7021
7022   fi
7023   test -n "$ac_cv_prog_NM" && break
7024 done
7025
7026 if test -z "$ac_cv_prog_NM" ; then
7027   set dummy nm
7028   if test $build = $host ; then
7029     NM="$2"
7030   else
7031     NM="${ncn_tool_prefix}$2"
7032   fi
7033 fi
7034
7035
7036
7037 if test -n "$RANLIB"; then
7038   ac_cv_prog_RANLIB=$RANLIB
7039 elif test -n "$ac_cv_prog_RANLIB"; then
7040   RANLIB=$ac_cv_prog_RANLIB
7041 fi
7042
7043 if test -n "$ac_cv_prog_RANLIB"; then
7044   for ncn_progname in ranlib; do
7045     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7046 set dummy ${ncn_progname}; ac_word=$2
7047 echo "$as_me:$LINENO: checking for $ac_word" >&5
7048 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7049 if test "${ac_cv_prog_RANLIB+set}" = set; then
7050   echo $ECHO_N "(cached) $ECHO_C" >&6
7051 else
7052   if test -n "$RANLIB"; then
7053   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7054 else
7055 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7056 for as_dir in $PATH
7057 do
7058   IFS=$as_save_IFS
7059   test -z "$as_dir" && as_dir=.
7060   for ac_exec_ext in '' $ac_executable_extensions; do
7061   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7062     ac_cv_prog_RANLIB="${ncn_progname}"
7063     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7064     break 2
7065   fi
7066 done
7067 done
7068
7069 fi
7070 fi
7071 RANLIB=$ac_cv_prog_RANLIB
7072 if test -n "$RANLIB"; then
7073   echo "$as_me:$LINENO: result: $RANLIB" >&5
7074 echo "${ECHO_T}$RANLIB" >&6
7075 else
7076   echo "$as_me:$LINENO: result: no" >&5
7077 echo "${ECHO_T}no" >&6
7078 fi
7079
7080   done
7081 fi
7082
7083 for ncn_progname in ranlib; do
7084   if test -n "$ncn_tool_prefix"; then
7085     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7086 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7087 echo "$as_me:$LINENO: checking for $ac_word" >&5
7088 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7089 if test "${ac_cv_prog_RANLIB+set}" = set; then
7090   echo $ECHO_N "(cached) $ECHO_C" >&6
7091 else
7092   if test -n "$RANLIB"; then
7093   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7094 else
7095 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7096 for as_dir in $PATH
7097 do
7098   IFS=$as_save_IFS
7099   test -z "$as_dir" && as_dir=.
7100   for ac_exec_ext in '' $ac_executable_extensions; do
7101   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7102     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7103     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7104     break 2
7105   fi
7106 done
7107 done
7108
7109 fi
7110 fi
7111 RANLIB=$ac_cv_prog_RANLIB
7112 if test -n "$RANLIB"; then
7113   echo "$as_me:$LINENO: result: $RANLIB" >&5
7114 echo "${ECHO_T}$RANLIB" >&6
7115 else
7116   echo "$as_me:$LINENO: result: no" >&5
7117 echo "${ECHO_T}no" >&6
7118 fi
7119
7120   fi
7121   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7122     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7123 set dummy ${ncn_progname}; ac_word=$2
7124 echo "$as_me:$LINENO: checking for $ac_word" >&5
7125 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7126 if test "${ac_cv_prog_RANLIB+set}" = set; then
7127   echo $ECHO_N "(cached) $ECHO_C" >&6
7128 else
7129   if test -n "$RANLIB"; then
7130   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7131 else
7132 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7133 for as_dir in $PATH
7134 do
7135   IFS=$as_save_IFS
7136   test -z "$as_dir" && as_dir=.
7137   for ac_exec_ext in '' $ac_executable_extensions; do
7138   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7139     ac_cv_prog_RANLIB="${ncn_progname}"
7140     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7141     break 2
7142   fi
7143 done
7144 done
7145
7146 fi
7147 fi
7148 RANLIB=$ac_cv_prog_RANLIB
7149 if test -n "$RANLIB"; then
7150   echo "$as_me:$LINENO: result: $RANLIB" >&5
7151 echo "${ECHO_T}$RANLIB" >&6
7152 else
7153   echo "$as_me:$LINENO: result: no" >&5
7154 echo "${ECHO_T}no" >&6
7155 fi
7156
7157   fi
7158   test -n "$ac_cv_prog_RANLIB" && break
7159 done
7160
7161 if test -z "$ac_cv_prog_RANLIB" ; then
7162   RANLIB=":"
7163 fi
7164
7165
7166
7167 if test -n "$STRIP"; then
7168   ac_cv_prog_STRIP=$STRIP
7169 elif test -n "$ac_cv_prog_STRIP"; then
7170   STRIP=$ac_cv_prog_STRIP
7171 fi
7172
7173 if test -n "$ac_cv_prog_STRIP"; then
7174   for ncn_progname in strip; do
7175     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7176 set dummy ${ncn_progname}; ac_word=$2
7177 echo "$as_me:$LINENO: checking for $ac_word" >&5
7178 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7179 if test "${ac_cv_prog_STRIP+set}" = set; then
7180   echo $ECHO_N "(cached) $ECHO_C" >&6
7181 else
7182   if test -n "$STRIP"; then
7183   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7184 else
7185 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7186 for as_dir in $PATH
7187 do
7188   IFS=$as_save_IFS
7189   test -z "$as_dir" && as_dir=.
7190   for ac_exec_ext in '' $ac_executable_extensions; do
7191   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7192     ac_cv_prog_STRIP="${ncn_progname}"
7193     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7194     break 2
7195   fi
7196 done
7197 done
7198
7199 fi
7200 fi
7201 STRIP=$ac_cv_prog_STRIP
7202 if test -n "$STRIP"; then
7203   echo "$as_me:$LINENO: result: $STRIP" >&5
7204 echo "${ECHO_T}$STRIP" >&6
7205 else
7206   echo "$as_me:$LINENO: result: no" >&5
7207 echo "${ECHO_T}no" >&6
7208 fi
7209
7210   done
7211 fi
7212
7213 for ncn_progname in strip; do
7214   if test -n "$ncn_tool_prefix"; then
7215     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7216 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7217 echo "$as_me:$LINENO: checking for $ac_word" >&5
7218 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7219 if test "${ac_cv_prog_STRIP+set}" = set; then
7220   echo $ECHO_N "(cached) $ECHO_C" >&6
7221 else
7222   if test -n "$STRIP"; then
7223   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7224 else
7225 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7226 for as_dir in $PATH
7227 do
7228   IFS=$as_save_IFS
7229   test -z "$as_dir" && as_dir=.
7230   for ac_exec_ext in '' $ac_executable_extensions; do
7231   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7232     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7233     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7234     break 2
7235   fi
7236 done
7237 done
7238
7239 fi
7240 fi
7241 STRIP=$ac_cv_prog_STRIP
7242 if test -n "$STRIP"; then
7243   echo "$as_me:$LINENO: result: $STRIP" >&5
7244 echo "${ECHO_T}$STRIP" >&6
7245 else
7246   echo "$as_me:$LINENO: result: no" >&5
7247 echo "${ECHO_T}no" >&6
7248 fi
7249
7250   fi
7251   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7252     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7253 set dummy ${ncn_progname}; ac_word=$2
7254 echo "$as_me:$LINENO: checking for $ac_word" >&5
7255 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7256 if test "${ac_cv_prog_STRIP+set}" = set; then
7257   echo $ECHO_N "(cached) $ECHO_C" >&6
7258 else
7259   if test -n "$STRIP"; then
7260   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7261 else
7262 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7263 for as_dir in $PATH
7264 do
7265   IFS=$as_save_IFS
7266   test -z "$as_dir" && as_dir=.
7267   for ac_exec_ext in '' $ac_executable_extensions; do
7268   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7269     ac_cv_prog_STRIP="${ncn_progname}"
7270     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7271     break 2
7272   fi
7273 done
7274 done
7275
7276 fi
7277 fi
7278 STRIP=$ac_cv_prog_STRIP
7279 if test -n "$STRIP"; then
7280   echo "$as_me:$LINENO: result: $STRIP" >&5
7281 echo "${ECHO_T}$STRIP" >&6
7282 else
7283   echo "$as_me:$LINENO: result: no" >&5
7284 echo "${ECHO_T}no" >&6
7285 fi
7286
7287   fi
7288   test -n "$ac_cv_prog_STRIP" && break
7289 done
7290
7291 if test -z "$ac_cv_prog_STRIP" ; then
7292   STRIP=":"
7293 fi
7294
7295
7296
7297 if test -n "$WINDRES"; then
7298   ac_cv_prog_WINDRES=$WINDRES
7299 elif test -n "$ac_cv_prog_WINDRES"; then
7300   WINDRES=$ac_cv_prog_WINDRES
7301 fi
7302
7303 if test -n "$ac_cv_prog_WINDRES"; then
7304   for ncn_progname in windres; do
7305     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7306 set dummy ${ncn_progname}; ac_word=$2
7307 echo "$as_me:$LINENO: checking for $ac_word" >&5
7308 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7309 if test "${ac_cv_prog_WINDRES+set}" = set; then
7310   echo $ECHO_N "(cached) $ECHO_C" >&6
7311 else
7312   if test -n "$WINDRES"; then
7313   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7314 else
7315 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7316 for as_dir in $PATH
7317 do
7318   IFS=$as_save_IFS
7319   test -z "$as_dir" && as_dir=.
7320   for ac_exec_ext in '' $ac_executable_extensions; do
7321   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7322     ac_cv_prog_WINDRES="${ncn_progname}"
7323     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7324     break 2
7325   fi
7326 done
7327 done
7328
7329 fi
7330 fi
7331 WINDRES=$ac_cv_prog_WINDRES
7332 if test -n "$WINDRES"; then
7333   echo "$as_me:$LINENO: result: $WINDRES" >&5
7334 echo "${ECHO_T}$WINDRES" >&6
7335 else
7336   echo "$as_me:$LINENO: result: no" >&5
7337 echo "${ECHO_T}no" >&6
7338 fi
7339
7340   done
7341 fi
7342
7343 for ncn_progname in windres; do
7344   if test -n "$ncn_tool_prefix"; then
7345     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7346 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7347 echo "$as_me:$LINENO: checking for $ac_word" >&5
7348 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7349 if test "${ac_cv_prog_WINDRES+set}" = set; then
7350   echo $ECHO_N "(cached) $ECHO_C" >&6
7351 else
7352   if test -n "$WINDRES"; then
7353   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7354 else
7355 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7356 for as_dir in $PATH
7357 do
7358   IFS=$as_save_IFS
7359   test -z "$as_dir" && as_dir=.
7360   for ac_exec_ext in '' $ac_executable_extensions; do
7361   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7362     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7363     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7364     break 2
7365   fi
7366 done
7367 done
7368
7369 fi
7370 fi
7371 WINDRES=$ac_cv_prog_WINDRES
7372 if test -n "$WINDRES"; then
7373   echo "$as_me:$LINENO: result: $WINDRES" >&5
7374 echo "${ECHO_T}$WINDRES" >&6
7375 else
7376   echo "$as_me:$LINENO: result: no" >&5
7377 echo "${ECHO_T}no" >&6
7378 fi
7379
7380   fi
7381   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7382     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7383 set dummy ${ncn_progname}; ac_word=$2
7384 echo "$as_me:$LINENO: checking for $ac_word" >&5
7385 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7386 if test "${ac_cv_prog_WINDRES+set}" = set; then
7387   echo $ECHO_N "(cached) $ECHO_C" >&6
7388 else
7389   if test -n "$WINDRES"; then
7390   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7391 else
7392 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7393 for as_dir in $PATH
7394 do
7395   IFS=$as_save_IFS
7396   test -z "$as_dir" && as_dir=.
7397   for ac_exec_ext in '' $ac_executable_extensions; do
7398   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7399     ac_cv_prog_WINDRES="${ncn_progname}"
7400     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7401     break 2
7402   fi
7403 done
7404 done
7405
7406 fi
7407 fi
7408 WINDRES=$ac_cv_prog_WINDRES
7409 if test -n "$WINDRES"; then
7410   echo "$as_me:$LINENO: result: $WINDRES" >&5
7411 echo "${ECHO_T}$WINDRES" >&6
7412 else
7413   echo "$as_me:$LINENO: result: no" >&5
7414 echo "${ECHO_T}no" >&6
7415 fi
7416
7417   fi
7418   test -n "$ac_cv_prog_WINDRES" && break
7419 done
7420
7421 if test -z "$ac_cv_prog_WINDRES" ; then
7422   set dummy windres
7423   if test $build = $host ; then
7424     WINDRES="$2"
7425   else
7426     WINDRES="${ncn_tool_prefix}$2"
7427   fi
7428 fi
7429
7430
7431
7432 if test -n "$OBJCOPY"; then
7433   ac_cv_prog_OBJCOPY=$OBJCOPY
7434 elif test -n "$ac_cv_prog_OBJCOPY"; then
7435   OBJCOPY=$ac_cv_prog_OBJCOPY
7436 fi
7437
7438 if test -n "$ac_cv_prog_OBJCOPY"; then
7439   for ncn_progname in objcopy; do
7440     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7441 set dummy ${ncn_progname}; ac_word=$2
7442 echo "$as_me:$LINENO: checking for $ac_word" >&5
7443 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7444 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7445   echo $ECHO_N "(cached) $ECHO_C" >&6
7446 else
7447   if test -n "$OBJCOPY"; then
7448   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7449 else
7450 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7451 for as_dir in $PATH
7452 do
7453   IFS=$as_save_IFS
7454   test -z "$as_dir" && as_dir=.
7455   for ac_exec_ext in '' $ac_executable_extensions; do
7456   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7457     ac_cv_prog_OBJCOPY="${ncn_progname}"
7458     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7459     break 2
7460   fi
7461 done
7462 done
7463
7464 fi
7465 fi
7466 OBJCOPY=$ac_cv_prog_OBJCOPY
7467 if test -n "$OBJCOPY"; then
7468   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7469 echo "${ECHO_T}$OBJCOPY" >&6
7470 else
7471   echo "$as_me:$LINENO: result: no" >&5
7472 echo "${ECHO_T}no" >&6
7473 fi
7474
7475   done
7476 fi
7477
7478 for ncn_progname in objcopy; do
7479   if test -n "$ncn_tool_prefix"; then
7480     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7481 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7482 echo "$as_me:$LINENO: checking for $ac_word" >&5
7483 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7484 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7485   echo $ECHO_N "(cached) $ECHO_C" >&6
7486 else
7487   if test -n "$OBJCOPY"; then
7488   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7489 else
7490 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7491 for as_dir in $PATH
7492 do
7493   IFS=$as_save_IFS
7494   test -z "$as_dir" && as_dir=.
7495   for ac_exec_ext in '' $ac_executable_extensions; do
7496   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7497     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7498     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7499     break 2
7500   fi
7501 done
7502 done
7503
7504 fi
7505 fi
7506 OBJCOPY=$ac_cv_prog_OBJCOPY
7507 if test -n "$OBJCOPY"; then
7508   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7509 echo "${ECHO_T}$OBJCOPY" >&6
7510 else
7511   echo "$as_me:$LINENO: result: no" >&5
7512 echo "${ECHO_T}no" >&6
7513 fi
7514
7515   fi
7516   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7517     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7518 set dummy ${ncn_progname}; ac_word=$2
7519 echo "$as_me:$LINENO: checking for $ac_word" >&5
7520 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7521 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7522   echo $ECHO_N "(cached) $ECHO_C" >&6
7523 else
7524   if test -n "$OBJCOPY"; then
7525   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7526 else
7527 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7528 for as_dir in $PATH
7529 do
7530   IFS=$as_save_IFS
7531   test -z "$as_dir" && as_dir=.
7532   for ac_exec_ext in '' $ac_executable_extensions; do
7533   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7534     ac_cv_prog_OBJCOPY="${ncn_progname}"
7535     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7536     break 2
7537   fi
7538 done
7539 done
7540
7541 fi
7542 fi
7543 OBJCOPY=$ac_cv_prog_OBJCOPY
7544 if test -n "$OBJCOPY"; then
7545   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7546 echo "${ECHO_T}$OBJCOPY" >&6
7547 else
7548   echo "$as_me:$LINENO: result: no" >&5
7549 echo "${ECHO_T}no" >&6
7550 fi
7551
7552   fi
7553   test -n "$ac_cv_prog_OBJCOPY" && break
7554 done
7555
7556 if test -z "$ac_cv_prog_OBJCOPY" ; then
7557   set dummy objcopy
7558   if test $build = $host ; then
7559     OBJCOPY="$2"
7560   else
7561     OBJCOPY="${ncn_tool_prefix}$2"
7562   fi
7563 fi
7564
7565
7566
7567 if test -n "$OBJDUMP"; then
7568   ac_cv_prog_OBJDUMP=$OBJDUMP
7569 elif test -n "$ac_cv_prog_OBJDUMP"; then
7570   OBJDUMP=$ac_cv_prog_OBJDUMP
7571 fi
7572
7573 if test -n "$ac_cv_prog_OBJDUMP"; then
7574   for ncn_progname in objdump; do
7575     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7576 set dummy ${ncn_progname}; ac_word=$2
7577 echo "$as_me:$LINENO: checking for $ac_word" >&5
7578 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7579 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7580   echo $ECHO_N "(cached) $ECHO_C" >&6
7581 else
7582   if test -n "$OBJDUMP"; then
7583   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7584 else
7585 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7586 for as_dir in $PATH
7587 do
7588   IFS=$as_save_IFS
7589   test -z "$as_dir" && as_dir=.
7590   for ac_exec_ext in '' $ac_executable_extensions; do
7591   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7592     ac_cv_prog_OBJDUMP="${ncn_progname}"
7593     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7594     break 2
7595   fi
7596 done
7597 done
7598
7599 fi
7600 fi
7601 OBJDUMP=$ac_cv_prog_OBJDUMP
7602 if test -n "$OBJDUMP"; then
7603   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7604 echo "${ECHO_T}$OBJDUMP" >&6
7605 else
7606   echo "$as_me:$LINENO: result: no" >&5
7607 echo "${ECHO_T}no" >&6
7608 fi
7609
7610   done
7611 fi
7612
7613 for ncn_progname in objdump; do
7614   if test -n "$ncn_tool_prefix"; then
7615     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7616 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7617 echo "$as_me:$LINENO: checking for $ac_word" >&5
7618 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7619 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7620   echo $ECHO_N "(cached) $ECHO_C" >&6
7621 else
7622   if test -n "$OBJDUMP"; then
7623   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7624 else
7625 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7626 for as_dir in $PATH
7627 do
7628   IFS=$as_save_IFS
7629   test -z "$as_dir" && as_dir=.
7630   for ac_exec_ext in '' $ac_executable_extensions; do
7631   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7632     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7633     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7634     break 2
7635   fi
7636 done
7637 done
7638
7639 fi
7640 fi
7641 OBJDUMP=$ac_cv_prog_OBJDUMP
7642 if test -n "$OBJDUMP"; then
7643   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7644 echo "${ECHO_T}$OBJDUMP" >&6
7645 else
7646   echo "$as_me:$LINENO: result: no" >&5
7647 echo "${ECHO_T}no" >&6
7648 fi
7649
7650   fi
7651   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7652     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7653 set dummy ${ncn_progname}; ac_word=$2
7654 echo "$as_me:$LINENO: checking for $ac_word" >&5
7655 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7656 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7657   echo $ECHO_N "(cached) $ECHO_C" >&6
7658 else
7659   if test -n "$OBJDUMP"; then
7660   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7661 else
7662 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7663 for as_dir in $PATH
7664 do
7665   IFS=$as_save_IFS
7666   test -z "$as_dir" && as_dir=.
7667   for ac_exec_ext in '' $ac_executable_extensions; do
7668   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7669     ac_cv_prog_OBJDUMP="${ncn_progname}"
7670     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7671     break 2
7672   fi
7673 done
7674 done
7675
7676 fi
7677 fi
7678 OBJDUMP=$ac_cv_prog_OBJDUMP
7679 if test -n "$OBJDUMP"; then
7680   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7681 echo "${ECHO_T}$OBJDUMP" >&6
7682 else
7683   echo "$as_me:$LINENO: result: no" >&5
7684 echo "${ECHO_T}no" >&6
7685 fi
7686
7687   fi
7688   test -n "$ac_cv_prog_OBJDUMP" && break
7689 done
7690
7691 if test -z "$ac_cv_prog_OBJDUMP" ; then
7692   set dummy objdump
7693   if test $build = $host ; then
7694     OBJDUMP="$2"
7695   else
7696     OBJDUMP="${ncn_tool_prefix}$2"
7697   fi
7698 fi
7699
7700
7701
7702
7703
7704
7705
7706 # Target tools.
7707
7708 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7709 if test "${with_build_time_tools+set}" = set; then
7710   withval="$with_build_time_tools"
7711   case x"$withval" in
7712      x/*) ;;
7713      *)
7714        with_build_time_tools=
7715        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7716 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7717        ;;
7718    esac
7719 else
7720   with_build_time_tools=
7721 fi;
7722
7723
7724
7725 if test -n "$CC_FOR_TARGET"; then
7726   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7727 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7728   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7729 fi
7730
7731 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7732   for ncn_progname in cc gcc; do
7733     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7734 set dummy ${ncn_progname}; ac_word=$2
7735 echo "$as_me:$LINENO: checking for $ac_word" >&5
7736 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7737 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7738   echo $ECHO_N "(cached) $ECHO_C" >&6
7739 else
7740   if test -n "$CC_FOR_TARGET"; then
7741   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7742 else
7743 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7744 for as_dir in $PATH
7745 do
7746   IFS=$as_save_IFS
7747   test -z "$as_dir" && as_dir=.
7748   for ac_exec_ext in '' $ac_executable_extensions; do
7749   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7750     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7751     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7752     break 2
7753   fi
7754 done
7755 done
7756
7757 fi
7758 fi
7759 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7760 if test -n "$CC_FOR_TARGET"; then
7761   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7762 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7763 else
7764   echo "$as_me:$LINENO: result: no" >&5
7765 echo "${ECHO_T}no" >&6
7766 fi
7767
7768   done
7769 fi
7770
7771 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
7772   for ncn_progname in cc gcc; do
7773     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7774 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7775     if test -x $with_build_time_tools/${ncn_progname}; then
7776       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7777       echo "$as_me:$LINENO: result: yes" >&5
7778 echo "${ECHO_T}yes" >&6
7779       break
7780     else
7781       echo "$as_me:$LINENO: result: no" >&5
7782 echo "${ECHO_T}no" >&6
7783     fi
7784   done
7785 fi
7786
7787 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
7788   for ncn_progname in cc gcc; do
7789     if test -n "$ncn_target_tool_prefix"; then
7790       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
7791 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
7792 echo "$as_me:$LINENO: checking for $ac_word" >&5
7793 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7794 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7795   echo $ECHO_N "(cached) $ECHO_C" >&6
7796 else
7797   if test -n "$CC_FOR_TARGET"; then
7798   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7799 else
7800 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7801 for as_dir in $PATH
7802 do
7803   IFS=$as_save_IFS
7804   test -z "$as_dir" && as_dir=.
7805   for ac_exec_ext in '' $ac_executable_extensions; do
7806   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7807     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
7808     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7809     break 2
7810   fi
7811 done
7812 done
7813
7814 fi
7815 fi
7816 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7817 if test -n "$CC_FOR_TARGET"; then
7818   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7819 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7820 else
7821   echo "$as_me:$LINENO: result: no" >&5
7822 echo "${ECHO_T}no" >&6
7823 fi
7824
7825     fi
7826     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
7827       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7828 set dummy ${ncn_progname}; ac_word=$2
7829 echo "$as_me:$LINENO: checking for $ac_word" >&5
7830 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7831 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7832   echo $ECHO_N "(cached) $ECHO_C" >&6
7833 else
7834   if test -n "$CC_FOR_TARGET"; then
7835   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7836 else
7837 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7838 for as_dir in $PATH
7839 do
7840   IFS=$as_save_IFS
7841   test -z "$as_dir" && as_dir=.
7842   for ac_exec_ext in '' $ac_executable_extensions; do
7843   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7844     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7845     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7846     break 2
7847   fi
7848 done
7849 done
7850
7851 fi
7852 fi
7853 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7854 if test -n "$CC_FOR_TARGET"; then
7855   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7856 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7857 else
7858   echo "$as_me:$LINENO: result: no" >&5
7859 echo "${ECHO_T}no" >&6
7860 fi
7861
7862     fi
7863     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
7864   done
7865 fi
7866
7867 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
7868   set dummy cc gcc
7869   if test $build = $target ; then
7870     CC_FOR_TARGET="$2"
7871   else
7872     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
7873   fi
7874 fi
7875
7876
7877
7878 if test -n "$CXX_FOR_TARGET"; then
7879   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
7880 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
7881   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7882 fi
7883
7884 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
7885   for ncn_progname in c++ g++ cxx gxx; do
7886     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7887 set dummy ${ncn_progname}; ac_word=$2
7888 echo "$as_me:$LINENO: checking for $ac_word" >&5
7889 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7890 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
7891   echo $ECHO_N "(cached) $ECHO_C" >&6
7892 else
7893   if test -n "$CXX_FOR_TARGET"; then
7894   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
7895 else
7896 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7897 for as_dir in $PATH
7898 do
7899   IFS=$as_save_IFS
7900   test -z "$as_dir" && as_dir=.
7901   for ac_exec_ext in '' $ac_executable_extensions; do
7902   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7903     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
7904     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7905     break 2
7906   fi
7907 done
7908 done
7909
7910 fi
7911 fi
7912 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7913 if test -n "$CXX_FOR_TARGET"; then
7914   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
7915 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
7916 else
7917   echo "$as_me:$LINENO: result: no" >&5
7918 echo "${ECHO_T}no" >&6
7919 fi
7920
7921   done
7922 fi
7923
7924 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
7925   for ncn_progname in c++ g++ cxx gxx; do
7926     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7927 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7928     if test -x $with_build_time_tools/${ncn_progname}; then
7929       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7930       echo "$as_me:$LINENO: result: yes" >&5
7931 echo "${ECHO_T}yes" >&6
7932       break
7933     else
7934       echo "$as_me:$LINENO: result: no" >&5
7935 echo "${ECHO_T}no" >&6
7936     fi
7937   done
7938 fi
7939
7940 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
7941   for ncn_progname in c++ g++ cxx gxx; do
7942     if test -n "$ncn_target_tool_prefix"; then
7943       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
7944 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
7945 echo "$as_me:$LINENO: checking for $ac_word" >&5
7946 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7947 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
7948   echo $ECHO_N "(cached) $ECHO_C" >&6
7949 else
7950   if test -n "$CXX_FOR_TARGET"; then
7951   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
7952 else
7953 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7954 for as_dir in $PATH
7955 do
7956   IFS=$as_save_IFS
7957   test -z "$as_dir" && as_dir=.
7958   for ac_exec_ext in '' $ac_executable_extensions; do
7959   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7960     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
7961     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7962     break 2
7963   fi
7964 done
7965 done
7966
7967 fi
7968 fi
7969 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7970 if test -n "$CXX_FOR_TARGET"; then
7971   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
7972 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
7973 else
7974   echo "$as_me:$LINENO: result: no" >&5
7975 echo "${ECHO_T}no" >&6
7976 fi
7977
7978     fi
7979     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
7980       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7981 set dummy ${ncn_progname}; ac_word=$2
7982 echo "$as_me:$LINENO: checking for $ac_word" >&5
7983 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7984 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
7985   echo $ECHO_N "(cached) $ECHO_C" >&6
7986 else
7987   if test -n "$CXX_FOR_TARGET"; then
7988   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
7989 else
7990 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7991 for as_dir in $PATH
7992 do
7993   IFS=$as_save_IFS
7994   test -z "$as_dir" && as_dir=.
7995   for ac_exec_ext in '' $ac_executable_extensions; do
7996   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7997     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
7998     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7999     break 2
8000   fi
8001 done
8002 done
8003
8004 fi
8005 fi
8006 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8007 if test -n "$CXX_FOR_TARGET"; then
8008   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8009 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8010 else
8011   echo "$as_me:$LINENO: result: no" >&5
8012 echo "${ECHO_T}no" >&6
8013 fi
8014
8015     fi
8016     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8017   done
8018 fi
8019
8020 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8021   set dummy c++ g++ cxx gxx
8022   if test $build = $target ; then
8023     CXX_FOR_TARGET="$2"
8024   else
8025     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8026   fi
8027 fi
8028
8029
8030
8031 if test -n "$GCC_FOR_TARGET"; then
8032   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8033 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8034   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8035 fi
8036
8037 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8038   for ncn_progname in gcc; do
8039     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8040 set dummy ${ncn_progname}; ac_word=$2
8041 echo "$as_me:$LINENO: checking for $ac_word" >&5
8042 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8043 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8044   echo $ECHO_N "(cached) $ECHO_C" >&6
8045 else
8046   if test -n "$GCC_FOR_TARGET"; then
8047   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8048 else
8049 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8050 for as_dir in $PATH
8051 do
8052   IFS=$as_save_IFS
8053   test -z "$as_dir" && as_dir=.
8054   for ac_exec_ext in '' $ac_executable_extensions; do
8055   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8056     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8057     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8058     break 2
8059   fi
8060 done
8061 done
8062
8063 fi
8064 fi
8065 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8066 if test -n "$GCC_FOR_TARGET"; then
8067   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8068 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8069 else
8070   echo "$as_me:$LINENO: result: no" >&5
8071 echo "${ECHO_T}no" >&6
8072 fi
8073
8074   done
8075 fi
8076
8077 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8078   for ncn_progname in gcc; do
8079     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8080 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8081     if test -x $with_build_time_tools/${ncn_progname}; then
8082       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8083       echo "$as_me:$LINENO: result: yes" >&5
8084 echo "${ECHO_T}yes" >&6
8085       break
8086     else
8087       echo "$as_me:$LINENO: result: no" >&5
8088 echo "${ECHO_T}no" >&6
8089     fi
8090   done
8091 fi
8092
8093 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8094   for ncn_progname in gcc; do
8095     if test -n "$ncn_target_tool_prefix"; then
8096       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8097 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8098 echo "$as_me:$LINENO: checking for $ac_word" >&5
8099 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8100 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8101   echo $ECHO_N "(cached) $ECHO_C" >&6
8102 else
8103   if test -n "$GCC_FOR_TARGET"; then
8104   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8105 else
8106 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8107 for as_dir in $PATH
8108 do
8109   IFS=$as_save_IFS
8110   test -z "$as_dir" && as_dir=.
8111   for ac_exec_ext in '' $ac_executable_extensions; do
8112   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8113     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8114     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8115     break 2
8116   fi
8117 done
8118 done
8119
8120 fi
8121 fi
8122 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8123 if test -n "$GCC_FOR_TARGET"; then
8124   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8125 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8126 else
8127   echo "$as_me:$LINENO: result: no" >&5
8128 echo "${ECHO_T}no" >&6
8129 fi
8130
8131     fi
8132     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8133       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8134 set dummy ${ncn_progname}; ac_word=$2
8135 echo "$as_me:$LINENO: checking for $ac_word" >&5
8136 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8137 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8138   echo $ECHO_N "(cached) $ECHO_C" >&6
8139 else
8140   if test -n "$GCC_FOR_TARGET"; then
8141   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8142 else
8143 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8144 for as_dir in $PATH
8145 do
8146   IFS=$as_save_IFS
8147   test -z "$as_dir" && as_dir=.
8148   for ac_exec_ext in '' $ac_executable_extensions; do
8149   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8150     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8151     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8152     break 2
8153   fi
8154 done
8155 done
8156
8157 fi
8158 fi
8159 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8160 if test -n "$GCC_FOR_TARGET"; then
8161   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8162 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8163 else
8164   echo "$as_me:$LINENO: result: no" >&5
8165 echo "${ECHO_T}no" >&6
8166 fi
8167
8168     fi
8169     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8170   done
8171 fi
8172
8173 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8174   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8175 fi
8176
8177
8178
8179 if test -n "$GCJ_FOR_TARGET"; then
8180   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8181 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8182   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8183 fi
8184
8185 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8186   for ncn_progname in gcj; do
8187     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8188 set dummy ${ncn_progname}; ac_word=$2
8189 echo "$as_me:$LINENO: checking for $ac_word" >&5
8190 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8191 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8192   echo $ECHO_N "(cached) $ECHO_C" >&6
8193 else
8194   if test -n "$GCJ_FOR_TARGET"; then
8195   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8196 else
8197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8198 for as_dir in $PATH
8199 do
8200   IFS=$as_save_IFS
8201   test -z "$as_dir" && as_dir=.
8202   for ac_exec_ext in '' $ac_executable_extensions; do
8203   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8204     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8205     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8206     break 2
8207   fi
8208 done
8209 done
8210
8211 fi
8212 fi
8213 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8214 if test -n "$GCJ_FOR_TARGET"; then
8215   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8216 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8217 else
8218   echo "$as_me:$LINENO: result: no" >&5
8219 echo "${ECHO_T}no" >&6
8220 fi
8221
8222   done
8223 fi
8224
8225 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8226   for ncn_progname in gcj; do
8227     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8228 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8229     if test -x $with_build_time_tools/${ncn_progname}; then
8230       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8231       echo "$as_me:$LINENO: result: yes" >&5
8232 echo "${ECHO_T}yes" >&6
8233       break
8234     else
8235       echo "$as_me:$LINENO: result: no" >&5
8236 echo "${ECHO_T}no" >&6
8237     fi
8238   done
8239 fi
8240
8241 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8242   for ncn_progname in gcj; do
8243     if test -n "$ncn_target_tool_prefix"; then
8244       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8245 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8246 echo "$as_me:$LINENO: checking for $ac_word" >&5
8247 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8248 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8249   echo $ECHO_N "(cached) $ECHO_C" >&6
8250 else
8251   if test -n "$GCJ_FOR_TARGET"; then
8252   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8253 else
8254 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8255 for as_dir in $PATH
8256 do
8257   IFS=$as_save_IFS
8258   test -z "$as_dir" && as_dir=.
8259   for ac_exec_ext in '' $ac_executable_extensions; do
8260   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8261     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8262     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8263     break 2
8264   fi
8265 done
8266 done
8267
8268 fi
8269 fi
8270 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8271 if test -n "$GCJ_FOR_TARGET"; then
8272   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8273 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8274 else
8275   echo "$as_me:$LINENO: result: no" >&5
8276 echo "${ECHO_T}no" >&6
8277 fi
8278
8279     fi
8280     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8281       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8282 set dummy ${ncn_progname}; ac_word=$2
8283 echo "$as_me:$LINENO: checking for $ac_word" >&5
8284 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8285 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8286   echo $ECHO_N "(cached) $ECHO_C" >&6
8287 else
8288   if test -n "$GCJ_FOR_TARGET"; then
8289   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8290 else
8291 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8292 for as_dir in $PATH
8293 do
8294   IFS=$as_save_IFS
8295   test -z "$as_dir" && as_dir=.
8296   for ac_exec_ext in '' $ac_executable_extensions; do
8297   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8298     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8299     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8300     break 2
8301   fi
8302 done
8303 done
8304
8305 fi
8306 fi
8307 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8308 if test -n "$GCJ_FOR_TARGET"; then
8309   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8310 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8311 else
8312   echo "$as_me:$LINENO: result: no" >&5
8313 echo "${ECHO_T}no" >&6
8314 fi
8315
8316     fi
8317     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8318   done
8319 fi
8320
8321 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8322   set dummy gcj
8323   if test $build = $target ; then
8324     GCJ_FOR_TARGET="$2"
8325   else
8326     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8327   fi
8328 fi
8329
8330
8331
8332 if test -n "$GFORTRAN_FOR_TARGET"; then
8333   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8334 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8335   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8336 fi
8337
8338 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8339   for ncn_progname in gfortran; do
8340     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8341 set dummy ${ncn_progname}; ac_word=$2
8342 echo "$as_me:$LINENO: checking for $ac_word" >&5
8343 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8344 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8345   echo $ECHO_N "(cached) $ECHO_C" >&6
8346 else
8347   if test -n "$GFORTRAN_FOR_TARGET"; then
8348   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8349 else
8350 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8351 for as_dir in $PATH
8352 do
8353   IFS=$as_save_IFS
8354   test -z "$as_dir" && as_dir=.
8355   for ac_exec_ext in '' $ac_executable_extensions; do
8356   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8357     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8358     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8359     break 2
8360   fi
8361 done
8362 done
8363
8364 fi
8365 fi
8366 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8367 if test -n "$GFORTRAN_FOR_TARGET"; then
8368   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8369 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8370 else
8371   echo "$as_me:$LINENO: result: no" >&5
8372 echo "${ECHO_T}no" >&6
8373 fi
8374
8375   done
8376 fi
8377
8378 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8379   for ncn_progname in gfortran; do
8380     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8381 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8382     if test -x $with_build_time_tools/${ncn_progname}; then
8383       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8384       echo "$as_me:$LINENO: result: yes" >&5
8385 echo "${ECHO_T}yes" >&6
8386       break
8387     else
8388       echo "$as_me:$LINENO: result: no" >&5
8389 echo "${ECHO_T}no" >&6
8390     fi
8391   done
8392 fi
8393
8394 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8395   for ncn_progname in gfortran; do
8396     if test -n "$ncn_target_tool_prefix"; then
8397       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8398 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8399 echo "$as_me:$LINENO: checking for $ac_word" >&5
8400 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8401 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8402   echo $ECHO_N "(cached) $ECHO_C" >&6
8403 else
8404   if test -n "$GFORTRAN_FOR_TARGET"; then
8405   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8406 else
8407 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8408 for as_dir in $PATH
8409 do
8410   IFS=$as_save_IFS
8411   test -z "$as_dir" && as_dir=.
8412   for ac_exec_ext in '' $ac_executable_extensions; do
8413   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8414     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8415     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8416     break 2
8417   fi
8418 done
8419 done
8420
8421 fi
8422 fi
8423 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8424 if test -n "$GFORTRAN_FOR_TARGET"; then
8425   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8426 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8427 else
8428   echo "$as_me:$LINENO: result: no" >&5
8429 echo "${ECHO_T}no" >&6
8430 fi
8431
8432     fi
8433     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8434       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8435 set dummy ${ncn_progname}; ac_word=$2
8436 echo "$as_me:$LINENO: checking for $ac_word" >&5
8437 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8438 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8439   echo $ECHO_N "(cached) $ECHO_C" >&6
8440 else
8441   if test -n "$GFORTRAN_FOR_TARGET"; then
8442   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8443 else
8444 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8445 for as_dir in $PATH
8446 do
8447   IFS=$as_save_IFS
8448   test -z "$as_dir" && as_dir=.
8449   for ac_exec_ext in '' $ac_executable_extensions; do
8450   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8451     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8452     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8453     break 2
8454   fi
8455 done
8456 done
8457
8458 fi
8459 fi
8460 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8461 if test -n "$GFORTRAN_FOR_TARGET"; then
8462   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8463 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8464 else
8465   echo "$as_me:$LINENO: result: no" >&5
8466 echo "${ECHO_T}no" >&6
8467 fi
8468
8469     fi
8470     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8471   done
8472 fi
8473
8474 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8475   set dummy gfortran
8476   if test $build = $target ; then
8477     GFORTRAN_FOR_TARGET="$2"
8478   else
8479     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8480   fi
8481 fi
8482
8483
8484
8485 cat > conftest.c << \EOF
8486 #ifdef __GNUC__
8487   gcc_yay;
8488 #endif
8489 EOF
8490 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8491   have_gcc_for_target=yes
8492 else
8493   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8494   have_gcc_for_target=no
8495 fi
8496 rm conftest.c
8497
8498
8499
8500
8501 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8502   if test -n "$with_build_time_tools"; then
8503     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8504 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8505     if test -x $with_build_time_tools/ar; then
8506       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8507       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8508       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8509 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8510     else
8511       echo "$as_me:$LINENO: result: no" >&5
8512 echo "${ECHO_T}no" >&6
8513     fi
8514   elif test $build != $host && test $have_gcc_for_target = yes; then
8515     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8516     test $AR_FOR_TARGET=ar && AR_FOR_TARGET=
8517     ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8518   fi
8519 fi
8520 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8521   # Extract the first word of "ar", so it can be a program name with args.
8522 set dummy ar; ac_word=$2
8523 echo "$as_me:$LINENO: checking for $ac_word" >&5
8524 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8525 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8526   echo $ECHO_N "(cached) $ECHO_C" >&6
8527 else
8528   case $AR_FOR_TARGET in
8529   [\\/]* | ?:[\\/]*)
8530   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8531   ;;
8532   *)
8533   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8534 for as_dir in $gcc_cv_tool_dirs
8535 do
8536   IFS=$as_save_IFS
8537   test -z "$as_dir" && as_dir=.
8538   for ac_exec_ext in '' $ac_executable_extensions; do
8539   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8540     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8541     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8542     break 2
8543   fi
8544 done
8545 done
8546
8547   ;;
8548 esac
8549 fi
8550 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8551
8552 if test -n "$AR_FOR_TARGET"; then
8553   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8554 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8555 else
8556   echo "$as_me:$LINENO: result: no" >&5
8557 echo "${ECHO_T}no" >&6
8558 fi
8559
8560 fi
8561 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8562
8563
8564 if test -n "$AR_FOR_TARGET"; then
8565   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8566 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8567   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8568 fi
8569
8570 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8571   for ncn_progname in ar; do
8572     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8573 set dummy ${ncn_progname}; ac_word=$2
8574 echo "$as_me:$LINENO: checking for $ac_word" >&5
8575 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8576 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8577   echo $ECHO_N "(cached) $ECHO_C" >&6
8578 else
8579   if test -n "$AR_FOR_TARGET"; then
8580   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8581 else
8582 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8583 for as_dir in $PATH
8584 do
8585   IFS=$as_save_IFS
8586   test -z "$as_dir" && as_dir=.
8587   for ac_exec_ext in '' $ac_executable_extensions; do
8588   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8589     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8590     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8591     break 2
8592   fi
8593 done
8594 done
8595
8596 fi
8597 fi
8598 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8599 if test -n "$AR_FOR_TARGET"; then
8600   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8601 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8602 else
8603   echo "$as_me:$LINENO: result: no" >&5
8604 echo "${ECHO_T}no" >&6
8605 fi
8606
8607   done
8608 fi
8609
8610 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8611   for ncn_progname in ar; do
8612     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8613 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8614     if test -x $with_build_time_tools/${ncn_progname}; then
8615       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8616       echo "$as_me:$LINENO: result: yes" >&5
8617 echo "${ECHO_T}yes" >&6
8618       break
8619     else
8620       echo "$as_me:$LINENO: result: no" >&5
8621 echo "${ECHO_T}no" >&6
8622     fi
8623   done
8624 fi
8625
8626 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8627   for ncn_progname in ar; do
8628     if test -n "$ncn_target_tool_prefix"; then
8629       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8630 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8631 echo "$as_me:$LINENO: checking for $ac_word" >&5
8632 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8633 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8634   echo $ECHO_N "(cached) $ECHO_C" >&6
8635 else
8636   if test -n "$AR_FOR_TARGET"; then
8637   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8638 else
8639 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8640 for as_dir in $PATH
8641 do
8642   IFS=$as_save_IFS
8643   test -z "$as_dir" && as_dir=.
8644   for ac_exec_ext in '' $ac_executable_extensions; do
8645   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8646     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8647     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8648     break 2
8649   fi
8650 done
8651 done
8652
8653 fi
8654 fi
8655 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8656 if test -n "$AR_FOR_TARGET"; then
8657   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8658 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8659 else
8660   echo "$as_me:$LINENO: result: no" >&5
8661 echo "${ECHO_T}no" >&6
8662 fi
8663
8664     fi
8665     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8666       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8667 set dummy ${ncn_progname}; ac_word=$2
8668 echo "$as_me:$LINENO: checking for $ac_word" >&5
8669 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8670 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8671   echo $ECHO_N "(cached) $ECHO_C" >&6
8672 else
8673   if test -n "$AR_FOR_TARGET"; then
8674   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8675 else
8676 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8677 for as_dir in $PATH
8678 do
8679   IFS=$as_save_IFS
8680   test -z "$as_dir" && as_dir=.
8681   for ac_exec_ext in '' $ac_executable_extensions; do
8682   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8683     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8684     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8685     break 2
8686   fi
8687 done
8688 done
8689
8690 fi
8691 fi
8692 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8693 if test -n "$AR_FOR_TARGET"; then
8694   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8695 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8696 else
8697   echo "$as_me:$LINENO: result: no" >&5
8698 echo "${ECHO_T}no" >&6
8699 fi
8700
8701     fi
8702     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8703   done
8704 fi
8705
8706 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8707   set dummy ar
8708   if test $build = $target ; then
8709     AR_FOR_TARGET="$2"
8710   else
8711     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8712   fi
8713 fi
8714
8715 else
8716   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8717 fi
8718
8719
8720
8721
8722 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8723   if test -n "$with_build_time_tools"; then
8724     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
8725 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
8726     if test -x $with_build_time_tools/as; then
8727       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
8728       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8729       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
8730 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
8731     else
8732       echo "$as_me:$LINENO: result: no" >&5
8733 echo "${ECHO_T}no" >&6
8734     fi
8735   elif test $build != $host && test $have_gcc_for_target = yes; then
8736     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
8737     test $AS_FOR_TARGET=as && AS_FOR_TARGET=
8738     ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8739   fi
8740 fi
8741 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8742   # Extract the first word of "as", so it can be a program name with args.
8743 set dummy as; ac_word=$2
8744 echo "$as_me:$LINENO: checking for $ac_word" >&5
8745 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8746 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
8747   echo $ECHO_N "(cached) $ECHO_C" >&6
8748 else
8749   case $AS_FOR_TARGET in
8750   [\\/]* | ?:[\\/]*)
8751   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
8752   ;;
8753   *)
8754   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8755 for as_dir in $gcc_cv_tool_dirs
8756 do
8757   IFS=$as_save_IFS
8758   test -z "$as_dir" && as_dir=.
8759   for ac_exec_ext in '' $ac_executable_extensions; do
8760   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8761     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8762     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8763     break 2
8764   fi
8765 done
8766 done
8767
8768   ;;
8769 esac
8770 fi
8771 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8772
8773 if test -n "$AS_FOR_TARGET"; then
8774   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8775 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8776 else
8777   echo "$as_me:$LINENO: result: no" >&5
8778 echo "${ECHO_T}no" >&6
8779 fi
8780
8781 fi
8782 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8783
8784
8785 if test -n "$AS_FOR_TARGET"; then
8786   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
8787 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8788   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8789 fi
8790
8791 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8792   for ncn_progname in as; do
8793     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8794 set dummy ${ncn_progname}; ac_word=$2
8795 echo "$as_me:$LINENO: checking for $ac_word" >&5
8796 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8797 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8798   echo $ECHO_N "(cached) $ECHO_C" >&6
8799 else
8800   if test -n "$AS_FOR_TARGET"; then
8801   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8802 else
8803 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8804 for as_dir in $PATH
8805 do
8806   IFS=$as_save_IFS
8807   test -z "$as_dir" && as_dir=.
8808   for ac_exec_ext in '' $ac_executable_extensions; do
8809   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8810     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
8811     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8812     break 2
8813   fi
8814 done
8815 done
8816
8817 fi
8818 fi
8819 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8820 if test -n "$AS_FOR_TARGET"; then
8821   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8822 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8823 else
8824   echo "$as_me:$LINENO: result: no" >&5
8825 echo "${ECHO_T}no" >&6
8826 fi
8827
8828   done
8829 fi
8830
8831 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
8832   for ncn_progname in as; do
8833     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8834 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8835     if test -x $with_build_time_tools/${ncn_progname}; then
8836       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8837       echo "$as_me:$LINENO: result: yes" >&5
8838 echo "${ECHO_T}yes" >&6
8839       break
8840     else
8841       echo "$as_me:$LINENO: result: no" >&5
8842 echo "${ECHO_T}no" >&6
8843     fi
8844   done
8845 fi
8846
8847 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
8848   for ncn_progname in as; do
8849     if test -n "$ncn_target_tool_prefix"; then
8850       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8851 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8852 echo "$as_me:$LINENO: checking for $ac_word" >&5
8853 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8854 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8855   echo $ECHO_N "(cached) $ECHO_C" >&6
8856 else
8857   if test -n "$AS_FOR_TARGET"; then
8858   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8859 else
8860 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8861 for as_dir in $PATH
8862 do
8863   IFS=$as_save_IFS
8864   test -z "$as_dir" && as_dir=.
8865   for ac_exec_ext in '' $ac_executable_extensions; do
8866   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8867     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8868     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8869     break 2
8870   fi
8871 done
8872 done
8873
8874 fi
8875 fi
8876 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8877 if test -n "$AS_FOR_TARGET"; then
8878   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8879 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8880 else
8881   echo "$as_me:$LINENO: result: no" >&5
8882 echo "${ECHO_T}no" >&6
8883 fi
8884
8885     fi
8886     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
8887       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8888 set dummy ${ncn_progname}; ac_word=$2
8889 echo "$as_me:$LINENO: checking for $ac_word" >&5
8890 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8891 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8892   echo $ECHO_N "(cached) $ECHO_C" >&6
8893 else
8894   if test -n "$AS_FOR_TARGET"; then
8895   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8896 else
8897 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8898 for as_dir in $PATH
8899 do
8900   IFS=$as_save_IFS
8901   test -z "$as_dir" && as_dir=.
8902   for ac_exec_ext in '' $ac_executable_extensions; do
8903   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8904     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
8905     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8906     break 2
8907   fi
8908 done
8909 done
8910
8911 fi
8912 fi
8913 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8914 if test -n "$AS_FOR_TARGET"; then
8915   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8916 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8917 else
8918   echo "$as_me:$LINENO: result: no" >&5
8919 echo "${ECHO_T}no" >&6
8920 fi
8921
8922     fi
8923     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
8924   done
8925 fi
8926
8927 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
8928   set dummy as
8929   if test $build = $target ; then
8930     AS_FOR_TARGET="$2"
8931   else
8932     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
8933   fi
8934 fi
8935
8936 else
8937   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8938 fi
8939
8940
8941
8942
8943 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
8944   if test -n "$with_build_time_tools"; then
8945     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
8946 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
8947     if test -x $with_build_time_tools/dlltool; then
8948       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
8949       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
8950       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
8951 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
8952     else
8953       echo "$as_me:$LINENO: result: no" >&5
8954 echo "${ECHO_T}no" >&6
8955     fi
8956   elif test $build != $host && test $have_gcc_for_target = yes; then
8957     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
8958     test $DLLTOOL_FOR_TARGET=dlltool && DLLTOOL_FOR_TARGET=
8959     ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
8960   fi
8961 fi
8962 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8963   # Extract the first word of "dlltool", so it can be a program name with args.
8964 set dummy dlltool; 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_path_DLLTOOL_FOR_TARGET+set}" = set; then
8968   echo $ECHO_N "(cached) $ECHO_C" >&6
8969 else
8970   case $DLLTOOL_FOR_TARGET in
8971   [\\/]* | ?:[\\/]*)
8972   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
8973   ;;
8974   *)
8975   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8976 for as_dir in $gcc_cv_tool_dirs
8977 do
8978   IFS=$as_save_IFS
8979   test -z "$as_dir" && as_dir=.
8980   for ac_exec_ext in '' $ac_executable_extensions; do
8981   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8982     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8983     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8984     break 2
8985   fi
8986 done
8987 done
8988
8989   ;;
8990 esac
8991 fi
8992 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
8993
8994 if test -n "$DLLTOOL_FOR_TARGET"; then
8995   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
8996 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
8997 else
8998   echo "$as_me:$LINENO: result: no" >&5
8999 echo "${ECHO_T}no" >&6
9000 fi
9001
9002 fi
9003 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9004
9005
9006 if test -n "$DLLTOOL_FOR_TARGET"; then
9007   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9008 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9009   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9010 fi
9011
9012 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9013   for ncn_progname in dlltool; do
9014     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9015 set dummy ${ncn_progname}; ac_word=$2
9016 echo "$as_me:$LINENO: checking for $ac_word" >&5
9017 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9018 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9019   echo $ECHO_N "(cached) $ECHO_C" >&6
9020 else
9021   if test -n "$DLLTOOL_FOR_TARGET"; then
9022   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9023 else
9024 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9025 for as_dir in $PATH
9026 do
9027   IFS=$as_save_IFS
9028   test -z "$as_dir" && as_dir=.
9029   for ac_exec_ext in '' $ac_executable_extensions; do
9030   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9031     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9032     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9033     break 2
9034   fi
9035 done
9036 done
9037
9038 fi
9039 fi
9040 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9041 if test -n "$DLLTOOL_FOR_TARGET"; then
9042   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9043 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9044 else
9045   echo "$as_me:$LINENO: result: no" >&5
9046 echo "${ECHO_T}no" >&6
9047 fi
9048
9049   done
9050 fi
9051
9052 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9053   for ncn_progname in dlltool; do
9054     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9055 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9056     if test -x $with_build_time_tools/${ncn_progname}; then
9057       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9058       echo "$as_me:$LINENO: result: yes" >&5
9059 echo "${ECHO_T}yes" >&6
9060       break
9061     else
9062       echo "$as_me:$LINENO: result: no" >&5
9063 echo "${ECHO_T}no" >&6
9064     fi
9065   done
9066 fi
9067
9068 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9069   for ncn_progname in dlltool; do
9070     if test -n "$ncn_target_tool_prefix"; then
9071       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9072 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9073 echo "$as_me:$LINENO: checking for $ac_word" >&5
9074 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9075 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9076   echo $ECHO_N "(cached) $ECHO_C" >&6
9077 else
9078   if test -n "$DLLTOOL_FOR_TARGET"; then
9079   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9080 else
9081 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9082 for as_dir in $PATH
9083 do
9084   IFS=$as_save_IFS
9085   test -z "$as_dir" && as_dir=.
9086   for ac_exec_ext in '' $ac_executable_extensions; do
9087   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9088     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9089     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9090     break 2
9091   fi
9092 done
9093 done
9094
9095 fi
9096 fi
9097 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9098 if test -n "$DLLTOOL_FOR_TARGET"; then
9099   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9100 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9101 else
9102   echo "$as_me:$LINENO: result: no" >&5
9103 echo "${ECHO_T}no" >&6
9104 fi
9105
9106     fi
9107     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9108       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9109 set dummy ${ncn_progname}; ac_word=$2
9110 echo "$as_me:$LINENO: checking for $ac_word" >&5
9111 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9112 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9113   echo $ECHO_N "(cached) $ECHO_C" >&6
9114 else
9115   if test -n "$DLLTOOL_FOR_TARGET"; then
9116   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9117 else
9118 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9119 for as_dir in $PATH
9120 do
9121   IFS=$as_save_IFS
9122   test -z "$as_dir" && as_dir=.
9123   for ac_exec_ext in '' $ac_executable_extensions; do
9124   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9125     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9126     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9127     break 2
9128   fi
9129 done
9130 done
9131
9132 fi
9133 fi
9134 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9135 if test -n "$DLLTOOL_FOR_TARGET"; then
9136   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9137 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9138 else
9139   echo "$as_me:$LINENO: result: no" >&5
9140 echo "${ECHO_T}no" >&6
9141 fi
9142
9143     fi
9144     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9145   done
9146 fi
9147
9148 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9149   set dummy dlltool
9150   if test $build = $target ; then
9151     DLLTOOL_FOR_TARGET="$2"
9152   else
9153     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9154   fi
9155 fi
9156
9157 else
9158   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9159 fi
9160
9161
9162
9163
9164 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9165   if test -n "$with_build_time_tools"; then
9166     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9167 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9168     if test -x $with_build_time_tools/ld; then
9169       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9170       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9171       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9172 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9173     else
9174       echo "$as_me:$LINENO: result: no" >&5
9175 echo "${ECHO_T}no" >&6
9176     fi
9177   elif test $build != $host && test $have_gcc_for_target = yes; then
9178     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9179     test $LD_FOR_TARGET=ld && LD_FOR_TARGET=
9180     ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9181   fi
9182 fi
9183 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9184   # Extract the first word of "ld", so it can be a program name with args.
9185 set dummy ld; ac_word=$2
9186 echo "$as_me:$LINENO: checking for $ac_word" >&5
9187 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9188 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9189   echo $ECHO_N "(cached) $ECHO_C" >&6
9190 else
9191   case $LD_FOR_TARGET in
9192   [\\/]* | ?:[\\/]*)
9193   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9194   ;;
9195   *)
9196   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9197 for as_dir in $gcc_cv_tool_dirs
9198 do
9199   IFS=$as_save_IFS
9200   test -z "$as_dir" && as_dir=.
9201   for ac_exec_ext in '' $ac_executable_extensions; do
9202   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9203     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9204     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9205     break 2
9206   fi
9207 done
9208 done
9209
9210   ;;
9211 esac
9212 fi
9213 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9214
9215 if test -n "$LD_FOR_TARGET"; then
9216   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9217 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9218 else
9219   echo "$as_me:$LINENO: result: no" >&5
9220 echo "${ECHO_T}no" >&6
9221 fi
9222
9223 fi
9224 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9225
9226
9227 if test -n "$LD_FOR_TARGET"; then
9228   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9229 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9230   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9231 fi
9232
9233 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9234   for ncn_progname in ld; do
9235     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9236 set dummy ${ncn_progname}; ac_word=$2
9237 echo "$as_me:$LINENO: checking for $ac_word" >&5
9238 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9239 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9240   echo $ECHO_N "(cached) $ECHO_C" >&6
9241 else
9242   if test -n "$LD_FOR_TARGET"; then
9243   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9244 else
9245 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9246 for as_dir in $PATH
9247 do
9248   IFS=$as_save_IFS
9249   test -z "$as_dir" && as_dir=.
9250   for ac_exec_ext in '' $ac_executable_extensions; do
9251   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9252     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9253     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9254     break 2
9255   fi
9256 done
9257 done
9258
9259 fi
9260 fi
9261 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9262 if test -n "$LD_FOR_TARGET"; then
9263   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9264 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9265 else
9266   echo "$as_me:$LINENO: result: no" >&5
9267 echo "${ECHO_T}no" >&6
9268 fi
9269
9270   done
9271 fi
9272
9273 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9274   for ncn_progname in ld; do
9275     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9276 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9277     if test -x $with_build_time_tools/${ncn_progname}; then
9278       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9279       echo "$as_me:$LINENO: result: yes" >&5
9280 echo "${ECHO_T}yes" >&6
9281       break
9282     else
9283       echo "$as_me:$LINENO: result: no" >&5
9284 echo "${ECHO_T}no" >&6
9285     fi
9286   done
9287 fi
9288
9289 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9290   for ncn_progname in ld; do
9291     if test -n "$ncn_target_tool_prefix"; then
9292       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9293 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9294 echo "$as_me:$LINENO: checking for $ac_word" >&5
9295 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9296 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9297   echo $ECHO_N "(cached) $ECHO_C" >&6
9298 else
9299   if test -n "$LD_FOR_TARGET"; then
9300   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9301 else
9302 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9303 for as_dir in $PATH
9304 do
9305   IFS=$as_save_IFS
9306   test -z "$as_dir" && as_dir=.
9307   for ac_exec_ext in '' $ac_executable_extensions; do
9308   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9309     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9310     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9311     break 2
9312   fi
9313 done
9314 done
9315
9316 fi
9317 fi
9318 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9319 if test -n "$LD_FOR_TARGET"; then
9320   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9321 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9322 else
9323   echo "$as_me:$LINENO: result: no" >&5
9324 echo "${ECHO_T}no" >&6
9325 fi
9326
9327     fi
9328     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9329       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9330 set dummy ${ncn_progname}; ac_word=$2
9331 echo "$as_me:$LINENO: checking for $ac_word" >&5
9332 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9333 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9334   echo $ECHO_N "(cached) $ECHO_C" >&6
9335 else
9336   if test -n "$LD_FOR_TARGET"; then
9337   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9338 else
9339 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9340 for as_dir in $PATH
9341 do
9342   IFS=$as_save_IFS
9343   test -z "$as_dir" && as_dir=.
9344   for ac_exec_ext in '' $ac_executable_extensions; do
9345   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9346     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9347     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9348     break 2
9349   fi
9350 done
9351 done
9352
9353 fi
9354 fi
9355 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9356 if test -n "$LD_FOR_TARGET"; then
9357   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9358 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9359 else
9360   echo "$as_me:$LINENO: result: no" >&5
9361 echo "${ECHO_T}no" >&6
9362 fi
9363
9364     fi
9365     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9366   done
9367 fi
9368
9369 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9370   set dummy ld
9371   if test $build = $target ; then
9372     LD_FOR_TARGET="$2"
9373   else
9374     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9375   fi
9376 fi
9377
9378 else
9379   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9380 fi
9381
9382
9383
9384
9385 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9386   if test -n "$with_build_time_tools"; then
9387     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9388 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9389     if test -x $with_build_time_tools/lipo; then
9390       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9391       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9392       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9393 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9394     else
9395       echo "$as_me:$LINENO: result: no" >&5
9396 echo "${ECHO_T}no" >&6
9397     fi
9398   elif test $build != $host && test $have_gcc_for_target = yes; then
9399     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9400     test $LIPO_FOR_TARGET=lipo && LIPO_FOR_TARGET=
9401     ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9402   fi
9403 fi
9404 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9405   # Extract the first word of "lipo", so it can be a program name with args.
9406 set dummy lipo; ac_word=$2
9407 echo "$as_me:$LINENO: checking for $ac_word" >&5
9408 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9409 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9410   echo $ECHO_N "(cached) $ECHO_C" >&6
9411 else
9412   case $LIPO_FOR_TARGET in
9413   [\\/]* | ?:[\\/]*)
9414   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9415   ;;
9416   *)
9417   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9418 for as_dir in $gcc_cv_tool_dirs
9419 do
9420   IFS=$as_save_IFS
9421   test -z "$as_dir" && as_dir=.
9422   for ac_exec_ext in '' $ac_executable_extensions; do
9423   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9424     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9425     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9426     break 2
9427   fi
9428 done
9429 done
9430
9431   ;;
9432 esac
9433 fi
9434 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9435
9436 if test -n "$LIPO_FOR_TARGET"; then
9437   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9438 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9439 else
9440   echo "$as_me:$LINENO: result: no" >&5
9441 echo "${ECHO_T}no" >&6
9442 fi
9443
9444 fi
9445 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9446
9447
9448 if test -n "$LIPO_FOR_TARGET"; then
9449   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9450 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9451   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9452 fi
9453
9454 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9455   for ncn_progname in lipo; do
9456     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9457 set dummy ${ncn_progname}; ac_word=$2
9458 echo "$as_me:$LINENO: checking for $ac_word" >&5
9459 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9460 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9461   echo $ECHO_N "(cached) $ECHO_C" >&6
9462 else
9463   if test -n "$LIPO_FOR_TARGET"; then
9464   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9465 else
9466 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9467 for as_dir in $PATH
9468 do
9469   IFS=$as_save_IFS
9470   test -z "$as_dir" && as_dir=.
9471   for ac_exec_ext in '' $ac_executable_extensions; do
9472   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9473     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9474     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9475     break 2
9476   fi
9477 done
9478 done
9479
9480 fi
9481 fi
9482 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9483 if test -n "$LIPO_FOR_TARGET"; then
9484   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9485 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9486 else
9487   echo "$as_me:$LINENO: result: no" >&5
9488 echo "${ECHO_T}no" >&6
9489 fi
9490
9491   done
9492 fi
9493
9494 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9495   for ncn_progname in lipo; do
9496     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9497 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9498     if test -x $with_build_time_tools/${ncn_progname}; then
9499       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9500       echo "$as_me:$LINENO: result: yes" >&5
9501 echo "${ECHO_T}yes" >&6
9502       break
9503     else
9504       echo "$as_me:$LINENO: result: no" >&5
9505 echo "${ECHO_T}no" >&6
9506     fi
9507   done
9508 fi
9509
9510 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9511   for ncn_progname in lipo; do
9512     if test -n "$ncn_target_tool_prefix"; then
9513       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9514 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9515 echo "$as_me:$LINENO: checking for $ac_word" >&5
9516 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9517 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9518   echo $ECHO_N "(cached) $ECHO_C" >&6
9519 else
9520   if test -n "$LIPO_FOR_TARGET"; then
9521   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9522 else
9523 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9524 for as_dir in $PATH
9525 do
9526   IFS=$as_save_IFS
9527   test -z "$as_dir" && as_dir=.
9528   for ac_exec_ext in '' $ac_executable_extensions; do
9529   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9530     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9531     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9532     break 2
9533   fi
9534 done
9535 done
9536
9537 fi
9538 fi
9539 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9540 if test -n "$LIPO_FOR_TARGET"; then
9541   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9542 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9543 else
9544   echo "$as_me:$LINENO: result: no" >&5
9545 echo "${ECHO_T}no" >&6
9546 fi
9547
9548     fi
9549     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9550       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9551 set dummy ${ncn_progname}; ac_word=$2
9552 echo "$as_me:$LINENO: checking for $ac_word" >&5
9553 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9554 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9555   echo $ECHO_N "(cached) $ECHO_C" >&6
9556 else
9557   if test -n "$LIPO_FOR_TARGET"; then
9558   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9559 else
9560 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9561 for as_dir in $PATH
9562 do
9563   IFS=$as_save_IFS
9564   test -z "$as_dir" && as_dir=.
9565   for ac_exec_ext in '' $ac_executable_extensions; do
9566   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9567     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9568     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9569     break 2
9570   fi
9571 done
9572 done
9573
9574 fi
9575 fi
9576 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9577 if test -n "$LIPO_FOR_TARGET"; then
9578   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9579 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9580 else
9581   echo "$as_me:$LINENO: result: no" >&5
9582 echo "${ECHO_T}no" >&6
9583 fi
9584
9585     fi
9586     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9587   done
9588 fi
9589
9590 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9591   set dummy lipo
9592   if test $build = $target ; then
9593     LIPO_FOR_TARGET="$2"
9594   else
9595     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9596   fi
9597 fi
9598
9599 else
9600   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9601 fi
9602
9603
9604
9605
9606 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9607   if test -n "$with_build_time_tools"; then
9608     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9609 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9610     if test -x $with_build_time_tools/nm; then
9611       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9612       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9613       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9614 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9615     else
9616       echo "$as_me:$LINENO: result: no" >&5
9617 echo "${ECHO_T}no" >&6
9618     fi
9619   elif test $build != $host && test $have_gcc_for_target = yes; then
9620     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9621     test $NM_FOR_TARGET=nm && NM_FOR_TARGET=
9622     ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9623   fi
9624 fi
9625 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9626   # Extract the first word of "nm", so it can be a program name with args.
9627 set dummy nm; ac_word=$2
9628 echo "$as_me:$LINENO: checking for $ac_word" >&5
9629 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9630 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9631   echo $ECHO_N "(cached) $ECHO_C" >&6
9632 else
9633   case $NM_FOR_TARGET in
9634   [\\/]* | ?:[\\/]*)
9635   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9636   ;;
9637   *)
9638   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9639 for as_dir in $gcc_cv_tool_dirs
9640 do
9641   IFS=$as_save_IFS
9642   test -z "$as_dir" && as_dir=.
9643   for ac_exec_ext in '' $ac_executable_extensions; do
9644   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9645     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9646     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9647     break 2
9648   fi
9649 done
9650 done
9651
9652   ;;
9653 esac
9654 fi
9655 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9656
9657 if test -n "$NM_FOR_TARGET"; then
9658   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9659 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9660 else
9661   echo "$as_me:$LINENO: result: no" >&5
9662 echo "${ECHO_T}no" >&6
9663 fi
9664
9665 fi
9666 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9667
9668
9669 if test -n "$NM_FOR_TARGET"; then
9670   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9671 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9672   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9673 fi
9674
9675 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9676   for ncn_progname in nm; do
9677     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9678 set dummy ${ncn_progname}; ac_word=$2
9679 echo "$as_me:$LINENO: checking for $ac_word" >&5
9680 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9681 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9682   echo $ECHO_N "(cached) $ECHO_C" >&6
9683 else
9684   if test -n "$NM_FOR_TARGET"; then
9685   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9686 else
9687 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9688 for as_dir in $PATH
9689 do
9690   IFS=$as_save_IFS
9691   test -z "$as_dir" && as_dir=.
9692   for ac_exec_ext in '' $ac_executable_extensions; do
9693   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9694     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9695     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9696     break 2
9697   fi
9698 done
9699 done
9700
9701 fi
9702 fi
9703 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9704 if test -n "$NM_FOR_TARGET"; then
9705   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9706 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9707 else
9708   echo "$as_me:$LINENO: result: no" >&5
9709 echo "${ECHO_T}no" >&6
9710 fi
9711
9712   done
9713 fi
9714
9715 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
9716   for ncn_progname in nm; do
9717     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9718 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9719     if test -x $with_build_time_tools/${ncn_progname}; then
9720       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9721       echo "$as_me:$LINENO: result: yes" >&5
9722 echo "${ECHO_T}yes" >&6
9723       break
9724     else
9725       echo "$as_me:$LINENO: result: no" >&5
9726 echo "${ECHO_T}no" >&6
9727     fi
9728   done
9729 fi
9730
9731 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
9732   for ncn_progname in nm; do
9733     if test -n "$ncn_target_tool_prefix"; then
9734       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9735 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9736 echo "$as_me:$LINENO: checking for $ac_word" >&5
9737 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9738 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9739   echo $ECHO_N "(cached) $ECHO_C" >&6
9740 else
9741   if test -n "$NM_FOR_TARGET"; then
9742   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9743 else
9744 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9745 for as_dir in $PATH
9746 do
9747   IFS=$as_save_IFS
9748   test -z "$as_dir" && as_dir=.
9749   for ac_exec_ext in '' $ac_executable_extensions; do
9750   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9751     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9752     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9753     break 2
9754   fi
9755 done
9756 done
9757
9758 fi
9759 fi
9760 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9761 if test -n "$NM_FOR_TARGET"; then
9762   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9763 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9764 else
9765   echo "$as_me:$LINENO: result: no" >&5
9766 echo "${ECHO_T}no" >&6
9767 fi
9768
9769     fi
9770     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
9771       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9772 set dummy ${ncn_progname}; ac_word=$2
9773 echo "$as_me:$LINENO: checking for $ac_word" >&5
9774 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9775 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9776   echo $ECHO_N "(cached) $ECHO_C" >&6
9777 else
9778   if test -n "$NM_FOR_TARGET"; then
9779   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9780 else
9781 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9782 for as_dir in $PATH
9783 do
9784   IFS=$as_save_IFS
9785   test -z "$as_dir" && as_dir=.
9786   for ac_exec_ext in '' $ac_executable_extensions; do
9787   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9788     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9789     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9790     break 2
9791   fi
9792 done
9793 done
9794
9795 fi
9796 fi
9797 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9798 if test -n "$NM_FOR_TARGET"; then
9799   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9800 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9801 else
9802   echo "$as_me:$LINENO: result: no" >&5
9803 echo "${ECHO_T}no" >&6
9804 fi
9805
9806     fi
9807     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
9808   done
9809 fi
9810
9811 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
9812   set dummy nm
9813   if test $build = $target ; then
9814     NM_FOR_TARGET="$2"
9815   else
9816     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
9817   fi
9818 fi
9819
9820 else
9821   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9822 fi
9823
9824
9825
9826
9827 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
9828   if test -n "$with_build_time_tools"; then
9829     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
9830 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
9831     if test -x $with_build_time_tools/objdump; then
9832       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
9833       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9834       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
9835 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
9836     else
9837       echo "$as_me:$LINENO: result: no" >&5
9838 echo "${ECHO_T}no" >&6
9839     fi
9840   elif test $build != $host && test $have_gcc_for_target = yes; then
9841     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
9842     test $OBJDUMP_FOR_TARGET=objdump && OBJDUMP_FOR_TARGET=
9843     ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9844   fi
9845 fi
9846 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9847   # Extract the first word of "objdump", so it can be a program name with args.
9848 set dummy objdump; ac_word=$2
9849 echo "$as_me:$LINENO: checking for $ac_word" >&5
9850 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9851 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
9852   echo $ECHO_N "(cached) $ECHO_C" >&6
9853 else
9854   case $OBJDUMP_FOR_TARGET in
9855   [\\/]* | ?:[\\/]*)
9856   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
9857   ;;
9858   *)
9859   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9860 for as_dir in $gcc_cv_tool_dirs
9861 do
9862   IFS=$as_save_IFS
9863   test -z "$as_dir" && as_dir=.
9864   for ac_exec_ext in '' $ac_executable_extensions; do
9865   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9866     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9867     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9868     break 2
9869   fi
9870 done
9871 done
9872
9873   ;;
9874 esac
9875 fi
9876 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
9877
9878 if test -n "$OBJDUMP_FOR_TARGET"; then
9879   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
9880 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
9881 else
9882   echo "$as_me:$LINENO: result: no" >&5
9883 echo "${ECHO_T}no" >&6
9884 fi
9885
9886 fi
9887 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
9888
9889
9890 if test -n "$OBJDUMP_FOR_TARGET"; then
9891   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9892 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9893   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
9894 fi
9895
9896 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9897   for ncn_progname in objdump; do
9898     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9899 set dummy ${ncn_progname}; ac_word=$2
9900 echo "$as_me:$LINENO: checking for $ac_word" >&5
9901 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9902 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
9903   echo $ECHO_N "(cached) $ECHO_C" >&6
9904 else
9905   if test -n "$OBJDUMP_FOR_TARGET"; then
9906   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
9907 else
9908 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9909 for as_dir in $PATH
9910 do
9911   IFS=$as_save_IFS
9912   test -z "$as_dir" && as_dir=.
9913   for ac_exec_ext in '' $ac_executable_extensions; do
9914   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9915     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
9916     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9917     break 2
9918   fi
9919 done
9920 done
9921
9922 fi
9923 fi
9924 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
9925 if test -n "$OBJDUMP_FOR_TARGET"; then
9926   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
9927 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
9928 else
9929   echo "$as_me:$LINENO: result: no" >&5
9930 echo "${ECHO_T}no" >&6
9931 fi
9932
9933   done
9934 fi
9935
9936 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
9937   for ncn_progname in objdump; do
9938     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9939 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9940     if test -x $with_build_time_tools/${ncn_progname}; then
9941       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9942       echo "$as_me:$LINENO: result: yes" >&5
9943 echo "${ECHO_T}yes" >&6
9944       break
9945     else
9946       echo "$as_me:$LINENO: result: no" >&5
9947 echo "${ECHO_T}no" >&6
9948     fi
9949   done
9950 fi
9951
9952 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9953   for ncn_progname in objdump; do
9954     if test -n "$ncn_target_tool_prefix"; then
9955       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9956 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9957 echo "$as_me:$LINENO: checking for $ac_word" >&5
9958 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9959 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
9960   echo $ECHO_N "(cached) $ECHO_C" >&6
9961 else
9962   if test -n "$OBJDUMP_FOR_TARGET"; then
9963   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
9964 else
9965 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9966 for as_dir in $PATH
9967 do
9968   IFS=$as_save_IFS
9969   test -z "$as_dir" && as_dir=.
9970   for ac_exec_ext in '' $ac_executable_extensions; do
9971   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9972     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9973     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9974     break 2
9975   fi
9976 done
9977 done
9978
9979 fi
9980 fi
9981 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
9982 if test -n "$OBJDUMP_FOR_TARGET"; then
9983   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
9984 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
9985 else
9986   echo "$as_me:$LINENO: result: no" >&5
9987 echo "${ECHO_T}no" >&6
9988 fi
9989
9990     fi
9991     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
9992       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9993 set dummy ${ncn_progname}; ac_word=$2
9994 echo "$as_me:$LINENO: checking for $ac_word" >&5
9995 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9996 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
9997   echo $ECHO_N "(cached) $ECHO_C" >&6
9998 else
9999   if test -n "$OBJDUMP_FOR_TARGET"; then
10000   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10001 else
10002 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10003 for as_dir in $PATH
10004 do
10005   IFS=$as_save_IFS
10006   test -z "$as_dir" && as_dir=.
10007   for ac_exec_ext in '' $ac_executable_extensions; do
10008   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10009     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10010     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10011     break 2
10012   fi
10013 done
10014 done
10015
10016 fi
10017 fi
10018 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10019 if test -n "$OBJDUMP_FOR_TARGET"; then
10020   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10021 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10022 else
10023   echo "$as_me:$LINENO: result: no" >&5
10024 echo "${ECHO_T}no" >&6
10025 fi
10026
10027     fi
10028     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10029   done
10030 fi
10031
10032 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10033   set dummy objdump
10034   if test $build = $target ; then
10035     OBJDUMP_FOR_TARGET="$2"
10036   else
10037     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10038   fi
10039 fi
10040
10041 else
10042   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10043 fi
10044
10045
10046
10047
10048 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10049   if test -n "$with_build_time_tools"; then
10050     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10051 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10052     if test -x $with_build_time_tools/ranlib; then
10053       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10054       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10055       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10056 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10057     else
10058       echo "$as_me:$LINENO: result: no" >&5
10059 echo "${ECHO_T}no" >&6
10060     fi
10061   elif test $build != $host && test $have_gcc_for_target = yes; then
10062     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10063     test $RANLIB_FOR_TARGET=ranlib && RANLIB_FOR_TARGET=
10064     ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10065   fi
10066 fi
10067 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10068   # Extract the first word of "ranlib", so it can be a program name with args.
10069 set dummy ranlib; ac_word=$2
10070 echo "$as_me:$LINENO: checking for $ac_word" >&5
10071 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10072 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10073   echo $ECHO_N "(cached) $ECHO_C" >&6
10074 else
10075   case $RANLIB_FOR_TARGET in
10076   [\\/]* | ?:[\\/]*)
10077   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10078   ;;
10079   *)
10080   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10081 for as_dir in $gcc_cv_tool_dirs
10082 do
10083   IFS=$as_save_IFS
10084   test -z "$as_dir" && as_dir=.
10085   for ac_exec_ext in '' $ac_executable_extensions; do
10086   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10087     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10088     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10089     break 2
10090   fi
10091 done
10092 done
10093
10094   ;;
10095 esac
10096 fi
10097 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10098
10099 if test -n "$RANLIB_FOR_TARGET"; then
10100   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10101 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10102 else
10103   echo "$as_me:$LINENO: result: no" >&5
10104 echo "${ECHO_T}no" >&6
10105 fi
10106
10107 fi
10108 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10109
10110
10111 if test -n "$RANLIB_FOR_TARGET"; then
10112   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10113 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10114   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10115 fi
10116
10117 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10118   for ncn_progname in ranlib; do
10119     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10120 set dummy ${ncn_progname}; ac_word=$2
10121 echo "$as_me:$LINENO: checking for $ac_word" >&5
10122 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10123 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10124   echo $ECHO_N "(cached) $ECHO_C" >&6
10125 else
10126   if test -n "$RANLIB_FOR_TARGET"; then
10127   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10128 else
10129 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10130 for as_dir in $PATH
10131 do
10132   IFS=$as_save_IFS
10133   test -z "$as_dir" && as_dir=.
10134   for ac_exec_ext in '' $ac_executable_extensions; do
10135   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10136     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10137     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10138     break 2
10139   fi
10140 done
10141 done
10142
10143 fi
10144 fi
10145 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10146 if test -n "$RANLIB_FOR_TARGET"; then
10147   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10148 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10149 else
10150   echo "$as_me:$LINENO: result: no" >&5
10151 echo "${ECHO_T}no" >&6
10152 fi
10153
10154   done
10155 fi
10156
10157 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10158   for ncn_progname in ranlib; do
10159     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10160 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10161     if test -x $with_build_time_tools/${ncn_progname}; then
10162       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10163       echo "$as_me:$LINENO: result: yes" >&5
10164 echo "${ECHO_T}yes" >&6
10165       break
10166     else
10167       echo "$as_me:$LINENO: result: no" >&5
10168 echo "${ECHO_T}no" >&6
10169     fi
10170   done
10171 fi
10172
10173 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10174   for ncn_progname in ranlib; do
10175     if test -n "$ncn_target_tool_prefix"; then
10176       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10177 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10178 echo "$as_me:$LINENO: checking for $ac_word" >&5
10179 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10180 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10181   echo $ECHO_N "(cached) $ECHO_C" >&6
10182 else
10183   if test -n "$RANLIB_FOR_TARGET"; then
10184   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10185 else
10186 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10187 for as_dir in $PATH
10188 do
10189   IFS=$as_save_IFS
10190   test -z "$as_dir" && as_dir=.
10191   for ac_exec_ext in '' $ac_executable_extensions; do
10192   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10193     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10194     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10195     break 2
10196   fi
10197 done
10198 done
10199
10200 fi
10201 fi
10202 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10203 if test -n "$RANLIB_FOR_TARGET"; then
10204   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10205 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10206 else
10207   echo "$as_me:$LINENO: result: no" >&5
10208 echo "${ECHO_T}no" >&6
10209 fi
10210
10211     fi
10212     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10213       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10214 set dummy ${ncn_progname}; ac_word=$2
10215 echo "$as_me:$LINENO: checking for $ac_word" >&5
10216 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10217 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10218   echo $ECHO_N "(cached) $ECHO_C" >&6
10219 else
10220   if test -n "$RANLIB_FOR_TARGET"; then
10221   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10222 else
10223 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10224 for as_dir in $PATH
10225 do
10226   IFS=$as_save_IFS
10227   test -z "$as_dir" && as_dir=.
10228   for ac_exec_ext in '' $ac_executable_extensions; do
10229   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10230     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10231     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10232     break 2
10233   fi
10234 done
10235 done
10236
10237 fi
10238 fi
10239 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10240 if test -n "$RANLIB_FOR_TARGET"; then
10241   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10242 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10243 else
10244   echo "$as_me:$LINENO: result: no" >&5
10245 echo "${ECHO_T}no" >&6
10246 fi
10247
10248     fi
10249     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10250   done
10251 fi
10252
10253 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10254   set dummy ranlib
10255   if test $build = $target ; then
10256     RANLIB_FOR_TARGET="$2"
10257   else
10258     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10259   fi
10260 fi
10261
10262 else
10263   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10264 fi
10265
10266
10267
10268
10269 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10270   if test -n "$with_build_time_tools"; then
10271     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10272 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10273     if test -x $with_build_time_tools/strip; then
10274       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10275       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10276       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10277 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10278     else
10279       echo "$as_me:$LINENO: result: no" >&5
10280 echo "${ECHO_T}no" >&6
10281     fi
10282   elif test $build != $host && test $have_gcc_for_target = yes; then
10283     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10284     test $STRIP_FOR_TARGET=strip && STRIP_FOR_TARGET=
10285     ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10286   fi
10287 fi
10288 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10289   # Extract the first word of "strip", so it can be a program name with args.
10290 set dummy strip; ac_word=$2
10291 echo "$as_me:$LINENO: checking for $ac_word" >&5
10292 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10293 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10294   echo $ECHO_N "(cached) $ECHO_C" >&6
10295 else
10296   case $STRIP_FOR_TARGET in
10297   [\\/]* | ?:[\\/]*)
10298   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10299   ;;
10300   *)
10301   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10302 for as_dir in $gcc_cv_tool_dirs
10303 do
10304   IFS=$as_save_IFS
10305   test -z "$as_dir" && as_dir=.
10306   for ac_exec_ext in '' $ac_executable_extensions; do
10307   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10308     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10309     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10310     break 2
10311   fi
10312 done
10313 done
10314
10315   ;;
10316 esac
10317 fi
10318 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10319
10320 if test -n "$STRIP_FOR_TARGET"; then
10321   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10322 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10323 else
10324   echo "$as_me:$LINENO: result: no" >&5
10325 echo "${ECHO_T}no" >&6
10326 fi
10327
10328 fi
10329 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10330
10331
10332 if test -n "$STRIP_FOR_TARGET"; then
10333   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10334 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10335   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10336 fi
10337
10338 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10339   for ncn_progname in strip; do
10340     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10341 set dummy ${ncn_progname}; ac_word=$2
10342 echo "$as_me:$LINENO: checking for $ac_word" >&5
10343 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10344 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10345   echo $ECHO_N "(cached) $ECHO_C" >&6
10346 else
10347   if test -n "$STRIP_FOR_TARGET"; then
10348   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10349 else
10350 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10351 for as_dir in $PATH
10352 do
10353   IFS=$as_save_IFS
10354   test -z "$as_dir" && as_dir=.
10355   for ac_exec_ext in '' $ac_executable_extensions; do
10356   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10357     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10358     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10359     break 2
10360   fi
10361 done
10362 done
10363
10364 fi
10365 fi
10366 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10367 if test -n "$STRIP_FOR_TARGET"; then
10368   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10369 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10370 else
10371   echo "$as_me:$LINENO: result: no" >&5
10372 echo "${ECHO_T}no" >&6
10373 fi
10374
10375   done
10376 fi
10377
10378 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10379   for ncn_progname in strip; do
10380     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10381 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10382     if test -x $with_build_time_tools/${ncn_progname}; then
10383       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10384       echo "$as_me:$LINENO: result: yes" >&5
10385 echo "${ECHO_T}yes" >&6
10386       break
10387     else
10388       echo "$as_me:$LINENO: result: no" >&5
10389 echo "${ECHO_T}no" >&6
10390     fi
10391   done
10392 fi
10393
10394 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10395   for ncn_progname in strip; do
10396     if test -n "$ncn_target_tool_prefix"; then
10397       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10398 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10399 echo "$as_me:$LINENO: checking for $ac_word" >&5
10400 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10401 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10402   echo $ECHO_N "(cached) $ECHO_C" >&6
10403 else
10404   if test -n "$STRIP_FOR_TARGET"; then
10405   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10406 else
10407 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10408 for as_dir in $PATH
10409 do
10410   IFS=$as_save_IFS
10411   test -z "$as_dir" && as_dir=.
10412   for ac_exec_ext in '' $ac_executable_extensions; do
10413   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10414     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10415     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10416     break 2
10417   fi
10418 done
10419 done
10420
10421 fi
10422 fi
10423 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10424 if test -n "$STRIP_FOR_TARGET"; then
10425   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10426 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10427 else
10428   echo "$as_me:$LINENO: result: no" >&5
10429 echo "${ECHO_T}no" >&6
10430 fi
10431
10432     fi
10433     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10434       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10435 set dummy ${ncn_progname}; ac_word=$2
10436 echo "$as_me:$LINENO: checking for $ac_word" >&5
10437 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10438 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10439   echo $ECHO_N "(cached) $ECHO_C" >&6
10440 else
10441   if test -n "$STRIP_FOR_TARGET"; then
10442   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10443 else
10444 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10445 for as_dir in $PATH
10446 do
10447   IFS=$as_save_IFS
10448   test -z "$as_dir" && as_dir=.
10449   for ac_exec_ext in '' $ac_executable_extensions; do
10450   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10451     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10452     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10453     break 2
10454   fi
10455 done
10456 done
10457
10458 fi
10459 fi
10460 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10461 if test -n "$STRIP_FOR_TARGET"; then
10462   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10463 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10464 else
10465   echo "$as_me:$LINENO: result: no" >&5
10466 echo "${ECHO_T}no" >&6
10467 fi
10468
10469     fi
10470     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10471   done
10472 fi
10473
10474 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10475   set dummy strip
10476   if test $build = $target ; then
10477     STRIP_FOR_TARGET="$2"
10478   else
10479     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10480   fi
10481 fi
10482
10483 else
10484   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10485 fi
10486
10487
10488
10489
10490 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10491   if test -n "$with_build_time_tools"; then
10492     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10493 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10494     if test -x $with_build_time_tools/windres; then
10495       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10496       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10497       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10498 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10499     else
10500       echo "$as_me:$LINENO: result: no" >&5
10501 echo "${ECHO_T}no" >&6
10502     fi
10503   elif test $build != $host && test $have_gcc_for_target = yes; then
10504     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10505     test $WINDRES_FOR_TARGET=windres && WINDRES_FOR_TARGET=
10506     ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10507   fi
10508 fi
10509 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10510   # Extract the first word of "windres", so it can be a program name with args.
10511 set dummy windres; ac_word=$2
10512 echo "$as_me:$LINENO: checking for $ac_word" >&5
10513 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10514 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10515   echo $ECHO_N "(cached) $ECHO_C" >&6
10516 else
10517   case $WINDRES_FOR_TARGET in
10518   [\\/]* | ?:[\\/]*)
10519   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10520   ;;
10521   *)
10522   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10523 for as_dir in $gcc_cv_tool_dirs
10524 do
10525   IFS=$as_save_IFS
10526   test -z "$as_dir" && as_dir=.
10527   for ac_exec_ext in '' $ac_executable_extensions; do
10528   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10529     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10530     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10531     break 2
10532   fi
10533 done
10534 done
10535
10536   ;;
10537 esac
10538 fi
10539 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10540
10541 if test -n "$WINDRES_FOR_TARGET"; then
10542   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10543 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10544 else
10545   echo "$as_me:$LINENO: result: no" >&5
10546 echo "${ECHO_T}no" >&6
10547 fi
10548
10549 fi
10550 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10551
10552
10553 if test -n "$WINDRES_FOR_TARGET"; then
10554   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10555 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10556   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10557 fi
10558
10559 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10560   for ncn_progname in windres; do
10561     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10562 set dummy ${ncn_progname}; ac_word=$2
10563 echo "$as_me:$LINENO: checking for $ac_word" >&5
10564 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10565 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10566   echo $ECHO_N "(cached) $ECHO_C" >&6
10567 else
10568   if test -n "$WINDRES_FOR_TARGET"; then
10569   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10570 else
10571 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10572 for as_dir in $PATH
10573 do
10574   IFS=$as_save_IFS
10575   test -z "$as_dir" && as_dir=.
10576   for ac_exec_ext in '' $ac_executable_extensions; do
10577   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10578     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10579     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10580     break 2
10581   fi
10582 done
10583 done
10584
10585 fi
10586 fi
10587 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10588 if test -n "$WINDRES_FOR_TARGET"; then
10589   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10590 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10591 else
10592   echo "$as_me:$LINENO: result: no" >&5
10593 echo "${ECHO_T}no" >&6
10594 fi
10595
10596   done
10597 fi
10598
10599 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10600   for ncn_progname in windres; do
10601     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10602 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10603     if test -x $with_build_time_tools/${ncn_progname}; then
10604       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10605       echo "$as_me:$LINENO: result: yes" >&5
10606 echo "${ECHO_T}yes" >&6
10607       break
10608     else
10609       echo "$as_me:$LINENO: result: no" >&5
10610 echo "${ECHO_T}no" >&6
10611     fi
10612   done
10613 fi
10614
10615 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10616   for ncn_progname in windres; do
10617     if test -n "$ncn_target_tool_prefix"; then
10618       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10619 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10620 echo "$as_me:$LINENO: checking for $ac_word" >&5
10621 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10622 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10623   echo $ECHO_N "(cached) $ECHO_C" >&6
10624 else
10625   if test -n "$WINDRES_FOR_TARGET"; then
10626   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10627 else
10628 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10629 for as_dir in $PATH
10630 do
10631   IFS=$as_save_IFS
10632   test -z "$as_dir" && as_dir=.
10633   for ac_exec_ext in '' $ac_executable_extensions; do
10634   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10635     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10636     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10637     break 2
10638   fi
10639 done
10640 done
10641
10642 fi
10643 fi
10644 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10645 if test -n "$WINDRES_FOR_TARGET"; then
10646   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10647 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10648 else
10649   echo "$as_me:$LINENO: result: no" >&5
10650 echo "${ECHO_T}no" >&6
10651 fi
10652
10653     fi
10654     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10655       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10656 set dummy ${ncn_progname}; ac_word=$2
10657 echo "$as_me:$LINENO: checking for $ac_word" >&5
10658 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10659 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10660   echo $ECHO_N "(cached) $ECHO_C" >&6
10661 else
10662   if test -n "$WINDRES_FOR_TARGET"; then
10663   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10664 else
10665 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10666 for as_dir in $PATH
10667 do
10668   IFS=$as_save_IFS
10669   test -z "$as_dir" && as_dir=.
10670   for ac_exec_ext in '' $ac_executable_extensions; do
10671   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10672     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10673     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10674     break 2
10675   fi
10676 done
10677 done
10678
10679 fi
10680 fi
10681 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10682 if test -n "$WINDRES_FOR_TARGET"; then
10683   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10684 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10685 else
10686   echo "$as_me:$LINENO: result: no" >&5
10687 echo "${ECHO_T}no" >&6
10688 fi
10689
10690     fi
10691     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10692   done
10693 fi
10694
10695 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10696   set dummy windres
10697   if test $build = $target ; then
10698     WINDRES_FOR_TARGET="$2"
10699   else
10700     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10701   fi
10702 fi
10703
10704 else
10705   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10706 fi
10707
10708
10709 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
10710
10711 echo "$as_me:$LINENO: checking where to find the target ar" >&5
10712 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
10713 if test "x${build}" != "x${host}" ; then
10714   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
10715     # We already found the complete path
10716     echo "$as_me:$LINENO: result: pre-installed in \`dirname $AR_FOR_TARGET\`" >&5
10717 echo "${ECHO_T}pre-installed in \`dirname $AR_FOR_TARGET\`" >&6
10718   else
10719     # Canadian cross, just use what we found
10720     echo "$as_me:$LINENO: result: pre-installed" >&5
10721 echo "${ECHO_T}pre-installed" >&6
10722   fi
10723 else
10724   ok=yes
10725   case " ${configdirs} " in
10726     *" binutils "*) ;;
10727     *) ok=no ;;
10728   esac
10729
10730   if test $ok = yes; then
10731     # An in-tree tool is available and we can use it
10732     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
10733     echo "$as_me:$LINENO: result: just compiled" >&5
10734 echo "${ECHO_T}just compiled" >&6
10735   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
10736     # We already found the complete path
10737     echo "$as_me:$LINENO: result: pre-installed in \`dirname $AR_FOR_TARGET\`" >&5
10738 echo "${ECHO_T}pre-installed in \`dirname $AR_FOR_TARGET\`" >&6
10739   elif test "x$target" = "x$host"; then
10740     # We can use an host tool
10741     AR_FOR_TARGET='$(AR)'
10742     echo "$as_me:$LINENO: result: host tool" >&5
10743 echo "${ECHO_T}host tool" >&6
10744   else
10745     # We need a cross tool
10746     echo "$as_me:$LINENO: result: pre-installed" >&5
10747 echo "${ECHO_T}pre-installed" >&6
10748   fi
10749 fi
10750
10751 echo "$as_me:$LINENO: checking where to find the target as" >&5
10752 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
10753 if test "x${build}" != "x${host}" ; then
10754   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
10755     # We already found the complete path
10756     echo "$as_me:$LINENO: result: pre-installed in \`dirname $AS_FOR_TARGET\`" >&5
10757 echo "${ECHO_T}pre-installed in \`dirname $AS_FOR_TARGET\`" >&6
10758   else
10759     # Canadian cross, just use what we found
10760     echo "$as_me:$LINENO: result: pre-installed" >&5
10761 echo "${ECHO_T}pre-installed" >&6
10762   fi
10763 else
10764   ok=yes
10765   case " ${configdirs} " in
10766     *" gas "*) ;;
10767     *) ok=no ;;
10768   esac
10769
10770   if test $ok = yes; then
10771     # An in-tree tool is available and we can use it
10772     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
10773     echo "$as_me:$LINENO: result: just compiled" >&5
10774 echo "${ECHO_T}just compiled" >&6
10775   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
10776     # We already found the complete path
10777     echo "$as_me:$LINENO: result: pre-installed in \`dirname $AS_FOR_TARGET\`" >&5
10778 echo "${ECHO_T}pre-installed in \`dirname $AS_FOR_TARGET\`" >&6
10779   elif test "x$target" = "x$host"; then
10780     # We can use an host tool
10781     AS_FOR_TARGET='$(AS)'
10782     echo "$as_me:$LINENO: result: host tool" >&5
10783 echo "${ECHO_T}host tool" >&6
10784   else
10785     # We need a cross tool
10786     echo "$as_me:$LINENO: result: pre-installed" >&5
10787 echo "${ECHO_T}pre-installed" >&6
10788   fi
10789 fi
10790
10791 echo "$as_me:$LINENO: checking where to find the target cc" >&5
10792 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
10793 if test "x${build}" != "x${host}" ; then
10794   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
10795     # We already found the complete path
10796     echo "$as_me:$LINENO: result: pre-installed in \`dirname $CC_FOR_TARGET\`" >&5
10797 echo "${ECHO_T}pre-installed in \`dirname $CC_FOR_TARGET\`" >&6
10798   else
10799     # Canadian cross, just use what we found
10800     echo "$as_me:$LINENO: result: pre-installed" >&5
10801 echo "${ECHO_T}pre-installed" >&6
10802   fi
10803 else
10804   ok=yes
10805   case " ${configdirs} " in
10806     *" gcc "*) ;;
10807     *) ok=no ;;
10808   esac
10809
10810   if test $ok = yes; then
10811     # An in-tree tool is available and we can use it
10812     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
10813     echo "$as_me:$LINENO: result: just compiled" >&5
10814 echo "${ECHO_T}just compiled" >&6
10815   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
10816     # We already found the complete path
10817     echo "$as_me:$LINENO: result: pre-installed in \`dirname $CC_FOR_TARGET\`" >&5
10818 echo "${ECHO_T}pre-installed in \`dirname $CC_FOR_TARGET\`" >&6
10819   elif test "x$target" = "x$host"; then
10820     # We can use an host tool
10821     CC_FOR_TARGET='$(CC)'
10822     echo "$as_me:$LINENO: result: host tool" >&5
10823 echo "${ECHO_T}host tool" >&6
10824   else
10825     # We need a cross tool
10826     echo "$as_me:$LINENO: result: pre-installed" >&5
10827 echo "${ECHO_T}pre-installed" >&6
10828   fi
10829 fi
10830
10831 echo "$as_me:$LINENO: checking where to find the target c++" >&5
10832 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
10833 if test "x${build}" != "x${host}" ; then
10834   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
10835     # We already found the complete path
10836     echo "$as_me:$LINENO: result: pre-installed in \`dirname $CXX_FOR_TARGET\`" >&5
10837 echo "${ECHO_T}pre-installed in \`dirname $CXX_FOR_TARGET\`" >&6
10838   else
10839     # Canadian cross, just use what we found
10840     echo "$as_me:$LINENO: result: pre-installed" >&5
10841 echo "${ECHO_T}pre-installed" >&6
10842   fi
10843 else
10844   ok=yes
10845   case " ${configdirs} " in
10846     *" gcc "*) ;;
10847     *) ok=no ;;
10848   esac
10849   case ,${enable_languages}, in
10850     *,c++,*) ;;
10851     *) ok=no ;;
10852   esac
10853   if test $ok = yes; then
10854     # An in-tree tool is available and we can use it
10855     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'
10856     echo "$as_me:$LINENO: result: just compiled" >&5
10857 echo "${ECHO_T}just compiled" >&6
10858   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
10859     # We already found the complete path
10860     echo "$as_me:$LINENO: result: pre-installed in \`dirname $CXX_FOR_TARGET\`" >&5
10861 echo "${ECHO_T}pre-installed in \`dirname $CXX_FOR_TARGET\`" >&6
10862   elif test "x$target" = "x$host"; then
10863     # We can use an host tool
10864     CXX_FOR_TARGET='$(CXX)'
10865     echo "$as_me:$LINENO: result: host tool" >&5
10866 echo "${ECHO_T}host tool" >&6
10867   else
10868     # We need a cross tool
10869     echo "$as_me:$LINENO: result: pre-installed" >&5
10870 echo "${ECHO_T}pre-installed" >&6
10871   fi
10872 fi
10873
10874 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
10875 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
10876 if test "x${build}" != "x${host}" ; then
10877   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
10878     # We already found the complete path
10879     echo "$as_me:$LINENO: result: pre-installed in \`dirname $RAW_CXX_FOR_TARGET\`" >&5
10880 echo "${ECHO_T}pre-installed in \`dirname $RAW_CXX_FOR_TARGET\`" >&6
10881   else
10882     # Canadian cross, just use what we found
10883     echo "$as_me:$LINENO: result: pre-installed" >&5
10884 echo "${ECHO_T}pre-installed" >&6
10885   fi
10886 else
10887   ok=yes
10888   case " ${configdirs} " in
10889     *" gcc "*) ;;
10890     *) ok=no ;;
10891   esac
10892   case ,${enable_languages}, in
10893     *,c++,*) ;;
10894     *) ok=no ;;
10895   esac
10896   if test $ok = yes; then
10897     # An in-tree tool is available and we can use it
10898     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'
10899     echo "$as_me:$LINENO: result: just compiled" >&5
10900 echo "${ECHO_T}just compiled" >&6
10901   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
10902     # We already found the complete path
10903     echo "$as_me:$LINENO: result: pre-installed in \`dirname $RAW_CXX_FOR_TARGET\`" >&5
10904 echo "${ECHO_T}pre-installed in \`dirname $RAW_CXX_FOR_TARGET\`" >&6
10905   elif test "x$target" = "x$host"; then
10906     # We can use an host tool
10907     RAW_CXX_FOR_TARGET='$(CXX)'
10908     echo "$as_me:$LINENO: result: host tool" >&5
10909 echo "${ECHO_T}host tool" >&6
10910   else
10911     # We need a cross tool
10912     echo "$as_me:$LINENO: result: pre-installed" >&5
10913 echo "${ECHO_T}pre-installed" >&6
10914   fi
10915 fi
10916
10917 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
10918 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
10919 if test "x${build}" != "x${host}" ; then
10920   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
10921     # We already found the complete path
10922     echo "$as_me:$LINENO: result: pre-installed in \`dirname $DLLTOOL_FOR_TARGET\`" >&5
10923 echo "${ECHO_T}pre-installed in \`dirname $DLLTOOL_FOR_TARGET\`" >&6
10924   else
10925     # Canadian cross, just use what we found
10926     echo "$as_me:$LINENO: result: pre-installed" >&5
10927 echo "${ECHO_T}pre-installed" >&6
10928   fi
10929 else
10930   ok=yes
10931   case " ${configdirs} " in
10932     *" binutils "*) ;;
10933     *) ok=no ;;
10934   esac
10935
10936   if test $ok = yes; then
10937     # An in-tree tool is available and we can use it
10938     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
10939     echo "$as_me:$LINENO: result: just compiled" >&5
10940 echo "${ECHO_T}just compiled" >&6
10941   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
10942     # We already found the complete path
10943     echo "$as_me:$LINENO: result: pre-installed in \`dirname $DLLTOOL_FOR_TARGET\`" >&5
10944 echo "${ECHO_T}pre-installed in \`dirname $DLLTOOL_FOR_TARGET\`" >&6
10945   elif test "x$target" = "x$host"; then
10946     # We can use an host tool
10947     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
10948     echo "$as_me:$LINENO: result: host tool" >&5
10949 echo "${ECHO_T}host tool" >&6
10950   else
10951     # We need a cross tool
10952     echo "$as_me:$LINENO: result: pre-installed" >&5
10953 echo "${ECHO_T}pre-installed" >&6
10954   fi
10955 fi
10956
10957 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
10958 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
10959 if test "x${build}" != "x${host}" ; then
10960   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
10961     # We already found the complete path
10962     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GCC_FOR_TARGET\`" >&5
10963 echo "${ECHO_T}pre-installed in \`dirname $GCC_FOR_TARGET\`" >&6
10964   else
10965     # Canadian cross, just use what we found
10966     echo "$as_me:$LINENO: result: pre-installed" >&5
10967 echo "${ECHO_T}pre-installed" >&6
10968   fi
10969 else
10970   ok=yes
10971   case " ${configdirs} " in
10972     *" gcc "*) ;;
10973     *) ok=no ;;
10974   esac
10975
10976   if test $ok = yes; then
10977     # An in-tree tool is available and we can use it
10978     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
10979     echo "$as_me:$LINENO: result: just compiled" >&5
10980 echo "${ECHO_T}just compiled" >&6
10981   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
10982     # We already found the complete path
10983     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GCC_FOR_TARGET\`" >&5
10984 echo "${ECHO_T}pre-installed in \`dirname $GCC_FOR_TARGET\`" >&6
10985   elif test "x$target" = "x$host"; then
10986     # We can use an host tool
10987     GCC_FOR_TARGET='$()'
10988     echo "$as_me:$LINENO: result: host tool" >&5
10989 echo "${ECHO_T}host tool" >&6
10990   else
10991     # We need a cross tool
10992     echo "$as_me:$LINENO: result: pre-installed" >&5
10993 echo "${ECHO_T}pre-installed" >&6
10994   fi
10995 fi
10996
10997 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
10998 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
10999 if test "x${build}" != "x${host}" ; then
11000   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11001     # We already found the complete path
11002     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GCJ_FOR_TARGET\`" >&5
11003 echo "${ECHO_T}pre-installed in \`dirname $GCJ_FOR_TARGET\`" >&6
11004   else
11005     # Canadian cross, just use what we found
11006     echo "$as_me:$LINENO: result: pre-installed" >&5
11007 echo "${ECHO_T}pre-installed" >&6
11008   fi
11009 else
11010   ok=yes
11011   case " ${configdirs} " in
11012     *" gcc "*) ;;
11013     *) ok=no ;;
11014   esac
11015   case ,${enable_languages}, in
11016     *,java,*) ;;
11017     *) ok=no ;;
11018   esac
11019   if test $ok = yes; then
11020     # An in-tree tool is available and we can use it
11021     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11022     echo "$as_me:$LINENO: result: just compiled" >&5
11023 echo "${ECHO_T}just compiled" >&6
11024   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11025     # We already found the complete path
11026     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GCJ_FOR_TARGET\`" >&5
11027 echo "${ECHO_T}pre-installed in \`dirname $GCJ_FOR_TARGET\`" >&6
11028   elif test "x$target" = "x$host"; then
11029     # We can use an host tool
11030     GCJ_FOR_TARGET='$(GCJ)'
11031     echo "$as_me:$LINENO: result: host tool" >&5
11032 echo "${ECHO_T}host tool" >&6
11033   else
11034     # We need a cross tool
11035     echo "$as_me:$LINENO: result: pre-installed" >&5
11036 echo "${ECHO_T}pre-installed" >&6
11037   fi
11038 fi
11039
11040 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11041 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11042 if test "x${build}" != "x${host}" ; then
11043   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11044     # We already found the complete path
11045     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GFORTRAN_FOR_TARGET\`" >&5
11046 echo "${ECHO_T}pre-installed in \`dirname $GFORTRAN_FOR_TARGET\`" >&6
11047   else
11048     # Canadian cross, just use what we found
11049     echo "$as_me:$LINENO: result: pre-installed" >&5
11050 echo "${ECHO_T}pre-installed" >&6
11051   fi
11052 else
11053   ok=yes
11054   case " ${configdirs} " in
11055     *" gcc "*) ;;
11056     *) ok=no ;;
11057   esac
11058   case ,${enable_languages}, in
11059     *,fortran,*) ;;
11060     *) ok=no ;;
11061   esac
11062   if test $ok = yes; then
11063     # An in-tree tool is available and we can use it
11064     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11065     echo "$as_me:$LINENO: result: just compiled" >&5
11066 echo "${ECHO_T}just compiled" >&6
11067   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11068     # We already found the complete path
11069     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GFORTRAN_FOR_TARGET\`" >&5
11070 echo "${ECHO_T}pre-installed in \`dirname $GFORTRAN_FOR_TARGET\`" >&6
11071   elif test "x$target" = "x$host"; then
11072     # We can use an host tool
11073     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11074     echo "$as_me:$LINENO: result: host tool" >&5
11075 echo "${ECHO_T}host tool" >&6
11076   else
11077     # We need a cross tool
11078     echo "$as_me:$LINENO: result: pre-installed" >&5
11079 echo "${ECHO_T}pre-installed" >&6
11080   fi
11081 fi
11082
11083 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11084 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11085 if test "x${build}" != "x${host}" ; then
11086   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11087     # We already found the complete path
11088     echo "$as_me:$LINENO: result: pre-installed in \`dirname $LD_FOR_TARGET\`" >&5
11089 echo "${ECHO_T}pre-installed in \`dirname $LD_FOR_TARGET\`" >&6
11090   else
11091     # Canadian cross, just use what we found
11092     echo "$as_me:$LINENO: result: pre-installed" >&5
11093 echo "${ECHO_T}pre-installed" >&6
11094   fi
11095 else
11096   ok=yes
11097   case " ${configdirs} " in
11098     *" ld "*) ;;
11099     *) ok=no ;;
11100   esac
11101
11102   if test $ok = yes; then
11103     # An in-tree tool is available and we can use it
11104     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11105     echo "$as_me:$LINENO: result: just compiled" >&5
11106 echo "${ECHO_T}just compiled" >&6
11107   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11108     # We already found the complete path
11109     echo "$as_me:$LINENO: result: pre-installed in \`dirname $LD_FOR_TARGET\`" >&5
11110 echo "${ECHO_T}pre-installed in \`dirname $LD_FOR_TARGET\`" >&6
11111   elif test "x$target" = "x$host"; then
11112     # We can use an host tool
11113     LD_FOR_TARGET='$(LD)'
11114     echo "$as_me:$LINENO: result: host tool" >&5
11115 echo "${ECHO_T}host tool" >&6
11116   else
11117     # We need a cross tool
11118     echo "$as_me:$LINENO: result: pre-installed" >&5
11119 echo "${ECHO_T}pre-installed" >&6
11120   fi
11121 fi
11122
11123 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11124 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11125 if test "x${build}" != "x${host}" ; then
11126   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11127     # We already found the complete path
11128     echo "$as_me:$LINENO: result: pre-installed in \`dirname $LIPO_FOR_TARGET\`" >&5
11129 echo "${ECHO_T}pre-installed in \`dirname $LIPO_FOR_TARGET\`" >&6
11130   else
11131     # Canadian cross, just use what we found
11132     echo "$as_me:$LINENO: result: pre-installed" >&5
11133 echo "${ECHO_T}pre-installed" >&6
11134   fi
11135 else
11136   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11137     # We already found the complete path
11138     echo "$as_me:$LINENO: result: pre-installed in \`dirname $LIPO_FOR_TARGET\`" >&5
11139 echo "${ECHO_T}pre-installed in \`dirname $LIPO_FOR_TARGET\`" >&6
11140   elif test "x$target" = "x$host"; then
11141     # We can use an host tool
11142     LIPO_FOR_TARGET='$(LIPO)'
11143     echo "$as_me:$LINENO: result: host tool" >&5
11144 echo "${ECHO_T}host tool" >&6
11145   else
11146     # We need a cross tool
11147     echo "$as_me:$LINENO: result: pre-installed" >&5
11148 echo "${ECHO_T}pre-installed" >&6
11149   fi
11150 fi
11151
11152 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11153 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11154 if test "x${build}" != "x${host}" ; then
11155   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11156     # We already found the complete path
11157     echo "$as_me:$LINENO: result: pre-installed in \`dirname $NM_FOR_TARGET\`" >&5
11158 echo "${ECHO_T}pre-installed in \`dirname $NM_FOR_TARGET\`" >&6
11159   else
11160     # Canadian cross, just use what we found
11161     echo "$as_me:$LINENO: result: pre-installed" >&5
11162 echo "${ECHO_T}pre-installed" >&6
11163   fi
11164 else
11165   ok=yes
11166   case " ${configdirs} " in
11167     *" binutils "*) ;;
11168     *) ok=no ;;
11169   esac
11170
11171   if test $ok = yes; then
11172     # An in-tree tool is available and we can use it
11173     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11174     echo "$as_me:$LINENO: result: just compiled" >&5
11175 echo "${ECHO_T}just compiled" >&6
11176   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11177     # We already found the complete path
11178     echo "$as_me:$LINENO: result: pre-installed in \`dirname $NM_FOR_TARGET\`" >&5
11179 echo "${ECHO_T}pre-installed in \`dirname $NM_FOR_TARGET\`" >&6
11180   elif test "x$target" = "x$host"; then
11181     # We can use an host tool
11182     NM_FOR_TARGET='$(NM)'
11183     echo "$as_me:$LINENO: result: host tool" >&5
11184 echo "${ECHO_T}host tool" >&6
11185   else
11186     # We need a cross tool
11187     echo "$as_me:$LINENO: result: pre-installed" >&5
11188 echo "${ECHO_T}pre-installed" >&6
11189   fi
11190 fi
11191
11192 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11193 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11194 if test "x${build}" != "x${host}" ; then
11195   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11196     # We already found the complete path
11197     echo "$as_me:$LINENO: result: pre-installed in \`dirname $OBJDUMP_FOR_TARGET\`" >&5
11198 echo "${ECHO_T}pre-installed in \`dirname $OBJDUMP_FOR_TARGET\`" >&6
11199   else
11200     # Canadian cross, just use what we found
11201     echo "$as_me:$LINENO: result: pre-installed" >&5
11202 echo "${ECHO_T}pre-installed" >&6
11203   fi
11204 else
11205   ok=yes
11206   case " ${configdirs} " in
11207     *" binutils "*) ;;
11208     *) ok=no ;;
11209   esac
11210
11211   if test $ok = yes; then
11212     # An in-tree tool is available and we can use it
11213     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11214     echo "$as_me:$LINENO: result: just compiled" >&5
11215 echo "${ECHO_T}just compiled" >&6
11216   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11217     # We already found the complete path
11218     echo "$as_me:$LINENO: result: pre-installed in \`dirname $OBJDUMP_FOR_TARGET\`" >&5
11219 echo "${ECHO_T}pre-installed in \`dirname $OBJDUMP_FOR_TARGET\`" >&6
11220   elif test "x$target" = "x$host"; then
11221     # We can use an host tool
11222     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11223     echo "$as_me:$LINENO: result: host tool" >&5
11224 echo "${ECHO_T}host tool" >&6
11225   else
11226     # We need a cross tool
11227     echo "$as_me:$LINENO: result: pre-installed" >&5
11228 echo "${ECHO_T}pre-installed" >&6
11229   fi
11230 fi
11231
11232 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11233 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11234 if test "x${build}" != "x${host}" ; then
11235   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11236     # We already found the complete path
11237     echo "$as_me:$LINENO: result: pre-installed in \`dirname $RANLIB_FOR_TARGET\`" >&5
11238 echo "${ECHO_T}pre-installed in \`dirname $RANLIB_FOR_TARGET\`" >&6
11239   else
11240     # Canadian cross, just use what we found
11241     echo "$as_me:$LINENO: result: pre-installed" >&5
11242 echo "${ECHO_T}pre-installed" >&6
11243   fi
11244 else
11245   ok=yes
11246   case " ${configdirs} " in
11247     *" binutils "*) ;;
11248     *) ok=no ;;
11249   esac
11250
11251   if test $ok = yes; then
11252     # An in-tree tool is available and we can use it
11253     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11254     echo "$as_me:$LINENO: result: just compiled" >&5
11255 echo "${ECHO_T}just compiled" >&6
11256   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11257     # We already found the complete path
11258     echo "$as_me:$LINENO: result: pre-installed in \`dirname $RANLIB_FOR_TARGET\`" >&5
11259 echo "${ECHO_T}pre-installed in \`dirname $RANLIB_FOR_TARGET\`" >&6
11260   elif test "x$target" = "x$host"; then
11261     # We can use an host tool
11262     RANLIB_FOR_TARGET='$(RANLIB)'
11263     echo "$as_me:$LINENO: result: host tool" >&5
11264 echo "${ECHO_T}host tool" >&6
11265   else
11266     # We need a cross tool
11267     echo "$as_me:$LINENO: result: pre-installed" >&5
11268 echo "${ECHO_T}pre-installed" >&6
11269   fi
11270 fi
11271
11272 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11273 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11274 if test "x${build}" != "x${host}" ; then
11275   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11276     # We already found the complete path
11277     echo "$as_me:$LINENO: result: pre-installed in \`dirname $STRIP_FOR_TARGET\`" >&5
11278 echo "${ECHO_T}pre-installed in \`dirname $STRIP_FOR_TARGET\`" >&6
11279   else
11280     # Canadian cross, just use what we found
11281     echo "$as_me:$LINENO: result: pre-installed" >&5
11282 echo "${ECHO_T}pre-installed" >&6
11283   fi
11284 else
11285   ok=yes
11286   case " ${configdirs} " in
11287     *" binutils "*) ;;
11288     *) ok=no ;;
11289   esac
11290
11291   if test $ok = yes; then
11292     # An in-tree tool is available and we can use it
11293     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11294     echo "$as_me:$LINENO: result: just compiled" >&5
11295 echo "${ECHO_T}just compiled" >&6
11296   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11297     # We already found the complete path
11298     echo "$as_me:$LINENO: result: pre-installed in \`dirname $STRIP_FOR_TARGET\`" >&5
11299 echo "${ECHO_T}pre-installed in \`dirname $STRIP_FOR_TARGET\`" >&6
11300   elif test "x$target" = "x$host"; then
11301     # We can use an host tool
11302     STRIP_FOR_TARGET='$(STRIP)'
11303     echo "$as_me:$LINENO: result: host tool" >&5
11304 echo "${ECHO_T}host tool" >&6
11305   else
11306     # We need a cross tool
11307     echo "$as_me:$LINENO: result: pre-installed" >&5
11308 echo "${ECHO_T}pre-installed" >&6
11309   fi
11310 fi
11311
11312 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11313 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11314 if test "x${build}" != "x${host}" ; then
11315   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11316     # We already found the complete path
11317     echo "$as_me:$LINENO: result: pre-installed in \`dirname $WINDRES_FOR_TARGET\`" >&5
11318 echo "${ECHO_T}pre-installed in \`dirname $WINDRES_FOR_TARGET\`" >&6
11319   else
11320     # Canadian cross, just use what we found
11321     echo "$as_me:$LINENO: result: pre-installed" >&5
11322 echo "${ECHO_T}pre-installed" >&6
11323   fi
11324 else
11325   ok=yes
11326   case " ${configdirs} " in
11327     *" binutils "*) ;;
11328     *) ok=no ;;
11329   esac
11330
11331   if test $ok = yes; then
11332     # An in-tree tool is available and we can use it
11333     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11334     echo "$as_me:$LINENO: result: just compiled" >&5
11335 echo "${ECHO_T}just compiled" >&6
11336   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11337     # We already found the complete path
11338     echo "$as_me:$LINENO: result: pre-installed in \`dirname $WINDRES_FOR_TARGET\`" >&5
11339 echo "${ECHO_T}pre-installed in \`dirname $WINDRES_FOR_TARGET\`" >&6
11340   elif test "x$target" = "x$host"; then
11341     # We can use an host tool
11342     WINDRES_FOR_TARGET='$(WINDRES)'
11343     echo "$as_me:$LINENO: result: host tool" >&5
11344 echo "${ECHO_T}host tool" >&6
11345   else
11346     # We need a cross tool
11347     echo "$as_me:$LINENO: result: pre-installed" >&5
11348 echo "${ECHO_T}pre-installed" >&6
11349   fi
11350 fi
11351
11352
11353
11354
11355
11356 # Certain tools may need extra flags.
11357 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11358 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11359 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11360
11361 # When building target libraries, except in a Canadian cross, we use
11362 # the same toolchain as the compiler we just built.
11363 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11364 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11365 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11366 if test $host = $build; then
11367   case " $configdirs " in
11368     *" gcc "*)
11369       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11370       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11371       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11372       ;;
11373   esac
11374 fi
11375
11376
11377
11378
11379
11380 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11381 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11382 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11383 if test "${enable_maintainer_mode+set}" = set; then
11384   enableval="$enable_maintainer_mode"
11385   USE_MAINTAINER_MODE=$enableval
11386 else
11387   USE_MAINTAINER_MODE=no
11388 fi;
11389 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11390 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11391
11392
11393 if test "$USE_MAINTAINER_MODE" = yes; then
11394   MAINTAINER_MODE_TRUE=
11395   MAINTAINER_MODE_FALSE='#'
11396 else
11397   MAINTAINER_MODE_TRUE='#'
11398   MAINTAINER_MODE_FALSE=
11399 fi
11400 MAINT=$MAINTAINER_MODE_TRUE
11401
11402 # ---------------------
11403 # GCC bootstrap support
11404 # ---------------------
11405
11406 # Stage specific cflags for build.
11407 stage1_cflags="-g"
11408 case $build in
11409   vax-*-*)
11410     case ${GCC} in
11411       yes) stage1_cflags="-g -Wa,-J" ;;
11412       *) stage1_cflags="-g -J" ;;
11413     esac ;;
11414 esac
11415
11416 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
11417 if test "$GCC" = yes; then
11418   saved_CFLAGS="$CFLAGS"
11419
11420   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
11421   CFLAGS="$CFLAGS -fkeep-inline-functions"
11422   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
11423 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
11424   cat >conftest.$ac_ext <<_ACEOF
11425 /* confdefs.h.  */
11426 _ACEOF
11427 cat confdefs.h >>conftest.$ac_ext
11428 cat >>conftest.$ac_ext <<_ACEOF
11429 /* end confdefs.h.  */
11430
11431 int
11432 main ()
11433 {
11434
11435   ;
11436   return 0;
11437 }
11438 _ACEOF
11439 rm -f conftest.$ac_objext
11440 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11441   (eval $ac_compile) 2>conftest.er1
11442   ac_status=$?
11443   grep -v '^ *+' conftest.er1 >conftest.err
11444   rm -f conftest.er1
11445   cat conftest.err >&5
11446   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11447   (exit $ac_status); } &&
11448          { ac_try='test -z "$ac_c_werror_flag"
11449                          || test ! -s conftest.err'
11450   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11451   (eval $ac_try) 2>&5
11452   ac_status=$?
11453   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11454   (exit $ac_status); }; } &&
11455          { ac_try='test -s conftest.$ac_objext'
11456   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11457   (eval $ac_try) 2>&5
11458   ac_status=$?
11459   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11460   (exit $ac_status); }; }; then
11461   echo "$as_me:$LINENO: result: yes" >&5
11462 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
11463 else
11464   echo "$as_me: failed program was:" >&5
11465 sed 's/^/| /' conftest.$ac_ext >&5
11466
11467 echo "$as_me:$LINENO: result: no" >&5
11468 echo "${ECHO_T}no" >&6
11469 fi
11470 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11471
11472   CFLAGS="$saved_CFLAGS"
11473 fi
11474
11475
11476
11477 # Enable --enable-checking in stage1 of the compiler.
11478 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
11479 if test "${enable_stage1_checking+set}" = set; then
11480   enableval="$enable_stage1_checking"
11481   stage1_checking=--enable-checking=${enable_stage1_checking}
11482 else
11483   if test "x$enable_checking" = xno; then
11484   stage1_checking=--enable-checking
11485 else
11486   stage1_checking=--enable-checking${enable_checking+=}$enable_checking
11487 fi
11488 fi;
11489
11490
11491 # Enable -Werror in bootstrap stage2 and later.
11492 # Check whether --enable-werror or --disable-werror was given.
11493 if test "${enable_werror+set}" = set; then
11494   enableval="$enable_werror"
11495
11496 else
11497   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
11498   enable_werror=yes
11499 else
11500   enable_werror=no
11501 fi
11502 fi;
11503 case ${enable_werror} in
11504   yes) stage2_werror_flag="--enable-werror-always" ;;
11505   *) stage2_werror_flag="" ;;
11506 esac
11507
11508
11509 # Flags needed to enable html installing and building
11510
11511 # Check whether --with-datarootdir or --without-datarootdir was given.
11512 if test "${with_datarootdir+set}" = set; then
11513   withval="$with_datarootdir"
11514   datarootdir="\${prefix}/${withval}"
11515 else
11516   datarootdir="\${prefix}/share"
11517 fi;
11518
11519
11520 # Check whether --with-docdir or --without-docdir was given.
11521 if test "${with_docdir+set}" = set; then
11522   withval="$with_docdir"
11523   docdir="\${prefix}/${withval}"
11524 else
11525   docdir="\${datarootdir}/doc"
11526 fi;
11527
11528
11529 # Check whether --with-htmldir or --without-htmldir was given.
11530 if test "${with_htmldir+set}" = set; then
11531   withval="$with_htmldir"
11532   htmldir="\${prefix}/${withval}"
11533 else
11534   htmldir="\${docdir}"
11535 fi;
11536
11537
11538
11539
11540
11541           ac_config_files="$ac_config_files Makefile"
11542 cat >confcache <<\_ACEOF
11543 # This file is a shell script that caches the results of configure
11544 # tests run on this system so they can be shared between configure
11545 # scripts and configure runs, see configure's option --config-cache.
11546 # It is not useful on other systems.  If it contains results you don't
11547 # want to keep, you may remove or edit it.
11548 #
11549 # config.status only pays attention to the cache file if you give it
11550 # the --recheck option to rerun configure.
11551 #
11552 # `ac_cv_env_foo' variables (set or unset) will be overridden when
11553 # loading this file, other *unset* `ac_cv_foo' will be assigned the
11554 # following values.
11555
11556 _ACEOF
11557
11558 # The following way of writing the cache mishandles newlines in values,
11559 # but we know of no workaround that is simple, portable, and efficient.
11560 # So, don't put newlines in cache variables' values.
11561 # Ultrix sh set writes to stderr and can't be redirected directly,
11562 # and sets the high bit in the cache file unless we assign to the vars.
11563 {
11564   (set) 2>&1 |
11565     case `(ac_space=' '; set | grep ac_space) 2>&1` in
11566     *ac_space=\ *)
11567       # `set' does not quote correctly, so add quotes (double-quote
11568       # substitution turns \\\\ into \\, and sed turns \\ into \).
11569       sed -n \
11570         "s/'/'\\\\''/g;
11571           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
11572       ;;
11573     *)
11574       # `set' quotes correctly as required by POSIX, so do not add quotes.
11575       sed -n \
11576         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
11577       ;;
11578     esac;
11579 } |
11580   sed '
11581      t clear
11582      : clear
11583      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
11584      t end
11585      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
11586      : end' >>confcache
11587 if diff $cache_file confcache >/dev/null 2>&1; then :; else
11588   if test -w $cache_file; then
11589     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
11590     cat confcache >$cache_file
11591   else
11592     echo "not updating unwritable cache $cache_file"
11593   fi
11594 fi
11595 rm -f confcache
11596
11597 test "x$prefix" = xNONE && prefix=$ac_default_prefix
11598 # Let make expand exec_prefix.
11599 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
11600
11601 # VPATH may cause trouble with some makes, so we remove $(srcdir),
11602 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
11603 # trailing colons and then remove the whole line if VPATH becomes empty
11604 # (actually we leave an empty line to preserve line numbers).
11605 if test "x$srcdir" = x.; then
11606   ac_vpsub='/^[  ]*VPATH[        ]*=/{
11607 s/:*\$(srcdir):*/:/;
11608 s/:*\${srcdir}:*/:/;
11609 s/:*@srcdir@:*/:/;
11610 s/^\([^=]*=[     ]*\):*/\1/;
11611 s/:*$//;
11612 s/^[^=]*=[       ]*$//;
11613 }'
11614 fi
11615
11616 # Transform confdefs.h into DEFS.
11617 # Protect against shell expansion while executing Makefile rules.
11618 # Protect against Makefile macro expansion.
11619 #
11620 # If the first sed substitution is executed (which looks for macros that
11621 # take arguments), then we branch to the quote section.  Otherwise,
11622 # look for a macro that doesn't take arguments.
11623 cat >confdef2opt.sed <<\_ACEOF
11624 t clear
11625 : clear
11626 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
11627 t quote
11628 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
11629 t quote
11630 d
11631 : quote
11632 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
11633 s,\[,\\&,g
11634 s,\],\\&,g
11635 s,\$,$$,g
11636 p
11637 _ACEOF
11638 # We use echo to avoid assuming a particular line-breaking character.
11639 # The extra dot is to prevent the shell from consuming trailing
11640 # line-breaks from the sub-command output.  A line-break within
11641 # single-quotes doesn't work because, if this script is created in a
11642 # platform that uses two characters for line-breaks (e.g., DOS), tr
11643 # would break.
11644 ac_LF_and_DOT=`echo; echo .`
11645 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
11646 rm -f confdef2opt.sed
11647
11648
11649 ac_libobjs=
11650 ac_ltlibobjs=
11651 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
11652   # 1. Remove the extension, and $U if already installed.
11653   ac_i=`echo "$ac_i" |
11654          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
11655   # 2. Add them.
11656   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
11657   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
11658 done
11659 LIBOBJS=$ac_libobjs
11660
11661 LTLIBOBJS=$ac_ltlibobjs
11662
11663
11664
11665 : ${CONFIG_STATUS=./config.status}
11666 ac_clean_files_save=$ac_clean_files
11667 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
11668 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
11669 echo "$as_me: creating $CONFIG_STATUS" >&6;}
11670 cat >$CONFIG_STATUS <<_ACEOF
11671 #! $SHELL
11672 # Generated by $as_me.
11673 # Run this file to recreate the current configuration.
11674 # Compiler output produced by configure, useful for debugging
11675 # configure, is in config.log if it exists.
11676
11677 debug=false
11678 ac_cs_recheck=false
11679 ac_cs_silent=false
11680 SHELL=\${CONFIG_SHELL-$SHELL}
11681 _ACEOF
11682
11683 cat >>$CONFIG_STATUS <<\_ACEOF
11684 ## --------------------- ##
11685 ## M4sh Initialization.  ##
11686 ## --------------------- ##
11687
11688 # Be Bourne compatible
11689 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
11690   emulate sh
11691   NULLCMD=:
11692   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
11693   # is contrary to our usage.  Disable this feature.
11694   alias -g '${1+"$@"}'='"$@"'
11695 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
11696   set -o posix
11697 fi
11698 DUALCASE=1; export DUALCASE # for MKS sh
11699
11700 # Support unset when possible.
11701 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
11702   as_unset=unset
11703 else
11704   as_unset=false
11705 fi
11706
11707
11708 # Work around bugs in pre-3.0 UWIN ksh.
11709 $as_unset ENV MAIL MAILPATH
11710 PS1='$ '
11711 PS2='> '
11712 PS4='+ '
11713
11714 # NLS nuisances.
11715 for as_var in \
11716   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
11717   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
11718   LC_TELEPHONE LC_TIME
11719 do
11720   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
11721     eval $as_var=C; export $as_var
11722   else
11723     $as_unset $as_var
11724   fi
11725 done
11726
11727 # Required to use basename.
11728 if expr a : '\(a\)' >/dev/null 2>&1; then
11729   as_expr=expr
11730 else
11731   as_expr=false
11732 fi
11733
11734 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
11735   as_basename=basename
11736 else
11737   as_basename=false
11738 fi
11739
11740
11741 # Name of the executable.
11742 as_me=`$as_basename "$0" ||
11743 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
11744          X"$0" : 'X\(//\)$' \| \
11745          X"$0" : 'X\(/\)$' \| \
11746          .     : '\(.\)' 2>/dev/null ||
11747 echo X/"$0" |
11748     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
11749           /^X\/\(\/\/\)$/{ s//\1/; q; }
11750           /^X\/\(\/\).*/{ s//\1/; q; }
11751           s/.*/./; q'`
11752
11753
11754 # PATH needs CR, and LINENO needs CR and PATH.
11755 # Avoid depending upon Character Ranges.
11756 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
11757 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
11758 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
11759 as_cr_digits='0123456789'
11760 as_cr_alnum=$as_cr_Letters$as_cr_digits
11761
11762 # The user is always right.
11763 if test "${PATH_SEPARATOR+set}" != set; then
11764   echo "#! /bin/sh" >conf$$.sh
11765   echo  "exit 0"   >>conf$$.sh
11766   chmod +x conf$$.sh
11767   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
11768     PATH_SEPARATOR=';'
11769   else
11770     PATH_SEPARATOR=:
11771   fi
11772   rm -f conf$$.sh
11773 fi
11774
11775
11776   as_lineno_1=$LINENO
11777   as_lineno_2=$LINENO
11778   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
11779   test "x$as_lineno_1" != "x$as_lineno_2" &&
11780   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
11781   # Find who we are.  Look in the path if we contain no path at all
11782   # relative or not.
11783   case $0 in
11784     *[\\/]* ) as_myself=$0 ;;
11785     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11786 for as_dir in $PATH
11787 do
11788   IFS=$as_save_IFS
11789   test -z "$as_dir" && as_dir=.
11790   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
11791 done
11792
11793        ;;
11794   esac
11795   # We did not find ourselves, most probably we were run as `sh COMMAND'
11796   # in which case we are not to be found in the path.
11797   if test "x$as_myself" = x; then
11798     as_myself=$0
11799   fi
11800   if test ! -f "$as_myself"; then
11801     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
11802 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
11803    { (exit 1); exit 1; }; }
11804   fi
11805   case $CONFIG_SHELL in
11806   '')
11807     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11808 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
11809 do
11810   IFS=$as_save_IFS
11811   test -z "$as_dir" && as_dir=.
11812   for as_base in sh bash ksh sh5; do
11813          case $as_dir in
11814          /*)
11815            if ("$as_dir/$as_base" -c '
11816   as_lineno_1=$LINENO
11817   as_lineno_2=$LINENO
11818   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
11819   test "x$as_lineno_1" != "x$as_lineno_2" &&
11820   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
11821              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
11822              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
11823              CONFIG_SHELL=$as_dir/$as_base
11824              export CONFIG_SHELL
11825              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
11826            fi;;
11827          esac
11828        done
11829 done
11830 ;;
11831   esac
11832
11833   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
11834   # uniformly replaced by the line number.  The first 'sed' inserts a
11835   # line-number line before each line; the second 'sed' does the real
11836   # work.  The second script uses 'N' to pair each line-number line
11837   # with the numbered line, and appends trailing '-' during
11838   # substitution so that $LINENO is not a special case at line end.
11839   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
11840   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
11841   sed '=' <$as_myself |
11842     sed '
11843       N
11844       s,$,-,
11845       : loop
11846       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
11847       t loop
11848       s,-$,,
11849       s,^['$as_cr_digits']*\n,,
11850     ' >$as_me.lineno &&
11851   chmod +x $as_me.lineno ||
11852     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
11853 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
11854    { (exit 1); exit 1; }; }
11855
11856   # Don't try to exec as it changes $[0], causing all sort of problems
11857   # (the dirname of $[0] is not the place where we might find the
11858   # original and so on.  Autoconf is especially sensible to this).
11859   . ./$as_me.lineno
11860   # Exit status is that of the last command.
11861   exit
11862 }
11863
11864
11865 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
11866   *c*,-n*) ECHO_N= ECHO_C='
11867 ' ECHO_T='      ' ;;
11868   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
11869   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
11870 esac
11871
11872 if expr a : '\(a\)' >/dev/null 2>&1; then
11873   as_expr=expr
11874 else
11875   as_expr=false
11876 fi
11877
11878 rm -f conf$$ conf$$.exe conf$$.file
11879 echo >conf$$.file
11880 if ln -s conf$$.file conf$$ 2>/dev/null; then
11881   # We could just check for DJGPP; but this test a) works b) is more generic
11882   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
11883   if test -f conf$$.exe; then
11884     # Don't use ln at all; we don't have any links
11885     as_ln_s='cp -p'
11886   else
11887     as_ln_s='ln -s'
11888   fi
11889 elif ln conf$$.file conf$$ 2>/dev/null; then
11890   as_ln_s=ln
11891 else
11892   as_ln_s='cp -p'
11893 fi
11894 rm -f conf$$ conf$$.exe conf$$.file
11895
11896 if mkdir -p . 2>/dev/null; then
11897   as_mkdir_p=:
11898 else
11899   test -d ./-p && rmdir ./-p
11900   as_mkdir_p=false
11901 fi
11902
11903 as_executable_p="test -f"
11904
11905 # Sed expression to map a string onto a valid CPP name.
11906 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
11907
11908 # Sed expression to map a string onto a valid variable name.
11909 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
11910
11911
11912 # IFS
11913 # We need space, tab and new line, in precisely that order.
11914 as_nl='
11915 '
11916 IFS="   $as_nl"
11917
11918 # CDPATH.
11919 $as_unset CDPATH
11920
11921 exec 6>&1
11922
11923 # Open the log real soon, to keep \$[0] and so on meaningful, and to
11924 # report actual input values of CONFIG_FILES etc. instead of their
11925 # values after options handling.  Logging --version etc. is OK.
11926 exec 5>>config.log
11927 {
11928   echo
11929   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
11930 ## Running $as_me. ##
11931 _ASBOX
11932 } >&5
11933 cat >&5 <<_CSEOF
11934
11935 This file was extended by $as_me, which was
11936 generated by GNU Autoconf 2.59.  Invocation command line was
11937
11938   CONFIG_FILES    = $CONFIG_FILES
11939   CONFIG_HEADERS  = $CONFIG_HEADERS
11940   CONFIG_LINKS    = $CONFIG_LINKS
11941   CONFIG_COMMANDS = $CONFIG_COMMANDS
11942   $ $0 $@
11943
11944 _CSEOF
11945 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
11946 echo >&5
11947 _ACEOF
11948
11949 # Files that config.status was made for.
11950 if test -n "$ac_config_files"; then
11951   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
11952 fi
11953
11954 if test -n "$ac_config_headers"; then
11955   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
11956 fi
11957
11958 if test -n "$ac_config_links"; then
11959   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
11960 fi
11961
11962 if test -n "$ac_config_commands"; then
11963   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
11964 fi
11965
11966 cat >>$CONFIG_STATUS <<\_ACEOF
11967
11968 ac_cs_usage="\
11969 \`$as_me' instantiates files from templates according to the
11970 current configuration.
11971
11972 Usage: $0 [OPTIONS] [FILE]...
11973
11974   -h, --help       print this help, then exit
11975   -V, --version    print version number, then exit
11976   -q, --quiet      do not print progress messages
11977   -d, --debug      don't remove temporary files
11978       --recheck    update $as_me by reconfiguring in the same conditions
11979   --file=FILE[:TEMPLATE]
11980                    instantiate the configuration file FILE
11981
11982 Configuration files:
11983 $config_files
11984
11985 Report bugs to <bug-autoconf@gnu.org>."
11986 _ACEOF
11987
11988 cat >>$CONFIG_STATUS <<_ACEOF
11989 ac_cs_version="\\
11990 config.status
11991 configured by $0, generated by GNU Autoconf 2.59,
11992   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
11993
11994 Copyright (C) 2003 Free Software Foundation, Inc.
11995 This config.status script is free software; the Free Software Foundation
11996 gives unlimited permission to copy, distribute and modify it."
11997 srcdir=$srcdir
11998 INSTALL="$INSTALL"
11999 _ACEOF
12000
12001 cat >>$CONFIG_STATUS <<\_ACEOF
12002 # If no file are specified by the user, then we need to provide default
12003 # value.  By we need to know if files were specified by the user.
12004 ac_need_defaults=:
12005 while test $# != 0
12006 do
12007   case $1 in
12008   --*=*)
12009     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12010     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12011     ac_shift=:
12012     ;;
12013   -*)
12014     ac_option=$1
12015     ac_optarg=$2
12016     ac_shift=shift
12017     ;;
12018   *) # This is not an option, so the user has probably given explicit
12019      # arguments.
12020      ac_option=$1
12021      ac_need_defaults=false;;
12022   esac
12023
12024   case $ac_option in
12025   # Handling of the options.
12026 _ACEOF
12027 cat >>$CONFIG_STATUS <<\_ACEOF
12028   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12029     ac_cs_recheck=: ;;
12030   --version | --vers* | -V )
12031     echo "$ac_cs_version"; exit 0 ;;
12032   --he | --h)
12033     # Conflict between --help and --header
12034     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12035 Try \`$0 --help' for more information." >&5
12036 echo "$as_me: error: ambiguous option: $1
12037 Try \`$0 --help' for more information." >&2;}
12038    { (exit 1); exit 1; }; };;
12039   --help | --hel | -h )
12040     echo "$ac_cs_usage"; exit 0 ;;
12041   --debug | --d* | -d )
12042     debug=: ;;
12043   --file | --fil | --fi | --f )
12044     $ac_shift
12045     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12046     ac_need_defaults=false;;
12047   --header | --heade | --head | --hea )
12048     $ac_shift
12049     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12050     ac_need_defaults=false;;
12051   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12052   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12053     ac_cs_silent=: ;;
12054
12055   # This is an error.
12056   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12057 Try \`$0 --help' for more information." >&5
12058 echo "$as_me: error: unrecognized option: $1
12059 Try \`$0 --help' for more information." >&2;}
12060    { (exit 1); exit 1; }; } ;;
12061
12062   *) ac_config_targets="$ac_config_targets $1" ;;
12063
12064   esac
12065   shift
12066 done
12067
12068 ac_configure_extra_args=
12069
12070 if $ac_cs_silent; then
12071   exec 6>/dev/null
12072   ac_configure_extra_args="$ac_configure_extra_args --silent"
12073 fi
12074
12075 _ACEOF
12076 cat >>$CONFIG_STATUS <<_ACEOF
12077 if \$ac_cs_recheck; then
12078   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12079   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12080 fi
12081
12082 _ACEOF
12083
12084
12085
12086
12087
12088 cat >>$CONFIG_STATUS <<\_ACEOF
12089 for ac_config_target in $ac_config_targets
12090 do
12091   case "$ac_config_target" in
12092   # Handling of arguments.
12093   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12094   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12095 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12096    { (exit 1); exit 1; }; };;
12097   esac
12098 done
12099
12100 # If the user did not use the arguments to specify the items to instantiate,
12101 # then the envvar interface is used.  Set only those that are not.
12102 # We use the long form for the default assignment because of an extremely
12103 # bizarre bug on SunOS 4.1.3.
12104 if $ac_need_defaults; then
12105   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12106 fi
12107
12108 # Have a temporary directory for convenience.  Make it in the build tree
12109 # simply because there is no reason to put it here, and in addition,
12110 # creating and moving files from /tmp can sometimes cause problems.
12111 # Create a temporary directory, and hook for its removal unless debugging.
12112 $debug ||
12113 {
12114   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12115   trap '{ (exit 1); exit 1; }' 1 2 13 15
12116 }
12117
12118 # Create a (secure) tmp directory for tmp files.
12119
12120 {
12121   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12122   test -n "$tmp" && test -d "$tmp"
12123 }  ||
12124 {
12125   tmp=./confstat$$-$RANDOM
12126   (umask 077 && mkdir $tmp)
12127 } ||
12128 {
12129    echo "$me: cannot create a temporary directory in ." >&2
12130    { (exit 1); exit 1; }
12131 }
12132
12133 _ACEOF
12134
12135 cat >>$CONFIG_STATUS <<_ACEOF
12136
12137 #
12138 # CONFIG_FILES section.
12139 #
12140
12141 # No need to generate the scripts if there are no CONFIG_FILES.
12142 # This happens for instance when ./config.status config.h
12143 if test -n "\$CONFIG_FILES"; then
12144   # Protect against being on the right side of a sed subst in config.status.
12145   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12146    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12147 s,@SHELL@,$SHELL,;t t
12148 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12149 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12150 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12151 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12152 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12153 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12154 s,@exec_prefix@,$exec_prefix,;t t
12155 s,@prefix@,$prefix,;t t
12156 s,@program_transform_name@,$program_transform_name,;t t
12157 s,@bindir@,$bindir,;t t
12158 s,@sbindir@,$sbindir,;t t
12159 s,@libexecdir@,$libexecdir,;t t
12160 s,@datadir@,$datadir,;t t
12161 s,@sysconfdir@,$sysconfdir,;t t
12162 s,@sharedstatedir@,$sharedstatedir,;t t
12163 s,@localstatedir@,$localstatedir,;t t
12164 s,@libdir@,$libdir,;t t
12165 s,@includedir@,$includedir,;t t
12166 s,@oldincludedir@,$oldincludedir,;t t
12167 s,@infodir@,$infodir,;t t
12168 s,@mandir@,$mandir,;t t
12169 s,@build_alias@,$build_alias,;t t
12170 s,@host_alias@,$host_alias,;t t
12171 s,@target_alias@,$target_alias,;t t
12172 s,@DEFS@,$DEFS,;t t
12173 s,@ECHO_C@,$ECHO_C,;t t
12174 s,@ECHO_N@,$ECHO_N,;t t
12175 s,@ECHO_T@,$ECHO_T,;t t
12176 s,@LIBS@,$LIBS,;t t
12177 s,@build@,$build,;t t
12178 s,@build_cpu@,$build_cpu,;t t
12179 s,@build_vendor@,$build_vendor,;t t
12180 s,@build_os@,$build_os,;t t
12181 s,@build_noncanonical@,$build_noncanonical,;t t
12182 s,@host_noncanonical@,$host_noncanonical,;t t
12183 s,@target_noncanonical@,$target_noncanonical,;t t
12184 s,@host@,$host,;t t
12185 s,@host_cpu@,$host_cpu,;t t
12186 s,@host_vendor@,$host_vendor,;t t
12187 s,@host_os@,$host_os,;t t
12188 s,@target@,$target,;t t
12189 s,@target_cpu@,$target_cpu,;t t
12190 s,@target_vendor@,$target_vendor,;t t
12191 s,@target_os@,$target_os,;t t
12192 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12193 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12194 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12195 s,@LN@,$LN,;t t
12196 s,@LN_S@,$LN_S,;t t
12197 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12198 s,@build_libsubdir@,$build_libsubdir,;t t
12199 s,@build_subdir@,$build_subdir,;t t
12200 s,@host_subdir@,$host_subdir,;t t
12201 s,@target_subdir@,$target_subdir,;t t
12202 s,@CC@,$CC,;t t
12203 s,@CFLAGS@,$CFLAGS,;t t
12204 s,@LDFLAGS@,$LDFLAGS,;t t
12205 s,@CPPFLAGS@,$CPPFLAGS,;t t
12206 s,@ac_ct_CC@,$ac_ct_CC,;t t
12207 s,@EXEEXT@,$EXEEXT,;t t
12208 s,@OBJEXT@,$OBJEXT,;t t
12209 s,@CXX@,$CXX,;t t
12210 s,@CXXFLAGS@,$CXXFLAGS,;t t
12211 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12212 s,@GNATBIND@,$GNATBIND,;t t
12213 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12214 s,@GNATMAKE@,$GNATMAKE,;t t
12215 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12216 s,@do_compare@,$do_compare,;t t
12217 s,@gmplibs@,$gmplibs,;t t
12218 s,@gmpinc@,$gmpinc,;t t
12219 s,@stage1_languages@,$stage1_languages,;t t
12220 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12221 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12222 s,@tooldir@,$tooldir,;t t
12223 s,@build_tooldir@,$build_tooldir,;t t
12224 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12225 s,@GDB_TK@,$GDB_TK,;t t
12226 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12227 s,@build_configargs@,$build_configargs,;t t
12228 s,@build_configdirs@,$build_configdirs,;t t
12229 s,@host_configargs@,$host_configargs,;t t
12230 s,@configdirs@,$configdirs,;t t
12231 s,@target_configargs@,$target_configargs,;t t
12232 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12233 s,@config_shell@,$config_shell,;t t
12234 s,@YACC@,$YACC,;t t
12235 s,@BISON@,$BISON,;t t
12236 s,@M4@,$M4,;t t
12237 s,@LEX@,$LEX,;t t
12238 s,@FLEX@,$FLEX,;t t
12239 s,@MAKEINFO@,$MAKEINFO,;t t
12240 s,@EXPECT@,$EXPECT,;t t
12241 s,@RUNTEST@,$RUNTEST,;t t
12242 s,@AR@,$AR,;t t
12243 s,@AS@,$AS,;t t
12244 s,@DLLTOOL@,$DLLTOOL,;t t
12245 s,@LD@,$LD,;t t
12246 s,@LIPO@,$LIPO,;t t
12247 s,@NM@,$NM,;t t
12248 s,@RANLIB@,$RANLIB,;t t
12249 s,@STRIP@,$STRIP,;t t
12250 s,@WINDRES@,$WINDRES,;t t
12251 s,@OBJCOPY@,$OBJCOPY,;t t
12252 s,@OBJDUMP@,$OBJDUMP,;t t
12253 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12254 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12255 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12256 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12257 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12258 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12259 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12260 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12261 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12262 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12263 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12264 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12265 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12266 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12267 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12268 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12269 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12270 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12271 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12272 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12273 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12274 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12275 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12276 s,@MAINT@,$MAINT,;t t
12277 s,@stage1_cflags@,$stage1_cflags,;t t
12278 s,@stage1_checking@,$stage1_checking,;t t
12279 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12280 s,@datarootdir@,$datarootdir,;t t
12281 s,@docdir@,$docdir,;t t
12282 s,@htmldir@,$htmldir,;t t
12283 s,@LIBOBJS@,$LIBOBJS,;t t
12284 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12285 /@serialization_dependencies@/r $serialization_dependencies
12286 s,@serialization_dependencies@,,;t t
12287 /@host_makefile_frag@/r $host_makefile_frag
12288 s,@host_makefile_frag@,,;t t
12289 /@target_makefile_frag@/r $target_makefile_frag
12290 s,@target_makefile_frag@,,;t t
12291 /@alphaieee_frag@/r $alphaieee_frag
12292 s,@alphaieee_frag@,,;t t
12293 /@ospace_frag@/r $ospace_frag
12294 s,@ospace_frag@,,;t t
12295 CEOF
12296
12297 _ACEOF
12298
12299   cat >>$CONFIG_STATUS <<\_ACEOF
12300   # Split the substitutions into bite-sized pieces for seds with
12301   # small command number limits, like on Digital OSF/1 and HP-UX.
12302   ac_max_sed_lines=48
12303   ac_sed_frag=1 # Number of current file.
12304   ac_beg=1 # First line for current file.
12305   ac_end=$ac_max_sed_lines # Line after last line for current file.
12306   ac_more_lines=:
12307   ac_sed_cmds=
12308   while $ac_more_lines; do
12309     if test $ac_beg -gt 1; then
12310       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12311     else
12312       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12313     fi
12314     if test ! -s $tmp/subs.frag; then
12315       ac_more_lines=false
12316     else
12317       # The purpose of the label and of the branching condition is to
12318       # speed up the sed processing (if there are no `@' at all, there
12319       # is no need to browse any of the substitutions).
12320       # These are the two extra sed commands mentioned above.
12321       (echo ':t
12322   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12323       if test -z "$ac_sed_cmds"; then
12324         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12325       else
12326         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12327       fi
12328       ac_sed_frag=`expr $ac_sed_frag + 1`
12329       ac_beg=$ac_end
12330       ac_end=`expr $ac_end + $ac_max_sed_lines`
12331     fi
12332   done
12333   if test -z "$ac_sed_cmds"; then
12334     ac_sed_cmds=cat
12335   fi
12336 fi # test -n "$CONFIG_FILES"
12337
12338 _ACEOF
12339 cat >>$CONFIG_STATUS <<\_ACEOF
12340 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12341   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12342   case $ac_file in
12343   - | *:- | *:-:* ) # input from stdin
12344         cat >$tmp/stdin
12345         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12346         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12347   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12348         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12349   * )   ac_file_in=$ac_file.in ;;
12350   esac
12351
12352   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12353   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12354 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12355          X"$ac_file" : 'X\(//\)[^/]' \| \
12356          X"$ac_file" : 'X\(//\)$' \| \
12357          X"$ac_file" : 'X\(/\)' \| \
12358          .     : '\(.\)' 2>/dev/null ||
12359 echo X"$ac_file" |
12360     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12361           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12362           /^X\(\/\/\)$/{ s//\1/; q; }
12363           /^X\(\/\).*/{ s//\1/; q; }
12364           s/.*/./; q'`
12365   { if $as_mkdir_p; then
12366     mkdir -p "$ac_dir"
12367   else
12368     as_dir="$ac_dir"
12369     as_dirs=
12370     while test ! -d "$as_dir"; do
12371       as_dirs="$as_dir $as_dirs"
12372       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12373 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12374          X"$as_dir" : 'X\(//\)[^/]' \| \
12375          X"$as_dir" : 'X\(//\)$' \| \
12376          X"$as_dir" : 'X\(/\)' \| \
12377          .     : '\(.\)' 2>/dev/null ||
12378 echo X"$as_dir" |
12379     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12380           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12381           /^X\(\/\/\)$/{ s//\1/; q; }
12382           /^X\(\/\).*/{ s//\1/; q; }
12383           s/.*/./; q'`
12384     done
12385     test ! -n "$as_dirs" || mkdir $as_dirs
12386   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
12387 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
12388    { (exit 1); exit 1; }; }; }
12389
12390   ac_builddir=.
12391
12392 if test "$ac_dir" != .; then
12393   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
12394   # A "../" for each directory in $ac_dir_suffix.
12395   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
12396 else
12397   ac_dir_suffix= ac_top_builddir=
12398 fi
12399
12400 case $srcdir in
12401   .)  # No --srcdir option.  We are building in place.
12402     ac_srcdir=.
12403     if test -z "$ac_top_builddir"; then
12404        ac_top_srcdir=.
12405     else
12406        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
12407     fi ;;
12408   [\\/]* | ?:[\\/]* )  # Absolute path.
12409     ac_srcdir=$srcdir$ac_dir_suffix;
12410     ac_top_srcdir=$srcdir ;;
12411   *) # Relative path.
12412     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
12413     ac_top_srcdir=$ac_top_builddir$srcdir ;;
12414 esac
12415
12416 # Do not use `cd foo && pwd` to compute absolute paths, because
12417 # the directories may not exist.
12418 case `pwd` in
12419 .) ac_abs_builddir="$ac_dir";;
12420 *)
12421   case "$ac_dir" in
12422   .) ac_abs_builddir=`pwd`;;
12423   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
12424   *) ac_abs_builddir=`pwd`/"$ac_dir";;
12425   esac;;
12426 esac
12427 case $ac_abs_builddir in
12428 .) ac_abs_top_builddir=${ac_top_builddir}.;;
12429 *)
12430   case ${ac_top_builddir}. in
12431   .) ac_abs_top_builddir=$ac_abs_builddir;;
12432   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
12433   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
12434   esac;;
12435 esac
12436 case $ac_abs_builddir in
12437 .) ac_abs_srcdir=$ac_srcdir;;
12438 *)
12439   case $ac_srcdir in
12440   .) ac_abs_srcdir=$ac_abs_builddir;;
12441   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
12442   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
12443   esac;;
12444 esac
12445 case $ac_abs_builddir in
12446 .) ac_abs_top_srcdir=$ac_top_srcdir;;
12447 *)
12448   case $ac_top_srcdir in
12449   .) ac_abs_top_srcdir=$ac_abs_builddir;;
12450   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
12451   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
12452   esac;;
12453 esac
12454
12455
12456   case $INSTALL in
12457   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
12458   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
12459   esac
12460
12461   if test x"$ac_file" != x-; then
12462     { echo "$as_me:$LINENO: creating $ac_file" >&5
12463 echo "$as_me: creating $ac_file" >&6;}
12464     rm -f "$ac_file"
12465   fi
12466   # Let's still pretend it is `configure' which instantiates (i.e., don't
12467   # use $as_me), people would be surprised to read:
12468   #    /* config.h.  Generated by config.status.  */
12469   if test x"$ac_file" = x-; then
12470     configure_input=
12471   else
12472     configure_input="$ac_file.  "
12473   fi
12474   configure_input=$configure_input"Generated from `echo $ac_file_in |
12475                                      sed 's,.*/,,'` by configure."
12476
12477   # First look for the input files in the build tree, otherwise in the
12478   # src tree.
12479   ac_file_inputs=`IFS=:
12480     for f in $ac_file_in; do
12481       case $f in
12482       -) echo $tmp/stdin ;;
12483       [\\/$]*)
12484          # Absolute (can't be DOS-style, as IFS=:)
12485          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
12486 echo "$as_me: error: cannot find input file: $f" >&2;}
12487    { (exit 1); exit 1; }; }
12488          echo "$f";;
12489       *) # Relative
12490          if test -f "$f"; then
12491            # Build tree
12492            echo "$f"
12493          elif test -f "$srcdir/$f"; then
12494            # Source tree
12495            echo "$srcdir/$f"
12496          else
12497            # /dev/null tree
12498            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
12499 echo "$as_me: error: cannot find input file: $f" >&2;}
12500    { (exit 1); exit 1; }; }
12501          fi;;
12502       esac
12503     done` || { (exit 1); exit 1; }
12504 _ACEOF
12505 cat >>$CONFIG_STATUS <<_ACEOF
12506   sed "$ac_vpsub
12507 $extrasub
12508 _ACEOF
12509 cat >>$CONFIG_STATUS <<\_ACEOF
12510 :t
12511 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
12512 s,@configure_input@,$configure_input,;t t
12513 s,@srcdir@,$ac_srcdir,;t t
12514 s,@abs_srcdir@,$ac_abs_srcdir,;t t
12515 s,@top_srcdir@,$ac_top_srcdir,;t t
12516 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
12517 s,@builddir@,$ac_builddir,;t t
12518 s,@abs_builddir@,$ac_abs_builddir,;t t
12519 s,@top_builddir@,$ac_top_builddir,;t t
12520 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
12521 s,@INSTALL@,$ac_INSTALL,;t t
12522 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
12523   rm -f $tmp/stdin
12524   if test x"$ac_file" != x-; then
12525     mv $tmp/out $ac_file
12526   else
12527     cat $tmp/out
12528     rm -f $tmp/out
12529   fi
12530
12531 done
12532 _ACEOF
12533
12534 cat >>$CONFIG_STATUS <<\_ACEOF
12535
12536 { (exit 0); exit 0; }
12537 _ACEOF
12538 chmod +x $CONFIG_STATUS
12539 ac_clean_files=$ac_clean_files_save
12540
12541
12542 # configure is writing to config.log, and then calls config.status.
12543 # config.status does its own redirection, appending to config.log.
12544 # Unfortunately, on DOS this fails, as config.log is still kept open
12545 # by configure, so config.status won't be able to write to it; its
12546 # output is simply discarded.  So we exec the FD to /dev/null,
12547 # effectively closing config.log, so it can be properly (re)opened and
12548 # appended to by config.status.  When coming back to configure, we
12549 # need to make the FD available again.
12550 if test "$no_create" != yes; then
12551   ac_cs_success=:
12552   ac_config_status_args=
12553   test "$silent" = yes &&
12554     ac_config_status_args="$ac_config_status_args --quiet"
12555   exec 5>/dev/null
12556   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
12557   exec 5>>config.log
12558   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
12559   # would make configure fail if this is the last instruction.
12560   $ac_cs_success || { (exit 1); exit 1; }
12561 fi
12562