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 pdfdir 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-pdfdir Install pdf in this directory.
 965   --with-htmldir        Install html in this directory.
 966
 967 Some influential environment variables:
 968   CC          C compiler command
 969   CFLAGS      C compiler flags
 970   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 971               nonstandard directory <lib dir>
 972   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 973               headers in a nonstandard directory <include dir>
 974   CXX         C++ compiler command
 975   CXXFLAGS    C++ compiler flags
 976   AR          AR for the host
 977   AS          AS for the host
 978   DLLTOOL     DLLTOOL for the host
 979   LD          LD for the host
 980   LIPO        LIPO for the host
 981   NM          NM for the host
 982   RANLIB      RANLIB for the host
 983   STRIP       STRIP for the host
 984   WINDRES     WINDRES for the host
 985   OBJCOPY     OBJCOPY for the host
 986   OBJDUMP     OBJDUMP for the host
 987   CC_FOR_TARGET
 988               CC for the target
 989   CXX_FOR_TARGET
 990               CXX for the target
 991   GCC_FOR_TARGET
 992               GCC for the target
 993   GCJ_FOR_TARGET
 994               GCJ for the target
 995   GFORTRAN_FOR_TARGET
 996               GFORTRAN for the target
 997   AR_FOR_TARGET
 998               AR for the target
 999   AS_FOR_TARGET
1000               AS for the target
1001   DLLTOOL_FOR_TARGET
1002               DLLTOOL for the target
1003   LD_FOR_TARGET
1004               LD for the target
1005   LIPO_FOR_TARGET
1006               LIPO for the target
1007   NM_FOR_TARGET
1008               NM for the target
1009   OBJDUMP_FOR_TARGET
1010               OBJDUMP for the target
1011   RANLIB_FOR_TARGET
1012               RANLIB for the target
1013   STRIP_FOR_TARGET
1014               STRIP for the target
1015   WINDRES_FOR_TARGET
1016               WINDRES for the target
1017
1018 Use these variables to override the choices made by `configure' or to help
1019 it to find libraries and programs with nonstandard names/locations.
1020
1021 _ACEOF
1022 fi
1023
1024 if test "$ac_init_help" = "recursive"; then
1025   # If there are subdirs, report their specific --help.
1026   ac_popdir=`pwd`
1027   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1028     test -d $ac_dir || continue
1029     ac_builddir=.
1030
1031 if test "$ac_dir" != .; then
1032   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1033   # A "../" for each directory in $ac_dir_suffix.
1034   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1035 else
1036   ac_dir_suffix= ac_top_builddir=
1037 fi
1038
1039 case $srcdir in
1040   .)  # No --srcdir option.  We are building in place.
1041     ac_srcdir=.
1042     if test -z "$ac_top_builddir"; then
1043        ac_top_srcdir=.
1044     else
1045        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1046     fi ;;
1047   [\\/]* | ?:[\\/]* )  # Absolute path.
1048     ac_srcdir=$srcdir$ac_dir_suffix;
1049     ac_top_srcdir=$srcdir ;;
1050   *) # Relative path.
1051     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1052     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1053 esac
1054
1055 # Do not use `cd foo && pwd` to compute absolute paths, because
1056 # the directories may not exist.
1057 case `pwd` in
1058 .) ac_abs_builddir="$ac_dir";;
1059 *)
1060   case "$ac_dir" in
1061   .) ac_abs_builddir=`pwd`;;
1062   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1063   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1064   esac;;
1065 esac
1066 case $ac_abs_builddir in
1067 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1068 *)
1069   case ${ac_top_builddir}. in
1070   .) ac_abs_top_builddir=$ac_abs_builddir;;
1071   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1072   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1073   esac;;
1074 esac
1075 case $ac_abs_builddir in
1076 .) ac_abs_srcdir=$ac_srcdir;;
1077 *)
1078   case $ac_srcdir in
1079   .) ac_abs_srcdir=$ac_abs_builddir;;
1080   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1081   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1082   esac;;
1083 esac
1084 case $ac_abs_builddir in
1085 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1086 *)
1087   case $ac_top_srcdir in
1088   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1089   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1090   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1091   esac;;
1092 esac
1093
1094     cd $ac_dir
1095     # Check for guested configure; otherwise get Cygnus style configure.
1096     if test -f $ac_srcdir/configure.gnu; then
1097       echo
1098       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1099     elif test -f $ac_srcdir/configure; then
1100       echo
1101       $SHELL $ac_srcdir/configure  --help=recursive
1102     elif test -f $ac_srcdir/configure.ac ||
1103            test -f $ac_srcdir/configure.in; then
1104       echo
1105       $ac_configure --help
1106     else
1107       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1108     fi
1109     cd $ac_popdir
1110   done
1111 fi
1112
1113 test -n "$ac_init_help" && exit 0
1114 if $ac_init_version; then
1115   cat <<\_ACEOF
1116
1117 Copyright (C) 2003 Free Software Foundation, Inc.
1118 This configure script is free software; the Free Software Foundation
1119 gives unlimited permission to copy, distribute and modify it.
1120 _ACEOF
1121   exit 0
1122 fi
1123 exec 5>config.log
1124 cat >&5 <<_ACEOF
1125 This file contains any messages produced by compilers while
1126 running configure, to aid debugging if configure makes a mistake.
1127
1128 It was created by $as_me, which was
1129 generated by GNU Autoconf 2.59.  Invocation command line was
1130
1131   $ $0 $@
1132
1133 _ACEOF
1134 {
1135 cat <<_ASUNAME
1136 ## --------- ##
1137 ## Platform. ##
1138 ## --------- ##
1139
1140 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1141 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1142 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1143 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1144 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1145
1146 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1147 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1148
1149 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1150 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1151 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1152 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1153 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1154 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1155 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1156
1157 _ASUNAME
1158
1159 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1160 for as_dir in $PATH
1161 do
1162   IFS=$as_save_IFS
1163   test -z "$as_dir" && as_dir=.
1164   echo "PATH: $as_dir"
1165 done
1166
1167 } >&5
1168
1169 cat >&5 <<_ACEOF
1170
1171
1172 ## ----------- ##
1173 ## Core tests. ##
1174 ## ----------- ##
1175
1176 _ACEOF
1177
1178
1179 # Keep a trace of the command line.
1180 # Strip out --no-create and --no-recursion so they do not pile up.
1181 # Strip out --silent because we don't want to record it for future runs.
1182 # Also quote any args containing shell meta-characters.
1183 # Make two passes to allow for proper duplicate-argument suppression.
1184 ac_configure_args=
1185 ac_configure_args0=
1186 ac_configure_args1=
1187 ac_sep=
1188 ac_must_keep_next=false
1189 for ac_pass in 1 2
1190 do
1191   for ac_arg
1192   do
1193     case $ac_arg in
1194     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1195     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1196     | -silent | --silent | --silen | --sile | --sil)
1197       continue ;;
1198     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1199       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1200     esac
1201     case $ac_pass in
1202     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1203     2)
1204       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1205       if test $ac_must_keep_next = true; then
1206         ac_must_keep_next=false # Got value, back to normal.
1207       else
1208         case $ac_arg in
1209           *=* | --config-cache | -C | -disable-* | --disable-* \
1210           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1211           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1212           | -with-* | --with-* | -without-* | --without-* | --x)
1213             case "$ac_configure_args0 " in
1214               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1215             esac
1216             ;;
1217           -* ) ac_must_keep_next=true ;;
1218         esac
1219       fi
1220       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1221       # Get rid of the leading space.
1222       ac_sep=" "
1223       ;;
1224     esac
1225   done
1226 done
1227 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1228 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1229
1230 # When interrupted or exit'd, cleanup temporary files, and complete
1231 # config.log.  We remove comments because anyway the quotes in there
1232 # would cause problems or look ugly.
1233 # WARNING: Be sure not to use single quotes in there, as some shells,
1234 # such as our DU 5.0 friend, will then `close' the trap.
1235 trap 'exit_status=$?
1236   # Save into config.log some information that might help in debugging.
1237   {
1238     echo
1239
1240     cat <<\_ASBOX
1241 ## ---------------- ##
1242 ## Cache variables. ##
1243 ## ---------------- ##
1244 _ASBOX
1245     echo
1246     # The following way of writing the cache mishandles newlines in values,
1247 {
1248   (set) 2>&1 |
1249     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1250     *ac_space=\ *)
1251       sed -n \
1252         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1253           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1254       ;;
1255     *)
1256       sed -n \
1257         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1258       ;;
1259     esac;
1260 }
1261     echo
1262
1263     cat <<\_ASBOX
1264 ## ----------------- ##
1265 ## Output variables. ##
1266 ## ----------------- ##
1267 _ASBOX
1268     echo
1269     for ac_var in $ac_subst_vars
1270     do
1271       eval ac_val=$`echo $ac_var`
1272       echo "$ac_var='"'"'$ac_val'"'"'"
1273     done | sort
1274     echo
1275
1276     if test -n "$ac_subst_files"; then
1277       cat <<\_ASBOX
1278 ## ------------- ##
1279 ## Output files. ##
1280 ## ------------- ##
1281 _ASBOX
1282       echo
1283       for ac_var in $ac_subst_files
1284       do
1285         eval ac_val=$`echo $ac_var`
1286         echo "$ac_var='"'"'$ac_val'"'"'"
1287       done | sort
1288       echo
1289     fi
1290
1291     if test -s confdefs.h; then
1292       cat <<\_ASBOX
1293 ## ----------- ##
1294 ## confdefs.h. ##
1295 ## ----------- ##
1296 _ASBOX
1297       echo
1298       sed "/^$/d" confdefs.h | sort
1299       echo
1300     fi
1301     test "$ac_signal" != 0 &&
1302       echo "$as_me: caught signal $ac_signal"
1303     echo "$as_me: exit $exit_status"
1304   } >&5
1305   rm -f core *.core &&
1306   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1307     exit $exit_status
1308      ' 0
1309 for ac_signal in 1 2 13 15; do
1310   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1311 done
1312 ac_signal=0
1313
1314 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1315 rm -rf conftest* confdefs.h
1316 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1317 echo >confdefs.h
1318
1319 # Predefined preprocessor variables.
1320
1321 cat >>confdefs.h <<_ACEOF
1322 #define PACKAGE_NAME "$PACKAGE_NAME"
1323 _ACEOF
1324
1325
1326 cat >>confdefs.h <<_ACEOF
1327 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1328 _ACEOF
1329
1330
1331 cat >>confdefs.h <<_ACEOF
1332 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1333 _ACEOF
1334
1335
1336 cat >>confdefs.h <<_ACEOF
1337 #define PACKAGE_STRING "$PACKAGE_STRING"
1338 _ACEOF
1339
1340
1341 cat >>confdefs.h <<_ACEOF
1342 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1343 _ACEOF
1344
1345
1346 # Let the site file select an alternate cache file if it wants to.
1347 # Prefer explicitly selected file to automatically selected ones.
1348 if test -z "$CONFIG_SITE"; then
1349   if test "x$prefix" != xNONE; then
1350     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1351   else
1352     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1353   fi
1354 fi
1355 for ac_site_file in $CONFIG_SITE; do
1356   if test -r "$ac_site_file"; then
1357     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1358 echo "$as_me: loading site script $ac_site_file" >&6;}
1359     sed 's/^/| /' "$ac_site_file" >&5
1360     . "$ac_site_file"
1361   fi
1362 done
1363
1364 if test -r "$cache_file"; then
1365   # Some versions of bash will fail to source /dev/null (special
1366   # files actually), so we avoid doing that.
1367   if test -f "$cache_file"; then
1368     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1369 echo "$as_me: loading cache $cache_file" >&6;}
1370     case $cache_file in
1371       [\\/]* | ?:[\\/]* ) . $cache_file;;
1372       *)                      . ./$cache_file;;
1373     esac
1374   fi
1375 else
1376   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1377 echo "$as_me: creating cache $cache_file" >&6;}
1378   >$cache_file
1379 fi
1380
1381 # Check that the precious variables saved in the cache have kept the same
1382 # value.
1383 ac_cache_corrupted=false
1384 for ac_var in `(set) 2>&1 |
1385                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1386   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1387   eval ac_new_set=\$ac_env_${ac_var}_set
1388   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1389   eval ac_new_val="\$ac_env_${ac_var}_value"
1390   case $ac_old_set,$ac_new_set in
1391     set,)
1392       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1393 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1394       ac_cache_corrupted=: ;;
1395     ,set)
1396       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1397 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1398       ac_cache_corrupted=: ;;
1399     ,);;
1400     *)
1401       if test "x$ac_old_val" != "x$ac_new_val"; then
1402         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1403 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1404         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1405 echo "$as_me:   former value:  $ac_old_val" >&2;}
1406         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1407 echo "$as_me:   current value: $ac_new_val" >&2;}
1408         ac_cache_corrupted=:
1409       fi;;
1410   esac
1411   # Pass precious variables to config.status.
1412   if test "$ac_new_set" = set; then
1413     case $ac_new_val in
1414     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1415       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1416     *) ac_arg=$ac_var=$ac_new_val ;;
1417     esac
1418     case " $ac_configure_args " in
1419       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1420       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1421     esac
1422   fi
1423 done
1424 if $ac_cache_corrupted; then
1425   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1426 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1427   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1428 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1429    { (exit 1); exit 1; }; }
1430 fi
1431
1432 ac_ext=c
1433 ac_cpp='$CPP $CPPFLAGS'
1434 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1435 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1436 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458 # Find the build, host, and target systems.
1459 ac_aux_dir=
1460 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1461   if test -f $ac_dir/install-sh; then
1462     ac_aux_dir=$ac_dir
1463     ac_install_sh="$ac_aux_dir/install-sh -c"
1464     break
1465   elif test -f $ac_dir/install.sh; then
1466     ac_aux_dir=$ac_dir
1467     ac_install_sh="$ac_aux_dir/install.sh -c"
1468     break
1469   elif test -f $ac_dir/shtool; then
1470     ac_aux_dir=$ac_dir
1471     ac_install_sh="$ac_aux_dir/shtool install -c"
1472     break
1473   fi
1474 done
1475 if test -z "$ac_aux_dir"; then
1476   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1477 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1478    { (exit 1); exit 1; }; }
1479 fi
1480 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1481 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1482 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1483
1484 # Make sure we can run config.sub.
1485 $ac_config_sub sun4 >/dev/null 2>&1 ||
1486   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1487 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1488    { (exit 1); exit 1; }; }
1489
1490 echo "$as_me:$LINENO: checking build system type" >&5
1491 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1492 if test "${ac_cv_build+set}" = set; then
1493   echo $ECHO_N "(cached) $ECHO_C" >&6
1494 else
1495   ac_cv_build_alias=$build_alias
1496 test -z "$ac_cv_build_alias" &&
1497   ac_cv_build_alias=`$ac_config_guess`
1498 test -z "$ac_cv_build_alias" &&
1499   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1500 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1501    { (exit 1); exit 1; }; }
1502 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1503   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1504 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1505    { (exit 1); exit 1; }; }
1506
1507 fi
1508 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1509 echo "${ECHO_T}$ac_cv_build" >&6
1510 build=$ac_cv_build
1511 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1512 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1513 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1514
1515
1516  case ${build_alias} in
1517   "") build_noncanonical=${build} ;;
1518   *) build_noncanonical=${build_alias} ;;
1519 esac
1520
1521
1522
1523  case ${host_alias} in
1524   "") host_noncanonical=${build_noncanonical} ;;
1525   *) host_noncanonical=${host_alias} ;;
1526 esac
1527
1528
1529
1530  case ${target_alias} in
1531   "") target_noncanonical=${host_noncanonical} ;;
1532   *) target_noncanonical=${target_alias} ;;
1533 esac
1534
1535
1536
1537
1538 test "$host_noncanonical" = "$target_noncanonical" &&
1539   test "$program_prefix$program_suffix$program_transform_name" = \
1540     NONENONEs,x,x, &&
1541   program_transform_name=s,y,y,
1542
1543 echo "$as_me:$LINENO: checking host system type" >&5
1544 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1545 if test "${ac_cv_host+set}" = set; then
1546   echo $ECHO_N "(cached) $ECHO_C" >&6
1547 else
1548   ac_cv_host_alias=$host_alias
1549 test -z "$ac_cv_host_alias" &&
1550   ac_cv_host_alias=$ac_cv_build_alias
1551 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1552   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1553 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1554    { (exit 1); exit 1; }; }
1555
1556 fi
1557 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1558 echo "${ECHO_T}$ac_cv_host" >&6
1559 host=$ac_cv_host
1560 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1561 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1562 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1563
1564
1565 echo "$as_me:$LINENO: checking target system type" >&5
1566 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1567 if test "${ac_cv_target+set}" = set; then
1568   echo $ECHO_N "(cached) $ECHO_C" >&6
1569 else
1570   ac_cv_target_alias=$target_alias
1571 test "x$ac_cv_target_alias" = "x" &&
1572   ac_cv_target_alias=$ac_cv_host_alias
1573 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1574   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1575 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1576    { (exit 1); exit 1; }; }
1577
1578 fi
1579 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1580 echo "${ECHO_T}$ac_cv_target" >&6
1581 target=$ac_cv_target
1582 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1583 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1584 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1585
1586
1587 # The aliases save the names the user supplied, while $host etc.
1588 # will get canonicalized.
1589 test -n "$target_alias" &&
1590   test "$program_prefix$program_suffix$program_transform_name" = \
1591     NONENONEs,x,x, &&
1592   program_prefix=${target_alias}-
1593 test "$program_prefix" != NONE &&
1594   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1595 # Use a double $ so make ignores it.
1596 test "$program_suffix" != NONE &&
1597   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1598 # Double any \ or $.  echo might interpret backslashes.
1599 # By default was `s,x,x', remove it if useless.
1600 cat <<\_ACEOF >conftest.sed
1601 s/[\\$]/&&/g;s/;s,x,x,$//
1602 _ACEOF
1603 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1604 rm conftest.sed
1605
1606
1607
1608 # Get 'install' or 'install-sh' and its variants.
1609 # Find a good install program.  We prefer a C program (faster),
1610 # so one script is as good as another.  But avoid the broken or
1611 # incompatible versions:
1612 # SysV /etc/install, /usr/sbin/install
1613 # SunOS /usr/etc/install
1614 # IRIX /sbin/install
1615 # AIX /bin/install
1616 # AmigaOS /C/install, which installs bootblocks on floppy discs
1617 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1618 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1619 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1620 # OS/2's system install, which has a completely different semantic
1621 # ./install, which can be erroneously created by make from ./install.sh.
1622 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1623 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1624 if test -z "$INSTALL"; then
1625 if test "${ac_cv_path_install+set}" = set; then
1626   echo $ECHO_N "(cached) $ECHO_C" >&6
1627 else
1628   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1629 for as_dir in $PATH
1630 do
1631   IFS=$as_save_IFS
1632   test -z "$as_dir" && as_dir=.
1633   # Account for people who put trailing slashes in PATH elements.
1634 case $as_dir/ in
1635   ./ | .// | /cC/* | \
1636   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1637   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1638   /usr/ucb/* ) ;;
1639   *)
1640     # OSF1 and SCO ODT 3.0 have their own names for install.
1641     # Don't use installbsd from OSF since it installs stuff as root
1642     # by default.
1643     for ac_prog in ginstall scoinst install; do
1644       for ac_exec_ext in '' $ac_executable_extensions; do
1645         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1646           if test $ac_prog = install &&
1647             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1648             # AIX install.  It has an incompatible calling convention.
1649             :
1650           elif test $ac_prog = install &&
1651             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1652             # program-specific install script used by HP pwplus--don't use.
1653             :
1654           else
1655             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1656             break 3
1657           fi
1658         fi
1659       done
1660     done
1661     ;;
1662 esac
1663 done
1664
1665
1666 fi
1667   if test "${ac_cv_path_install+set}" = set; then
1668     INSTALL=$ac_cv_path_install
1669   else
1670     # As a last resort, use the slow shell script.  We don't cache a
1671     # path for INSTALL within a source directory, because that will
1672     # break other packages using the cache if that directory is
1673     # removed, or if the path is relative.
1674     INSTALL=$ac_install_sh
1675   fi
1676 fi
1677 echo "$as_me:$LINENO: result: $INSTALL" >&5
1678 echo "${ECHO_T}$INSTALL" >&6
1679
1680 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1681 # It thinks the first close brace ends the variable substitution.
1682 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1683
1684 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1685
1686 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1687
1688 echo "$as_me:$LINENO: checking whether ln works" >&5
1689 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1690 if test "${acx_cv_prog_LN+set}" = set; then
1691   echo $ECHO_N "(cached) $ECHO_C" >&6
1692 else
1693   rm -f conftestdata_t
1694 echo >conftestdata_f
1695 if ln conftestdata_f conftestdata_t 2>/dev/null
1696 then
1697   acx_cv_prog_LN=ln
1698 else
1699   acx_cv_prog_LN=no
1700 fi
1701 rm -f conftestdata_f conftestdata_t
1702
1703 fi
1704 if test $acx_cv_prog_LN = no; then
1705   LN="cp"
1706   echo "$as_me:$LINENO: result: no, using $LN" >&5
1707 echo "${ECHO_T}no, using $LN" >&6
1708 else
1709   LN="$acx_cv_prog_LN"
1710   echo "$as_me:$LINENO: result: yes" >&5
1711 echo "${ECHO_T}yes" >&6
1712 fi
1713
1714 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1715 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1716 LN_S=$as_ln_s
1717 if test "$LN_S" = "ln -s"; then
1718   echo "$as_me:$LINENO: result: yes" >&5
1719 echo "${ECHO_T}yes" >&6
1720 else
1721   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1722 echo "${ECHO_T}no, using $LN_S" >&6
1723 fi
1724
1725
1726 ### we might need to use some other shell than /bin/sh for running subshells
1727 ### If we are on Windows, search for the shell.  This will permit people
1728 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1729 ### without also having to set CONFIG_SHELL.  This code will work when
1730 ### using bash, which sets OSTYPE.
1731 case "${OSTYPE}" in
1732 *win32*)
1733   if test x${CONFIG_SHELL} = x ; then
1734     if test ! -f /bin/sh ; then
1735       if test x${SHELL} != x && test -f ${SHELL} ; then
1736         CONFIG_SHELL=${SHELL}
1737         export CONFIG_SHELL
1738       else
1739         for prog in sh sh.exe bash bash.exe; do
1740           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1741           for dir in $PATH; do
1742             test -z "$dir" && dir=.
1743             if test -f $dir/$prog; then
1744               CONFIG_SHELL=$dir/$prog
1745               export CONFIG_SHELL
1746               break
1747             fi
1748           done
1749           IFS="$save_ifs"
1750           test -n "${CONFIG_SHELL}" && break
1751         done
1752       fi
1753     fi
1754   fi
1755   ;;
1756 esac
1757
1758 config_shell=${CONFIG_SHELL-/bin/sh}
1759
1760 progname=$0
1761 # if PWD already has a value, it is probably wrong.
1762 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1763
1764 # Export original configure arguments for use by sub-configures.
1765 # Quote arguments with shell meta charatcers.
1766 TOPLEVEL_CONFIGURE_ARGUMENTS=
1767 set -- "$progname" "$@"
1768 for ac_arg
1769 do
1770   case "$ac_arg" in
1771   *" "*|*"      "*|*\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?*)
1772     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1773     # if the argument is of the form -foo=baz, quote the baz part only
1774     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1775   *) ;;
1776   esac
1777   # Add the quoted argument to the list.
1778   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1779 done
1780 # Remove the initial space we just introduced and, as these will be
1781 # expanded by make, quote '$'.
1782 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1783
1784
1785 moveifchange=${srcdir}/move-if-change
1786
1787 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1788
1789 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1790 # a relative path.
1791 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1792   INSTALL="${srcpwd}/install-sh -c"
1793 fi
1794
1795 # Set srcdir to "." if that's what it is.
1796 # This is important for multilib support.
1797 pwd=`${PWDCMD-pwd}`
1798 if test "${pwd}" = "${srcpwd}" ; then
1799   srcdir=.
1800 fi
1801
1802 topsrcdir=$srcpwd
1803
1804 extra_host_args=
1805
1806 ### To add a new directory to the tree, first choose whether it is a target
1807 ### or a host dependent tool.  Then put it into the appropriate list
1808 ### (library or tools, host or target), doing a dependency sort.
1809
1810 # Subdirs will be configured in the order listed in build_configdirs,
1811 # configdirs, or target_configdirs; see the serialization section below.
1812
1813 # Dependency sorting is only needed when *configuration* must be done in
1814 # a particular order.  In all cases a dependency should be specified in
1815 # the Makefile, whether or not it's implicitly specified here.
1816
1817 # Double entries in build_configdirs, configdirs, or target_configdirs may
1818 # cause circular dependencies and break everything horribly.
1819
1820 # these library is used by various programs built for the build
1821 # environment
1822 #
1823 build_libs="build-libiberty"
1824
1825 # these tools are built for the build environment
1826 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1827
1828 # these libraries are used by various programs built for the host environment
1829 #
1830 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1831
1832 # these tools are built for the host environment
1833 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1834 # know that we are building the simulator.
1835 # binutils, gas and ld appear in that order because it makes sense to run
1836 # "make check" in that particular order.
1837 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"
1838
1839 # libgcj represents the runtime libraries only used by gcj.
1840 libgcj="target-libffi \
1841         target-zlib \
1842         target-qthreads \
1843         target-libjava"
1844
1845 # these libraries are built for the target environment, and are built after
1846 # the host libraries and the host tools (which may be a cross compiler)
1847 #
1848 target_libraries="target-libgcc \
1849                 target-libiberty \
1850                 target-libgloss \
1851                 target-newlib \
1852                 target-libstdc++-v3 \
1853                 target-libmudflap \
1854                 target-libssp \
1855                 target-libgfortran \
1856                 target-boehm-gc \
1857                 ${libgcj} \
1858                 target-libobjc \
1859                 target-libada \
1860                 target-libgomp"
1861
1862 # these tools are built using the target libraries, and are intended to
1863 # run only in the target environment
1864 #
1865 # note: any program that *uses* libraries that are in the "target_libraries"
1866 # list belongs in this list.  those programs are also very likely
1867 # candidates for the "native_only" list which follows
1868 #
1869 target_tools="target-examples target-groff target-gperf target-rda"
1870
1871 ################################################################################
1872
1873 ## All tools belong in one of the four categories, and are assigned above
1874 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1875 ## is important because configure will choke if they ever get through.
1876 ## ${configdirs} is directories we build using the host tools.
1877 ## ${target_configdirs} is directories we build using the target tools.
1878 configdirs=`echo ${host_libs} ${host_tools}`
1879 target_configdirs=`echo ${target_libraries} ${target_tools}`
1880 build_configdirs=`echo ${build_libs} ${build_tools}`
1881
1882 ################################################################################
1883
1884 srcname="gnu development package"
1885
1886 # This gets set non-empty for some net releases of packages.
1887 appdirs=""
1888
1889 # Define is_cross_compiler to save on calls to 'test'.
1890 is_cross_compiler=
1891 if test x"${host}" = x"${target}" ; then
1892   is_cross_compiler=no
1893 else
1894   is_cross_compiler=yes
1895 fi
1896
1897 # Find the build and target subdir names.
1898
1899 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1900 # have matching libraries, they should use host libraries: Makefile.tpl
1901 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1902 # However, they still use the build modules, because the corresponding
1903 # host modules (e.g. bison) are only built for the host when bootstrap
1904 # finishes. So:
1905 # - build_subdir is where we find build modules, and never changes.
1906 # - build_libsubdir is where we find build libraries, and can be overridden.
1907
1908 # Prefix 'build-' so this never conflicts with target_subdir.
1909 build_subdir="build-${build_noncanonical}"
1910
1911 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1912 if test "${with_build_libsubdir+set}" = set; then
1913   withval="$with_build_libsubdir"
1914   build_libsubdir="$withval"
1915 else
1916   build_libsubdir="$build_subdir"
1917 fi;
1918 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1919 if ( test $srcdir = . && test -d gcc ) \
1920    || test -d $srcdir/../host-${host_noncanonical}; then
1921   host_subdir="host-${host_noncanonical}"
1922 else
1923   host_subdir=.
1924 fi
1925 # No prefix.
1926 target_subdir=${target_noncanonical}
1927
1928
1929 # Skipdirs are removed silently.
1930 skipdirs=
1931 # Noconfigdirs are removed loudly.
1932 noconfigdirs=""
1933
1934 use_gnu_ld=
1935 # Make sure we don't let GNU ld be added if we didn't want it.
1936 if test x$with_gnu_ld = xno ; then
1937   use_gnu_ld=no
1938   noconfigdirs="$noconfigdirs ld"
1939 fi
1940
1941 use_gnu_as=
1942 # Make sure we don't let GNU as be added if we didn't want it.
1943 if test x$with_gnu_as = xno ; then
1944   use_gnu_as=no
1945   noconfigdirs="$noconfigdirs gas"
1946 fi
1947
1948 # some tools are so dependent upon X11 that if we're not building with X,
1949 # it's not even worth trying to configure, much less build, that tool.
1950
1951 case ${with_x} in
1952   yes | "") ;; # the default value for this tree is that X11 is available
1953   no)
1954     skipdirs="${skipdirs} tk itcl libgui"
1955     # We won't be able to build gdbtk without X.
1956     enable_gdbtk=no
1957     ;;
1958   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1959 esac
1960
1961 # Some tools are only suitable for building in a "native" situation.
1962 # Remove these if host!=target.
1963 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"
1964
1965 # Similarly, some are only suitable for cross toolchains.
1966 # Remove these if host=target.
1967 cross_only="target-libgloss target-newlib target-opcodes"
1968
1969 case $is_cross_compiler in
1970   no) skipdirs="${skipdirs} ${cross_only}" ;;
1971   yes) skipdirs="${skipdirs} ${native_only}" ;;
1972 esac
1973
1974 # If both --with-headers and --with-libs are specified, default to
1975 # --without-newlib.
1976 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
1977    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
1978   if test x"${with_newlib}" = x ; then
1979     with_newlib=no
1980   fi
1981 fi
1982
1983 # Recognize --with-newlib/--without-newlib.
1984 case ${with_newlib} in
1985   no) skipdirs="${skipdirs} target-newlib" ;;
1986   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
1987 esac
1988
1989 # Configure extra directories which are host specific
1990
1991 case "${host}" in
1992   *-cygwin*)
1993     configdirs="$configdirs libtermcap" ;;
1994 esac
1995
1996 # A target can indicate whether a language isn't supported for some reason.
1997 # Only spaces may be used in this macro; not newlines or tabs.
1998 unsupported_languages=
1999
2000 # Remove more programs from consideration, based on the host or
2001 # target this usually means that a port of the program doesn't
2002 # exist yet.
2003
2004 case "${host}" in
2005   hppa*64*-*-*)
2006     noconfigdirs="$noconfigdirs byacc"
2007     ;;
2008   i[3456789]86-*-vsta)
2009     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2010     ;;
2011   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2012     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2013     ;;
2014   x86_64-*-mingw*)
2015     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2016     ;;
2017   i[3456789]86-*-mingw32*)
2018     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2019     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2020     ;;
2021   i[3456789]86-*-beos*)
2022     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2023     ;;
2024   *-*-cygwin*)
2025     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2026     ;;
2027   *-*-netbsd*)
2028     noconfigdirs="$noconfigdirs rcs"
2029     ;;
2030   ppc*-*-pe)
2031     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2032     ;;
2033   powerpc-*-beos*)
2034     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2035     ;;
2036 esac
2037
2038
2039 # Check whether --enable-libada or --disable-libada was given.
2040 if test "${enable_libada+set}" = set; then
2041   enableval="$enable_libada"
2042   ENABLE_LIBADA=$enableval
2043 else
2044   ENABLE_LIBADA=yes
2045 fi;
2046 if test "${ENABLE_LIBADA}" != "yes" ; then
2047   noconfigdirs="$noconfigdirs gnattools"
2048 fi
2049
2050 # Check whether --enable-libssp or --disable-libssp was given.
2051 if test "${enable_libssp+set}" = set; then
2052   enableval="$enable_libssp"
2053   ENABLE_LIBSSP=$enableval
2054 else
2055   ENABLE_LIBSSP=yes
2056 fi;
2057
2058 # Save it here so that, even in case of --enable-libgcj, if the Java
2059 # front-end isn't enabled, we still get libgcj disabled.
2060 libgcj_saved=$libgcj
2061 case $enable_libgcj in
2062 yes)
2063   # If we reset it here, it won't get added to noconfigdirs in the
2064   # target-specific build rules, so it will be forcibly enabled
2065   # (unless the Java language itself isn't enabled).
2066   libgcj=
2067   ;;
2068 no)
2069   # Make sure we get it printed in the list of not supported target libs.
2070   noconfigdirs="$noconfigdirs ${libgcj}"
2071   ;;
2072 esac
2073
2074
2075 # Disable libmudflap on some systems.
2076 if test x$enable_libmudflap = x ; then
2077     case "${target}" in
2078     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2079         # Enable libmudflap by default in GNU and friends.
2080         ;;
2081     *-*-freebsd*)
2082         # Enable libmudflap by default in FreeBSD.
2083         ;;
2084     *)
2085         # Disable it by default everywhere else.
2086         noconfigdirs="$noconfigdirs target-libmudflap"
2087         ;;
2088     esac
2089 fi
2090
2091 # Disable libgomp on non POSIX hosted systems.
2092 if test x$enable_libgomp = x ; then
2093     # Enable libgomp by default on hosted POSIX systems.
2094     case "${target}" in
2095     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2096         ;;
2097     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2098         ;;
2099     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2100         ;;
2101     *-*-darwin* | *-*-aix*)
2102         ;;
2103     *)
2104         noconfigdirs="$noconfigdirs target-libgomp"
2105         ;;
2106     esac
2107 fi
2108
2109
2110 case "${target}" in
2111   *-*-chorusos)
2112     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2113     ;;
2114   powerpc-*-darwin* | i[3456789]86-*-darwin*)
2115     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2116     noconfigdirs="$noconfigdirs sim target-rda"
2117     ;;
2118   *-*-darwin*)
2119     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2120     noconfigdirs="$noconfigdirs sim target-rda"
2121     noconfigdirs="$noconfigdirs ${libgcj}"
2122     ;;
2123   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2124     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2125     ;;
2126   *-*-freebsd*)
2127     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2128     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2129         && test -f /usr/local/include/gmp.h; then
2130       with_gmp=/usr/local
2131     fi
2132
2133     # Skip some stuff that's unsupported on some FreeBSD configurations.
2134     case "${target}" in
2135       i*86-*-*) ;;
2136       alpha*-*-*) ;;
2137       *)
2138         noconfigdirs="$noconfigdirs ${libgcj}"
2139         ;;
2140     esac
2141     ;;
2142   *-*-kaos*)
2143     # Remove unsupported stuff on all kaOS configurations.
2144     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2145     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2146     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2147     noconfigdirs="$noconfigdirs target-libgloss"
2148     ;;
2149   *-*-netbsd*)
2150     # Skip some stuff on all NetBSD configurations.
2151     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2152
2153     # Skip some stuff that's unsupported on some NetBSD configurations.
2154     case "${target}" in
2155       i*86-*-netbsdelf*) ;;
2156       arm*-*-netbsdelf*) ;;
2157       *)
2158         noconfigdirs="$noconfigdirs ${libgcj}"
2159         ;;
2160     esac
2161     ;;
2162   *-*-netware*)
2163     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2164     ;;
2165   *-*-rtems*)
2166     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2167     ;;
2168     # The tpf target doesn't support gdb yet.
2169   *-*-tpf*)
2170     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2171     ;;
2172   *-*-uclinux*)
2173     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2174     ;;
2175   *-*-vxworks*)
2176     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2177     ;;
2178   alpha*-dec-osf*)
2179     # ld works, but does not support shared libraries.
2180     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2181     # gas doesn't generate exception information.
2182     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2183     ;;
2184   alpha*-*-*vms*)
2185     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2186     ;;
2187   alpha*-*-linux*)
2188     # newlib is not 64 bit ready
2189     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2190     ;;
2191   alpha*-*-*)
2192     # newlib is not 64 bit ready
2193     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2194     ;;
2195   am33_2.0-*-linux*)
2196     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2197     ;;
2198   sh-*-linux*)
2199     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2200     ;;
2201   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2202     noconfigdirs="$noconfigdirs ${libgcj}"
2203     noconfigdirs="$noconfigdirs target-examples"
2204     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2205     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2206     noconfigdirs="$noconfigdirs expect dejagnu"
2207     # the C++ libraries don't build on top of CE's C libraries
2208     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2209     noconfigdirs="$noconfigdirs target-newlib"
2210     case "${host}" in
2211       *-*-cygwin*) ;; # keep gdb and readline
2212       *) noconfigdirs="$noconfigdirs gdb readline"
2213          ;;
2214     esac
2215     ;;
2216   arc-*-*)
2217     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2218     ;;
2219   arm-semi-aof )
2220     ;;
2221   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2222     noconfigdirs="$noconfigdirs ${libgcj}"
2223     ;;
2224   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2225     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2226     ;;
2227   arm*-*-linux-gnueabi)
2228     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2229     noconfigdirs="$noconfigdirs target-libjava target-libobjc"
2230     ;;
2231   arm*-*-symbianelf*)
2232     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2233     ;;
2234   arm-*-pe*)
2235     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2236     ;;
2237   thumb-*-coff)
2238     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2239     ;;
2240   thumb-*-elf)
2241     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2242     ;;
2243   thumb-*-pe)
2244     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2245     ;;
2246   arm-*-riscix*)
2247     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2248     ;;
2249   avr-*-*)
2250     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2251     ;;
2252   bfin-*-*)
2253     noconfigdirs="$noconfigdirs gdb"
2254     if test x${is_cross_compiler} != xno ; then
2255       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2256     fi
2257     ;;
2258   c4x-*-* | tic4x-*-*)
2259     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2260     ;;
2261   c54x*-*-* | tic54x-*-*)
2262     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2263     ;;
2264   cris-*-* | crisv32-*-*)
2265     unsupported_languages="$unsupported_languages java"
2266     case "${target}" in
2267       *-*-aout)
2268         unsupported_languages="$unsupported_languages fortran"
2269         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2270       *-*-elf)
2271         unsupported_languages="$unsupported_languages fortran"
2272         noconfigdirs="$noconfigdirs target-boehm-gc";;
2273       *-*-linux*)
2274         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2275       *)
2276         unsupported_languages="$unsupported_languages fortran"
2277         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2278     esac
2279     ;;
2280   crx-*-*)
2281     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2282     ;;
2283   d10v-*-*)
2284     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2285     ;;
2286   d30v-*-*)
2287     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2288     ;;
2289   fr30-*-elf*)
2290     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2291     ;;
2292   frv-*-*)
2293     noconfigdirs="$noconfigdirs ${libgcj}"
2294     ;;
2295   h8300*-*-*)
2296     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2297     ;;
2298   h8500-*-*)
2299     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2300     ;;
2301   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2302     ;;
2303   hppa*64*-*-linux* | parisc*64*-*-linux*)
2304     # In this case, it's because the hppa64-linux target is for
2305     # the kernel only at this point and has no libc, and thus no
2306     # headers, crt*.o, etc., all of which are needed by these.
2307     noconfigdirs="$noconfigdirs target-zlib"
2308     ;;
2309   parisc*-*-linux* | hppa*-*-linux*)
2310     ;;
2311   hppa*-*-*elf* | \
2312   hppa*-*-lites* | \
2313   hppa*-*-openbsd* | \
2314   hppa*64*-*-*)
2315     noconfigdirs="$noconfigdirs ${libgcj}"
2316     ;;
2317   hppa*-hp-hpux11*)
2318     noconfigdirs="$noconfigdirs ld shellutils"
2319     ;;
2320   hppa*-*-*)
2321     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2322     # build on HP-UX 10.20.
2323     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2324     ;;
2325   i960-*-*)
2326     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2327     ;;
2328   ia64*-*-elf*)
2329     # No gdb support yet.
2330     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2331     ;;
2332   ia64*-**-hpux*)
2333     # No gdb or ld support yet.
2334     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2335     ;;
2336   i370-*-opened*)
2337     ;;
2338   i[3456789]86-*-coff | i[3456789]86-*-elf)
2339     noconfigdirs="$noconfigdirs ${libgcj}"
2340     ;;
2341   i[3456789]86-*-linux*)
2342     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2343     # not build java stuff by default.
2344     case "${target}" in
2345       *-*-*libc1*)
2346         noconfigdirs="$noconfigdirs ${libgcj}";;
2347     esac
2348
2349     # This section makes it possible to build newlib natively on linux.
2350     # If we are using a cross compiler then don't configure newlib.
2351     if test x${is_cross_compiler} != xno ; then
2352       noconfigdirs="$noconfigdirs target-newlib"
2353     fi
2354     noconfigdirs="$noconfigdirs target-libgloss"
2355     # If we are not using a cross compiler, do configure newlib.
2356     # Note however, that newlib will only be configured in this situation
2357     # if the --with-newlib option has been given, because otherwise
2358     # 'target-newlib' will appear in skipdirs.
2359     ;;
2360   i[3456789]86-*-mingw32*)
2361     target_configdirs="$target_configdirs target-winsup"
2362     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2363     ;;
2364   x86_64-*-mingw*)
2365     target_configdirs="$target_configdirs target-winsup"
2366     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2367     ;;
2368   *-*-cygwin*)
2369     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2370     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2371     # always build newlib if winsup directory is present.
2372     if test -d "$srcdir/winsup/cygwin"; then
2373       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2374     elif test -d "$srcdir/newlib"; then
2375       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2376     fi
2377     ;;
2378   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2379   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2380     ;;
2381   i[3456789]86-*-pe)
2382     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2383     ;;
2384   i[3456789]86-*-sco3.2v5*)
2385     # The linker does not yet know about weak symbols in COFF,
2386     # and is not configured to handle mixed ELF and COFF.
2387     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2388     ;;
2389   i[3456789]86-*-sco*)
2390     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2391     ;;
2392   i[3456789]86-*-solaris2*)
2393     noconfigdirs="$noconfigdirs target-libgloss"
2394     ;;
2395   i[3456789]86-*-sysv4*)
2396     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2397     ;;
2398   i[3456789]86-*-beos*)
2399     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2400     ;;
2401   i[3456789]86-*-rdos*)
2402     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2403     ;;
2404   m32r-*-*)
2405     noconfigdirs="$noconfigdirs ${libgcj}"
2406     ;;
2407   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2408     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2409     ;;
2410   m68k-*-elf*)
2411     noconfigdirs="$noconfigdirs ${libgcj}"
2412     ;;
2413   m68k-*-coff*)
2414     noconfigdirs="$noconfigdirs ${libgcj}"
2415     ;;
2416   mcore-*-pe*)
2417   # The EPOC C++ environment does not support exceptions or rtti,
2418   # and so building libstdc++-v3 tends not to always work.
2419     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2420     ;;
2421   mmix-*-*)
2422     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2423     unsupported_languages="$unsupported_languages fortran java"
2424     ;;
2425   mn10200-*-*)
2426     noconfigdirs="$noconfigdirs ${libgcj}"
2427     ;;
2428   mn10300-*-*)
2429     noconfigdirs="$noconfigdirs ${libgcj}"
2430     ;;
2431   mt-*-*)
2432     noconfigdirs="$noconfigdirs sim"
2433     ;;
2434   powerpc-*-aix*)
2435     # copied from rs6000-*-* entry
2436     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2437     ;;
2438   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2439     target_configdirs="$target_configdirs target-winsup"
2440     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2441     # always build newlib.
2442     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2443     ;;
2444     # This is temporary until we can link against shared libraries
2445   powerpcle-*-solaris*)
2446     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2447     ;;
2448   powerpc-*-beos*)
2449     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2450     ;;
2451   powerpc-*-eabi)
2452     noconfigdirs="$noconfigdirs ${libgcj}"
2453     ;;
2454   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2455     ;;
2456   rs6000-*-lynxos*)
2457     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2458     ;;
2459   rs6000-*-aix*)
2460     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2461     ;;
2462   rs6000-*-*)
2463     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2464     ;;
2465   m68k-apollo-*)
2466     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2467     ;;
2468   mips*-*-irix5*)
2469     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2470     ;;
2471   mips*-*-irix6*)
2472     # Linking libjava exceeds command-line length limits on at least
2473     # IRIX 6.2, but not on IRIX 6.5.
2474     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2475     # <oldham@codesourcery.com>
2476     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2477     ;;
2478   mips*-*-bsd*)
2479     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2480     ;;
2481   mips64*-*-linux*)
2482     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2483     ;;
2484   mips*-*-linux*)
2485     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2486     ;;
2487   mips*-*-*)
2488     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2489     ;;
2490   romp-*-*)
2491     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2492     ;;
2493   sh-*-* | sh64-*-*)
2494     case "${host}" in
2495       i[3456789]86-*-vsta) ;; # don't add gprof back in
2496       i[3456789]86-*-go32*) ;; # don't add gprof back in
2497       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2498       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2499     esac
2500     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2501     ;;
2502   sparc-*-elf*)
2503     noconfigdirs="$noconfigdirs ${libgcj}"
2504     ;;
2505   sparc64-*-elf*)
2506     noconfigdirs="$noconfigdirs ${libgcj}"
2507     ;;
2508   sparclite-*-*)
2509     noconfigdirs="$noconfigdirs ${libgcj}"
2510     ;;
2511   sparc-*-sunos4*)
2512     noconfigdirs="$noconfigdirs ${libgcj}"
2513     if test x${is_cross_compiler} != xno ; then
2514            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2515     else
2516            use_gnu_ld=no
2517     fi
2518     ;;
2519   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2520     noconfigdirs="$noconfigdirs ${libgcj}"
2521     ;;
2522   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2523     ;;
2524   spu-*-*)
2525     skipdirs="target-libssp"
2526     ;;
2527   v810-*-*)
2528     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2529     ;;
2530   v850-*-*)
2531     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2532     ;;
2533   v850e-*-*)
2534     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2535     ;;
2536   v850ea-*-*)
2537     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2538     ;;
2539   vax-*-vms)
2540     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2541     ;;
2542   vax-*-*)
2543     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2544     ;;
2545   xtensa-*-*)
2546     noconfigdirs="$noconfigdirs ${libgcj}"
2547     ;;
2548   ip2k-*-*)
2549     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2550     ;;
2551   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2552     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2553     ;;
2554   *-*-lynxos*)
2555     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2556     ;;
2557   *-*-*)
2558     noconfigdirs="$noconfigdirs ${libgcj}"
2559     ;;
2560 esac
2561
2562 # If we aren't building newlib, then don't build libgloss, since libgloss
2563 # depends upon some newlib header files.
2564 case "${noconfigdirs}" in
2565   *target-libgloss*) ;;
2566   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2567 esac
2568
2569 # Work in distributions that contain no compiler tools, like Autoconf.
2570 tentative_cc=""
2571 host_makefile_frag=/dev/null
2572 if test -d ${srcdir}/config ; then
2573 case "${host}" in
2574   m68k-hp-hpux*)
2575     # Avoid "too much defining" errors from HPUX compiler.
2576     tentative_cc="cc -Wp,-H256000"
2577     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2578     # If it's HP/UX ar, this should be harmless.
2579     RANLIB="ar ts"
2580     ;;
2581   m68k-apollo-sysv*)
2582     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2583     ;;
2584   m68k-apollo-bsd*)
2585     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2586     # chokes on bfd, the compiler won't let you assign integers to enums, and
2587     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2588     # the apollo compiler" (the preferred version of GCC could be called cc,
2589     # or whatever), but I'm not sure leaving CC as cc is any better...
2590     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2591     # Used to have BISON=yacc.
2592     tentative_cc=gcc
2593     ;;
2594   m88k-dg-dgux*)
2595     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2596     ;;
2597   m88k-harris-cxux*)
2598     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2599     tentative_cc="cc -Xa"
2600     host_makefile_frag="config/mh-cxux"
2601     ;;
2602   m88k-motorola-sysv*)
2603     ;;
2604   mips*-dec-ultrix*)
2605     tentative_cc="cc -Wf,-XNg1000"
2606     host_makefile_frag="config/mh-decstation"
2607     ;;
2608   mips*-nec-sysv4*)
2609     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2610     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2611     host_makefile_frag="config/mh-necv4"
2612     ;;
2613   mips*-sgi-irix4*)
2614     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2615     # environment.  Also bump switch table size so that cp-parse will
2616     # compile.  Bump string length limit so linker builds.
2617     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2618     ;;
2619   mips*-*-sysv4*)
2620     host_makefile_frag="config/mh-sysv4"
2621     ;;
2622   mips*-*-sysv*)
2623     # This is for a MIPS running RISC/os 4.52C.
2624
2625     # This is needed for GDB, but needs to be in the top-level make because
2626     # if a library is compiled with the bsd headers and gets linked with the
2627     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2628     # a different size).
2629     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2630     # known except to select the sysv environment.  Could we use /proc instead?
2631     # These "sysv environments" and "bsd environments" often end up being a pain.
2632     #
2633     # This is not part of CFLAGS because perhaps not all C compilers have this
2634     # option.
2635     tentative_cc="cc -systype sysv"
2636     ;;
2637   i370-ibm-opened*)
2638     tentative_cc="c89"
2639     ;;
2640   i[3456789]86-*-sysv5*)
2641     host_makefile_frag="config/mh-sysv5"
2642     ;;
2643   i[3456789]86-*-dgux*)
2644     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2645     host_makefile_frag="config/mh-dgux386"
2646     ;;
2647   i[3456789]86-ncr-sysv4.3*)
2648     # The MetaWare compiler will generate a copyright message unless you
2649     # turn it off by adding the -Hnocopyr flag.
2650     tentative_cc="cc -Hnocopyr"
2651     ;;
2652   i[3456789]86-ncr-sysv4*)
2653     # for an NCR 3000 (i486/SVR4) system.
2654     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2655     # This compiler not only emits obnoxious copyright messages every time
2656     # you run it, but it chokes and dies on a whole bunch of GNU source
2657     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2658     tentative_cc="/usr/ccs/ATT/cc"
2659     host_makefile_frag="config/mh-ncr3000"
2660     ;;
2661   i[3456789]86-*-sco3.2v5*)
2662     ;;
2663   i[3456789]86-*-sco*)
2664     # The native C compiler botches some simple uses of const.  Unfortunately,
2665     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2666     tentative_cc="cc -Dconst="
2667     host_makefile_frag="config/mh-sco"
2668     ;;
2669   i[3456789]86-*-udk*)
2670     host_makefile_frag="config/mh-sysv5"
2671     ;;
2672   i[3456789]86-*-solaris2*)
2673     host_makefile_frag="config/mh-sysv4"
2674     ;;
2675   i[3456789]86-*-msdosdjgpp*)
2676     host_makefile_frag="config/mh-djgpp"
2677     ;;
2678   *-cygwin*)
2679     host_makefile_frag="config/mh-cygwin"
2680     ;;
2681   *-mingw32*)
2682     ;;
2683   *-mingw64*)
2684     ;;
2685   *-interix*)
2686     host_makefile_frag="config/mh-interix"
2687     ;;
2688   vax-*-ultrix2*)
2689     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2690     tentative_cc=gcc
2691     ;;
2692   *-*-solaris2*)
2693     host_makefile_frag="config/mh-solaris"
2694     ;;
2695   m68k-sun-sunos*)
2696     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2697     # without overflowing the jump tables (-J says to use a 32 bit table)
2698     tentative_cc="cc -J"
2699     ;;
2700   *-hp-hpux*)
2701     tentative_cc="cc -Wp,-H256000"
2702     ;;
2703   *-*-hiux*)
2704     tentative_cc="cc -Wp,-H256000"
2705     ;;
2706   rs6000-*-lynxos*)
2707     # /bin/cc is less than useful for our purposes.  Always use GCC
2708     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2709     host_makefile_frag="config/mh-lynxrs6k"
2710     ;;
2711   powerpc-*-darwin*)
2712     host_makefile_frag="config/mh-ppc-darwin"
2713     ;;
2714   powerpc-*-aix*)
2715     host_makefile_frag="config/mh-ppc-aix"
2716     ;;
2717   rs6000-*-aix*)
2718     host_makefile_frag="config/mh-ppc-aix"
2719     ;;
2720   *-*-lynxos*)
2721     # /bin/cc is less than useful for our purposes.  Always use GCC
2722     tentative_cc="/bin/gcc"
2723     ;;
2724   *-*-sysv4*)
2725     host_makefile_frag="config/mh-sysv4"
2726     ;;
2727   # This is placed last to prevent interfering with the cases above.
2728   i[3456789]86-*-*)
2729     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2730     host_makefile_frag="config/mh-x86omitfp"
2731     ;;
2732 esac
2733 fi
2734
2735 # If we aren't going to be using gcc, see if we can extract a definition
2736 # of CC from the fragment.
2737 # Actually, use the 'pre-extracted' version above.
2738 if test -z "${CC}" && test "${build}" = "${host}" ; then
2739   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2740   found=
2741   for dir in $PATH; do
2742     test -z "$dir" && dir=.
2743     if test -f $dir/gcc; then
2744       found=yes
2745       break
2746     fi
2747   done
2748   IFS="$save_ifs"
2749   if test -z "${found}" && test -n "${tentative_cc}" ; then
2750     CC=$tentative_cc
2751   fi
2752 fi
2753
2754 if test "${build}" != "${host}" ; then
2755   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2756 else
2757   CC_FOR_BUILD="\$(CC)"
2758 fi
2759
2760 ac_ext=c
2761 ac_cpp='$CPP $CPPFLAGS'
2762 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2763 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2764 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2765 if test -n "$ac_tool_prefix"; then
2766   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2767 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2768 echo "$as_me:$LINENO: checking for $ac_word" >&5
2769 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2770 if test "${ac_cv_prog_CC+set}" = set; then
2771   echo $ECHO_N "(cached) $ECHO_C" >&6
2772 else
2773   if test -n "$CC"; then
2774   ac_cv_prog_CC="$CC" # Let the user override the test.
2775 else
2776 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2777 for as_dir in $PATH
2778 do
2779   IFS=$as_save_IFS
2780   test -z "$as_dir" && as_dir=.
2781   for ac_exec_ext in '' $ac_executable_extensions; do
2782   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2783     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2784     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2785     break 2
2786   fi
2787 done
2788 done
2789
2790 fi
2791 fi
2792 CC=$ac_cv_prog_CC
2793 if test -n "$CC"; then
2794   echo "$as_me:$LINENO: result: $CC" >&5
2795 echo "${ECHO_T}$CC" >&6
2796 else
2797   echo "$as_me:$LINENO: result: no" >&5
2798 echo "${ECHO_T}no" >&6
2799 fi
2800
2801 fi
2802 if test -z "$ac_cv_prog_CC"; then
2803   ac_ct_CC=$CC
2804   # Extract the first word of "gcc", so it can be a program name with args.
2805 set dummy gcc; ac_word=$2
2806 echo "$as_me:$LINENO: checking for $ac_word" >&5
2807 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2808 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2809   echo $ECHO_N "(cached) $ECHO_C" >&6
2810 else
2811   if test -n "$ac_ct_CC"; then
2812   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2813 else
2814 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2815 for as_dir in $PATH
2816 do
2817   IFS=$as_save_IFS
2818   test -z "$as_dir" && as_dir=.
2819   for ac_exec_ext in '' $ac_executable_extensions; do
2820   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2821     ac_cv_prog_ac_ct_CC="gcc"
2822     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2823     break 2
2824   fi
2825 done
2826 done
2827
2828 fi
2829 fi
2830 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2831 if test -n "$ac_ct_CC"; then
2832   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2833 echo "${ECHO_T}$ac_ct_CC" >&6
2834 else
2835   echo "$as_me:$LINENO: result: no" >&5
2836 echo "${ECHO_T}no" >&6
2837 fi
2838
2839   CC=$ac_ct_CC
2840 else
2841   CC="$ac_cv_prog_CC"
2842 fi
2843
2844 if test -z "$CC"; then
2845   if test -n "$ac_tool_prefix"; then
2846   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2847 set dummy ${ac_tool_prefix}cc; ac_word=$2
2848 echo "$as_me:$LINENO: checking for $ac_word" >&5
2849 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2850 if test "${ac_cv_prog_CC+set}" = set; then
2851   echo $ECHO_N "(cached) $ECHO_C" >&6
2852 else
2853   if test -n "$CC"; then
2854   ac_cv_prog_CC="$CC" # Let the user override the test.
2855 else
2856 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2857 for as_dir in $PATH
2858 do
2859   IFS=$as_save_IFS
2860   test -z "$as_dir" && as_dir=.
2861   for ac_exec_ext in '' $ac_executable_extensions; do
2862   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2863     ac_cv_prog_CC="${ac_tool_prefix}cc"
2864     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2865     break 2
2866   fi
2867 done
2868 done
2869
2870 fi
2871 fi
2872 CC=$ac_cv_prog_CC
2873 if test -n "$CC"; then
2874   echo "$as_me:$LINENO: result: $CC" >&5
2875 echo "${ECHO_T}$CC" >&6
2876 else
2877   echo "$as_me:$LINENO: result: no" >&5
2878 echo "${ECHO_T}no" >&6
2879 fi
2880
2881 fi
2882 if test -z "$ac_cv_prog_CC"; then
2883   ac_ct_CC=$CC
2884   # Extract the first word of "cc", so it can be a program name with args.
2885 set dummy cc; ac_word=$2
2886 echo "$as_me:$LINENO: checking for $ac_word" >&5
2887 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2888 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2889   echo $ECHO_N "(cached) $ECHO_C" >&6
2890 else
2891   if test -n "$ac_ct_CC"; then
2892   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2893 else
2894 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2895 for as_dir in $PATH
2896 do
2897   IFS=$as_save_IFS
2898   test -z "$as_dir" && as_dir=.
2899   for ac_exec_ext in '' $ac_executable_extensions; do
2900   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2901     ac_cv_prog_ac_ct_CC="cc"
2902     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2903     break 2
2904   fi
2905 done
2906 done
2907
2908 fi
2909 fi
2910 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2911 if test -n "$ac_ct_CC"; then
2912   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2913 echo "${ECHO_T}$ac_ct_CC" >&6
2914 else
2915   echo "$as_me:$LINENO: result: no" >&5
2916 echo "${ECHO_T}no" >&6
2917 fi
2918
2919   CC=$ac_ct_CC
2920 else
2921   CC="$ac_cv_prog_CC"
2922 fi
2923
2924 fi
2925 if test -z "$CC"; then
2926   # Extract the first word of "cc", so it can be a program name with args.
2927 set dummy cc; ac_word=$2
2928 echo "$as_me:$LINENO: checking for $ac_word" >&5
2929 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2930 if test "${ac_cv_prog_CC+set}" = set; then
2931   echo $ECHO_N "(cached) $ECHO_C" >&6
2932 else
2933   if test -n "$CC"; then
2934   ac_cv_prog_CC="$CC" # Let the user override the test.
2935 else
2936   ac_prog_rejected=no
2937 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2938 for as_dir in $PATH
2939 do
2940   IFS=$as_save_IFS
2941   test -z "$as_dir" && as_dir=.
2942   for ac_exec_ext in '' $ac_executable_extensions; do
2943   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2944     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2945        ac_prog_rejected=yes
2946        continue
2947      fi
2948     ac_cv_prog_CC="cc"
2949     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2950     break 2
2951   fi
2952 done
2953 done
2954
2955 if test $ac_prog_rejected = yes; then
2956   # We found a bogon in the path, so make sure we never use it.
2957   set dummy $ac_cv_prog_CC
2958   shift
2959   if test $# != 0; then
2960     # We chose a different compiler from the bogus one.
2961     # However, it has the same basename, so the bogon will be chosen
2962     # first if we set CC to just the basename; use the full file name.
2963     shift
2964     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
2965   fi
2966 fi
2967 fi
2968 fi
2969 CC=$ac_cv_prog_CC
2970 if test -n "$CC"; then
2971   echo "$as_me:$LINENO: result: $CC" >&5
2972 echo "${ECHO_T}$CC" >&6
2973 else
2974   echo "$as_me:$LINENO: result: no" >&5
2975 echo "${ECHO_T}no" >&6
2976 fi
2977
2978 fi
2979 if test -z "$CC"; then
2980   if test -n "$ac_tool_prefix"; then
2981   for ac_prog in cl
2982   do
2983     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2984 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2985 echo "$as_me:$LINENO: checking for $ac_word" >&5
2986 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2987 if test "${ac_cv_prog_CC+set}" = set; then
2988   echo $ECHO_N "(cached) $ECHO_C" >&6
2989 else
2990   if test -n "$CC"; then
2991   ac_cv_prog_CC="$CC" # Let the user override the test.
2992 else
2993 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2994 for as_dir in $PATH
2995 do
2996   IFS=$as_save_IFS
2997   test -z "$as_dir" && as_dir=.
2998   for ac_exec_ext in '' $ac_executable_extensions; do
2999   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3000     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3001     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3002     break 2
3003   fi
3004 done
3005 done
3006
3007 fi
3008 fi
3009 CC=$ac_cv_prog_CC
3010 if test -n "$CC"; then
3011   echo "$as_me:$LINENO: result: $CC" >&5
3012 echo "${ECHO_T}$CC" >&6
3013 else
3014   echo "$as_me:$LINENO: result: no" >&5
3015 echo "${ECHO_T}no" >&6
3016 fi
3017
3018     test -n "$CC" && break
3019   done
3020 fi
3021 if test -z "$CC"; then
3022   ac_ct_CC=$CC
3023   for ac_prog in cl
3024 do
3025   # Extract the first word of "$ac_prog", so it can be a program name with args.
3026 set dummy $ac_prog; ac_word=$2
3027 echo "$as_me:$LINENO: checking for $ac_word" >&5
3028 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3029 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3030   echo $ECHO_N "(cached) $ECHO_C" >&6
3031 else
3032   if test -n "$ac_ct_CC"; then
3033   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3034 else
3035 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3036 for as_dir in $PATH
3037 do
3038   IFS=$as_save_IFS
3039   test -z "$as_dir" && as_dir=.
3040   for ac_exec_ext in '' $ac_executable_extensions; do
3041   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3042     ac_cv_prog_ac_ct_CC="$ac_prog"
3043     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3044     break 2
3045   fi
3046 done
3047 done
3048
3049 fi
3050 fi
3051 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3052 if test -n "$ac_ct_CC"; then
3053   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3054 echo "${ECHO_T}$ac_ct_CC" >&6
3055 else
3056   echo "$as_me:$LINENO: result: no" >&5
3057 echo "${ECHO_T}no" >&6
3058 fi
3059
3060   test -n "$ac_ct_CC" && break
3061 done
3062
3063   CC=$ac_ct_CC
3064 fi
3065
3066 fi
3067
3068
3069 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3070 See \`config.log' for more details." >&5
3071 echo "$as_me: error: no acceptable C compiler found in \$PATH
3072 See \`config.log' for more details." >&2;}
3073    { (exit 1); exit 1; }; }
3074
3075 # Provide some information about the compiler.
3076 echo "$as_me:$LINENO:" \
3077      "checking for C compiler version" >&5
3078 ac_compiler=`set X $ac_compile; echo $2`
3079 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3080   (eval $ac_compiler --version </dev/null >&5) 2>&5
3081   ac_status=$?
3082   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3083   (exit $ac_status); }
3084 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3085   (eval $ac_compiler -v </dev/null >&5) 2>&5
3086   ac_status=$?
3087   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3088   (exit $ac_status); }
3089 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3090   (eval $ac_compiler -V </dev/null >&5) 2>&5
3091   ac_status=$?
3092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3093   (exit $ac_status); }
3094
3095 cat >conftest.$ac_ext <<_ACEOF
3096 /* confdefs.h.  */
3097 _ACEOF
3098 cat confdefs.h >>conftest.$ac_ext
3099 cat >>conftest.$ac_ext <<_ACEOF
3100 /* end confdefs.h.  */
3101
3102 int
3103 main ()
3104 {
3105
3106   ;
3107   return 0;
3108 }
3109 _ACEOF
3110 ac_clean_files_save=$ac_clean_files
3111 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3112 # Try to create an executable without -o first, disregard a.out.
3113 # It will help us diagnose broken compilers, and finding out an intuition
3114 # of exeext.
3115 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3116 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3117 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3118 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3119   (eval $ac_link_default) 2>&5
3120   ac_status=$?
3121   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3122   (exit $ac_status); }; then
3123   # Find the output, starting from the most likely.  This scheme is
3124 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3125 # resort.
3126
3127 # Be careful to initialize this variable, since it used to be cached.
3128 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3129 ac_cv_exeext=
3130 # b.out is created by i960 compilers.
3131 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3132 do
3133   test -f "$ac_file" || continue
3134   case $ac_file in
3135     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3136         ;;
3137     conftest.$ac_ext )
3138         # This is the source file.
3139         ;;
3140     [ab].out )
3141         # We found the default executable, but exeext='' is most
3142         # certainly right.
3143         break;;
3144     *.* )
3145         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3146         # FIXME: I believe we export ac_cv_exeext for Libtool,
3147         # but it would be cool to find out if it's true.  Does anybody
3148         # maintain Libtool? --akim.
3149         export ac_cv_exeext
3150         break;;
3151     * )
3152         break;;
3153   esac
3154 done
3155 else
3156   echo "$as_me: failed program was:" >&5
3157 sed 's/^/| /' conftest.$ac_ext >&5
3158
3159 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3160 See \`config.log' for more details." >&5
3161 echo "$as_me: error: C compiler cannot create executables
3162 See \`config.log' for more details." >&2;}
3163    { (exit 77); exit 77; }; }
3164 fi
3165
3166 ac_exeext=$ac_cv_exeext
3167 echo "$as_me:$LINENO: result: $ac_file" >&5
3168 echo "${ECHO_T}$ac_file" >&6
3169
3170 # Check the compiler produces executables we can run.  If not, either
3171 # the compiler is broken, or we cross compile.
3172 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3173 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3174 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3175 # If not cross compiling, check that we can run a simple program.
3176 if test "$cross_compiling" != yes; then
3177   if { ac_try='./$ac_file'
3178   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3179   (eval $ac_try) 2>&5
3180   ac_status=$?
3181   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3182   (exit $ac_status); }; }; then
3183     cross_compiling=no
3184   else
3185     if test "$cross_compiling" = maybe; then
3186         cross_compiling=yes
3187     else
3188         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3189 If you meant to cross compile, use \`--host'.
3190 See \`config.log' for more details." >&5
3191 echo "$as_me: error: cannot run C compiled programs.
3192 If you meant to cross compile, use \`--host'.
3193 See \`config.log' for more details." >&2;}
3194    { (exit 1); exit 1; }; }
3195     fi
3196   fi
3197 fi
3198 echo "$as_me:$LINENO: result: yes" >&5
3199 echo "${ECHO_T}yes" >&6
3200
3201 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3202 ac_clean_files=$ac_clean_files_save
3203 # Check the compiler produces executables we can run.  If not, either
3204 # the compiler is broken, or we cross compile.
3205 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3206 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3207 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3208 echo "${ECHO_T}$cross_compiling" >&6
3209
3210 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3211 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3212 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3213   (eval $ac_link) 2>&5
3214   ac_status=$?
3215   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3216   (exit $ac_status); }; then
3217   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3218 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3219 # work properly (i.e., refer to `conftest.exe'), while it won't with
3220 # `rm'.
3221 for ac_file in conftest.exe conftest conftest.*; do
3222   test -f "$ac_file" || continue
3223   case $ac_file in
3224     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3225     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3226           export ac_cv_exeext
3227           break;;
3228     * ) break;;
3229   esac
3230 done
3231 else
3232   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3233 See \`config.log' for more details." >&5
3234 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3235 See \`config.log' for more details." >&2;}
3236    { (exit 1); exit 1; }; }
3237 fi
3238
3239 rm -f conftest$ac_cv_exeext
3240 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3241 echo "${ECHO_T}$ac_cv_exeext" >&6
3242
3243 rm -f conftest.$ac_ext
3244 EXEEXT=$ac_cv_exeext
3245 ac_exeext=$EXEEXT
3246 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3247 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3248 if test "${ac_cv_objext+set}" = set; then
3249   echo $ECHO_N "(cached) $ECHO_C" >&6
3250 else
3251   cat >conftest.$ac_ext <<_ACEOF
3252 /* confdefs.h.  */
3253 _ACEOF
3254 cat confdefs.h >>conftest.$ac_ext
3255 cat >>conftest.$ac_ext <<_ACEOF
3256 /* end confdefs.h.  */
3257
3258 int
3259 main ()
3260 {
3261
3262   ;
3263   return 0;
3264 }
3265 _ACEOF
3266 rm -f conftest.o conftest.obj
3267 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3268   (eval $ac_compile) 2>&5
3269   ac_status=$?
3270   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3271   (exit $ac_status); }; then
3272   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3273   case $ac_file in
3274     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3275     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3276        break;;
3277   esac
3278 done
3279 else
3280   echo "$as_me: failed program was:" >&5
3281 sed 's/^/| /' conftest.$ac_ext >&5
3282
3283 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3284 See \`config.log' for more details." >&5
3285 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3286 See \`config.log' for more details." >&2;}
3287    { (exit 1); exit 1; }; }
3288 fi
3289
3290 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3291 fi
3292 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3293 echo "${ECHO_T}$ac_cv_objext" >&6
3294 OBJEXT=$ac_cv_objext
3295 ac_objext=$OBJEXT
3296 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3297 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3298 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3299   echo $ECHO_N "(cached) $ECHO_C" >&6
3300 else
3301   cat >conftest.$ac_ext <<_ACEOF
3302 /* confdefs.h.  */
3303 _ACEOF
3304 cat confdefs.h >>conftest.$ac_ext
3305 cat >>conftest.$ac_ext <<_ACEOF
3306 /* end confdefs.h.  */
3307
3308 int
3309 main ()
3310 {
3311 #ifndef __GNUC__
3312        choke me
3313 #endif
3314
3315   ;
3316   return 0;
3317 }
3318 _ACEOF
3319 rm -f conftest.$ac_objext
3320 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3321   (eval $ac_compile) 2>conftest.er1
3322   ac_status=$?
3323   grep -v '^ *+' conftest.er1 >conftest.err
3324   rm -f conftest.er1
3325   cat conftest.err >&5
3326   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3327   (exit $ac_status); } &&
3328          { ac_try='test -z "$ac_c_werror_flag"
3329                          || test ! -s conftest.err'
3330   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3331   (eval $ac_try) 2>&5
3332   ac_status=$?
3333   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3334   (exit $ac_status); }; } &&
3335          { ac_try='test -s conftest.$ac_objext'
3336   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3337   (eval $ac_try) 2>&5
3338   ac_status=$?
3339   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3340   (exit $ac_status); }; }; then
3341   ac_compiler_gnu=yes
3342 else
3343   echo "$as_me: failed program was:" >&5
3344 sed 's/^/| /' conftest.$ac_ext >&5
3345
3346 ac_compiler_gnu=no
3347 fi
3348 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3349 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3350
3351 fi
3352 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3353 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3354 GCC=`test $ac_compiler_gnu = yes && echo yes`
3355 ac_test_CFLAGS=${CFLAGS+set}
3356 ac_save_CFLAGS=$CFLAGS
3357 CFLAGS="-g"
3358 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3359 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3360 if test "${ac_cv_prog_cc_g+set}" = set; then
3361   echo $ECHO_N "(cached) $ECHO_C" >&6
3362 else
3363   cat >conftest.$ac_ext <<_ACEOF
3364 /* confdefs.h.  */
3365 _ACEOF
3366 cat confdefs.h >>conftest.$ac_ext
3367 cat >>conftest.$ac_ext <<_ACEOF
3368 /* end confdefs.h.  */
3369
3370 int
3371 main ()
3372 {
3373
3374   ;
3375   return 0;
3376 }
3377 _ACEOF
3378 rm -f conftest.$ac_objext
3379 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3380   (eval $ac_compile) 2>conftest.er1
3381   ac_status=$?
3382   grep -v '^ *+' conftest.er1 >conftest.err
3383   rm -f conftest.er1
3384   cat conftest.err >&5
3385   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3386   (exit $ac_status); } &&
3387          { ac_try='test -z "$ac_c_werror_flag"
3388                          || test ! -s conftest.err'
3389   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3390   (eval $ac_try) 2>&5
3391   ac_status=$?
3392   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3393   (exit $ac_status); }; } &&
3394          { ac_try='test -s conftest.$ac_objext'
3395   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3396   (eval $ac_try) 2>&5
3397   ac_status=$?
3398   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3399   (exit $ac_status); }; }; then
3400   ac_cv_prog_cc_g=yes
3401 else
3402   echo "$as_me: failed program was:" >&5
3403 sed 's/^/| /' conftest.$ac_ext >&5
3404
3405 ac_cv_prog_cc_g=no
3406 fi
3407 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3408 fi
3409 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3410 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3411 if test "$ac_test_CFLAGS" = set; then
3412   CFLAGS=$ac_save_CFLAGS
3413 elif test $ac_cv_prog_cc_g = yes; then
3414   if test "$GCC" = yes; then
3415     CFLAGS="-g -O2"
3416   else
3417     CFLAGS="-g"
3418   fi
3419 else
3420   if test "$GCC" = yes; then
3421     CFLAGS="-O2"
3422   else
3423     CFLAGS=
3424   fi
3425 fi
3426 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3427 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3428 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3429   echo $ECHO_N "(cached) $ECHO_C" >&6
3430 else
3431   ac_cv_prog_cc_stdc=no
3432 ac_save_CC=$CC
3433 cat >conftest.$ac_ext <<_ACEOF
3434 /* confdefs.h.  */
3435 _ACEOF
3436 cat confdefs.h >>conftest.$ac_ext
3437 cat >>conftest.$ac_ext <<_ACEOF
3438 /* end confdefs.h.  */
3439 #include <stdarg.h>
3440 #include <stdio.h>
3441 #include <sys/types.h>
3442 #include <sys/stat.h>
3443 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3444 struct buf { int x; };
3445 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3446 static char *e (p, i)
3447      char **p;
3448      int i;
3449 {
3450   return p[i];
3451 }
3452 static char *f (char * (*g) (char **, int), char **p, ...)
3453 {
3454   char *s;
3455   va_list v;
3456   va_start (v,p);
3457   s = g (p, va_arg (v,int));
3458   va_end (v);
3459   return s;
3460 }
3461
3462 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3463    function prototypes and stuff, but not '\xHH' hex character constants.
3464    These don't provoke an error unfortunately, instead are silently treated
3465    as 'x'.  The following induces an error, until -std1 is added to get
3466    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3467    array size at least.  It's necessary to write '\x00'==0 to get something
3468    that's true only with -std1.  */
3469 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3470
3471 int test (int i, double x);
3472 struct s1 {int (*f) (int a);};
3473 struct s2 {int (*f) (double a);};
3474 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3475 int argc;
3476 char **argv;
3477 int
3478 main ()
3479 {
3480 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3481   ;
3482   return 0;
3483 }
3484 _ACEOF
3485 # Don't try gcc -ansi; that turns off useful extensions and
3486 # breaks some systems' header files.
3487 # AIX                   -qlanglvl=ansi
3488 # Ultrix and OSF/1      -std1
3489 # HP-UX 10.20 and later -Ae
3490 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3491 # SVR4                  -Xc -D__EXTENSIONS__
3492 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3493 do
3494   CC="$ac_save_CC $ac_arg"
3495   rm -f conftest.$ac_objext
3496 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3497   (eval $ac_compile) 2>conftest.er1
3498   ac_status=$?
3499   grep -v '^ *+' conftest.er1 >conftest.err
3500   rm -f conftest.er1
3501   cat conftest.err >&5
3502   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3503   (exit $ac_status); } &&
3504          { ac_try='test -z "$ac_c_werror_flag"
3505                          || test ! -s conftest.err'
3506   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3507   (eval $ac_try) 2>&5
3508   ac_status=$?
3509   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3510   (exit $ac_status); }; } &&
3511          { ac_try='test -s conftest.$ac_objext'
3512   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3513   (eval $ac_try) 2>&5
3514   ac_status=$?
3515   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3516   (exit $ac_status); }; }; then
3517   ac_cv_prog_cc_stdc=$ac_arg
3518 break
3519 else
3520   echo "$as_me: failed program was:" >&5
3521 sed 's/^/| /' conftest.$ac_ext >&5
3522
3523 fi
3524 rm -f conftest.err conftest.$ac_objext
3525 done
3526 rm -f conftest.$ac_ext conftest.$ac_objext
3527 CC=$ac_save_CC
3528
3529 fi
3530
3531 case "x$ac_cv_prog_cc_stdc" in
3532   x|xno)
3533     echo "$as_me:$LINENO: result: none needed" >&5
3534 echo "${ECHO_T}none needed" >&6 ;;
3535   *)
3536     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3537 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3538     CC="$CC $ac_cv_prog_cc_stdc" ;;
3539 esac
3540
3541 # Some people use a C++ compiler to compile C.  Since we use `exit',
3542 # in C++ we need to declare it.  In case someone uses the same compiler
3543 # for both compiling C and C++ we need to have the C++ compiler decide
3544 # the declaration of exit, since it's the most demanding environment.
3545 cat >conftest.$ac_ext <<_ACEOF
3546 #ifndef __cplusplus
3547   choke me
3548 #endif
3549 _ACEOF
3550 rm -f conftest.$ac_objext
3551 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3552   (eval $ac_compile) 2>conftest.er1
3553   ac_status=$?
3554   grep -v '^ *+' conftest.er1 >conftest.err
3555   rm -f conftest.er1
3556   cat conftest.err >&5
3557   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3558   (exit $ac_status); } &&
3559          { ac_try='test -z "$ac_c_werror_flag"
3560                          || test ! -s conftest.err'
3561   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3562   (eval $ac_try) 2>&5
3563   ac_status=$?
3564   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3565   (exit $ac_status); }; } &&
3566          { ac_try='test -s conftest.$ac_objext'
3567   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3568   (eval $ac_try) 2>&5
3569   ac_status=$?
3570   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3571   (exit $ac_status); }; }; then
3572   for ac_declaration in \
3573    '' \
3574    'extern "C" void std::exit (int) throw (); using std::exit;' \
3575    'extern "C" void std::exit (int); using std::exit;' \
3576    'extern "C" void exit (int) throw ();' \
3577    'extern "C" void exit (int);' \
3578    'void exit (int);'
3579 do
3580   cat >conftest.$ac_ext <<_ACEOF
3581 /* confdefs.h.  */
3582 _ACEOF
3583 cat confdefs.h >>conftest.$ac_ext
3584 cat >>conftest.$ac_ext <<_ACEOF
3585 /* end confdefs.h.  */
3586 $ac_declaration
3587 #include <stdlib.h>
3588 int
3589 main ()
3590 {
3591 exit (42);
3592   ;
3593   return 0;
3594 }
3595 _ACEOF
3596 rm -f conftest.$ac_objext
3597 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3598   (eval $ac_compile) 2>conftest.er1
3599   ac_status=$?
3600   grep -v '^ *+' conftest.er1 >conftest.err
3601   rm -f conftest.er1
3602   cat conftest.err >&5
3603   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3604   (exit $ac_status); } &&
3605          { ac_try='test -z "$ac_c_werror_flag"
3606                          || test ! -s conftest.err'
3607   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3608   (eval $ac_try) 2>&5
3609   ac_status=$?
3610   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3611   (exit $ac_status); }; } &&
3612          { ac_try='test -s conftest.$ac_objext'
3613   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3614   (eval $ac_try) 2>&5
3615   ac_status=$?
3616   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3617   (exit $ac_status); }; }; then
3618   :
3619 else
3620   echo "$as_me: failed program was:" >&5
3621 sed 's/^/| /' conftest.$ac_ext >&5
3622
3623 continue
3624 fi
3625 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3626   cat >conftest.$ac_ext <<_ACEOF
3627 /* confdefs.h.  */
3628 _ACEOF
3629 cat confdefs.h >>conftest.$ac_ext
3630 cat >>conftest.$ac_ext <<_ACEOF
3631 /* end confdefs.h.  */
3632 $ac_declaration
3633 int
3634 main ()
3635 {
3636 exit (42);
3637   ;
3638   return 0;
3639 }
3640 _ACEOF
3641 rm -f conftest.$ac_objext
3642 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3643   (eval $ac_compile) 2>conftest.er1
3644   ac_status=$?
3645   grep -v '^ *+' conftest.er1 >conftest.err
3646   rm -f conftest.er1
3647   cat conftest.err >&5
3648   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3649   (exit $ac_status); } &&
3650          { ac_try='test -z "$ac_c_werror_flag"
3651                          || test ! -s conftest.err'
3652   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3653   (eval $ac_try) 2>&5
3654   ac_status=$?
3655   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3656   (exit $ac_status); }; } &&
3657          { ac_try='test -s conftest.$ac_objext'
3658   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3659   (eval $ac_try) 2>&5
3660   ac_status=$?
3661   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3662   (exit $ac_status); }; }; then
3663   break
3664 else
3665   echo "$as_me: failed program was:" >&5
3666 sed 's/^/| /' conftest.$ac_ext >&5
3667
3668 fi
3669 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3670 done
3671 rm -f conftest*
3672 if test -n "$ac_declaration"; then
3673   echo '#ifdef __cplusplus' >>confdefs.h
3674   echo $ac_declaration      >>confdefs.h
3675   echo '#endif'             >>confdefs.h
3676 fi
3677
3678 else
3679   echo "$as_me: failed program was:" >&5
3680 sed 's/^/| /' conftest.$ac_ext >&5
3681
3682 fi
3683 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3684 ac_ext=c
3685 ac_cpp='$CPP $CPPFLAGS'
3686 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3687 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3688 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3689
3690 ac_ext=cc
3691 ac_cpp='$CXXCPP $CPPFLAGS'
3692 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3693 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3694 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3695 if test -n "$ac_tool_prefix"; then
3696   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3697   do
3698     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3699 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3700 echo "$as_me:$LINENO: checking for $ac_word" >&5
3701 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3702 if test "${ac_cv_prog_CXX+set}" = set; then
3703   echo $ECHO_N "(cached) $ECHO_C" >&6
3704 else
3705   if test -n "$CXX"; then
3706   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3707 else
3708 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3709 for as_dir in $PATH
3710 do
3711   IFS=$as_save_IFS
3712   test -z "$as_dir" && as_dir=.
3713   for ac_exec_ext in '' $ac_executable_extensions; do
3714   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3715     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3716     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3717     break 2
3718   fi
3719 done
3720 done
3721
3722 fi
3723 fi
3724 CXX=$ac_cv_prog_CXX
3725 if test -n "$CXX"; then
3726   echo "$as_me:$LINENO: result: $CXX" >&5
3727 echo "${ECHO_T}$CXX" >&6
3728 else
3729   echo "$as_me:$LINENO: result: no" >&5
3730 echo "${ECHO_T}no" >&6
3731 fi
3732
3733     test -n "$CXX" && break
3734   done
3735 fi
3736 if test -z "$CXX"; then
3737   ac_ct_CXX=$CXX
3738   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3739 do
3740   # Extract the first word of "$ac_prog", so it can be a program name with args.
3741 set dummy $ac_prog; ac_word=$2
3742 echo "$as_me:$LINENO: checking for $ac_word" >&5
3743 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3744 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3745   echo $ECHO_N "(cached) $ECHO_C" >&6
3746 else
3747   if test -n "$ac_ct_CXX"; then
3748   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3749 else
3750 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3751 for as_dir in $PATH
3752 do
3753   IFS=$as_save_IFS
3754   test -z "$as_dir" && as_dir=.
3755   for ac_exec_ext in '' $ac_executable_extensions; do
3756   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3757     ac_cv_prog_ac_ct_CXX="$ac_prog"
3758     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3759     break 2
3760   fi
3761 done
3762 done
3763
3764 fi
3765 fi
3766 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3767 if test -n "$ac_ct_CXX"; then
3768   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3769 echo "${ECHO_T}$ac_ct_CXX" >&6
3770 else
3771   echo "$as_me:$LINENO: result: no" >&5
3772 echo "${ECHO_T}no" >&6
3773 fi
3774
3775   test -n "$ac_ct_CXX" && break
3776 done
3777 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3778
3779   CXX=$ac_ct_CXX
3780 fi
3781
3782
3783 # Provide some information about the compiler.
3784 echo "$as_me:$LINENO:" \
3785      "checking for C++ compiler version" >&5
3786 ac_compiler=`set X $ac_compile; echo $2`
3787 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3788   (eval $ac_compiler --version </dev/null >&5) 2>&5
3789   ac_status=$?
3790   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3791   (exit $ac_status); }
3792 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3793   (eval $ac_compiler -v </dev/null >&5) 2>&5
3794   ac_status=$?
3795   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3796   (exit $ac_status); }
3797 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3798   (eval $ac_compiler -V </dev/null >&5) 2>&5
3799   ac_status=$?
3800   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3801   (exit $ac_status); }
3802
3803 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3804 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3805 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3806   echo $ECHO_N "(cached) $ECHO_C" >&6
3807 else
3808   cat >conftest.$ac_ext <<_ACEOF
3809 /* confdefs.h.  */
3810 _ACEOF
3811 cat confdefs.h >>conftest.$ac_ext
3812 cat >>conftest.$ac_ext <<_ACEOF
3813 /* end confdefs.h.  */
3814
3815 int
3816 main ()
3817 {
3818 #ifndef __GNUC__
3819        choke me
3820 #endif
3821
3822   ;
3823   return 0;
3824 }
3825 _ACEOF
3826 rm -f conftest.$ac_objext
3827 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3828   (eval $ac_compile) 2>conftest.er1
3829   ac_status=$?
3830   grep -v '^ *+' conftest.er1 >conftest.err
3831   rm -f conftest.er1
3832   cat conftest.err >&5
3833   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3834   (exit $ac_status); } &&
3835          { ac_try='test -z "$ac_cxx_werror_flag"
3836                          || test ! -s conftest.err'
3837   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3838   (eval $ac_try) 2>&5
3839   ac_status=$?
3840   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3841   (exit $ac_status); }; } &&
3842          { ac_try='test -s conftest.$ac_objext'
3843   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3844   (eval $ac_try) 2>&5
3845   ac_status=$?
3846   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3847   (exit $ac_status); }; }; then
3848   ac_compiler_gnu=yes
3849 else
3850   echo "$as_me: failed program was:" >&5
3851 sed 's/^/| /' conftest.$ac_ext >&5
3852
3853 ac_compiler_gnu=no
3854 fi
3855 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3856 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3857
3858 fi
3859 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3860 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3861 GXX=`test $ac_compiler_gnu = yes && echo yes`
3862 ac_test_CXXFLAGS=${CXXFLAGS+set}
3863 ac_save_CXXFLAGS=$CXXFLAGS
3864 CXXFLAGS="-g"
3865 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3866 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3867 if test "${ac_cv_prog_cxx_g+set}" = set; then
3868   echo $ECHO_N "(cached) $ECHO_C" >&6
3869 else
3870   cat >conftest.$ac_ext <<_ACEOF
3871 /* confdefs.h.  */
3872 _ACEOF
3873 cat confdefs.h >>conftest.$ac_ext
3874 cat >>conftest.$ac_ext <<_ACEOF
3875 /* end confdefs.h.  */
3876
3877 int
3878 main ()
3879 {
3880
3881   ;
3882   return 0;
3883 }
3884 _ACEOF
3885 rm -f conftest.$ac_objext
3886 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3887   (eval $ac_compile) 2>conftest.er1
3888   ac_status=$?
3889   grep -v '^ *+' conftest.er1 >conftest.err
3890   rm -f conftest.er1
3891   cat conftest.err >&5
3892   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3893   (exit $ac_status); } &&
3894          { ac_try='test -z "$ac_cxx_werror_flag"
3895                          || test ! -s conftest.err'
3896   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3897   (eval $ac_try) 2>&5
3898   ac_status=$?
3899   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3900   (exit $ac_status); }; } &&
3901          { ac_try='test -s conftest.$ac_objext'
3902   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3903   (eval $ac_try) 2>&5
3904   ac_status=$?
3905   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3906   (exit $ac_status); }; }; then
3907   ac_cv_prog_cxx_g=yes
3908 else
3909   echo "$as_me: failed program was:" >&5
3910 sed 's/^/| /' conftest.$ac_ext >&5
3911
3912 ac_cv_prog_cxx_g=no
3913 fi
3914 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3915 fi
3916 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3917 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
3918 if test "$ac_test_CXXFLAGS" = set; then
3919   CXXFLAGS=$ac_save_CXXFLAGS
3920 elif test $ac_cv_prog_cxx_g = yes; then
3921   if test "$GXX" = yes; then
3922     CXXFLAGS="-g -O2"
3923   else
3924     CXXFLAGS="-g"
3925   fi
3926 else
3927   if test "$GXX" = yes; then
3928     CXXFLAGS="-O2"
3929   else
3930     CXXFLAGS=
3931   fi
3932 fi
3933 for ac_declaration in \
3934    '' \
3935    'extern "C" void std::exit (int) throw (); using std::exit;' \
3936    'extern "C" void std::exit (int); using std::exit;' \
3937    'extern "C" void exit (int) throw ();' \
3938    'extern "C" void exit (int);' \
3939    'void exit (int);'
3940 do
3941   cat >conftest.$ac_ext <<_ACEOF
3942 /* confdefs.h.  */
3943 _ACEOF
3944 cat confdefs.h >>conftest.$ac_ext
3945 cat >>conftest.$ac_ext <<_ACEOF
3946 /* end confdefs.h.  */
3947 $ac_declaration
3948 #include <stdlib.h>
3949 int
3950 main ()
3951 {
3952 exit (42);
3953   ;
3954   return 0;
3955 }
3956 _ACEOF
3957 rm -f conftest.$ac_objext
3958 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3959   (eval $ac_compile) 2>conftest.er1
3960   ac_status=$?
3961   grep -v '^ *+' conftest.er1 >conftest.err
3962   rm -f conftest.er1
3963   cat conftest.err >&5
3964   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3965   (exit $ac_status); } &&
3966          { ac_try='test -z "$ac_cxx_werror_flag"
3967                          || test ! -s conftest.err'
3968   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3969   (eval $ac_try) 2>&5
3970   ac_status=$?
3971   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3972   (exit $ac_status); }; } &&
3973          { ac_try='test -s conftest.$ac_objext'
3974   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3975   (eval $ac_try) 2>&5
3976   ac_status=$?
3977   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3978   (exit $ac_status); }; }; then
3979   :
3980 else
3981   echo "$as_me: failed program was:" >&5
3982 sed 's/^/| /' conftest.$ac_ext >&5
3983
3984 continue
3985 fi
3986 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3987   cat >conftest.$ac_ext <<_ACEOF
3988 /* confdefs.h.  */
3989 _ACEOF
3990 cat confdefs.h >>conftest.$ac_ext
3991 cat >>conftest.$ac_ext <<_ACEOF
3992 /* end confdefs.h.  */
3993 $ac_declaration
3994 int
3995 main ()
3996 {
3997 exit (42);
3998   ;
3999   return 0;
4000 }
4001 _ACEOF
4002 rm -f conftest.$ac_objext
4003 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4004   (eval $ac_compile) 2>conftest.er1
4005   ac_status=$?
4006   grep -v '^ *+' conftest.er1 >conftest.err
4007   rm -f conftest.er1
4008   cat conftest.err >&5
4009   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4010   (exit $ac_status); } &&
4011          { ac_try='test -z "$ac_cxx_werror_flag"
4012                          || test ! -s conftest.err'
4013   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4014   (eval $ac_try) 2>&5
4015   ac_status=$?
4016   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4017   (exit $ac_status); }; } &&
4018          { ac_try='test -s conftest.$ac_objext'
4019   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4020   (eval $ac_try) 2>&5
4021   ac_status=$?
4022   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4023   (exit $ac_status); }; }; then
4024   break
4025 else
4026   echo "$as_me: failed program was:" >&5
4027 sed 's/^/| /' conftest.$ac_ext >&5
4028
4029 fi
4030 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4031 done
4032 rm -f conftest*
4033 if test -n "$ac_declaration"; then
4034   echo '#ifdef __cplusplus' >>confdefs.h
4035   echo $ac_declaration      >>confdefs.h
4036   echo '#endif'             >>confdefs.h
4037 fi
4038
4039 ac_ext=c
4040 ac_cpp='$CPP $CPPFLAGS'
4041 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4042 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4043 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4044
4045
4046 # We must set the default linker to the linker used by gcc for the correct
4047 # operation of libtool.  If LD is not defined and we are using gcc, try to
4048 # set the LD default to the ld used by gcc.
4049 if test -z "$LD"; then
4050   if test "$GCC" = yes; then
4051     case $build in
4052     *-*-mingw*)
4053       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4054     *)
4055       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4056     esac
4057     case $gcc_prog_ld in
4058     # Accept absolute paths.
4059     [\\/]* | [A-Za-z]:[\\/]*)
4060       LD="$gcc_prog_ld" ;;
4061     esac
4062   fi
4063 fi
4064
4065
4066
4067
4068 if test -n "$ac_tool_prefix"; then
4069   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4070 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4071 echo "$as_me:$LINENO: checking for $ac_word" >&5
4072 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4073 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4074   echo $ECHO_N "(cached) $ECHO_C" >&6
4075 else
4076   if test -n "$GNATBIND"; then
4077   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4078 else
4079 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4080 for as_dir in $PATH
4081 do
4082   IFS=$as_save_IFS
4083   test -z "$as_dir" && as_dir=.
4084   for ac_exec_ext in '' $ac_executable_extensions; do
4085   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4086     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4087     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4088     break 2
4089   fi
4090 done
4091 done
4092
4093 fi
4094 fi
4095 GNATBIND=$ac_cv_prog_GNATBIND
4096 if test -n "$GNATBIND"; then
4097   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4098 echo "${ECHO_T}$GNATBIND" >&6
4099 else
4100   echo "$as_me:$LINENO: result: no" >&5
4101 echo "${ECHO_T}no" >&6
4102 fi
4103
4104 fi
4105 if test -z "$ac_cv_prog_GNATBIND"; then
4106   ac_ct_GNATBIND=$GNATBIND
4107   # Extract the first word of "gnatbind", so it can be a program name with args.
4108 set dummy gnatbind; ac_word=$2
4109 echo "$as_me:$LINENO: checking for $ac_word" >&5
4110 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4111 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4112   echo $ECHO_N "(cached) $ECHO_C" >&6
4113 else
4114   if test -n "$ac_ct_GNATBIND"; then
4115   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4116 else
4117 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4118 for as_dir in $PATH
4119 do
4120   IFS=$as_save_IFS
4121   test -z "$as_dir" && as_dir=.
4122   for ac_exec_ext in '' $ac_executable_extensions; do
4123   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4124     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4125     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4126     break 2
4127   fi
4128 done
4129 done
4130
4131   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4132 fi
4133 fi
4134 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4135 if test -n "$ac_ct_GNATBIND"; then
4136   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4137 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4138 else
4139   echo "$as_me:$LINENO: result: no" >&5
4140 echo "${ECHO_T}no" >&6
4141 fi
4142
4143   GNATBIND=$ac_ct_GNATBIND
4144 else
4145   GNATBIND="$ac_cv_prog_GNATBIND"
4146 fi
4147
4148 if test -n "$ac_tool_prefix"; then
4149   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4150 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4151 echo "$as_me:$LINENO: checking for $ac_word" >&5
4152 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4153 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4154   echo $ECHO_N "(cached) $ECHO_C" >&6
4155 else
4156   if test -n "$GNATMAKE"; then
4157   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4158 else
4159 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4160 for as_dir in $PATH
4161 do
4162   IFS=$as_save_IFS
4163   test -z "$as_dir" && as_dir=.
4164   for ac_exec_ext in '' $ac_executable_extensions; do
4165   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4166     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4167     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4168     break 2
4169   fi
4170 done
4171 done
4172
4173 fi
4174 fi
4175 GNATMAKE=$ac_cv_prog_GNATMAKE
4176 if test -n "$GNATMAKE"; then
4177   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4178 echo "${ECHO_T}$GNATMAKE" >&6
4179 else
4180   echo "$as_me:$LINENO: result: no" >&5
4181 echo "${ECHO_T}no" >&6
4182 fi
4183
4184 fi
4185 if test -z "$ac_cv_prog_GNATMAKE"; then
4186   ac_ct_GNATMAKE=$GNATMAKE
4187   # Extract the first word of "gnatmake", so it can be a program name with args.
4188 set dummy gnatmake; ac_word=$2
4189 echo "$as_me:$LINENO: checking for $ac_word" >&5
4190 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4191 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4192   echo $ECHO_N "(cached) $ECHO_C" >&6
4193 else
4194   if test -n "$ac_ct_GNATMAKE"; then
4195   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4196 else
4197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4198 for as_dir in $PATH
4199 do
4200   IFS=$as_save_IFS
4201   test -z "$as_dir" && as_dir=.
4202   for ac_exec_ext in '' $ac_executable_extensions; do
4203   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4204     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4205     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4206     break 2
4207   fi
4208 done
4209 done
4210
4211   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4212 fi
4213 fi
4214 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4215 if test -n "$ac_ct_GNATMAKE"; then
4216   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4217 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4218 else
4219   echo "$as_me:$LINENO: result: no" >&5
4220 echo "${ECHO_T}no" >&6
4221 fi
4222
4223   GNATMAKE=$ac_ct_GNATMAKE
4224 else
4225   GNATMAKE="$ac_cv_prog_GNATMAKE"
4226 fi
4227
4228 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4229 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4230 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4231   echo $ECHO_N "(cached) $ECHO_C" >&6
4232 else
4233   cat >conftest.adb <<EOF
4234 procedure conftest is begin null; end conftest;
4235 EOF
4236 acx_cv_cc_gcc_supports_ada=no
4237 # There is a bug in old released versions of GCC which causes the
4238 # driver to exit successfully when the appropriate language module
4239 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4240 # Therefore we must check for the error message as well as an
4241 # unsuccessful exit.
4242 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4243 # given a .adb file, but produce no object file.  So we must check
4244 # if an object file was really produced to guard against this.
4245 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4246 if test x"$errors" = x && test -f conftest.$ac_objext; then
4247   acx_cv_cc_gcc_supports_ada=yes
4248 fi
4249 rm -f conftest.*
4250 fi
4251 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4252 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4253
4254 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4255   have_gnat=yes
4256 else
4257   have_gnat=no
4258 fi
4259
4260 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4261 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4262 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4263   echo $ECHO_N "(cached) $ECHO_C" >&6
4264 else
4265    echo abfoo >t1
4266   echo cdfoo >t2
4267   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4268   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4269     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4270       :
4271     else
4272       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4273     fi
4274   fi
4275   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4276     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4277       :
4278     else
4279       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4280     fi
4281   fi
4282   rm t1 t2
4283
4284 fi
4285 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4286 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4287 do_compare="$gcc_cv_prog_cmp_skip"
4288
4289
4290
4291 # Check for GMP and MPFR
4292 gmplibs="-lmpfr -lgmp"
4293 gmpinc=
4294 have_gmp=no
4295
4296 # Specify a location for mpfr
4297 # check for this first so it ends up on the link line before gmp.
4298
4299 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4300 if test "${with_mpfr_dir+set}" = set; then
4301   withval="$with_mpfr_dir"
4302   { { echo "$as_me:$LINENO: 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" >&5
4304 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4305 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4306    { (exit 1); exit 1; }; }
4307 fi;
4308
4309
4310 # Check whether --with-mpfr or --without-mpfr was given.
4311 if test "${with_mpfr+set}" = set; then
4312   withval="$with_mpfr"
4313
4314 fi;
4315
4316 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4317 if test "${with_mpfr_include+set}" = set; then
4318   withval="$with_mpfr_include"
4319
4320 fi;
4321
4322 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4323 if test "${with_mpfr_lib+set}" = set; then
4324   withval="$with_mpfr_lib"
4325
4326 fi;
4327
4328 if test "x$with_mpfr" != x; then
4329   gmplibs="-L$with_mpfr/lib $gmplibs"
4330   gmpinc="-I$with_mpfr/include"
4331 fi
4332 if test "x$with_mpfr_include" != x; then
4333   gmpinc="-I$with_mpfr_include"
4334 fi
4335 if test "x$with_mpfr_lib" != x; then
4336   gmplibs="-L$with_mpfr_lib $gmplibs"
4337 fi
4338 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4339   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4340   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4341   # Do not test the mpfr version.  Assume that it is sufficient, since
4342   # it is in the source tree, and the library has not been built yet
4343   # but it would be included on the link line in the version check below
4344   # hence making the test fail.
4345   have_gmp=yes
4346 fi
4347
4348 # Specify a location for gmp
4349
4350 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4351 if test "${with_gmp_dir+set}" = set; then
4352   withval="$with_gmp_dir"
4353   { { echo "$as_me:$LINENO: 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" >&5
4355 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4356 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4357    { (exit 1); exit 1; }; }
4358 fi;
4359
4360
4361 # Check whether --with-gmp or --without-gmp was given.
4362 if test "${with_gmp+set}" = set; then
4363   withval="$with_gmp"
4364
4365 fi;
4366
4367 # Check whether --with-gmp_include or --without-gmp_include was given.
4368 if test "${with_gmp_include+set}" = set; then
4369   withval="$with_gmp_include"
4370
4371 fi;
4372
4373 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4374 if test "${with_gmp_lib+set}" = set; then
4375   withval="$with_gmp_lib"
4376
4377 fi;
4378
4379
4380 if test "x$with_gmp" != x; then
4381   gmplibs="-L$with_gmp/lib $gmplibs"
4382   gmpinc="-I$with_gmp/include $gmpinc"
4383 fi
4384 if test "x$with_gmp_include" != x; then
4385   gmpinc="-I$with_gmp_include $gmpinc"
4386 fi
4387 if test "x$with_gmp_lib" != x; then
4388   gmplibs="-L$with_gmp_lib $gmplibs"
4389 fi
4390 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4391   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4392   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4393   # Do not test the gmp version.  Assume that it is sufficient, since
4394   # it is in the source tree, and the library has not been built yet
4395   # but it would be included on the link line in the version check below
4396   # hence making the test fail.
4397   have_gmp=yes
4398 fi
4399
4400 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4401   have_gmp=yes
4402   saved_CFLAGS="$CFLAGS"
4403   CFLAGS="$CFLAGS $gmpinc"
4404   # Check GMP actually works
4405   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4406 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4407
4408 cat >conftest.$ac_ext <<_ACEOF
4409 /* confdefs.h.  */
4410 _ACEOF
4411 cat confdefs.h >>conftest.$ac_ext
4412 cat >>conftest.$ac_ext <<_ACEOF
4413 /* end confdefs.h.  */
4414 #include "gmp.h"
4415 int
4416 main ()
4417 {
4418
4419   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4420   choke me
4421   #endif
4422
4423   ;
4424   return 0;
4425 }
4426 _ACEOF
4427 rm -f conftest.$ac_objext
4428 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4429   (eval $ac_compile) 2>conftest.er1
4430   ac_status=$?
4431   grep -v '^ *+' conftest.er1 >conftest.err
4432   rm -f conftest.er1
4433   cat conftest.err >&5
4434   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4435   (exit $ac_status); } &&
4436          { ac_try='test -z "$ac_c_werror_flag"
4437                          || test ! -s conftest.err'
4438   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4439   (eval $ac_try) 2>&5
4440   ac_status=$?
4441   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4442   (exit $ac_status); }; } &&
4443          { ac_try='test -s conftest.$ac_objext'
4444   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4445   (eval $ac_try) 2>&5
4446   ac_status=$?
4447   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4448   (exit $ac_status); }; }; then
4449   echo "$as_me:$LINENO: result: yes" >&5
4450 echo "${ECHO_T}yes" >&6
4451 else
4452   echo "$as_me: failed program was:" >&5
4453 sed 's/^/| /' conftest.$ac_ext >&5
4454
4455 echo "$as_me:$LINENO: result: no" >&5
4456 echo "${ECHO_T}no" >&6; have_gmp=no
4457 fi
4458 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4459
4460   if test x"$have_gmp" = xyes; then
4461     saved_LIBS="$LIBS"
4462     LIBS="$LIBS $gmplibs"
4463         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4464 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4465     cat >conftest.$ac_ext <<_ACEOF
4466 /* confdefs.h.  */
4467 _ACEOF
4468 cat confdefs.h >>conftest.$ac_ext
4469 cat >>conftest.$ac_ext <<_ACEOF
4470 /* end confdefs.h.  */
4471 #include <gmp.h>
4472     #include <mpfr.h>
4473 int
4474 main ()
4475 {
4476
4477     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,0)
4478     choke me
4479     #endif
4480     mpfr_t n;
4481     mpfr_t x;
4482     int t;
4483     mpfr_init (n);
4484     mpfr_init (x);
4485     mpfr_atan2 (n, n, x, GMP_RNDN);
4486     mpfr_erfc (n, x, GMP_RNDN);
4487     mpfr_subnormalize (x, t, GMP_RNDN);
4488
4489   ;
4490   return 0;
4491 }
4492 _ACEOF
4493 rm -f conftest.$ac_objext conftest$ac_exeext
4494 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4495   (eval $ac_link) 2>conftest.er1
4496   ac_status=$?
4497   grep -v '^ *+' conftest.er1 >conftest.err
4498   rm -f conftest.er1
4499   cat conftest.err >&5
4500   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4501   (exit $ac_status); } &&
4502          { ac_try='test -z "$ac_c_werror_flag"
4503                          || test ! -s conftest.err'
4504   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4505   (eval $ac_try) 2>&5
4506   ac_status=$?
4507   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4508   (exit $ac_status); }; } &&
4509          { ac_try='test -s conftest$ac_exeext'
4510   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4511   (eval $ac_try) 2>&5
4512   ac_status=$?
4513   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4514   (exit $ac_status); }; }; then
4515   cat >conftest.$ac_ext <<_ACEOF
4516 /* confdefs.h.  */
4517 _ACEOF
4518 cat confdefs.h >>conftest.$ac_ext
4519 cat >>conftest.$ac_ext <<_ACEOF
4520 /* end confdefs.h.  */
4521 #include <gmp.h>
4522     #include <mpfr.h>
4523 int
4524 main ()
4525 {
4526
4527     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4528     choke me
4529     #endif
4530     mpfr_t n; mpfr_init(n);
4531
4532   ;
4533   return 0;
4534 }
4535 _ACEOF
4536 rm -f conftest.$ac_objext conftest$ac_exeext
4537 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4538   (eval $ac_link) 2>conftest.er1
4539   ac_status=$?
4540   grep -v '^ *+' conftest.er1 >conftest.err
4541   rm -f conftest.er1
4542   cat conftest.err >&5
4543   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4544   (exit $ac_status); } &&
4545          { ac_try='test -z "$ac_c_werror_flag"
4546                          || test ! -s conftest.err'
4547   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4548   (eval $ac_try) 2>&5
4549   ac_status=$?
4550   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4551   (exit $ac_status); }; } &&
4552          { ac_try='test -s conftest$ac_exeext'
4553   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4554   (eval $ac_try) 2>&5
4555   ac_status=$?
4556   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4557   (exit $ac_status); }; }; then
4558   echo "$as_me:$LINENO: result: yes" >&5
4559 echo "${ECHO_T}yes" >&6
4560 else
4561   echo "$as_me: failed program was:" >&5
4562 sed 's/^/| /' conftest.$ac_ext >&5
4563
4564 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4565 echo "${ECHO_T}buggy but acceptable" >&6
4566 fi
4567 rm -f conftest.err conftest.$ac_objext \
4568       conftest$ac_exeext conftest.$ac_ext
4569 else
4570   echo "$as_me: failed program was:" >&5
4571 sed 's/^/| /' conftest.$ac_ext >&5
4572
4573 echo "$as_me:$LINENO: result: no" >&5
4574 echo "${ECHO_T}no" >&6; have_gmp=no
4575 fi
4576 rm -f conftest.err conftest.$ac_objext \
4577       conftest$ac_exeext conftest.$ac_ext
4578       LIBS="$saved_LIBS"
4579   fi
4580   CFLAGS="$saved_CFLAGS"
4581
4582   if test x$have_gmp != xyes; then
4583     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4584 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4585 Copies of these libraries' source code can be found at their respective
4586 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4587 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4588 If you obtained GMP and/or MPFR from a vendor distribution package, make
4589 sure that you have installed both the libraries and the header files.
4590 They may be located in separate packages." >&5
4591 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4592 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4593 Copies of these libraries' source code can be found at their respective
4594 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4595 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4596 If you obtained GMP and/or MPFR from a vendor distribution package, make
4597 sure that you have installed both the libraries and the header files.
4598 They may be located in separate packages." >&2;}
4599    { (exit 1); exit 1; }; }
4600   fi
4601 fi
4602
4603 # Flags needed for both GMP and/or MPFR
4604
4605
4606
4607 # By default, C is the only stage 1 language.
4608 stage1_languages=,c,
4609
4610 # Figure out what language subdirectories are present.
4611 # Look if the user specified --enable-languages="..."; if not, use
4612 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4613 # go away some day.
4614 # NB:  embedded tabs in this IF block -- do not untabify
4615 if test -d ${srcdir}/gcc; then
4616   if test x"${enable_languages+set}" != xset; then
4617     if test x"${LANGUAGES+set}" = xset; then
4618       enable_languages="${LANGUAGES}"
4619         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4620     else
4621       enable_languages=all
4622     fi
4623   else
4624     if test x"${enable_languages}" = x ||
4625        test x"${enable_languages}" = xyes;
4626        then
4627       echo configure.in: --enable-languages needs at least one language argument 1>&2
4628       exit 1
4629     fi
4630   fi
4631   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4632
4633   # 'f95' is the old name for the 'fortran' language. We issue a warning
4634   # and make the substitution.
4635   case ,${enable_languages}, in
4636     *,f95,*)
4637       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4638       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4639       ;;
4640   esac
4641
4642   # First scan to see if an enabled language requires some other language.
4643   # We assume that a given config-lang.in will list all the language
4644   # front ends it requires, even if some are required indirectly.
4645   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4646     case ${lang_frag} in
4647       ..) ;;
4648       # The odd quoting in the next line works around
4649       # an apparent bug in bash 1.12 on linux.
4650       ${srcdir}/gcc/[*]/config-lang.in) ;;
4651       *)
4652         # From the config-lang.in, get $language, $lang_requires
4653         language=
4654         lang_requires=
4655         . ${lang_frag}
4656         for other in ${lang_requires} ; do
4657           case ,${enable_languages}, in
4658             *,$other,*) ;;
4659             *,all,*) ;;
4660             *,$language,*)
4661               echo " \`$other' language required by \`$language'; enabling" 1>&2
4662               enable_languages="${enable_languages},${other}"
4663               ;;
4664           esac
4665         done
4666         ;;
4667     esac
4668   done
4669
4670   new_enable_languages=,c,
4671   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4672   potential_languages=,c,
4673
4674   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4675     case ${lang_frag} in
4676       ..) ;;
4677       # The odd quoting in the next line works around
4678       # an apparent bug in bash 1.12 on linux.
4679       ${srcdir}/gcc/[*]/config-lang.in) ;;
4680       *)
4681         # From the config-lang.in, get $language, $target_libs,
4682         # $lang_dirs, $boot_language, and $build_by_default
4683         language=
4684         target_libs=
4685         lang_dirs=
4686         subdir_requires=
4687         boot_language=no
4688         build_by_default=yes
4689         . ${lang_frag}
4690         if test x${language} = x; then
4691           echo "${lang_frag} doesn't set \$language." 1>&2
4692           exit 1
4693         fi
4694
4695         case ,${enable_languages}, in
4696           *,${language},*)
4697             # Language was explicitly selected; include it.
4698             add_this_lang=yes
4699             ;;
4700           *,all,*)
4701             # 'all' was selected, select it if it is a default language
4702             add_this_lang=${build_by_default}
4703             ;;
4704           *)
4705             add_this_lang=no
4706             ;;
4707         esac
4708
4709         # Disable languages that need other directories if these aren't available.
4710         for i in $subdir_requires; do
4711           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4712           case ,${enable_languages}, in
4713             *,${language},*)
4714               # Specifically requested language; tell them.
4715               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4716 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4717    { (exit 1); exit 1; }; }
4718               ;;
4719             *)
4720               # Silently disable.
4721               add_this_lang=unsupported
4722               ;;
4723           esac
4724         done
4725
4726         # Disable Ada if no preexisting GNAT is available.
4727         case ,${enable_languages},:${language}:${have_gnat} in
4728           *,${language},*:ada:no)
4729             # Specifically requested language; tell them.
4730             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4731 echo "$as_me: error: GNAT is required to build $language" >&2;}
4732    { (exit 1); exit 1; }; }
4733             ;;
4734           *:ada:no)
4735             # Silently disable.
4736             add_this_lang=unsupported
4737             ;;
4738         esac
4739
4740         # Disable a language that is unsupported by the target.
4741         case " $unsupported_languages " in
4742           *" $language "*)
4743             add_this_lang=unsupported
4744             ;;
4745         esac
4746
4747         case $add_this_lang in
4748           unsupported)
4749             # Remove language-dependent dirs.
4750             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4751             ;;
4752           no)
4753             # Remove language-dependent dirs; still show language as supported.
4754             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4755             potential_languages="${potential_languages}${language},"
4756             ;;
4757           yes)
4758             new_enable_languages="${new_enable_languages}${language},"
4759             potential_languages="${potential_languages}${language},"
4760             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4761             case ${boot_language} in
4762               yes)
4763                 # Add to (comma-separated) list of stage 1 languages.
4764                 stage1_languages="${stage1_languages}${language},"
4765                 ;;
4766             esac
4767             ;;
4768         esac
4769         ;;
4770     esac
4771   done
4772
4773   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4774 if test "${enable_stage1_languages+set}" = set; then
4775   enableval="$enable_stage1_languages"
4776   case ,${enable_stage1_languages}, in
4777     ,no,|,,)
4778       # Set it to something that will have no effect in the loop below
4779       enable_stage1_languages=c ;;
4780     ,yes,)
4781       enable_stage1_languages=`echo $new_enable_languages | \
4782         sed -e "s/^,//" -e "s/,$//" ` ;;
4783     *,all,*)
4784       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4785         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4786   esac
4787
4788   # Add "good" languages from enable_stage1_languages to stage1_languages,
4789   # while "bad" languages go in missing_languages.  Leave no duplicates.
4790   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4791     case $potential_languages in
4792       *,$i,*)
4793         case $stage1_languages in
4794           *,$i,*) ;;
4795           *) stage1_languages="$stage1_languages$i," ;;
4796         esac ;;
4797       *)
4798         case $missing_languages in
4799           *,$i,*) ;;
4800           *) missing_languages="$missing_languages$i," ;;
4801         esac ;;
4802      esac
4803   done
4804 fi;
4805
4806   # Remove leading/trailing commas that were added for simplicity
4807   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4808   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4809   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4810   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4811
4812   if test "x$missing_languages" != x; then
4813     { { echo "$as_me:$LINENO: error:
4814 The following requested languages could not be built: ${missing_languages}
4815 Supported languages are: ${potential_languages}" >&5
4816 echo "$as_me: error:
4817 The following requested languages could not be built: ${missing_languages}
4818 Supported languages are: ${potential_languages}" >&2;}
4819    { (exit 1); exit 1; }; }
4820   fi
4821   if test "x$new_enable_languages" != "x$enable_languages"; then
4822     echo The following languages will be built: ${new_enable_languages}
4823     enable_languages="$new_enable_languages"
4824   fi
4825
4826
4827   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4828 fi
4829
4830 # Handle --disable-<component> generically.
4831 for dir in $configdirs $build_configdirs $target_configdirs ; do
4832   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4833   if eval test x\${enable_${dirname}} "=" xno ; then
4834     noconfigdirs="$noconfigdirs $dir"
4835   fi
4836 done
4837
4838 # Check for Boehm's garbage collector
4839 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4840 if test "${enable_objc_gc+set}" = set; then
4841   enableval="$enable_objc_gc"
4842   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4843   *,objc,*:*:yes:*target-boehm-gc*)
4844     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4845 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4846    { (exit 1); exit 1; }; }
4847     ;;
4848 esac
4849 fi;
4850
4851 # Make sure we only build Boehm's garbage collector if required.
4852 case ,${enable_languages},:${enable_objc_gc} in
4853   *,objc,*:yes)
4854     # Keep target-boehm-gc if requested for Objective-C.
4855     ;;
4856   *)
4857     # Otherwise remove target-boehm-gc depending on target-libjava.
4858     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4859       noconfigdirs="$noconfigdirs target-boehm-gc"
4860     fi
4861     ;;
4862 esac
4863
4864 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4865 # $build_configdirs and $target_configdirs.
4866 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4867
4868 notsupp=""
4869 for dir in . $skipdirs $noconfigdirs ; do
4870   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4871   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4872     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4873     if test -r $srcdir/$dirname/configure ; then
4874       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4875         true
4876       else
4877         notsupp="$notsupp $dir"
4878       fi
4879     fi
4880   fi
4881   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4882     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4883     if test -r $srcdir/$dirname/configure ; then
4884       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4885         true
4886       else
4887         notsupp="$notsupp $dir"
4888       fi
4889     fi
4890   fi
4891   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4892     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4893     if test -r $srcdir/$dirname/configure ; then
4894       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4895         true
4896       else
4897         notsupp="$notsupp $dir"
4898       fi
4899     fi
4900   fi
4901 done
4902
4903 # Sometimes the tools are distributed with libiberty but with no other
4904 # libraries.  In that case, we don't want to build target-libiberty.
4905 # Don't let libgcc imply libiberty either.
4906 if test -n "${target_configdirs}" ; then
4907   libgcc=
4908   others=
4909   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
4910     if test "$i" = "libgcc"; then
4911       libgcc=target-libgcc
4912     elif test "$i" != "libiberty" ; then
4913       if test -r $srcdir/$i/configure ; then
4914         others=yes;
4915         break;
4916       fi
4917     fi
4918   done
4919   if test -z "${others}" ; then
4920     target_configdirs=$libgcc
4921   fi
4922 fi
4923
4924 # Quietly strip out all directories which aren't configurable in this tree.
4925 # This relies on all configurable subdirectories being autoconfiscated, which
4926 # is now the case.
4927 build_configdirs_all="$build_configdirs"
4928 build_configdirs=
4929 for i in ${build_configdirs_all} ; do
4930   j=`echo $i | sed -e s/build-//g`
4931   if test -f ${srcdir}/$j/configure ; then
4932     build_configdirs="${build_configdirs} $i"
4933   fi
4934 done
4935
4936 configdirs_all="$configdirs"
4937 configdirs=
4938 for i in ${configdirs_all} ; do
4939   if test -f ${srcdir}/$i/configure ; then
4940     configdirs="${configdirs} $i"
4941   fi
4942 done
4943
4944 target_configdirs_all="$target_configdirs"
4945 target_configdirs=
4946 for i in ${target_configdirs_all} ; do
4947   j=`echo $i | sed -e s/target-//g`
4948   if test -f ${srcdir}/$j/configure ; then
4949     target_configdirs="${target_configdirs} $i"
4950   fi
4951 done
4952
4953 # Produce a warning message for the subdirs we can't configure.
4954 # This isn't especially interesting in the Cygnus tree, but in the individual
4955 # FSF releases, it's important to let people know when their machine isn't
4956 # supported by the one or two programs in a package.
4957
4958 if test -n "${notsupp}" && test -z "${norecursion}" ; then
4959   # If $appdirs is non-empty, at least one of those directories must still
4960   # be configured, or we error out.  (E.g., if the gas release supports a
4961   # specified target in some subdirs but not the gas subdir, we shouldn't
4962   # pretend that all is well.)
4963   if test -n "$appdirs" ; then
4964     for dir in $appdirs ; do
4965       if test -r $dir/Makefile.in ; then
4966         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4967           appdirs=""
4968           break
4969         fi
4970         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
4971           appdirs=""
4972           break
4973         fi
4974       fi
4975     done
4976     if test -n "$appdirs" ; then
4977       echo "*** This configuration is not supported by this package." 1>&2
4978       exit 1
4979     fi
4980   fi
4981   # Okay, some application will build, or we don't care to check.  Still
4982   # notify of subdirs not getting built.
4983   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
4984   echo "    ${notsupp}" 1>&2
4985   echo "    (Any other directories should still work fine.)" 1>&2
4986 fi
4987
4988 case "$host" in
4989   *msdosdjgpp*)
4990     enable_gdbtk=no ;;
4991 esac
4992
4993 # To find our prefix, in gcc_cv_tool_prefix.
4994
4995 # The user is always right.
4996 if test "${PATH_SEPARATOR+set}" != set; then
4997   echo "#! /bin/sh" >conf$$.sh
4998   echo  "exit 0"   >>conf$$.sh
4999   chmod +x conf$$.sh
5000   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5001     PATH_SEPARATOR=';'
5002   else
5003     PATH_SEPARATOR=:
5004   fi
5005   rm -f conf$$.sh
5006 fi
5007
5008
5009
5010 if test "x$exec_prefix" = xNONE; then
5011         if test "x$prefix" = xNONE; then
5012                 gcc_cv_tool_prefix=$ac_default_prefix
5013         else
5014                 gcc_cv_tool_prefix=$prefix
5015         fi
5016 else
5017         gcc_cv_tool_prefix=$exec_prefix
5018 fi
5019
5020 # If there is no compiler in the tree, use the PATH only.  In any
5021 # case, if there is no compiler in the tree nobody should use
5022 # AS_FOR_TARGET and LD_FOR_TARGET.
5023 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5024     gcc_version=`cat $srcdir/gcc/BASE-VER`
5025     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5026     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5027     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5028     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5029     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5030     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5031 else
5032     gcc_cv_tool_dirs=
5033 fi
5034
5035 if test x$build = x$target && test -n "$md_exec_prefix"; then
5036         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5037 fi
5038
5039
5040
5041 copy_dirs=
5042
5043
5044 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5045 if test "${with_build_sysroot+set}" = set; then
5046   withval="$with_build_sysroot"
5047   if test x"$withval" != x ; then
5048      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5049    fi
5050 else
5051   SYSROOT_CFLAGS_FOR_TARGET=
5052 fi;
5053
5054
5055 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5056 # the named directory are copied to $(tooldir)/sys-include.
5057 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5058   if test x${is_cross_compiler} = xno ; then
5059     echo 1>&2 '***' --with-headers is only supported when cross compiling
5060     exit 1
5061   fi
5062   if test x"${with_headers}" != xyes ; then
5063     x=${gcc_cv_tool_prefix}
5064     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5065   fi
5066 fi
5067
5068 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5069 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5070 # are permitted.
5071 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5072   if test x${is_cross_compiler} = xno ; then
5073     echo 1>&2 '***' --with-libs is only supported when cross compiling
5074     exit 1
5075   fi
5076   if test x"${with_libs}" != xyes ; then
5077     # Copy the libraries in reverse order, so that files in the first named
5078     # library override files in subsequent libraries.
5079     x=${gcc_cv_tool_prefix}
5080     for l in ${with_libs}; do
5081       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5082     done
5083   fi
5084 fi
5085
5086 # Set with_gnu_as and with_gnu_ld as appropriate.
5087 #
5088 # This is done by determining whether or not the appropriate directory
5089 # is available, and by checking whether or not specific configurations
5090 # have requested that this magic not happen.
5091 #
5092 # The command line options always override the explicit settings in
5093 # configure.in, and the settings in configure.in override this magic.
5094 #
5095 # If the default for a toolchain is to use GNU as and ld, and you don't
5096 # want to do that, then you should use the --without-gnu-as and
5097 # --without-gnu-ld options for the configure script.
5098
5099 if test x${use_gnu_as} = x &&
5100    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5101   with_gnu_as=yes
5102   extra_host_args="$extra_host_args --with-gnu-as"
5103 fi
5104
5105 if test x${use_gnu_ld} = x &&
5106    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5107   with_gnu_ld=yes
5108   extra_host_args="$extra_host_args --with-gnu-ld"
5109 fi
5110
5111 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5112 # can detect this case.
5113
5114 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5115   with_newlib=yes
5116   extra_host_args="$extra_host_args --with-newlib"
5117 fi
5118
5119 # Handle ${copy_dirs}
5120 set fnord ${copy_dirs}
5121 shift
5122 while test $# != 0 ; do
5123   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5124     :
5125   else
5126     echo Copying $1 to $2
5127
5128     # Use the install script to create the directory and all required
5129     # parent directories.
5130     if test -d $2 ; then
5131       :
5132     else
5133       echo >config.temp
5134       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5135     fi
5136
5137     # Copy the directory, assuming we have tar.
5138     # FIXME: Should we use B in the second tar?  Not all systems support it.
5139     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5140
5141     # It is the responsibility of the user to correctly adjust all
5142     # symlinks.  If somebody can figure out how to handle them correctly
5143     # here, feel free to add the code.
5144
5145     echo $1 > $2/COPIED
5146   fi
5147   shift; shift
5148 done
5149
5150 # Determine a target-dependent exec_prefix that the installed
5151 # gcc will search in.  Keep this list sorted by triplet, with
5152 # the *-*-osname triplets last.
5153 md_exec_prefix=
5154 case "${target}" in
5155   alpha*-*-*vms*)
5156     md_exec_prefix=/gnu/lib/gcc-lib
5157     ;;
5158   i3456786-pc-msdosdjgpp*)
5159     md_exec_prefix=/dev/env/DJDIR/bin
5160     ;;
5161   i3456786-*-sco3.2v5*)
5162     if test $with_gnu_as = yes; then
5163       md_exec_prefix=/usr/gnu/bin
5164     else
5165       md_exec_prefix=/usr/ccs/bin/elf
5166     fi
5167     ;;
5168
5169   mn10300-*-* | \
5170   powerpc-*-chorusos* | \
5171   powerpc*-*-eabi* | \
5172   powerpc*-*-sysv* | \
5173   powerpc*-*-kaos* | \
5174   s390x-ibm-tpf*)
5175     md_exec_prefix=/usr/ccs/bin
5176     ;;
5177   sparc64-*-elf*)
5178     ;;
5179   v850*-*-*)
5180     md_exec_prefix=/usr/ccs/bin
5181     ;;
5182   xtensa-*-elf*)
5183     ;;
5184
5185   *-*-beos* | \
5186   *-*-elf* | \
5187   *-*-hpux* | \
5188   *-*-netware* | \
5189   *-*-nto-qnx* | \
5190   *-*-rtems* | \
5191   *-*-solaris2* | \
5192   *-*-sysv45* | \
5193   *-*-vxworks* | \
5194   *-wrs-windiss)
5195     md_exec_prefix=/usr/ccs/bin
5196     ;;
5197 esac
5198
5199 extra_arflags_for_target=
5200 extra_nmflags_for_target=
5201 extra_ranlibflags_for_target=
5202 target_makefile_frag=/dev/null
5203 case "${target}" in
5204   mep*-*-*)
5205     target_makefile_frag="config/mt-mep"
5206     ;;
5207   spu-*-*)
5208     target_makefile_frag="config/mt-spu"
5209     ;;
5210   *-*-netware*)
5211     target_makefile_frag="config/mt-netware"
5212     ;;
5213   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5214     target_makefile_frag="config/mt-gnu"
5215     ;;
5216   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5217     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5218     # commands to handle both 32-bit and 64-bit objects.  These flags are
5219     # harmless if we're using GNU nm or ar.
5220     extra_arflags_for_target=" -X32_64"
5221     extra_nmflags_for_target=" -B -X32_64"
5222     ;;
5223   *-*-darwin*)
5224     # ranlib from Darwin requires the -c flag to look at common symbols.
5225     extra_ranlibflags_for_target=" -c"
5226     ;;
5227   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5228     target_makefile_frag="config/mt-wince"
5229     ;;
5230 esac
5231
5232 alphaieee_frag=/dev/null
5233 case $target in
5234   alpha*-*-*)
5235     # This just makes sure to use the -mieee option to build target libs.
5236     # This should probably be set individually by each library.
5237     alphaieee_frag="config/mt-alphaieee"
5238     ;;
5239 esac
5240
5241 # If --enable-target-optspace always use -Os instead of -O2 to build
5242 # the target libraries, similarly if it is not specified, use -Os
5243 # on selected platforms.
5244 ospace_frag=/dev/null
5245 case "${enable_target_optspace}:${target}" in
5246   yes:*)
5247     ospace_frag="config/mt-ospace"
5248     ;;
5249   :d30v-*)
5250     ospace_frag="config/mt-d30v"
5251     ;;
5252   :m32r-* | :d10v-* | :fr30-*)
5253     ospace_frag="config/mt-ospace"
5254     ;;
5255   no:* | :*)
5256     ;;
5257   *)
5258     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5259     ;;
5260 esac
5261
5262 # Default to using --with-stabs for certain targets.
5263 if test x${with_stabs} = x ; then
5264   case "${target}" in
5265   mips*-*-irix[56]*)
5266     ;;
5267   mips*-*-* | alpha*-*-osf*)
5268     with_stabs=yes;
5269     extra_host_args="${extra_host_args} --with-stabs"
5270     ;;
5271   esac
5272 fi
5273
5274 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5275 # them automatically.
5276 case "${host}" in
5277   hppa*64*-*-hpux11*)
5278     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5279     ;;
5280 esac
5281
5282 # Some systems (e.g., one of the i386-aix systems the gas testers are
5283 # using) don't handle "\$" correctly, so don't use it here.
5284 tooldir='${exec_prefix}'/${target_noncanonical}
5285 build_tooldir=${tooldir}
5286
5287 # Create a .gdbinit file which runs the one in srcdir
5288 # and tells GDB to look there for source files.
5289
5290 if test -r ${srcdir}/.gdbinit ; then
5291   case ${srcdir} in
5292     .) ;;
5293     *) cat > ./.gdbinit <<EOF
5294 # ${NO_EDIT}
5295 dir ${srcdir}
5296 dir .
5297 source ${srcdir}/.gdbinit
5298 EOF
5299     ;;
5300   esac
5301 fi
5302
5303 # Make sure that the compiler is able to generate an executable.  If it
5304 # can't, we are probably in trouble.  We don't care whether we can run the
5305 # executable--we might be using a cross compiler--we only care whether it
5306 # can be created.  At this point the main configure script has set CC.
5307 we_are_ok=no
5308 echo "int main () { return 0; }" > conftest.c
5309 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5310 if test $? = 0 ; then
5311   if test -s conftest || test -s conftest.exe ; then
5312     we_are_ok=yes
5313   fi
5314 fi
5315 case $we_are_ok in
5316   no)
5317     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5318     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5319     rm -f conftest*
5320     exit 1
5321     ;;
5322 esac
5323 rm -f conftest*
5324
5325 # The Solaris /usr/ucb/cc compiler does not appear to work.
5326 case "${host}" in
5327   sparc-sun-solaris2*)
5328       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5329       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5330           could_use=
5331           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5332           if test -d /opt/cygnus/bin ; then
5333               if test "$could_use" = "" ; then
5334                   could_use="/opt/cygnus/bin"
5335               else
5336                   could_use="$could_use or /opt/cygnus/bin"
5337               fi
5338           fi
5339         if test "$could_use" = "" ; then
5340             echo "Warning: compilation may fail because you're using"
5341             echo "/usr/ucb/cc.  You should change your PATH or CC "
5342             echo "variable and rerun configure."
5343         else
5344             echo "Warning: compilation may fail because you're using"
5345             echo "/usr/ucb/cc, when you should use the C compiler from"
5346             echo "$could_use.  You should change your"
5347             echo "PATH or CC variable and rerun configure."
5348         fi
5349       fi
5350   ;;
5351 esac
5352
5353 case "${host}" in
5354   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5355   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5356   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5357 esac
5358
5359 # Record target_configdirs and the configure arguments for target and
5360 # build configuration in Makefile.
5361 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5362 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5363
5364 # Determine whether gdb needs tk/tcl or not.
5365 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5366 # and in that case we want gdb to be built without tk.  Ugh!
5367 # In fact I believe gdb is the *only* package directly dependent on tk,
5368 # so we should be able to put the 'maybe's in unconditionally and
5369 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5370 # 100% sure that that's safe though.
5371
5372 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5373 case "$enable_gdbtk" in
5374   no)
5375     GDB_TK="" ;;
5376   yes)
5377     GDB_TK="${gdb_tk}" ;;
5378   *)
5379     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5380     # distro.  Eventually someone will fix this and move Insight, nee
5381     # gdbtk to a separate directory.
5382     if test -d ${srcdir}/gdb/gdbtk ; then
5383       GDB_TK="${gdb_tk}"
5384     else
5385       GDB_TK=""
5386     fi
5387     ;;
5388 esac
5389 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5390 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5391
5392 # Strip out unwanted targets.
5393
5394 # While at that, we remove Makefiles if we were started for recursive
5395 # configuration, so that the top-level Makefile reconfigures them,
5396 # like we used to do when configure itself was recursive.
5397
5398 # Loop over modules.  $extrasub must be used with care, limiting as
5399 # much as possible the usage of range addresses.  That's because autoconf
5400 # splits the sed script to overcome limits in the number of commands,
5401 # and relying on carefully-timed sed passes may turn out to be very hard
5402 # to maintain later.  In this particular case, you just have to be careful
5403 # not to nest @if/@endif pairs, because configure will not warn you at all.
5404
5405 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5406 if test "${enable_bootstrap+set}" = set; then
5407   enableval="$enable_bootstrap"
5408
5409 else
5410   enable_bootstrap=default
5411 fi;
5412
5413 # Issue errors and warnings for invalid/strange bootstrap combinations.
5414 case "$configdirs" in
5415   *gcc*) have_compiler=yes ;;
5416   *) have_compiler=no ;;
5417 esac
5418
5419 case "$have_compiler:$host:$target:$enable_bootstrap" in
5420   *:*:*:no) ;;
5421
5422   # Default behavior.  Enable bootstrap if we have a compiler
5423   # and we are in a native configuration.
5424   yes:$build:$build:default)
5425     enable_bootstrap=yes ;;
5426
5427   *:*:*:default)
5428     enable_bootstrap=no ;;
5429
5430   # We have a compiler and we are in a native configuration, bootstrap is ok
5431   yes:$build:$build:yes)
5432     ;;
5433
5434   # Other configurations, but we have a compiler.  Assume the user knows
5435   # what he's doing.
5436   yes:*:*:yes)
5437     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5438 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5439     ;;
5440
5441   # No compiler: if they passed --enable-bootstrap explicitly, fail
5442   no:*:*:yes)
5443     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5444 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5445    { (exit 1); exit 1; }; } ;;
5446
5447   # Fail if wrong command line
5448   *)
5449     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5450 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5451    { (exit 1); exit 1; }; }
5452     ;;
5453 esac
5454
5455 # Adjust the toplevel makefile according to whether bootstrap was selected.
5456 case "$enable_bootstrap" in
5457   yes)
5458     bootstrap_suffix=bootstrap ;;
5459   no)
5460     bootstrap_suffix=no-bootstrap ;;
5461 esac
5462
5463 for module in ${build_configdirs} ; do
5464   if test -z "${no_recursion}" \
5465      && test -f ${build_subdir}/${module}/Makefile; then
5466     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5467     rm -f ${build_subdir}/${module}/Makefile
5468   fi
5469   extrasub="$extrasub
5470 /^@if build-$module\$/d
5471 /^@endif build-$module\$/d
5472 /^@if build-$module-$bootstrap_suffix\$/d
5473 /^@endif build-$module-$bootstrap_suffix\$/d"
5474 done
5475 for module in ${configdirs} ; do
5476   if test -z "${no_recursion}"; then
5477     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5478       if test -f ${file}; then
5479         echo 1>&2 "*** removing ${file} to force reconfigure"
5480         rm -f ${file}
5481       fi
5482     done
5483   fi
5484   extrasub="$extrasub
5485 /^@if $module\$/d
5486 /^@endif $module\$/d
5487 /^@if $module-$bootstrap_suffix\$/d
5488 /^@endif $module-$bootstrap_suffix\$/d"
5489 done
5490 for module in ${target_configdirs} ; do
5491   if test -z "${no_recursion}" \
5492      && test -f ${target_subdir}/${module}/Makefile; then
5493     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5494     rm -f ${target_subdir}/${module}/Makefile
5495   fi
5496   extrasub="$extrasub
5497 /^@if target-$module\$/d
5498 /^@endif target-$module\$/d
5499 /^@if target-$module-$bootstrap_suffix\$/d
5500 /^@endif target-$module-$bootstrap_suffix\$/d"
5501 done
5502
5503 extrasub="$extrasub
5504 /^@if /,/^@endif /d"
5505
5506 # Create the serialization dependencies.  This uses a temporary file.
5507
5508 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5509 if test "${enable_serial_configure+set}" = set; then
5510   enableval="$enable_serial_configure"
5511
5512 fi;
5513
5514 case ${enable_serial_configure} in
5515   yes)
5516     enable_serial_build_configure=yes
5517     enable_serial_host_configure=yes
5518     enable_serial_target_configure=yes
5519     ;;
5520 esac
5521
5522 # These force 'configure's to be done one at a time, to avoid problems
5523 # with contention over a shared config.cache.
5524 rm -f serdep.tmp
5525 echo '# serdep.tmp' > serdep.tmp
5526 olditem=
5527 test "x${enable_serial_build_configure}" = xyes &&
5528 for item in ${build_configdirs} ; do
5529   case ${olditem} in
5530     "") ;;
5531     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5532   esac
5533   olditem=${item}
5534 done
5535 olditem=
5536 test "x${enable_serial_host_configure}" = xyes &&
5537 for item in ${configdirs} ; do
5538   case ${olditem} in
5539     "") ;;
5540     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5541   esac
5542   olditem=${item}
5543 done
5544 olditem=
5545 test "x${enable_serial_target_configure}" = xyes &&
5546 for item in ${target_configdirs} ; do
5547   case ${olditem} in
5548     "") ;;
5549     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5550   esac
5551   olditem=${item}
5552 done
5553 serialization_dependencies=serdep.tmp
5554
5555
5556 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5557 # target, nonopt, and variable assignments.  These are the ones we
5558 # might not want to pass down to subconfigures.  Also strip
5559 # program-prefix, program-suffix, and program-transform-name, so that
5560 # we can pass down a consistent program-transform-name.
5561 baseargs=
5562 keep_next=no
5563 skip_next=no
5564 eval "set -- $ac_configure_args"
5565 for ac_arg
5566 do
5567   if test X"$skip_next" = X"yes"; then
5568     skip_next=no
5569     continue
5570   fi
5571   if test X"$keep_next" = X"yes"; then
5572     case $ac_arg in
5573       *\'*)
5574         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5575     esac
5576     baseargs="$baseargs '$ac_arg'"
5577     keep_next=no
5578     continue
5579   fi
5580
5581   # Handle separated arguments.  Based on the logic generated by
5582   # autoconf 2.59.
5583   case $ac_arg in
5584     *=* | --config-cache | -C | -disable-* | --disable-* \
5585       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5586       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5587       | -with-* | --with-* | -without-* | --without-* | --x)
5588       separate_arg=no
5589       ;;
5590     -*)
5591       separate_arg=yes
5592       ;;
5593     *)
5594       separate_arg=no
5595       ;;
5596   esac
5597
5598   case "$ac_arg" in
5599     --no*)
5600       continue
5601       ;;
5602     --c* | \
5603     --sr* | \
5604     --ho* | \
5605     --bu* | \
5606     --t* | \
5607     --program-* | \
5608     -cache_file* | \
5609     -srcdir* | \
5610     -host* | \
5611     -build* | \
5612     -target* | \
5613     -program-prefix* | \
5614     -program-suffix* | \
5615     -program-transform-name* )
5616       skip_next=$separate_arg
5617       continue
5618       ;;
5619     -*)
5620       # An option.  Add it.
5621       case $ac_arg in
5622         *\'*)
5623           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5624       esac
5625       baseargs="$baseargs '$ac_arg'"
5626       keep_next=$separate_arg
5627       ;;
5628     *)
5629       # Either a variable assignment, or a nonopt (triplet).  Don't
5630       # pass it down; let the Makefile handle this.
5631       continue
5632       ;;
5633   esac
5634 done
5635 # Remove the initial space we just introduced and, as these will be
5636 # expanded by make, quote '$'.
5637 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5638
5639 # Add in --program-transform-name, after --program-prefix and
5640 # --program-suffix have been applied to it.  Autoconf has already
5641 # doubled dollar signs and backslashes in program_transform_name; we want
5642 # the backslashes un-doubled, and then the entire thing wrapped in single
5643 # quotes, because this will be expanded first by make and then by the shell.
5644 # Also, because we want to override the logic in subdir configure scripts to
5645 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5646 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5647 ${program_transform_name}
5648 EOF_SED
5649 gcc_transform_name=`cat conftestsed.out`
5650 rm -f conftestsed.out
5651 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5652
5653 # For the build-side libraries, we just need to pretend we're native,
5654 # and not use the same cache file.  Multilibs are neither needed nor
5655 # desired.
5656 build_configargs="--cache-file=../config.cache ${baseargs}"
5657
5658 # For host modules, accept cache file option, or specification as blank.
5659 case "${cache_file}" in
5660 "") # empty
5661   cache_file_option="" ;;
5662 /* | [A-Za-z]:[\\/]* ) # absolute path
5663   cache_file_option="--cache-file=${cache_file}" ;;
5664 *) # relative path
5665   cache_file_option="--cache-file=../${cache_file}" ;;
5666 esac
5667
5668 # Host dirs don't like to share a cache file either, horribly enough.
5669 # This seems to be due to autoconf 2.5x stupidity.
5670 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5671
5672 target_configargs=${baseargs}
5673
5674 # Passing a --with-cross-host argument lets the target libraries know
5675 # whether they are being built with a cross-compiler or being built
5676 # native.  However, it would be better to use other mechanisms to make the
5677 # sorts of decisions they want to make on this basis.  Please consider
5678 # this option to be deprecated.  FIXME.
5679 if test x${is_cross_compiler} = xyes ; then
5680   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5681 fi
5682
5683 # Default to --enable-multilib.
5684 if test x${enable_multilib} = x ; then
5685   target_configargs="--enable-multilib ${target_configargs}"
5686 fi
5687
5688 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5689 # changed from the earlier setting of with_newlib.
5690 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5691   target_configargs="--with-newlib ${target_configargs}"
5692 fi
5693
5694 # Different target subdirs use different values of certain variables
5695 # (notably CXX).  Worse, multilibs use *lots* of different values.
5696 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5697 # it doesn't automatically accept command-line overrides of them.
5698 # This means it's not safe for target subdirs to share a cache file,
5699 # which is disgusting, but there you have it.  Hopefully this can be
5700 # fixed in future.  It's still worthwhile to use a cache file for each
5701 # directory.  I think.
5702
5703 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5704 # We need to pass --target, as newer autoconf's requires consistency
5705 # for target_alias and gcc doesn't manage it consistently.
5706 target_configargs="--cache-file=./config.cache ${target_configargs}"
5707
5708 FLAGS_FOR_TARGET=
5709 case " $target_configdirs " in
5710  *" newlib "*)
5711   case " $target_configargs " in
5712   *" --with-newlib "*)
5713    case "$target" in
5714    *-cygwin*)
5715      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' ;;
5716    esac
5717
5718    # If we're not building GCC, don't discard standard headers.
5719    if test -d ${srcdir}/gcc; then
5720      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5721
5722      if test "${build}" != "${host}"; then
5723        # On Canadian crosses, CC_FOR_TARGET will have already been set
5724        # by `configure', so we won't have an opportunity to add -Bgcc/
5725        # to it.  This is right: we don't want to search that directory
5726        # for binaries, but we want the header files in there, so add
5727        # them explicitly.
5728        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5729
5730        # Someone might think of using the pre-installed headers on
5731        # Canadian crosses, in case the installed compiler is not fully
5732        # compatible with the compiler being built.  In this case, it
5733        # would be better to flag an error than risking having
5734        # incompatible object files being constructed.  We can't
5735        # guarantee that an error will be flagged, but let's hope the
5736        # compiler will do it, when presented with incompatible header
5737        # files.
5738      fi
5739    fi
5740
5741    case "${target}-${is_cross_compiler}" in
5742    i[3456789]86-*-linux*-no)
5743       # Here host == target, so we don't need to build gcc,
5744       # so we don't want to discard standard headers.
5745       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5746       ;;
5747    *)
5748       # If we're building newlib, use its generic headers last, but search
5749       # for any libc-related directories first (so make it the last -B
5750       # switch).
5751       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5752       ;;
5753    esac
5754    ;;
5755   esac
5756   ;;
5757 esac
5758 case "$target" in
5759 *-mingw*)
5760   # Can't be handled as Cygwin above since Mingw does not use newlib.
5761   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' ;;
5762 esac
5763
5764 # Allow the user to override the flags for
5765 # our build compiler if desired.
5766 CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5767
5768 # On Canadian crosses, we'll be searching the right directories for
5769 # the previously-installed cross compiler, so don't bother to add
5770 # flags for directories within the install tree of the compiler
5771 # being built; programs in there won't even run.
5772 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5773   # Search for pre-installed headers if nothing else fits.
5774   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5775 fi
5776
5777 if test "x${use_gnu_ld}" = x &&
5778    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5779   # Arrange for us to find uninstalled linker scripts.
5780   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5781 fi
5782
5783 # Search for other target-specific linker scripts and such.
5784 case "${target}" in
5785   m32c-*-* )
5786     if test -d ${srcdir}/libgloss/m32c; then
5787       # This is for crt0.o
5788       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5789       # This is for r8c.ld
5790       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5791       # This is for libnosys.a
5792       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5793     fi
5794     ;;
5795   mep*)
5796     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5797     ;;
5798 esac
5799
5800 # Makefile fragments.
5801 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5802 do
5803   eval fragval=\$$frag
5804   if test $fragval != /dev/null; then
5805     eval $frag=${srcdir}/$fragval
5806   fi
5807 done
5808
5809
5810
5811
5812
5813 # Miscellanea: directories, flags, etc.
5814
5815
5816
5817
5818
5819
5820
5821 # Build module lists & subconfigure args.
5822
5823
5824
5825 # Host module lists & subconfigure args.
5826
5827
5828
5829 # Target module lists & subconfigure args.
5830
5831
5832
5833 # Build tools.
5834
5835
5836
5837 # Generate default definitions for YACC, M4, LEX and other programs that run
5838 # on the build machine.  These are used if the Makefile can't locate these
5839 # programs in objdir.
5840 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5841
5842 for ac_prog in 'bison -y' byacc yacc
5843 do
5844   # Extract the first word of "$ac_prog", so it can be a program name with args.
5845 set dummy $ac_prog; ac_word=$2
5846 echo "$as_me:$LINENO: checking for $ac_word" >&5
5847 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5848 if test "${ac_cv_prog_YACC+set}" = set; then
5849   echo $ECHO_N "(cached) $ECHO_C" >&6
5850 else
5851   if test -n "$YACC"; then
5852   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5853 else
5854 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5855 for as_dir in $PATH
5856 do
5857   IFS=$as_save_IFS
5858   test -z "$as_dir" && as_dir=.
5859   for ac_exec_ext in '' $ac_executable_extensions; do
5860   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5861     ac_cv_prog_YACC="$ac_prog"
5862     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5863     break 2
5864   fi
5865 done
5866 done
5867
5868 fi
5869 fi
5870 YACC=$ac_cv_prog_YACC
5871 if test -n "$YACC"; then
5872   echo "$as_me:$LINENO: result: $YACC" >&5
5873 echo "${ECHO_T}$YACC" >&6
5874 else
5875   echo "$as_me:$LINENO: result: no" >&5
5876 echo "${ECHO_T}no" >&6
5877 fi
5878
5879   test -n "$YACC" && break
5880 done
5881 test -n "$YACC" || YACC="$MISSING bison -y"
5882
5883 case " $build_configdirs " in
5884   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
5885   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
5886 esac
5887
5888 for ac_prog in bison
5889 do
5890   # Extract the first word of "$ac_prog", so it can be a program name with args.
5891 set dummy $ac_prog; ac_word=$2
5892 echo "$as_me:$LINENO: checking for $ac_word" >&5
5893 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5894 if test "${ac_cv_prog_BISON+set}" = set; then
5895   echo $ECHO_N "(cached) $ECHO_C" >&6
5896 else
5897   if test -n "$BISON"; then
5898   ac_cv_prog_BISON="$BISON" # Let the user override the test.
5899 else
5900 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5901 for as_dir in $PATH
5902 do
5903   IFS=$as_save_IFS
5904   test -z "$as_dir" && as_dir=.
5905   for ac_exec_ext in '' $ac_executable_extensions; do
5906   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5907     ac_cv_prog_BISON="$ac_prog"
5908     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5909     break 2
5910   fi
5911 done
5912 done
5913
5914 fi
5915 fi
5916 BISON=$ac_cv_prog_BISON
5917 if test -n "$BISON"; then
5918   echo "$as_me:$LINENO: result: $BISON" >&5
5919 echo "${ECHO_T}$BISON" >&6
5920 else
5921   echo "$as_me:$LINENO: result: no" >&5
5922 echo "${ECHO_T}no" >&6
5923 fi
5924
5925   test -n "$BISON" && break
5926 done
5927 test -n "$BISON" || BISON="$MISSING bison"
5928
5929 case " $build_configdirs " in
5930   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
5931 esac
5932
5933 for ac_prog in gm4 gnum4 m4
5934 do
5935   # Extract the first word of "$ac_prog", so it can be a program name with args.
5936 set dummy $ac_prog; ac_word=$2
5937 echo "$as_me:$LINENO: checking for $ac_word" >&5
5938 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5939 if test "${ac_cv_prog_M4+set}" = set; then
5940   echo $ECHO_N "(cached) $ECHO_C" >&6
5941 else
5942   if test -n "$M4"; then
5943   ac_cv_prog_M4="$M4" # Let the user override the test.
5944 else
5945 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5946 for as_dir in $PATH
5947 do
5948   IFS=$as_save_IFS
5949   test -z "$as_dir" && as_dir=.
5950   for ac_exec_ext in '' $ac_executable_extensions; do
5951   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5952     ac_cv_prog_M4="$ac_prog"
5953     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5954     break 2
5955   fi
5956 done
5957 done
5958
5959 fi
5960 fi
5961 M4=$ac_cv_prog_M4
5962 if test -n "$M4"; then
5963   echo "$as_me:$LINENO: result: $M4" >&5
5964 echo "${ECHO_T}$M4" >&6
5965 else
5966   echo "$as_me:$LINENO: result: no" >&5
5967 echo "${ECHO_T}no" >&6
5968 fi
5969
5970   test -n "$M4" && break
5971 done
5972 test -n "$M4" || M4="$MISSING m4"
5973
5974 case " $build_configdirs " in
5975   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
5976 esac
5977
5978 for ac_prog in flex lex
5979 do
5980   # Extract the first word of "$ac_prog", so it can be a program name with args.
5981 set dummy $ac_prog; ac_word=$2
5982 echo "$as_me:$LINENO: checking for $ac_word" >&5
5983 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5984 if test "${ac_cv_prog_LEX+set}" = set; then
5985   echo $ECHO_N "(cached) $ECHO_C" >&6
5986 else
5987   if test -n "$LEX"; then
5988   ac_cv_prog_LEX="$LEX" # Let the user override the test.
5989 else
5990 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5991 for as_dir in $PATH
5992 do
5993   IFS=$as_save_IFS
5994   test -z "$as_dir" && as_dir=.
5995   for ac_exec_ext in '' $ac_executable_extensions; do
5996   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5997     ac_cv_prog_LEX="$ac_prog"
5998     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5999     break 2
6000   fi
6001 done
6002 done
6003
6004 fi
6005 fi
6006 LEX=$ac_cv_prog_LEX
6007 if test -n "$LEX"; then
6008   echo "$as_me:$LINENO: result: $LEX" >&5
6009 echo "${ECHO_T}$LEX" >&6
6010 else
6011   echo "$as_me:$LINENO: result: no" >&5
6012 echo "${ECHO_T}no" >&6
6013 fi
6014
6015   test -n "$LEX" && break
6016 done
6017 test -n "$LEX" || LEX="$MISSING flex"
6018
6019 case " $build_configdirs " in
6020   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6021   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6022 esac
6023
6024 for ac_prog in flex
6025 do
6026   # Extract the first word of "$ac_prog", so it can be a program name with args.
6027 set dummy $ac_prog; ac_word=$2
6028 echo "$as_me:$LINENO: checking for $ac_word" >&5
6029 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6030 if test "${ac_cv_prog_FLEX+set}" = set; then
6031   echo $ECHO_N "(cached) $ECHO_C" >&6
6032 else
6033   if test -n "$FLEX"; then
6034   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6035 else
6036 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6037 for as_dir in $PATH
6038 do
6039   IFS=$as_save_IFS
6040   test -z "$as_dir" && as_dir=.
6041   for ac_exec_ext in '' $ac_executable_extensions; do
6042   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6043     ac_cv_prog_FLEX="$ac_prog"
6044     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6045     break 2
6046   fi
6047 done
6048 done
6049
6050 fi
6051 fi
6052 FLEX=$ac_cv_prog_FLEX
6053 if test -n "$FLEX"; then
6054   echo "$as_me:$LINENO: result: $FLEX" >&5
6055 echo "${ECHO_T}$FLEX" >&6
6056 else
6057   echo "$as_me:$LINENO: result: no" >&5
6058 echo "${ECHO_T}no" >&6
6059 fi
6060
6061   test -n "$FLEX" && break
6062 done
6063 test -n "$FLEX" || FLEX="$MISSING flex"
6064
6065 case " $build_configdirs " in
6066   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6067 esac
6068
6069 for ac_prog in makeinfo
6070 do
6071   # Extract the first word of "$ac_prog", so it can be a program name with args.
6072 set dummy $ac_prog; ac_word=$2
6073 echo "$as_me:$LINENO: checking for $ac_word" >&5
6074 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6075 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6076   echo $ECHO_N "(cached) $ECHO_C" >&6
6077 else
6078   if test -n "$MAKEINFO"; then
6079   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6080 else
6081 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6082 for as_dir in $PATH
6083 do
6084   IFS=$as_save_IFS
6085   test -z "$as_dir" && as_dir=.
6086   for ac_exec_ext in '' $ac_executable_extensions; do
6087   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6088     ac_cv_prog_MAKEINFO="$ac_prog"
6089     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6090     break 2
6091   fi
6092 done
6093 done
6094
6095 fi
6096 fi
6097 MAKEINFO=$ac_cv_prog_MAKEINFO
6098 if test -n "$MAKEINFO"; then
6099   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6100 echo "${ECHO_T}$MAKEINFO" >&6
6101 else
6102   echo "$as_me:$LINENO: result: no" >&5
6103 echo "${ECHO_T}no" >&6
6104 fi
6105
6106   test -n "$MAKEINFO" && break
6107 done
6108 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6109
6110 case " $build_configdirs " in
6111   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6112   *)
6113
6114     # For an installed makeinfo, we require it to be from texinfo 4.4 or
6115     # higher, else we use the "missing" dummy.
6116     if ${MAKEINFO} --version \
6117        | egrep 'texinfo[^0-9]*([1-3][0-9]|4\.[4-9]|[5-9])' >/dev/null 2>&1; then
6118       :
6119     else
6120       MAKEINFO="$MISSING makeinfo"
6121     fi
6122     ;;
6123
6124 esac
6125
6126 # FIXME: expect and dejagnu may become build tools?
6127
6128 for ac_prog in expect
6129 do
6130   # Extract the first word of "$ac_prog", so it can be a program name with args.
6131 set dummy $ac_prog; ac_word=$2
6132 echo "$as_me:$LINENO: checking for $ac_word" >&5
6133 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6134 if test "${ac_cv_prog_EXPECT+set}" = set; then
6135   echo $ECHO_N "(cached) $ECHO_C" >&6
6136 else
6137   if test -n "$EXPECT"; then
6138   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6139 else
6140 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6141 for as_dir in $PATH
6142 do
6143   IFS=$as_save_IFS
6144   test -z "$as_dir" && as_dir=.
6145   for ac_exec_ext in '' $ac_executable_extensions; do
6146   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6147     ac_cv_prog_EXPECT="$ac_prog"
6148     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6149     break 2
6150   fi
6151 done
6152 done
6153
6154 fi
6155 fi
6156 EXPECT=$ac_cv_prog_EXPECT
6157 if test -n "$EXPECT"; then
6158   echo "$as_me:$LINENO: result: $EXPECT" >&5
6159 echo "${ECHO_T}$EXPECT" >&6
6160 else
6161   echo "$as_me:$LINENO: result: no" >&5
6162 echo "${ECHO_T}no" >&6
6163 fi
6164
6165   test -n "$EXPECT" && break
6166 done
6167 test -n "$EXPECT" || EXPECT="expect"
6168
6169 case " $configdirs " in
6170   *" expect "*)
6171     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6172     ;;
6173 esac
6174
6175 for ac_prog in runtest
6176 do
6177   # Extract the first word of "$ac_prog", so it can be a program name with args.
6178 set dummy $ac_prog; ac_word=$2
6179 echo "$as_me:$LINENO: checking for $ac_word" >&5
6180 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6181 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6182   echo $ECHO_N "(cached) $ECHO_C" >&6
6183 else
6184   if test -n "$RUNTEST"; then
6185   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6186 else
6187 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6188 for as_dir in $PATH
6189 do
6190   IFS=$as_save_IFS
6191   test -z "$as_dir" && as_dir=.
6192   for ac_exec_ext in '' $ac_executable_extensions; do
6193   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6194     ac_cv_prog_RUNTEST="$ac_prog"
6195     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6196     break 2
6197   fi
6198 done
6199 done
6200
6201 fi
6202 fi
6203 RUNTEST=$ac_cv_prog_RUNTEST
6204 if test -n "$RUNTEST"; then
6205   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6206 echo "${ECHO_T}$RUNTEST" >&6
6207 else
6208   echo "$as_me:$LINENO: result: no" >&5
6209 echo "${ECHO_T}no" >&6
6210 fi
6211
6212   test -n "$RUNTEST" && break
6213 done
6214 test -n "$RUNTEST" || RUNTEST="runtest"
6215
6216 case " $configdirs " in
6217   *" dejagnu "*)
6218     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6219     ;;
6220 esac
6221
6222
6223 # Host tools.
6224 ncn_tool_prefix=
6225 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6226 ncn_target_tool_prefix=
6227 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6228
6229
6230
6231 if test -n "$AR"; then
6232   ac_cv_prog_AR=$AR
6233 elif test -n "$ac_cv_prog_AR"; then
6234   AR=$ac_cv_prog_AR
6235 fi
6236
6237 if test -n "$ac_cv_prog_AR"; then
6238   for ncn_progname in ar; do
6239     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6240 set dummy ${ncn_progname}; ac_word=$2
6241 echo "$as_me:$LINENO: checking for $ac_word" >&5
6242 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6243 if test "${ac_cv_prog_AR+set}" = set; then
6244   echo $ECHO_N "(cached) $ECHO_C" >&6
6245 else
6246   if test -n "$AR"; then
6247   ac_cv_prog_AR="$AR" # Let the user override the test.
6248 else
6249 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6250 for as_dir in $PATH
6251 do
6252   IFS=$as_save_IFS
6253   test -z "$as_dir" && as_dir=.
6254   for ac_exec_ext in '' $ac_executable_extensions; do
6255   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6256     ac_cv_prog_AR="${ncn_progname}"
6257     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6258     break 2
6259   fi
6260 done
6261 done
6262
6263 fi
6264 fi
6265 AR=$ac_cv_prog_AR
6266 if test -n "$AR"; then
6267   echo "$as_me:$LINENO: result: $AR" >&5
6268 echo "${ECHO_T}$AR" >&6
6269 else
6270   echo "$as_me:$LINENO: result: no" >&5
6271 echo "${ECHO_T}no" >&6
6272 fi
6273
6274   done
6275 fi
6276
6277 for ncn_progname in ar; do
6278   if test -n "$ncn_tool_prefix"; then
6279     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6280 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6281 echo "$as_me:$LINENO: checking for $ac_word" >&5
6282 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6283 if test "${ac_cv_prog_AR+set}" = set; then
6284   echo $ECHO_N "(cached) $ECHO_C" >&6
6285 else
6286   if test -n "$AR"; then
6287   ac_cv_prog_AR="$AR" # Let the user override the test.
6288 else
6289 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6290 for as_dir in $PATH
6291 do
6292   IFS=$as_save_IFS
6293   test -z "$as_dir" && as_dir=.
6294   for ac_exec_ext in '' $ac_executable_extensions; do
6295   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6296     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6297     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6298     break 2
6299   fi
6300 done
6301 done
6302
6303 fi
6304 fi
6305 AR=$ac_cv_prog_AR
6306 if test -n "$AR"; then
6307   echo "$as_me:$LINENO: result: $AR" >&5
6308 echo "${ECHO_T}$AR" >&6
6309 else
6310   echo "$as_me:$LINENO: result: no" >&5
6311 echo "${ECHO_T}no" >&6
6312 fi
6313
6314   fi
6315   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6316     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6317 set dummy ${ncn_progname}; ac_word=$2
6318 echo "$as_me:$LINENO: checking for $ac_word" >&5
6319 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6320 if test "${ac_cv_prog_AR+set}" = set; then
6321   echo $ECHO_N "(cached) $ECHO_C" >&6
6322 else
6323   if test -n "$AR"; then
6324   ac_cv_prog_AR="$AR" # Let the user override the test.
6325 else
6326 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6327 for as_dir in $PATH
6328 do
6329   IFS=$as_save_IFS
6330   test -z "$as_dir" && as_dir=.
6331   for ac_exec_ext in '' $ac_executable_extensions; do
6332   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6333     ac_cv_prog_AR="${ncn_progname}"
6334     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6335     break 2
6336   fi
6337 done
6338 done
6339
6340 fi
6341 fi
6342 AR=$ac_cv_prog_AR
6343 if test -n "$AR"; then
6344   echo "$as_me:$LINENO: result: $AR" >&5
6345 echo "${ECHO_T}$AR" >&6
6346 else
6347   echo "$as_me:$LINENO: result: no" >&5
6348 echo "${ECHO_T}no" >&6
6349 fi
6350
6351   fi
6352   test -n "$ac_cv_prog_AR" && break
6353 done
6354
6355 if test -z "$ac_cv_prog_AR" ; then
6356   set dummy ar
6357   if test $build = $host ; then
6358     AR="$2"
6359   else
6360     AR="${ncn_tool_prefix}$2"
6361   fi
6362 fi
6363
6364
6365
6366 if test -n "$AS"; then
6367   ac_cv_prog_AS=$AS
6368 elif test -n "$ac_cv_prog_AS"; then
6369   AS=$ac_cv_prog_AS
6370 fi
6371
6372 if test -n "$ac_cv_prog_AS"; then
6373   for ncn_progname in as; do
6374     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6375 set dummy ${ncn_progname}; ac_word=$2
6376 echo "$as_me:$LINENO: checking for $ac_word" >&5
6377 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6378 if test "${ac_cv_prog_AS+set}" = set; then
6379   echo $ECHO_N "(cached) $ECHO_C" >&6
6380 else
6381   if test -n "$AS"; then
6382   ac_cv_prog_AS="$AS" # Let the user override the test.
6383 else
6384 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6385 for as_dir in $PATH
6386 do
6387   IFS=$as_save_IFS
6388   test -z "$as_dir" && as_dir=.
6389   for ac_exec_ext in '' $ac_executable_extensions; do
6390   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6391     ac_cv_prog_AS="${ncn_progname}"
6392     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6393     break 2
6394   fi
6395 done
6396 done
6397
6398 fi
6399 fi
6400 AS=$ac_cv_prog_AS
6401 if test -n "$AS"; then
6402   echo "$as_me:$LINENO: result: $AS" >&5
6403 echo "${ECHO_T}$AS" >&6
6404 else
6405   echo "$as_me:$LINENO: result: no" >&5
6406 echo "${ECHO_T}no" >&6
6407 fi
6408
6409   done
6410 fi
6411
6412 for ncn_progname in as; do
6413   if test -n "$ncn_tool_prefix"; then
6414     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6415 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6416 echo "$as_me:$LINENO: checking for $ac_word" >&5
6417 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6418 if test "${ac_cv_prog_AS+set}" = set; then
6419   echo $ECHO_N "(cached) $ECHO_C" >&6
6420 else
6421   if test -n "$AS"; then
6422   ac_cv_prog_AS="$AS" # Let the user override the test.
6423 else
6424 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6425 for as_dir in $PATH
6426 do
6427   IFS=$as_save_IFS
6428   test -z "$as_dir" && as_dir=.
6429   for ac_exec_ext in '' $ac_executable_extensions; do
6430   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6431     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6432     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6433     break 2
6434   fi
6435 done
6436 done
6437
6438 fi
6439 fi
6440 AS=$ac_cv_prog_AS
6441 if test -n "$AS"; then
6442   echo "$as_me:$LINENO: result: $AS" >&5
6443 echo "${ECHO_T}$AS" >&6
6444 else
6445   echo "$as_me:$LINENO: result: no" >&5
6446 echo "${ECHO_T}no" >&6
6447 fi
6448
6449   fi
6450   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6451     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6452 set dummy ${ncn_progname}; ac_word=$2
6453 echo "$as_me:$LINENO: checking for $ac_word" >&5
6454 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6455 if test "${ac_cv_prog_AS+set}" = set; then
6456   echo $ECHO_N "(cached) $ECHO_C" >&6
6457 else
6458   if test -n "$AS"; then
6459   ac_cv_prog_AS="$AS" # Let the user override the test.
6460 else
6461 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6462 for as_dir in $PATH
6463 do
6464   IFS=$as_save_IFS
6465   test -z "$as_dir" && as_dir=.
6466   for ac_exec_ext in '' $ac_executable_extensions; do
6467   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6468     ac_cv_prog_AS="${ncn_progname}"
6469     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6470     break 2
6471   fi
6472 done
6473 done
6474
6475 fi
6476 fi
6477 AS=$ac_cv_prog_AS
6478 if test -n "$AS"; then
6479   echo "$as_me:$LINENO: result: $AS" >&5
6480 echo "${ECHO_T}$AS" >&6
6481 else
6482   echo "$as_me:$LINENO: result: no" >&5
6483 echo "${ECHO_T}no" >&6
6484 fi
6485
6486   fi
6487   test -n "$ac_cv_prog_AS" && break
6488 done
6489
6490 if test -z "$ac_cv_prog_AS" ; then
6491   set dummy as
6492   if test $build = $host ; then
6493     AS="$2"
6494   else
6495     AS="${ncn_tool_prefix}$2"
6496   fi
6497 fi
6498
6499
6500
6501 if test -n "$DLLTOOL"; then
6502   ac_cv_prog_DLLTOOL=$DLLTOOL
6503 elif test -n "$ac_cv_prog_DLLTOOL"; then
6504   DLLTOOL=$ac_cv_prog_DLLTOOL
6505 fi
6506
6507 if test -n "$ac_cv_prog_DLLTOOL"; then
6508   for ncn_progname in dlltool; do
6509     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6510 set dummy ${ncn_progname}; ac_word=$2
6511 echo "$as_me:$LINENO: checking for $ac_word" >&5
6512 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6513 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6514   echo $ECHO_N "(cached) $ECHO_C" >&6
6515 else
6516   if test -n "$DLLTOOL"; then
6517   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6518 else
6519 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6520 for as_dir in $PATH
6521 do
6522   IFS=$as_save_IFS
6523   test -z "$as_dir" && as_dir=.
6524   for ac_exec_ext in '' $ac_executable_extensions; do
6525   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6526     ac_cv_prog_DLLTOOL="${ncn_progname}"
6527     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6528     break 2
6529   fi
6530 done
6531 done
6532
6533 fi
6534 fi
6535 DLLTOOL=$ac_cv_prog_DLLTOOL
6536 if test -n "$DLLTOOL"; then
6537   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6538 echo "${ECHO_T}$DLLTOOL" >&6
6539 else
6540   echo "$as_me:$LINENO: result: no" >&5
6541 echo "${ECHO_T}no" >&6
6542 fi
6543
6544   done
6545 fi
6546
6547 for ncn_progname in dlltool; do
6548   if test -n "$ncn_tool_prefix"; then
6549     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6550 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6551 echo "$as_me:$LINENO: checking for $ac_word" >&5
6552 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6553 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6554   echo $ECHO_N "(cached) $ECHO_C" >&6
6555 else
6556   if test -n "$DLLTOOL"; then
6557   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6558 else
6559 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6560 for as_dir in $PATH
6561 do
6562   IFS=$as_save_IFS
6563   test -z "$as_dir" && as_dir=.
6564   for ac_exec_ext in '' $ac_executable_extensions; do
6565   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6566     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6567     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6568     break 2
6569   fi
6570 done
6571 done
6572
6573 fi
6574 fi
6575 DLLTOOL=$ac_cv_prog_DLLTOOL
6576 if test -n "$DLLTOOL"; then
6577   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6578 echo "${ECHO_T}$DLLTOOL" >&6
6579 else
6580   echo "$as_me:$LINENO: result: no" >&5
6581 echo "${ECHO_T}no" >&6
6582 fi
6583
6584   fi
6585   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6586     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6587 set dummy ${ncn_progname}; ac_word=$2
6588 echo "$as_me:$LINENO: checking for $ac_word" >&5
6589 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6590 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6591   echo $ECHO_N "(cached) $ECHO_C" >&6
6592 else
6593   if test -n "$DLLTOOL"; then
6594   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6595 else
6596 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6597 for as_dir in $PATH
6598 do
6599   IFS=$as_save_IFS
6600   test -z "$as_dir" && as_dir=.
6601   for ac_exec_ext in '' $ac_executable_extensions; do
6602   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6603     ac_cv_prog_DLLTOOL="${ncn_progname}"
6604     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6605     break 2
6606   fi
6607 done
6608 done
6609
6610 fi
6611 fi
6612 DLLTOOL=$ac_cv_prog_DLLTOOL
6613 if test -n "$DLLTOOL"; then
6614   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6615 echo "${ECHO_T}$DLLTOOL" >&6
6616 else
6617   echo "$as_me:$LINENO: result: no" >&5
6618 echo "${ECHO_T}no" >&6
6619 fi
6620
6621   fi
6622   test -n "$ac_cv_prog_DLLTOOL" && break
6623 done
6624
6625 if test -z "$ac_cv_prog_DLLTOOL" ; then
6626   set dummy dlltool
6627   if test $build = $host ; then
6628     DLLTOOL="$2"
6629   else
6630     DLLTOOL="${ncn_tool_prefix}$2"
6631   fi
6632 fi
6633
6634
6635
6636 if test -n "$LD"; then
6637   ac_cv_prog_LD=$LD
6638 elif test -n "$ac_cv_prog_LD"; then
6639   LD=$ac_cv_prog_LD
6640 fi
6641
6642 if test -n "$ac_cv_prog_LD"; then
6643   for ncn_progname in ld; do
6644     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6645 set dummy ${ncn_progname}; ac_word=$2
6646 echo "$as_me:$LINENO: checking for $ac_word" >&5
6647 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6648 if test "${ac_cv_prog_LD+set}" = set; then
6649   echo $ECHO_N "(cached) $ECHO_C" >&6
6650 else
6651   if test -n "$LD"; then
6652   ac_cv_prog_LD="$LD" # Let the user override the test.
6653 else
6654 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6655 for as_dir in $PATH
6656 do
6657   IFS=$as_save_IFS
6658   test -z "$as_dir" && as_dir=.
6659   for ac_exec_ext in '' $ac_executable_extensions; do
6660   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6661     ac_cv_prog_LD="${ncn_progname}"
6662     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6663     break 2
6664   fi
6665 done
6666 done
6667
6668 fi
6669 fi
6670 LD=$ac_cv_prog_LD
6671 if test -n "$LD"; then
6672   echo "$as_me:$LINENO: result: $LD" >&5
6673 echo "${ECHO_T}$LD" >&6
6674 else
6675   echo "$as_me:$LINENO: result: no" >&5
6676 echo "${ECHO_T}no" >&6
6677 fi
6678
6679   done
6680 fi
6681
6682 for ncn_progname in ld; do
6683   if test -n "$ncn_tool_prefix"; then
6684     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6685 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6686 echo "$as_me:$LINENO: checking for $ac_word" >&5
6687 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6688 if test "${ac_cv_prog_LD+set}" = set; then
6689   echo $ECHO_N "(cached) $ECHO_C" >&6
6690 else
6691   if test -n "$LD"; then
6692   ac_cv_prog_LD="$LD" # Let the user override the test.
6693 else
6694 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6695 for as_dir in $PATH
6696 do
6697   IFS=$as_save_IFS
6698   test -z "$as_dir" && as_dir=.
6699   for ac_exec_ext in '' $ac_executable_extensions; do
6700   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6701     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6702     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6703     break 2
6704   fi
6705 done
6706 done
6707
6708 fi
6709 fi
6710 LD=$ac_cv_prog_LD
6711 if test -n "$LD"; then
6712   echo "$as_me:$LINENO: result: $LD" >&5
6713 echo "${ECHO_T}$LD" >&6
6714 else
6715   echo "$as_me:$LINENO: result: no" >&5
6716 echo "${ECHO_T}no" >&6
6717 fi
6718
6719   fi
6720   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6721     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6722 set dummy ${ncn_progname}; ac_word=$2
6723 echo "$as_me:$LINENO: checking for $ac_word" >&5
6724 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6725 if test "${ac_cv_prog_LD+set}" = set; then
6726   echo $ECHO_N "(cached) $ECHO_C" >&6
6727 else
6728   if test -n "$LD"; then
6729   ac_cv_prog_LD="$LD" # Let the user override the test.
6730 else
6731 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6732 for as_dir in $PATH
6733 do
6734   IFS=$as_save_IFS
6735   test -z "$as_dir" && as_dir=.
6736   for ac_exec_ext in '' $ac_executable_extensions; do
6737   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6738     ac_cv_prog_LD="${ncn_progname}"
6739     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6740     break 2
6741   fi
6742 done
6743 done
6744
6745 fi
6746 fi
6747 LD=$ac_cv_prog_LD
6748 if test -n "$LD"; then
6749   echo "$as_me:$LINENO: result: $LD" >&5
6750 echo "${ECHO_T}$LD" >&6
6751 else
6752   echo "$as_me:$LINENO: result: no" >&5
6753 echo "${ECHO_T}no" >&6
6754 fi
6755
6756   fi
6757   test -n "$ac_cv_prog_LD" && break
6758 done
6759
6760 if test -z "$ac_cv_prog_LD" ; then
6761   set dummy ld
6762   if test $build = $host ; then
6763     LD="$2"
6764   else
6765     LD="${ncn_tool_prefix}$2"
6766   fi
6767 fi
6768
6769
6770
6771 if test -n "$LIPO"; then
6772   ac_cv_prog_LIPO=$LIPO
6773 elif test -n "$ac_cv_prog_LIPO"; then
6774   LIPO=$ac_cv_prog_LIPO
6775 fi
6776
6777 if test -n "$ac_cv_prog_LIPO"; then
6778   for ncn_progname in lipo; do
6779     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6780 set dummy ${ncn_progname}; ac_word=$2
6781 echo "$as_me:$LINENO: checking for $ac_word" >&5
6782 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6783 if test "${ac_cv_prog_LIPO+set}" = set; then
6784   echo $ECHO_N "(cached) $ECHO_C" >&6
6785 else
6786   if test -n "$LIPO"; then
6787   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6788 else
6789 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6790 for as_dir in $PATH
6791 do
6792   IFS=$as_save_IFS
6793   test -z "$as_dir" && as_dir=.
6794   for ac_exec_ext in '' $ac_executable_extensions; do
6795   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6796     ac_cv_prog_LIPO="${ncn_progname}"
6797     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6798     break 2
6799   fi
6800 done
6801 done
6802
6803 fi
6804 fi
6805 LIPO=$ac_cv_prog_LIPO
6806 if test -n "$LIPO"; then
6807   echo "$as_me:$LINENO: result: $LIPO" >&5
6808 echo "${ECHO_T}$LIPO" >&6
6809 else
6810   echo "$as_me:$LINENO: result: no" >&5
6811 echo "${ECHO_T}no" >&6
6812 fi
6813
6814   done
6815 fi
6816
6817 for ncn_progname in lipo; do
6818   if test -n "$ncn_tool_prefix"; then
6819     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6820 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6821 echo "$as_me:$LINENO: checking for $ac_word" >&5
6822 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6823 if test "${ac_cv_prog_LIPO+set}" = set; then
6824   echo $ECHO_N "(cached) $ECHO_C" >&6
6825 else
6826   if test -n "$LIPO"; then
6827   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6828 else
6829 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6830 for as_dir in $PATH
6831 do
6832   IFS=$as_save_IFS
6833   test -z "$as_dir" && as_dir=.
6834   for ac_exec_ext in '' $ac_executable_extensions; do
6835   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6836     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6837     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6838     break 2
6839   fi
6840 done
6841 done
6842
6843 fi
6844 fi
6845 LIPO=$ac_cv_prog_LIPO
6846 if test -n "$LIPO"; then
6847   echo "$as_me:$LINENO: result: $LIPO" >&5
6848 echo "${ECHO_T}$LIPO" >&6
6849 else
6850   echo "$as_me:$LINENO: result: no" >&5
6851 echo "${ECHO_T}no" >&6
6852 fi
6853
6854   fi
6855   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6856     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6857 set dummy ${ncn_progname}; ac_word=$2
6858 echo "$as_me:$LINENO: checking for $ac_word" >&5
6859 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6860 if test "${ac_cv_prog_LIPO+set}" = set; then
6861   echo $ECHO_N "(cached) $ECHO_C" >&6
6862 else
6863   if test -n "$LIPO"; then
6864   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6865 else
6866 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6867 for as_dir in $PATH
6868 do
6869   IFS=$as_save_IFS
6870   test -z "$as_dir" && as_dir=.
6871   for ac_exec_ext in '' $ac_executable_extensions; do
6872   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6873     ac_cv_prog_LIPO="${ncn_progname}"
6874     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6875     break 2
6876   fi
6877 done
6878 done
6879
6880 fi
6881 fi
6882 LIPO=$ac_cv_prog_LIPO
6883 if test -n "$LIPO"; then
6884   echo "$as_me:$LINENO: result: $LIPO" >&5
6885 echo "${ECHO_T}$LIPO" >&6
6886 else
6887   echo "$as_me:$LINENO: result: no" >&5
6888 echo "${ECHO_T}no" >&6
6889 fi
6890
6891   fi
6892   test -n "$ac_cv_prog_LIPO" && break
6893 done
6894
6895 if test -z "$ac_cv_prog_LIPO" ; then
6896   set dummy lipo
6897   if test $build = $host ; then
6898     LIPO="$2"
6899   else
6900     LIPO="${ncn_tool_prefix}$2"
6901   fi
6902 fi
6903
6904
6905
6906 if test -n "$NM"; then
6907   ac_cv_prog_NM=$NM
6908 elif test -n "$ac_cv_prog_NM"; then
6909   NM=$ac_cv_prog_NM
6910 fi
6911
6912 if test -n "$ac_cv_prog_NM"; then
6913   for ncn_progname in nm; do
6914     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6915 set dummy ${ncn_progname}; ac_word=$2
6916 echo "$as_me:$LINENO: checking for $ac_word" >&5
6917 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6918 if test "${ac_cv_prog_NM+set}" = set; then
6919   echo $ECHO_N "(cached) $ECHO_C" >&6
6920 else
6921   if test -n "$NM"; then
6922   ac_cv_prog_NM="$NM" # Let the user override the test.
6923 else
6924 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6925 for as_dir in $PATH
6926 do
6927   IFS=$as_save_IFS
6928   test -z "$as_dir" && as_dir=.
6929   for ac_exec_ext in '' $ac_executable_extensions; do
6930   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6931     ac_cv_prog_NM="${ncn_progname}"
6932     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6933     break 2
6934   fi
6935 done
6936 done
6937
6938 fi
6939 fi
6940 NM=$ac_cv_prog_NM
6941 if test -n "$NM"; then
6942   echo "$as_me:$LINENO: result: $NM" >&5
6943 echo "${ECHO_T}$NM" >&6
6944 else
6945   echo "$as_me:$LINENO: result: no" >&5
6946 echo "${ECHO_T}no" >&6
6947 fi
6948
6949   done
6950 fi
6951
6952 for ncn_progname in nm; do
6953   if test -n "$ncn_tool_prefix"; then
6954     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6955 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6956 echo "$as_me:$LINENO: checking for $ac_word" >&5
6957 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6958 if test "${ac_cv_prog_NM+set}" = set; then
6959   echo $ECHO_N "(cached) $ECHO_C" >&6
6960 else
6961   if test -n "$NM"; then
6962   ac_cv_prog_NM="$NM" # Let the user override the test.
6963 else
6964 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6965 for as_dir in $PATH
6966 do
6967   IFS=$as_save_IFS
6968   test -z "$as_dir" && as_dir=.
6969   for ac_exec_ext in '' $ac_executable_extensions; do
6970   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6971     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
6972     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6973     break 2
6974   fi
6975 done
6976 done
6977
6978 fi
6979 fi
6980 NM=$ac_cv_prog_NM
6981 if test -n "$NM"; then
6982   echo "$as_me:$LINENO: result: $NM" >&5
6983 echo "${ECHO_T}$NM" >&6
6984 else
6985   echo "$as_me:$LINENO: result: no" >&5
6986 echo "${ECHO_T}no" >&6
6987 fi
6988
6989   fi
6990   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
6991     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6992 set dummy ${ncn_progname}; ac_word=$2
6993 echo "$as_me:$LINENO: checking for $ac_word" >&5
6994 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6995 if test "${ac_cv_prog_NM+set}" = set; then
6996   echo $ECHO_N "(cached) $ECHO_C" >&6
6997 else
6998   if test -n "$NM"; then
6999   ac_cv_prog_NM="$NM" # Let the user override the test.
7000 else
7001 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7002 for as_dir in $PATH
7003 do
7004   IFS=$as_save_IFS
7005   test -z "$as_dir" && as_dir=.
7006   for ac_exec_ext in '' $ac_executable_extensions; do
7007   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7008     ac_cv_prog_NM="${ncn_progname}"
7009     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7010     break 2
7011   fi
7012 done
7013 done
7014
7015 fi
7016 fi
7017 NM=$ac_cv_prog_NM
7018 if test -n "$NM"; then
7019   echo "$as_me:$LINENO: result: $NM" >&5
7020 echo "${ECHO_T}$NM" >&6
7021 else
7022   echo "$as_me:$LINENO: result: no" >&5
7023 echo "${ECHO_T}no" >&6
7024 fi
7025
7026   fi
7027   test -n "$ac_cv_prog_NM" && break
7028 done
7029
7030 if test -z "$ac_cv_prog_NM" ; then
7031   set dummy nm
7032   if test $build = $host ; then
7033     NM="$2"
7034   else
7035     NM="${ncn_tool_prefix}$2"
7036   fi
7037 fi
7038
7039
7040
7041 if test -n "$RANLIB"; then
7042   ac_cv_prog_RANLIB=$RANLIB
7043 elif test -n "$ac_cv_prog_RANLIB"; then
7044   RANLIB=$ac_cv_prog_RANLIB
7045 fi
7046
7047 if test -n "$ac_cv_prog_RANLIB"; then
7048   for ncn_progname in ranlib; do
7049     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7050 set dummy ${ncn_progname}; ac_word=$2
7051 echo "$as_me:$LINENO: checking for $ac_word" >&5
7052 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7053 if test "${ac_cv_prog_RANLIB+set}" = set; then
7054   echo $ECHO_N "(cached) $ECHO_C" >&6
7055 else
7056   if test -n "$RANLIB"; then
7057   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7058 else
7059 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7060 for as_dir in $PATH
7061 do
7062   IFS=$as_save_IFS
7063   test -z "$as_dir" && as_dir=.
7064   for ac_exec_ext in '' $ac_executable_extensions; do
7065   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7066     ac_cv_prog_RANLIB="${ncn_progname}"
7067     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7068     break 2
7069   fi
7070 done
7071 done
7072
7073 fi
7074 fi
7075 RANLIB=$ac_cv_prog_RANLIB
7076 if test -n "$RANLIB"; then
7077   echo "$as_me:$LINENO: result: $RANLIB" >&5
7078 echo "${ECHO_T}$RANLIB" >&6
7079 else
7080   echo "$as_me:$LINENO: result: no" >&5
7081 echo "${ECHO_T}no" >&6
7082 fi
7083
7084   done
7085 fi
7086
7087 for ncn_progname in ranlib; do
7088   if test -n "$ncn_tool_prefix"; then
7089     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7090 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7091 echo "$as_me:$LINENO: checking for $ac_word" >&5
7092 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7093 if test "${ac_cv_prog_RANLIB+set}" = set; then
7094   echo $ECHO_N "(cached) $ECHO_C" >&6
7095 else
7096   if test -n "$RANLIB"; then
7097   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7098 else
7099 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7100 for as_dir in $PATH
7101 do
7102   IFS=$as_save_IFS
7103   test -z "$as_dir" && as_dir=.
7104   for ac_exec_ext in '' $ac_executable_extensions; do
7105   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7106     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7107     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7108     break 2
7109   fi
7110 done
7111 done
7112
7113 fi
7114 fi
7115 RANLIB=$ac_cv_prog_RANLIB
7116 if test -n "$RANLIB"; then
7117   echo "$as_me:$LINENO: result: $RANLIB" >&5
7118 echo "${ECHO_T}$RANLIB" >&6
7119 else
7120   echo "$as_me:$LINENO: result: no" >&5
7121 echo "${ECHO_T}no" >&6
7122 fi
7123
7124   fi
7125   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7126     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7127 set dummy ${ncn_progname}; ac_word=$2
7128 echo "$as_me:$LINENO: checking for $ac_word" >&5
7129 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7130 if test "${ac_cv_prog_RANLIB+set}" = set; then
7131   echo $ECHO_N "(cached) $ECHO_C" >&6
7132 else
7133   if test -n "$RANLIB"; then
7134   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7135 else
7136 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7137 for as_dir in $PATH
7138 do
7139   IFS=$as_save_IFS
7140   test -z "$as_dir" && as_dir=.
7141   for ac_exec_ext in '' $ac_executable_extensions; do
7142   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7143     ac_cv_prog_RANLIB="${ncn_progname}"
7144     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7145     break 2
7146   fi
7147 done
7148 done
7149
7150 fi
7151 fi
7152 RANLIB=$ac_cv_prog_RANLIB
7153 if test -n "$RANLIB"; then
7154   echo "$as_me:$LINENO: result: $RANLIB" >&5
7155 echo "${ECHO_T}$RANLIB" >&6
7156 else
7157   echo "$as_me:$LINENO: result: no" >&5
7158 echo "${ECHO_T}no" >&6
7159 fi
7160
7161   fi
7162   test -n "$ac_cv_prog_RANLIB" && break
7163 done
7164
7165 if test -z "$ac_cv_prog_RANLIB" ; then
7166   RANLIB=":"
7167 fi
7168
7169
7170
7171 if test -n "$STRIP"; then
7172   ac_cv_prog_STRIP=$STRIP
7173 elif test -n "$ac_cv_prog_STRIP"; then
7174   STRIP=$ac_cv_prog_STRIP
7175 fi
7176
7177 if test -n "$ac_cv_prog_STRIP"; then
7178   for ncn_progname in strip; do
7179     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7180 set dummy ${ncn_progname}; ac_word=$2
7181 echo "$as_me:$LINENO: checking for $ac_word" >&5
7182 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7183 if test "${ac_cv_prog_STRIP+set}" = set; then
7184   echo $ECHO_N "(cached) $ECHO_C" >&6
7185 else
7186   if test -n "$STRIP"; then
7187   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7188 else
7189 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7190 for as_dir in $PATH
7191 do
7192   IFS=$as_save_IFS
7193   test -z "$as_dir" && as_dir=.
7194   for ac_exec_ext in '' $ac_executable_extensions; do
7195   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7196     ac_cv_prog_STRIP="${ncn_progname}"
7197     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7198     break 2
7199   fi
7200 done
7201 done
7202
7203 fi
7204 fi
7205 STRIP=$ac_cv_prog_STRIP
7206 if test -n "$STRIP"; then
7207   echo "$as_me:$LINENO: result: $STRIP" >&5
7208 echo "${ECHO_T}$STRIP" >&6
7209 else
7210   echo "$as_me:$LINENO: result: no" >&5
7211 echo "${ECHO_T}no" >&6
7212 fi
7213
7214   done
7215 fi
7216
7217 for ncn_progname in strip; do
7218   if test -n "$ncn_tool_prefix"; then
7219     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7220 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7221 echo "$as_me:$LINENO: checking for $ac_word" >&5
7222 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7223 if test "${ac_cv_prog_STRIP+set}" = set; then
7224   echo $ECHO_N "(cached) $ECHO_C" >&6
7225 else
7226   if test -n "$STRIP"; then
7227   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7228 else
7229 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7230 for as_dir in $PATH
7231 do
7232   IFS=$as_save_IFS
7233   test -z "$as_dir" && as_dir=.
7234   for ac_exec_ext in '' $ac_executable_extensions; do
7235   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7236     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7237     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7238     break 2
7239   fi
7240 done
7241 done
7242
7243 fi
7244 fi
7245 STRIP=$ac_cv_prog_STRIP
7246 if test -n "$STRIP"; then
7247   echo "$as_me:$LINENO: result: $STRIP" >&5
7248 echo "${ECHO_T}$STRIP" >&6
7249 else
7250   echo "$as_me:$LINENO: result: no" >&5
7251 echo "${ECHO_T}no" >&6
7252 fi
7253
7254   fi
7255   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7256     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7257 set dummy ${ncn_progname}; ac_word=$2
7258 echo "$as_me:$LINENO: checking for $ac_word" >&5
7259 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7260 if test "${ac_cv_prog_STRIP+set}" = set; then
7261   echo $ECHO_N "(cached) $ECHO_C" >&6
7262 else
7263   if test -n "$STRIP"; then
7264   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7265 else
7266 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7267 for as_dir in $PATH
7268 do
7269   IFS=$as_save_IFS
7270   test -z "$as_dir" && as_dir=.
7271   for ac_exec_ext in '' $ac_executable_extensions; do
7272   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7273     ac_cv_prog_STRIP="${ncn_progname}"
7274     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7275     break 2
7276   fi
7277 done
7278 done
7279
7280 fi
7281 fi
7282 STRIP=$ac_cv_prog_STRIP
7283 if test -n "$STRIP"; then
7284   echo "$as_me:$LINENO: result: $STRIP" >&5
7285 echo "${ECHO_T}$STRIP" >&6
7286 else
7287   echo "$as_me:$LINENO: result: no" >&5
7288 echo "${ECHO_T}no" >&6
7289 fi
7290
7291   fi
7292   test -n "$ac_cv_prog_STRIP" && break
7293 done
7294
7295 if test -z "$ac_cv_prog_STRIP" ; then
7296   STRIP=":"
7297 fi
7298
7299
7300
7301 if test -n "$WINDRES"; then
7302   ac_cv_prog_WINDRES=$WINDRES
7303 elif test -n "$ac_cv_prog_WINDRES"; then
7304   WINDRES=$ac_cv_prog_WINDRES
7305 fi
7306
7307 if test -n "$ac_cv_prog_WINDRES"; then
7308   for ncn_progname in windres; do
7309     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7310 set dummy ${ncn_progname}; ac_word=$2
7311 echo "$as_me:$LINENO: checking for $ac_word" >&5
7312 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7313 if test "${ac_cv_prog_WINDRES+set}" = set; then
7314   echo $ECHO_N "(cached) $ECHO_C" >&6
7315 else
7316   if test -n "$WINDRES"; then
7317   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7318 else
7319 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7320 for as_dir in $PATH
7321 do
7322   IFS=$as_save_IFS
7323   test -z "$as_dir" && as_dir=.
7324   for ac_exec_ext in '' $ac_executable_extensions; do
7325   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7326     ac_cv_prog_WINDRES="${ncn_progname}"
7327     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7328     break 2
7329   fi
7330 done
7331 done
7332
7333 fi
7334 fi
7335 WINDRES=$ac_cv_prog_WINDRES
7336 if test -n "$WINDRES"; then
7337   echo "$as_me:$LINENO: result: $WINDRES" >&5
7338 echo "${ECHO_T}$WINDRES" >&6
7339 else
7340   echo "$as_me:$LINENO: result: no" >&5
7341 echo "${ECHO_T}no" >&6
7342 fi
7343
7344   done
7345 fi
7346
7347 for ncn_progname in windres; do
7348   if test -n "$ncn_tool_prefix"; then
7349     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7350 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7351 echo "$as_me:$LINENO: checking for $ac_word" >&5
7352 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7353 if test "${ac_cv_prog_WINDRES+set}" = set; then
7354   echo $ECHO_N "(cached) $ECHO_C" >&6
7355 else
7356   if test -n "$WINDRES"; then
7357   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7358 else
7359 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7360 for as_dir in $PATH
7361 do
7362   IFS=$as_save_IFS
7363   test -z "$as_dir" && as_dir=.
7364   for ac_exec_ext in '' $ac_executable_extensions; do
7365   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7366     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7367     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7368     break 2
7369   fi
7370 done
7371 done
7372
7373 fi
7374 fi
7375 WINDRES=$ac_cv_prog_WINDRES
7376 if test -n "$WINDRES"; then
7377   echo "$as_me:$LINENO: result: $WINDRES" >&5
7378 echo "${ECHO_T}$WINDRES" >&6
7379 else
7380   echo "$as_me:$LINENO: result: no" >&5
7381 echo "${ECHO_T}no" >&6
7382 fi
7383
7384   fi
7385   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7386     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7387 set dummy ${ncn_progname}; ac_word=$2
7388 echo "$as_me:$LINENO: checking for $ac_word" >&5
7389 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7390 if test "${ac_cv_prog_WINDRES+set}" = set; then
7391   echo $ECHO_N "(cached) $ECHO_C" >&6
7392 else
7393   if test -n "$WINDRES"; then
7394   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7395 else
7396 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7397 for as_dir in $PATH
7398 do
7399   IFS=$as_save_IFS
7400   test -z "$as_dir" && as_dir=.
7401   for ac_exec_ext in '' $ac_executable_extensions; do
7402   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7403     ac_cv_prog_WINDRES="${ncn_progname}"
7404     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7405     break 2
7406   fi
7407 done
7408 done
7409
7410 fi
7411 fi
7412 WINDRES=$ac_cv_prog_WINDRES
7413 if test -n "$WINDRES"; then
7414   echo "$as_me:$LINENO: result: $WINDRES" >&5
7415 echo "${ECHO_T}$WINDRES" >&6
7416 else
7417   echo "$as_me:$LINENO: result: no" >&5
7418 echo "${ECHO_T}no" >&6
7419 fi
7420
7421   fi
7422   test -n "$ac_cv_prog_WINDRES" && break
7423 done
7424
7425 if test -z "$ac_cv_prog_WINDRES" ; then
7426   set dummy windres
7427   if test $build = $host ; then
7428     WINDRES="$2"
7429   else
7430     WINDRES="${ncn_tool_prefix}$2"
7431   fi
7432 fi
7433
7434
7435
7436 if test -n "$OBJCOPY"; then
7437   ac_cv_prog_OBJCOPY=$OBJCOPY
7438 elif test -n "$ac_cv_prog_OBJCOPY"; then
7439   OBJCOPY=$ac_cv_prog_OBJCOPY
7440 fi
7441
7442 if test -n "$ac_cv_prog_OBJCOPY"; then
7443   for ncn_progname in objcopy; do
7444     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7445 set dummy ${ncn_progname}; ac_word=$2
7446 echo "$as_me:$LINENO: checking for $ac_word" >&5
7447 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7448 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7449   echo $ECHO_N "(cached) $ECHO_C" >&6
7450 else
7451   if test -n "$OBJCOPY"; then
7452   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7453 else
7454 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7455 for as_dir in $PATH
7456 do
7457   IFS=$as_save_IFS
7458   test -z "$as_dir" && as_dir=.
7459   for ac_exec_ext in '' $ac_executable_extensions; do
7460   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7461     ac_cv_prog_OBJCOPY="${ncn_progname}"
7462     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7463     break 2
7464   fi
7465 done
7466 done
7467
7468 fi
7469 fi
7470 OBJCOPY=$ac_cv_prog_OBJCOPY
7471 if test -n "$OBJCOPY"; then
7472   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7473 echo "${ECHO_T}$OBJCOPY" >&6
7474 else
7475   echo "$as_me:$LINENO: result: no" >&5
7476 echo "${ECHO_T}no" >&6
7477 fi
7478
7479   done
7480 fi
7481
7482 for ncn_progname in objcopy; do
7483   if test -n "$ncn_tool_prefix"; then
7484     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7485 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7486 echo "$as_me:$LINENO: checking for $ac_word" >&5
7487 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7488 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7489   echo $ECHO_N "(cached) $ECHO_C" >&6
7490 else
7491   if test -n "$OBJCOPY"; then
7492   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7493 else
7494 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7495 for as_dir in $PATH
7496 do
7497   IFS=$as_save_IFS
7498   test -z "$as_dir" && as_dir=.
7499   for ac_exec_ext in '' $ac_executable_extensions; do
7500   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7501     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7502     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7503     break 2
7504   fi
7505 done
7506 done
7507
7508 fi
7509 fi
7510 OBJCOPY=$ac_cv_prog_OBJCOPY
7511 if test -n "$OBJCOPY"; then
7512   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7513 echo "${ECHO_T}$OBJCOPY" >&6
7514 else
7515   echo "$as_me:$LINENO: result: no" >&5
7516 echo "${ECHO_T}no" >&6
7517 fi
7518
7519   fi
7520   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7521     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7522 set dummy ${ncn_progname}; ac_word=$2
7523 echo "$as_me:$LINENO: checking for $ac_word" >&5
7524 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7525 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7526   echo $ECHO_N "(cached) $ECHO_C" >&6
7527 else
7528   if test -n "$OBJCOPY"; then
7529   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7530 else
7531 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7532 for as_dir in $PATH
7533 do
7534   IFS=$as_save_IFS
7535   test -z "$as_dir" && as_dir=.
7536   for ac_exec_ext in '' $ac_executable_extensions; do
7537   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7538     ac_cv_prog_OBJCOPY="${ncn_progname}"
7539     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7540     break 2
7541   fi
7542 done
7543 done
7544
7545 fi
7546 fi
7547 OBJCOPY=$ac_cv_prog_OBJCOPY
7548 if test -n "$OBJCOPY"; then
7549   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7550 echo "${ECHO_T}$OBJCOPY" >&6
7551 else
7552   echo "$as_me:$LINENO: result: no" >&5
7553 echo "${ECHO_T}no" >&6
7554 fi
7555
7556   fi
7557   test -n "$ac_cv_prog_OBJCOPY" && break
7558 done
7559
7560 if test -z "$ac_cv_prog_OBJCOPY" ; then
7561   set dummy objcopy
7562   if test $build = $host ; then
7563     OBJCOPY="$2"
7564   else
7565     OBJCOPY="${ncn_tool_prefix}$2"
7566   fi
7567 fi
7568
7569
7570
7571 if test -n "$OBJDUMP"; then
7572   ac_cv_prog_OBJDUMP=$OBJDUMP
7573 elif test -n "$ac_cv_prog_OBJDUMP"; then
7574   OBJDUMP=$ac_cv_prog_OBJDUMP
7575 fi
7576
7577 if test -n "$ac_cv_prog_OBJDUMP"; then
7578   for ncn_progname in objdump; do
7579     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7580 set dummy ${ncn_progname}; ac_word=$2
7581 echo "$as_me:$LINENO: checking for $ac_word" >&5
7582 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7583 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7584   echo $ECHO_N "(cached) $ECHO_C" >&6
7585 else
7586   if test -n "$OBJDUMP"; then
7587   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7588 else
7589 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7590 for as_dir in $PATH
7591 do
7592   IFS=$as_save_IFS
7593   test -z "$as_dir" && as_dir=.
7594   for ac_exec_ext in '' $ac_executable_extensions; do
7595   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7596     ac_cv_prog_OBJDUMP="${ncn_progname}"
7597     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7598     break 2
7599   fi
7600 done
7601 done
7602
7603 fi
7604 fi
7605 OBJDUMP=$ac_cv_prog_OBJDUMP
7606 if test -n "$OBJDUMP"; then
7607   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7608 echo "${ECHO_T}$OBJDUMP" >&6
7609 else
7610   echo "$as_me:$LINENO: result: no" >&5
7611 echo "${ECHO_T}no" >&6
7612 fi
7613
7614   done
7615 fi
7616
7617 for ncn_progname in objdump; do
7618   if test -n "$ncn_tool_prefix"; then
7619     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7620 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7621 echo "$as_me:$LINENO: checking for $ac_word" >&5
7622 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7623 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7624   echo $ECHO_N "(cached) $ECHO_C" >&6
7625 else
7626   if test -n "$OBJDUMP"; then
7627   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7628 else
7629 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7630 for as_dir in $PATH
7631 do
7632   IFS=$as_save_IFS
7633   test -z "$as_dir" && as_dir=.
7634   for ac_exec_ext in '' $ac_executable_extensions; do
7635   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7636     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7637     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7638     break 2
7639   fi
7640 done
7641 done
7642
7643 fi
7644 fi
7645 OBJDUMP=$ac_cv_prog_OBJDUMP
7646 if test -n "$OBJDUMP"; then
7647   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7648 echo "${ECHO_T}$OBJDUMP" >&6
7649 else
7650   echo "$as_me:$LINENO: result: no" >&5
7651 echo "${ECHO_T}no" >&6
7652 fi
7653
7654   fi
7655   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7656     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7657 set dummy ${ncn_progname}; ac_word=$2
7658 echo "$as_me:$LINENO: checking for $ac_word" >&5
7659 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7660 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7661   echo $ECHO_N "(cached) $ECHO_C" >&6
7662 else
7663   if test -n "$OBJDUMP"; then
7664   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7665 else
7666 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7667 for as_dir in $PATH
7668 do
7669   IFS=$as_save_IFS
7670   test -z "$as_dir" && as_dir=.
7671   for ac_exec_ext in '' $ac_executable_extensions; do
7672   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7673     ac_cv_prog_OBJDUMP="${ncn_progname}"
7674     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7675     break 2
7676   fi
7677 done
7678 done
7679
7680 fi
7681 fi
7682 OBJDUMP=$ac_cv_prog_OBJDUMP
7683 if test -n "$OBJDUMP"; then
7684   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7685 echo "${ECHO_T}$OBJDUMP" >&6
7686 else
7687   echo "$as_me:$LINENO: result: no" >&5
7688 echo "${ECHO_T}no" >&6
7689 fi
7690
7691   fi
7692   test -n "$ac_cv_prog_OBJDUMP" && break
7693 done
7694
7695 if test -z "$ac_cv_prog_OBJDUMP" ; then
7696   set dummy objdump
7697   if test $build = $host ; then
7698     OBJDUMP="$2"
7699   else
7700     OBJDUMP="${ncn_tool_prefix}$2"
7701   fi
7702 fi
7703
7704
7705
7706
7707
7708
7709
7710 # Target tools.
7711
7712 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7713 if test "${with_build_time_tools+set}" = set; then
7714   withval="$with_build_time_tools"
7715   case x"$withval" in
7716      x/*) ;;
7717      *)
7718        with_build_time_tools=
7719        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7720 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7721        ;;
7722    esac
7723 else
7724   with_build_time_tools=
7725 fi;
7726
7727
7728
7729 if test -n "$CC_FOR_TARGET"; then
7730   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7731 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7732   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7733 fi
7734
7735 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7736   for ncn_progname in cc gcc; do
7737     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7738 set dummy ${ncn_progname}; ac_word=$2
7739 echo "$as_me:$LINENO: checking for $ac_word" >&5
7740 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7741 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7742   echo $ECHO_N "(cached) $ECHO_C" >&6
7743 else
7744   if test -n "$CC_FOR_TARGET"; then
7745   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7746 else
7747 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7748 for as_dir in $PATH
7749 do
7750   IFS=$as_save_IFS
7751   test -z "$as_dir" && as_dir=.
7752   for ac_exec_ext in '' $ac_executable_extensions; do
7753   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7754     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7755     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7756     break 2
7757   fi
7758 done
7759 done
7760
7761 fi
7762 fi
7763 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7764 if test -n "$CC_FOR_TARGET"; then
7765   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7766 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7767 else
7768   echo "$as_me:$LINENO: result: no" >&5
7769 echo "${ECHO_T}no" >&6
7770 fi
7771
7772   done
7773 fi
7774
7775 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
7776   for ncn_progname in cc gcc; do
7777     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7778 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7779     if test -x $with_build_time_tools/${ncn_progname}; then
7780       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7781       echo "$as_me:$LINENO: result: yes" >&5
7782 echo "${ECHO_T}yes" >&6
7783       break
7784     else
7785       echo "$as_me:$LINENO: result: no" >&5
7786 echo "${ECHO_T}no" >&6
7787     fi
7788   done
7789 fi
7790
7791 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
7792   for ncn_progname in cc gcc; do
7793     if test -n "$ncn_target_tool_prefix"; then
7794       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
7795 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
7796 echo "$as_me:$LINENO: checking for $ac_word" >&5
7797 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7798 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7799   echo $ECHO_N "(cached) $ECHO_C" >&6
7800 else
7801   if test -n "$CC_FOR_TARGET"; then
7802   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7803 else
7804 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7805 for as_dir in $PATH
7806 do
7807   IFS=$as_save_IFS
7808   test -z "$as_dir" && as_dir=.
7809   for ac_exec_ext in '' $ac_executable_extensions; do
7810   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7811     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
7812     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7813     break 2
7814   fi
7815 done
7816 done
7817
7818 fi
7819 fi
7820 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7821 if test -n "$CC_FOR_TARGET"; then
7822   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7823 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7824 else
7825   echo "$as_me:$LINENO: result: no" >&5
7826 echo "${ECHO_T}no" >&6
7827 fi
7828
7829     fi
7830     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
7831       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7832 set dummy ${ncn_progname}; ac_word=$2
7833 echo "$as_me:$LINENO: checking for $ac_word" >&5
7834 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7835 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7836   echo $ECHO_N "(cached) $ECHO_C" >&6
7837 else
7838   if test -n "$CC_FOR_TARGET"; then
7839   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7840 else
7841 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7842 for as_dir in $PATH
7843 do
7844   IFS=$as_save_IFS
7845   test -z "$as_dir" && as_dir=.
7846   for ac_exec_ext in '' $ac_executable_extensions; do
7847   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7848     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7849     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7850     break 2
7851   fi
7852 done
7853 done
7854
7855 fi
7856 fi
7857 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7858 if test -n "$CC_FOR_TARGET"; then
7859   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7860 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7861 else
7862   echo "$as_me:$LINENO: result: no" >&5
7863 echo "${ECHO_T}no" >&6
7864 fi
7865
7866     fi
7867     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
7868   done
7869 fi
7870
7871 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
7872   set dummy cc gcc
7873   if test $build = $target ; then
7874     CC_FOR_TARGET="$2"
7875   else
7876     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
7877   fi
7878 fi
7879
7880
7881
7882 if test -n "$CXX_FOR_TARGET"; then
7883   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
7884 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
7885   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7886 fi
7887
7888 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
7889   for ncn_progname in c++ g++ cxx gxx; do
7890     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7891 set dummy ${ncn_progname}; ac_word=$2
7892 echo "$as_me:$LINENO: checking for $ac_word" >&5
7893 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7894 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
7895   echo $ECHO_N "(cached) $ECHO_C" >&6
7896 else
7897   if test -n "$CXX_FOR_TARGET"; then
7898   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
7899 else
7900 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7901 for as_dir in $PATH
7902 do
7903   IFS=$as_save_IFS
7904   test -z "$as_dir" && as_dir=.
7905   for ac_exec_ext in '' $ac_executable_extensions; do
7906   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7907     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
7908     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7909     break 2
7910   fi
7911 done
7912 done
7913
7914 fi
7915 fi
7916 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7917 if test -n "$CXX_FOR_TARGET"; then
7918   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
7919 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
7920 else
7921   echo "$as_me:$LINENO: result: no" >&5
7922 echo "${ECHO_T}no" >&6
7923 fi
7924
7925   done
7926 fi
7927
7928 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
7929   for ncn_progname in c++ g++ cxx gxx; do
7930     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7931 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7932     if test -x $with_build_time_tools/${ncn_progname}; then
7933       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7934       echo "$as_me:$LINENO: result: yes" >&5
7935 echo "${ECHO_T}yes" >&6
7936       break
7937     else
7938       echo "$as_me:$LINENO: result: no" >&5
7939 echo "${ECHO_T}no" >&6
7940     fi
7941   done
7942 fi
7943
7944 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
7945   for ncn_progname in c++ g++ cxx gxx; do
7946     if test -n "$ncn_target_tool_prefix"; then
7947       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
7948 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
7949 echo "$as_me:$LINENO: checking for $ac_word" >&5
7950 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7951 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
7952   echo $ECHO_N "(cached) $ECHO_C" >&6
7953 else
7954   if test -n "$CXX_FOR_TARGET"; then
7955   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
7956 else
7957 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7958 for as_dir in $PATH
7959 do
7960   IFS=$as_save_IFS
7961   test -z "$as_dir" && as_dir=.
7962   for ac_exec_ext in '' $ac_executable_extensions; do
7963   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7964     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
7965     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7966     break 2
7967   fi
7968 done
7969 done
7970
7971 fi
7972 fi
7973 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7974 if test -n "$CXX_FOR_TARGET"; then
7975   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
7976 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
7977 else
7978   echo "$as_me:$LINENO: result: no" >&5
7979 echo "${ECHO_T}no" >&6
7980 fi
7981
7982     fi
7983     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
7984       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7985 set dummy ${ncn_progname}; ac_word=$2
7986 echo "$as_me:$LINENO: checking for $ac_word" >&5
7987 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7988 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
7989   echo $ECHO_N "(cached) $ECHO_C" >&6
7990 else
7991   if test -n "$CXX_FOR_TARGET"; then
7992   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
7993 else
7994 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7995 for as_dir in $PATH
7996 do
7997   IFS=$as_save_IFS
7998   test -z "$as_dir" && as_dir=.
7999   for ac_exec_ext in '' $ac_executable_extensions; do
8000   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8001     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8002     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8003     break 2
8004   fi
8005 done
8006 done
8007
8008 fi
8009 fi
8010 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8011 if test -n "$CXX_FOR_TARGET"; then
8012   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8013 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8014 else
8015   echo "$as_me:$LINENO: result: no" >&5
8016 echo "${ECHO_T}no" >&6
8017 fi
8018
8019     fi
8020     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8021   done
8022 fi
8023
8024 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8025   set dummy c++ g++ cxx gxx
8026   if test $build = $target ; then
8027     CXX_FOR_TARGET="$2"
8028   else
8029     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8030   fi
8031 fi
8032
8033
8034
8035 if test -n "$GCC_FOR_TARGET"; then
8036   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8037 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8038   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8039 fi
8040
8041 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8042   for ncn_progname in gcc; do
8043     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8044 set dummy ${ncn_progname}; ac_word=$2
8045 echo "$as_me:$LINENO: checking for $ac_word" >&5
8046 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8047 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8048   echo $ECHO_N "(cached) $ECHO_C" >&6
8049 else
8050   if test -n "$GCC_FOR_TARGET"; then
8051   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8052 else
8053 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8054 for as_dir in $PATH
8055 do
8056   IFS=$as_save_IFS
8057   test -z "$as_dir" && as_dir=.
8058   for ac_exec_ext in '' $ac_executable_extensions; do
8059   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8060     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8061     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8062     break 2
8063   fi
8064 done
8065 done
8066
8067 fi
8068 fi
8069 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8070 if test -n "$GCC_FOR_TARGET"; then
8071   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8072 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8073 else
8074   echo "$as_me:$LINENO: result: no" >&5
8075 echo "${ECHO_T}no" >&6
8076 fi
8077
8078   done
8079 fi
8080
8081 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8082   for ncn_progname in gcc; do
8083     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8084 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8085     if test -x $with_build_time_tools/${ncn_progname}; then
8086       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8087       echo "$as_me:$LINENO: result: yes" >&5
8088 echo "${ECHO_T}yes" >&6
8089       break
8090     else
8091       echo "$as_me:$LINENO: result: no" >&5
8092 echo "${ECHO_T}no" >&6
8093     fi
8094   done
8095 fi
8096
8097 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8098   for ncn_progname in gcc; do
8099     if test -n "$ncn_target_tool_prefix"; then
8100       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8101 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8102 echo "$as_me:$LINENO: checking for $ac_word" >&5
8103 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8104 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8105   echo $ECHO_N "(cached) $ECHO_C" >&6
8106 else
8107   if test -n "$GCC_FOR_TARGET"; then
8108   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8109 else
8110 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8111 for as_dir in $PATH
8112 do
8113   IFS=$as_save_IFS
8114   test -z "$as_dir" && as_dir=.
8115   for ac_exec_ext in '' $ac_executable_extensions; do
8116   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8117     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8118     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8119     break 2
8120   fi
8121 done
8122 done
8123
8124 fi
8125 fi
8126 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8127 if test -n "$GCC_FOR_TARGET"; then
8128   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8129 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8130 else
8131   echo "$as_me:$LINENO: result: no" >&5
8132 echo "${ECHO_T}no" >&6
8133 fi
8134
8135     fi
8136     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8137       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8138 set dummy ${ncn_progname}; ac_word=$2
8139 echo "$as_me:$LINENO: checking for $ac_word" >&5
8140 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8141 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8142   echo $ECHO_N "(cached) $ECHO_C" >&6
8143 else
8144   if test -n "$GCC_FOR_TARGET"; then
8145   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8146 else
8147 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8148 for as_dir in $PATH
8149 do
8150   IFS=$as_save_IFS
8151   test -z "$as_dir" && as_dir=.
8152   for ac_exec_ext in '' $ac_executable_extensions; do
8153   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8154     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8155     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8156     break 2
8157   fi
8158 done
8159 done
8160
8161 fi
8162 fi
8163 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8164 if test -n "$GCC_FOR_TARGET"; then
8165   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8166 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8167 else
8168   echo "$as_me:$LINENO: result: no" >&5
8169 echo "${ECHO_T}no" >&6
8170 fi
8171
8172     fi
8173     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8174   done
8175 fi
8176
8177 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8178   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8179 fi
8180
8181
8182
8183 if test -n "$GCJ_FOR_TARGET"; then
8184   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8185 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8186   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8187 fi
8188
8189 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8190   for ncn_progname in gcj; do
8191     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8192 set dummy ${ncn_progname}; ac_word=$2
8193 echo "$as_me:$LINENO: checking for $ac_word" >&5
8194 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8195 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8196   echo $ECHO_N "(cached) $ECHO_C" >&6
8197 else
8198   if test -n "$GCJ_FOR_TARGET"; then
8199   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8200 else
8201 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8202 for as_dir in $PATH
8203 do
8204   IFS=$as_save_IFS
8205   test -z "$as_dir" && as_dir=.
8206   for ac_exec_ext in '' $ac_executable_extensions; do
8207   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8208     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8209     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8210     break 2
8211   fi
8212 done
8213 done
8214
8215 fi
8216 fi
8217 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8218 if test -n "$GCJ_FOR_TARGET"; then
8219   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8220 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8221 else
8222   echo "$as_me:$LINENO: result: no" >&5
8223 echo "${ECHO_T}no" >&6
8224 fi
8225
8226   done
8227 fi
8228
8229 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8230   for ncn_progname in gcj; do
8231     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8232 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8233     if test -x $with_build_time_tools/${ncn_progname}; then
8234       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8235       echo "$as_me:$LINENO: result: yes" >&5
8236 echo "${ECHO_T}yes" >&6
8237       break
8238     else
8239       echo "$as_me:$LINENO: result: no" >&5
8240 echo "${ECHO_T}no" >&6
8241     fi
8242   done
8243 fi
8244
8245 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8246   for ncn_progname in gcj; do
8247     if test -n "$ncn_target_tool_prefix"; then
8248       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8249 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8250 echo "$as_me:$LINENO: checking for $ac_word" >&5
8251 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8252 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8253   echo $ECHO_N "(cached) $ECHO_C" >&6
8254 else
8255   if test -n "$GCJ_FOR_TARGET"; then
8256   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8257 else
8258 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8259 for as_dir in $PATH
8260 do
8261   IFS=$as_save_IFS
8262   test -z "$as_dir" && as_dir=.
8263   for ac_exec_ext in '' $ac_executable_extensions; do
8264   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8265     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8266     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8267     break 2
8268   fi
8269 done
8270 done
8271
8272 fi
8273 fi
8274 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8275 if test -n "$GCJ_FOR_TARGET"; then
8276   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8277 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8278 else
8279   echo "$as_me:$LINENO: result: no" >&5
8280 echo "${ECHO_T}no" >&6
8281 fi
8282
8283     fi
8284     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8285       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8286 set dummy ${ncn_progname}; ac_word=$2
8287 echo "$as_me:$LINENO: checking for $ac_word" >&5
8288 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8289 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8290   echo $ECHO_N "(cached) $ECHO_C" >&6
8291 else
8292   if test -n "$GCJ_FOR_TARGET"; then
8293   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8294 else
8295 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8296 for as_dir in $PATH
8297 do
8298   IFS=$as_save_IFS
8299   test -z "$as_dir" && as_dir=.
8300   for ac_exec_ext in '' $ac_executable_extensions; do
8301   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8302     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8303     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8304     break 2
8305   fi
8306 done
8307 done
8308
8309 fi
8310 fi
8311 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8312 if test -n "$GCJ_FOR_TARGET"; then
8313   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8314 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8315 else
8316   echo "$as_me:$LINENO: result: no" >&5
8317 echo "${ECHO_T}no" >&6
8318 fi
8319
8320     fi
8321     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8322   done
8323 fi
8324
8325 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8326   set dummy gcj
8327   if test $build = $target ; then
8328     GCJ_FOR_TARGET="$2"
8329   else
8330     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8331   fi
8332 fi
8333
8334
8335
8336 if test -n "$GFORTRAN_FOR_TARGET"; then
8337   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8338 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8339   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8340 fi
8341
8342 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8343   for ncn_progname in gfortran; do
8344     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8345 set dummy ${ncn_progname}; ac_word=$2
8346 echo "$as_me:$LINENO: checking for $ac_word" >&5
8347 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8348 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8349   echo $ECHO_N "(cached) $ECHO_C" >&6
8350 else
8351   if test -n "$GFORTRAN_FOR_TARGET"; then
8352   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8353 else
8354 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8355 for as_dir in $PATH
8356 do
8357   IFS=$as_save_IFS
8358   test -z "$as_dir" && as_dir=.
8359   for ac_exec_ext in '' $ac_executable_extensions; do
8360   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8361     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8362     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8363     break 2
8364   fi
8365 done
8366 done
8367
8368 fi
8369 fi
8370 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8371 if test -n "$GFORTRAN_FOR_TARGET"; then
8372   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8373 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8374 else
8375   echo "$as_me:$LINENO: result: no" >&5
8376 echo "${ECHO_T}no" >&6
8377 fi
8378
8379   done
8380 fi
8381
8382 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8383   for ncn_progname in gfortran; do
8384     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8385 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8386     if test -x $with_build_time_tools/${ncn_progname}; then
8387       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8388       echo "$as_me:$LINENO: result: yes" >&5
8389 echo "${ECHO_T}yes" >&6
8390       break
8391     else
8392       echo "$as_me:$LINENO: result: no" >&5
8393 echo "${ECHO_T}no" >&6
8394     fi
8395   done
8396 fi
8397
8398 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8399   for ncn_progname in gfortran; do
8400     if test -n "$ncn_target_tool_prefix"; then
8401       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8402 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8403 echo "$as_me:$LINENO: checking for $ac_word" >&5
8404 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8405 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8406   echo $ECHO_N "(cached) $ECHO_C" >&6
8407 else
8408   if test -n "$GFORTRAN_FOR_TARGET"; then
8409   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8410 else
8411 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8412 for as_dir in $PATH
8413 do
8414   IFS=$as_save_IFS
8415   test -z "$as_dir" && as_dir=.
8416   for ac_exec_ext in '' $ac_executable_extensions; do
8417   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8418     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8419     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8420     break 2
8421   fi
8422 done
8423 done
8424
8425 fi
8426 fi
8427 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8428 if test -n "$GFORTRAN_FOR_TARGET"; then
8429   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8430 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8431 else
8432   echo "$as_me:$LINENO: result: no" >&5
8433 echo "${ECHO_T}no" >&6
8434 fi
8435
8436     fi
8437     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8438       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8439 set dummy ${ncn_progname}; ac_word=$2
8440 echo "$as_me:$LINENO: checking for $ac_word" >&5
8441 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8442 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8443   echo $ECHO_N "(cached) $ECHO_C" >&6
8444 else
8445   if test -n "$GFORTRAN_FOR_TARGET"; then
8446   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8447 else
8448 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8449 for as_dir in $PATH
8450 do
8451   IFS=$as_save_IFS
8452   test -z "$as_dir" && as_dir=.
8453   for ac_exec_ext in '' $ac_executable_extensions; do
8454   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8455     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8456     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8457     break 2
8458   fi
8459 done
8460 done
8461
8462 fi
8463 fi
8464 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8465 if test -n "$GFORTRAN_FOR_TARGET"; then
8466   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8467 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8468 else
8469   echo "$as_me:$LINENO: result: no" >&5
8470 echo "${ECHO_T}no" >&6
8471 fi
8472
8473     fi
8474     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8475   done
8476 fi
8477
8478 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8479   set dummy gfortran
8480   if test $build = $target ; then
8481     GFORTRAN_FOR_TARGET="$2"
8482   else
8483     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8484   fi
8485 fi
8486
8487
8488
8489 cat > conftest.c << \EOF
8490 #ifdef __GNUC__
8491   gcc_yay;
8492 #endif
8493 EOF
8494 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8495   have_gcc_for_target=yes
8496 else
8497   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8498   have_gcc_for_target=no
8499 fi
8500 rm conftest.c
8501
8502
8503
8504
8505 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8506   if test -n "$with_build_time_tools"; then
8507     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8508 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8509     if test -x $with_build_time_tools/ar; then
8510       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8511       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8512       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8513 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8514     else
8515       echo "$as_me:$LINENO: result: no" >&5
8516 echo "${ECHO_T}no" >&6
8517     fi
8518   elif test $build != $host && test $have_gcc_for_target = yes; then
8519     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8520     test $AR_FOR_TARGET=ar && AR_FOR_TARGET=
8521     ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8522   fi
8523 fi
8524 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8525   # Extract the first word of "ar", so it can be a program name with args.
8526 set dummy ar; ac_word=$2
8527 echo "$as_me:$LINENO: checking for $ac_word" >&5
8528 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8529 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8530   echo $ECHO_N "(cached) $ECHO_C" >&6
8531 else
8532   case $AR_FOR_TARGET in
8533   [\\/]* | ?:[\\/]*)
8534   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8535   ;;
8536   *)
8537   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8538 for as_dir in $gcc_cv_tool_dirs
8539 do
8540   IFS=$as_save_IFS
8541   test -z "$as_dir" && as_dir=.
8542   for ac_exec_ext in '' $ac_executable_extensions; do
8543   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8544     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8545     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8546     break 2
8547   fi
8548 done
8549 done
8550
8551   ;;
8552 esac
8553 fi
8554 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8555
8556 if test -n "$AR_FOR_TARGET"; then
8557   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8558 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8559 else
8560   echo "$as_me:$LINENO: result: no" >&5
8561 echo "${ECHO_T}no" >&6
8562 fi
8563
8564 fi
8565 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8566
8567
8568 if test -n "$AR_FOR_TARGET"; then
8569   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8570 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8571   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8572 fi
8573
8574 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8575   for ncn_progname in ar; do
8576     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8577 set dummy ${ncn_progname}; ac_word=$2
8578 echo "$as_me:$LINENO: checking for $ac_word" >&5
8579 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8580 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8581   echo $ECHO_N "(cached) $ECHO_C" >&6
8582 else
8583   if test -n "$AR_FOR_TARGET"; then
8584   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8585 else
8586 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8587 for as_dir in $PATH
8588 do
8589   IFS=$as_save_IFS
8590   test -z "$as_dir" && as_dir=.
8591   for ac_exec_ext in '' $ac_executable_extensions; do
8592   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8593     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8594     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8595     break 2
8596   fi
8597 done
8598 done
8599
8600 fi
8601 fi
8602 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8603 if test -n "$AR_FOR_TARGET"; then
8604   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8605 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8606 else
8607   echo "$as_me:$LINENO: result: no" >&5
8608 echo "${ECHO_T}no" >&6
8609 fi
8610
8611   done
8612 fi
8613
8614 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8615   for ncn_progname in ar; do
8616     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8617 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8618     if test -x $with_build_time_tools/${ncn_progname}; then
8619       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8620       echo "$as_me:$LINENO: result: yes" >&5
8621 echo "${ECHO_T}yes" >&6
8622       break
8623     else
8624       echo "$as_me:$LINENO: result: no" >&5
8625 echo "${ECHO_T}no" >&6
8626     fi
8627   done
8628 fi
8629
8630 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8631   for ncn_progname in ar; do
8632     if test -n "$ncn_target_tool_prefix"; then
8633       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8634 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8635 echo "$as_me:$LINENO: checking for $ac_word" >&5
8636 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8637 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8638   echo $ECHO_N "(cached) $ECHO_C" >&6
8639 else
8640   if test -n "$AR_FOR_TARGET"; then
8641   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8642 else
8643 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8644 for as_dir in $PATH
8645 do
8646   IFS=$as_save_IFS
8647   test -z "$as_dir" && as_dir=.
8648   for ac_exec_ext in '' $ac_executable_extensions; do
8649   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8650     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8651     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8652     break 2
8653   fi
8654 done
8655 done
8656
8657 fi
8658 fi
8659 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8660 if test -n "$AR_FOR_TARGET"; then
8661   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8662 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8663 else
8664   echo "$as_me:$LINENO: result: no" >&5
8665 echo "${ECHO_T}no" >&6
8666 fi
8667
8668     fi
8669     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8670       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8671 set dummy ${ncn_progname}; ac_word=$2
8672 echo "$as_me:$LINENO: checking for $ac_word" >&5
8673 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8674 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8675   echo $ECHO_N "(cached) $ECHO_C" >&6
8676 else
8677   if test -n "$AR_FOR_TARGET"; then
8678   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8679 else
8680 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8681 for as_dir in $PATH
8682 do
8683   IFS=$as_save_IFS
8684   test -z "$as_dir" && as_dir=.
8685   for ac_exec_ext in '' $ac_executable_extensions; do
8686   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8687     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8688     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8689     break 2
8690   fi
8691 done
8692 done
8693
8694 fi
8695 fi
8696 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8697 if test -n "$AR_FOR_TARGET"; then
8698   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8699 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8700 else
8701   echo "$as_me:$LINENO: result: no" >&5
8702 echo "${ECHO_T}no" >&6
8703 fi
8704
8705     fi
8706     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8707   done
8708 fi
8709
8710 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8711   set dummy ar
8712   if test $build = $target ; then
8713     AR_FOR_TARGET="$2"
8714   else
8715     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8716   fi
8717 fi
8718
8719 else
8720   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8721 fi
8722
8723
8724
8725
8726 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8727   if test -n "$with_build_time_tools"; then
8728     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
8729 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
8730     if test -x $with_build_time_tools/as; then
8731       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
8732       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8733       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
8734 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
8735     else
8736       echo "$as_me:$LINENO: result: no" >&5
8737 echo "${ECHO_T}no" >&6
8738     fi
8739   elif test $build != $host && test $have_gcc_for_target = yes; then
8740     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
8741     test $AS_FOR_TARGET=as && AS_FOR_TARGET=
8742     ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8743   fi
8744 fi
8745 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8746   # Extract the first word of "as", so it can be a program name with args.
8747 set dummy as; ac_word=$2
8748 echo "$as_me:$LINENO: checking for $ac_word" >&5
8749 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8750 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
8751   echo $ECHO_N "(cached) $ECHO_C" >&6
8752 else
8753   case $AS_FOR_TARGET in
8754   [\\/]* | ?:[\\/]*)
8755   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
8756   ;;
8757   *)
8758   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8759 for as_dir in $gcc_cv_tool_dirs
8760 do
8761   IFS=$as_save_IFS
8762   test -z "$as_dir" && as_dir=.
8763   for ac_exec_ext in '' $ac_executable_extensions; do
8764   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8765     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8766     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8767     break 2
8768   fi
8769 done
8770 done
8771
8772   ;;
8773 esac
8774 fi
8775 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8776
8777 if test -n "$AS_FOR_TARGET"; then
8778   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8779 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8780 else
8781   echo "$as_me:$LINENO: result: no" >&5
8782 echo "${ECHO_T}no" >&6
8783 fi
8784
8785 fi
8786 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8787
8788
8789 if test -n "$AS_FOR_TARGET"; then
8790   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
8791 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8792   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8793 fi
8794
8795 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8796   for ncn_progname in as; do
8797     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8798 set dummy ${ncn_progname}; ac_word=$2
8799 echo "$as_me:$LINENO: checking for $ac_word" >&5
8800 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8801 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8802   echo $ECHO_N "(cached) $ECHO_C" >&6
8803 else
8804   if test -n "$AS_FOR_TARGET"; then
8805   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8806 else
8807 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8808 for as_dir in $PATH
8809 do
8810   IFS=$as_save_IFS
8811   test -z "$as_dir" && as_dir=.
8812   for ac_exec_ext in '' $ac_executable_extensions; do
8813   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8814     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
8815     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8816     break 2
8817   fi
8818 done
8819 done
8820
8821 fi
8822 fi
8823 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8824 if test -n "$AS_FOR_TARGET"; then
8825   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8826 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8827 else
8828   echo "$as_me:$LINENO: result: no" >&5
8829 echo "${ECHO_T}no" >&6
8830 fi
8831
8832   done
8833 fi
8834
8835 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
8836   for ncn_progname in as; do
8837     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8838 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8839     if test -x $with_build_time_tools/${ncn_progname}; then
8840       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8841       echo "$as_me:$LINENO: result: yes" >&5
8842 echo "${ECHO_T}yes" >&6
8843       break
8844     else
8845       echo "$as_me:$LINENO: result: no" >&5
8846 echo "${ECHO_T}no" >&6
8847     fi
8848   done
8849 fi
8850
8851 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
8852   for ncn_progname in as; do
8853     if test -n "$ncn_target_tool_prefix"; then
8854       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8855 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8856 echo "$as_me:$LINENO: checking for $ac_word" >&5
8857 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8858 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8859   echo $ECHO_N "(cached) $ECHO_C" >&6
8860 else
8861   if test -n "$AS_FOR_TARGET"; then
8862   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8863 else
8864 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8865 for as_dir in $PATH
8866 do
8867   IFS=$as_save_IFS
8868   test -z "$as_dir" && as_dir=.
8869   for ac_exec_ext in '' $ac_executable_extensions; do
8870   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8871     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8872     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8873     break 2
8874   fi
8875 done
8876 done
8877
8878 fi
8879 fi
8880 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8881 if test -n "$AS_FOR_TARGET"; then
8882   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8883 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8884 else
8885   echo "$as_me:$LINENO: result: no" >&5
8886 echo "${ECHO_T}no" >&6
8887 fi
8888
8889     fi
8890     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
8891       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8892 set dummy ${ncn_progname}; ac_word=$2
8893 echo "$as_me:$LINENO: checking for $ac_word" >&5
8894 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8895 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8896   echo $ECHO_N "(cached) $ECHO_C" >&6
8897 else
8898   if test -n "$AS_FOR_TARGET"; then
8899   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8900 else
8901 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8902 for as_dir in $PATH
8903 do
8904   IFS=$as_save_IFS
8905   test -z "$as_dir" && as_dir=.
8906   for ac_exec_ext in '' $ac_executable_extensions; do
8907   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8908     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
8909     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8910     break 2
8911   fi
8912 done
8913 done
8914
8915 fi
8916 fi
8917 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8918 if test -n "$AS_FOR_TARGET"; then
8919   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8920 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8921 else
8922   echo "$as_me:$LINENO: result: no" >&5
8923 echo "${ECHO_T}no" >&6
8924 fi
8925
8926     fi
8927     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
8928   done
8929 fi
8930
8931 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
8932   set dummy as
8933   if test $build = $target ; then
8934     AS_FOR_TARGET="$2"
8935   else
8936     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
8937   fi
8938 fi
8939
8940 else
8941   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8942 fi
8943
8944
8945
8946
8947 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
8948   if test -n "$with_build_time_tools"; then
8949     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
8950 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
8951     if test -x $with_build_time_tools/dlltool; then
8952       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
8953       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
8954       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
8955 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
8956     else
8957       echo "$as_me:$LINENO: result: no" >&5
8958 echo "${ECHO_T}no" >&6
8959     fi
8960   elif test $build != $host && test $have_gcc_for_target = yes; then
8961     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
8962     test $DLLTOOL_FOR_TARGET=dlltool && DLLTOOL_FOR_TARGET=
8963     ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
8964   fi
8965 fi
8966 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8967   # Extract the first word of "dlltool", so it can be a program name with args.
8968 set dummy dlltool; ac_word=$2
8969 echo "$as_me:$LINENO: checking for $ac_word" >&5
8970 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8971 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
8972   echo $ECHO_N "(cached) $ECHO_C" >&6
8973 else
8974   case $DLLTOOL_FOR_TARGET in
8975   [\\/]* | ?:[\\/]*)
8976   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
8977   ;;
8978   *)
8979   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8980 for as_dir in $gcc_cv_tool_dirs
8981 do
8982   IFS=$as_save_IFS
8983   test -z "$as_dir" && as_dir=.
8984   for ac_exec_ext in '' $ac_executable_extensions; do
8985   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8986     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8987     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8988     break 2
8989   fi
8990 done
8991 done
8992
8993   ;;
8994 esac
8995 fi
8996 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
8997
8998 if test -n "$DLLTOOL_FOR_TARGET"; then
8999   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9000 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9001 else
9002   echo "$as_me:$LINENO: result: no" >&5
9003 echo "${ECHO_T}no" >&6
9004 fi
9005
9006 fi
9007 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9008
9009
9010 if test -n "$DLLTOOL_FOR_TARGET"; then
9011   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9012 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9013   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9014 fi
9015
9016 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9017   for ncn_progname in dlltool; do
9018     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9019 set dummy ${ncn_progname}; ac_word=$2
9020 echo "$as_me:$LINENO: checking for $ac_word" >&5
9021 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9022 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9023   echo $ECHO_N "(cached) $ECHO_C" >&6
9024 else
9025   if test -n "$DLLTOOL_FOR_TARGET"; then
9026   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9027 else
9028 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9029 for as_dir in $PATH
9030 do
9031   IFS=$as_save_IFS
9032   test -z "$as_dir" && as_dir=.
9033   for ac_exec_ext in '' $ac_executable_extensions; do
9034   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9035     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9036     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9037     break 2
9038   fi
9039 done
9040 done
9041
9042 fi
9043 fi
9044 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9045 if test -n "$DLLTOOL_FOR_TARGET"; then
9046   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9047 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9048 else
9049   echo "$as_me:$LINENO: result: no" >&5
9050 echo "${ECHO_T}no" >&6
9051 fi
9052
9053   done
9054 fi
9055
9056 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9057   for ncn_progname in dlltool; do
9058     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9059 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9060     if test -x $with_build_time_tools/${ncn_progname}; then
9061       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9062       echo "$as_me:$LINENO: result: yes" >&5
9063 echo "${ECHO_T}yes" >&6
9064       break
9065     else
9066       echo "$as_me:$LINENO: result: no" >&5
9067 echo "${ECHO_T}no" >&6
9068     fi
9069   done
9070 fi
9071
9072 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9073   for ncn_progname in dlltool; do
9074     if test -n "$ncn_target_tool_prefix"; then
9075       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9076 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9077 echo "$as_me:$LINENO: checking for $ac_word" >&5
9078 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9079 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9080   echo $ECHO_N "(cached) $ECHO_C" >&6
9081 else
9082   if test -n "$DLLTOOL_FOR_TARGET"; then
9083   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9084 else
9085 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9086 for as_dir in $PATH
9087 do
9088   IFS=$as_save_IFS
9089   test -z "$as_dir" && as_dir=.
9090   for ac_exec_ext in '' $ac_executable_extensions; do
9091   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9092     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9093     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9094     break 2
9095   fi
9096 done
9097 done
9098
9099 fi
9100 fi
9101 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9102 if test -n "$DLLTOOL_FOR_TARGET"; then
9103   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9104 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9105 else
9106   echo "$as_me:$LINENO: result: no" >&5
9107 echo "${ECHO_T}no" >&6
9108 fi
9109
9110     fi
9111     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9112       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9113 set dummy ${ncn_progname}; ac_word=$2
9114 echo "$as_me:$LINENO: checking for $ac_word" >&5
9115 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9116 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9117   echo $ECHO_N "(cached) $ECHO_C" >&6
9118 else
9119   if test -n "$DLLTOOL_FOR_TARGET"; then
9120   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9121 else
9122 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9123 for as_dir in $PATH
9124 do
9125   IFS=$as_save_IFS
9126   test -z "$as_dir" && as_dir=.
9127   for ac_exec_ext in '' $ac_executable_extensions; do
9128   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9129     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9130     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9131     break 2
9132   fi
9133 done
9134 done
9135
9136 fi
9137 fi
9138 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9139 if test -n "$DLLTOOL_FOR_TARGET"; then
9140   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9141 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9142 else
9143   echo "$as_me:$LINENO: result: no" >&5
9144 echo "${ECHO_T}no" >&6
9145 fi
9146
9147     fi
9148     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9149   done
9150 fi
9151
9152 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9153   set dummy dlltool
9154   if test $build = $target ; then
9155     DLLTOOL_FOR_TARGET="$2"
9156   else
9157     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9158   fi
9159 fi
9160
9161 else
9162   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9163 fi
9164
9165
9166
9167
9168 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9169   if test -n "$with_build_time_tools"; then
9170     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9171 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9172     if test -x $with_build_time_tools/ld; then
9173       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9174       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9175       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9176 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9177     else
9178       echo "$as_me:$LINENO: result: no" >&5
9179 echo "${ECHO_T}no" >&6
9180     fi
9181   elif test $build != $host && test $have_gcc_for_target = yes; then
9182     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9183     test $LD_FOR_TARGET=ld && LD_FOR_TARGET=
9184     ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9185   fi
9186 fi
9187 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9188   # Extract the first word of "ld", so it can be a program name with args.
9189 set dummy ld; ac_word=$2
9190 echo "$as_me:$LINENO: checking for $ac_word" >&5
9191 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9192 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9193   echo $ECHO_N "(cached) $ECHO_C" >&6
9194 else
9195   case $LD_FOR_TARGET in
9196   [\\/]* | ?:[\\/]*)
9197   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9198   ;;
9199   *)
9200   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9201 for as_dir in $gcc_cv_tool_dirs
9202 do
9203   IFS=$as_save_IFS
9204   test -z "$as_dir" && as_dir=.
9205   for ac_exec_ext in '' $ac_executable_extensions; do
9206   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9207     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9208     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9209     break 2
9210   fi
9211 done
9212 done
9213
9214   ;;
9215 esac
9216 fi
9217 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9218
9219 if test -n "$LD_FOR_TARGET"; then
9220   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9221 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9222 else
9223   echo "$as_me:$LINENO: result: no" >&5
9224 echo "${ECHO_T}no" >&6
9225 fi
9226
9227 fi
9228 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9229
9230
9231 if test -n "$LD_FOR_TARGET"; then
9232   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9233 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9234   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9235 fi
9236
9237 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9238   for ncn_progname in ld; do
9239     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9240 set dummy ${ncn_progname}; ac_word=$2
9241 echo "$as_me:$LINENO: checking for $ac_word" >&5
9242 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9243 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9244   echo $ECHO_N "(cached) $ECHO_C" >&6
9245 else
9246   if test -n "$LD_FOR_TARGET"; then
9247   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9248 else
9249 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9250 for as_dir in $PATH
9251 do
9252   IFS=$as_save_IFS
9253   test -z "$as_dir" && as_dir=.
9254   for ac_exec_ext in '' $ac_executable_extensions; do
9255   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9256     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9257     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9258     break 2
9259   fi
9260 done
9261 done
9262
9263 fi
9264 fi
9265 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9266 if test -n "$LD_FOR_TARGET"; then
9267   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9268 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9269 else
9270   echo "$as_me:$LINENO: result: no" >&5
9271 echo "${ECHO_T}no" >&6
9272 fi
9273
9274   done
9275 fi
9276
9277 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9278   for ncn_progname in ld; do
9279     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9280 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9281     if test -x $with_build_time_tools/${ncn_progname}; then
9282       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9283       echo "$as_me:$LINENO: result: yes" >&5
9284 echo "${ECHO_T}yes" >&6
9285       break
9286     else
9287       echo "$as_me:$LINENO: result: no" >&5
9288 echo "${ECHO_T}no" >&6
9289     fi
9290   done
9291 fi
9292
9293 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9294   for ncn_progname in ld; do
9295     if test -n "$ncn_target_tool_prefix"; then
9296       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9297 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9298 echo "$as_me:$LINENO: checking for $ac_word" >&5
9299 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9300 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9301   echo $ECHO_N "(cached) $ECHO_C" >&6
9302 else
9303   if test -n "$LD_FOR_TARGET"; then
9304   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9305 else
9306 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9307 for as_dir in $PATH
9308 do
9309   IFS=$as_save_IFS
9310   test -z "$as_dir" && as_dir=.
9311   for ac_exec_ext in '' $ac_executable_extensions; do
9312   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9313     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9314     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9315     break 2
9316   fi
9317 done
9318 done
9319
9320 fi
9321 fi
9322 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9323 if test -n "$LD_FOR_TARGET"; then
9324   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9325 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9326 else
9327   echo "$as_me:$LINENO: result: no" >&5
9328 echo "${ECHO_T}no" >&6
9329 fi
9330
9331     fi
9332     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9333       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9334 set dummy ${ncn_progname}; ac_word=$2
9335 echo "$as_me:$LINENO: checking for $ac_word" >&5
9336 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9337 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9338   echo $ECHO_N "(cached) $ECHO_C" >&6
9339 else
9340   if test -n "$LD_FOR_TARGET"; then
9341   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9342 else
9343 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9344 for as_dir in $PATH
9345 do
9346   IFS=$as_save_IFS
9347   test -z "$as_dir" && as_dir=.
9348   for ac_exec_ext in '' $ac_executable_extensions; do
9349   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9350     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9351     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9352     break 2
9353   fi
9354 done
9355 done
9356
9357 fi
9358 fi
9359 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9360 if test -n "$LD_FOR_TARGET"; then
9361   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9362 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9363 else
9364   echo "$as_me:$LINENO: result: no" >&5
9365 echo "${ECHO_T}no" >&6
9366 fi
9367
9368     fi
9369     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9370   done
9371 fi
9372
9373 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9374   set dummy ld
9375   if test $build = $target ; then
9376     LD_FOR_TARGET="$2"
9377   else
9378     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9379   fi
9380 fi
9381
9382 else
9383   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9384 fi
9385
9386
9387
9388
9389 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9390   if test -n "$with_build_time_tools"; then
9391     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9392 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9393     if test -x $with_build_time_tools/lipo; then
9394       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9395       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9396       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9397 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9398     else
9399       echo "$as_me:$LINENO: result: no" >&5
9400 echo "${ECHO_T}no" >&6
9401     fi
9402   elif test $build != $host && test $have_gcc_for_target = yes; then
9403     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9404     test $LIPO_FOR_TARGET=lipo && LIPO_FOR_TARGET=
9405     ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9406   fi
9407 fi
9408 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9409   # Extract the first word of "lipo", so it can be a program name with args.
9410 set dummy lipo; ac_word=$2
9411 echo "$as_me:$LINENO: checking for $ac_word" >&5
9412 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9413 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9414   echo $ECHO_N "(cached) $ECHO_C" >&6
9415 else
9416   case $LIPO_FOR_TARGET in
9417   [\\/]* | ?:[\\/]*)
9418   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9419   ;;
9420   *)
9421   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9422 for as_dir in $gcc_cv_tool_dirs
9423 do
9424   IFS=$as_save_IFS
9425   test -z "$as_dir" && as_dir=.
9426   for ac_exec_ext in '' $ac_executable_extensions; do
9427   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9428     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9429     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9430     break 2
9431   fi
9432 done
9433 done
9434
9435   ;;
9436 esac
9437 fi
9438 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9439
9440 if test -n "$LIPO_FOR_TARGET"; then
9441   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9442 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9443 else
9444   echo "$as_me:$LINENO: result: no" >&5
9445 echo "${ECHO_T}no" >&6
9446 fi
9447
9448 fi
9449 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9450
9451
9452 if test -n "$LIPO_FOR_TARGET"; then
9453   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9454 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9455   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9456 fi
9457
9458 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9459   for ncn_progname in lipo; do
9460     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9461 set dummy ${ncn_progname}; ac_word=$2
9462 echo "$as_me:$LINENO: checking for $ac_word" >&5
9463 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9464 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9465   echo $ECHO_N "(cached) $ECHO_C" >&6
9466 else
9467   if test -n "$LIPO_FOR_TARGET"; then
9468   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9469 else
9470 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9471 for as_dir in $PATH
9472 do
9473   IFS=$as_save_IFS
9474   test -z "$as_dir" && as_dir=.
9475   for ac_exec_ext in '' $ac_executable_extensions; do
9476   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9477     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9478     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9479     break 2
9480   fi
9481 done
9482 done
9483
9484 fi
9485 fi
9486 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9487 if test -n "$LIPO_FOR_TARGET"; then
9488   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9489 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9490 else
9491   echo "$as_me:$LINENO: result: no" >&5
9492 echo "${ECHO_T}no" >&6
9493 fi
9494
9495   done
9496 fi
9497
9498 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9499   for ncn_progname in lipo; do
9500     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9501 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9502     if test -x $with_build_time_tools/${ncn_progname}; then
9503       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9504       echo "$as_me:$LINENO: result: yes" >&5
9505 echo "${ECHO_T}yes" >&6
9506       break
9507     else
9508       echo "$as_me:$LINENO: result: no" >&5
9509 echo "${ECHO_T}no" >&6
9510     fi
9511   done
9512 fi
9513
9514 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9515   for ncn_progname in lipo; do
9516     if test -n "$ncn_target_tool_prefix"; then
9517       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9518 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9519 echo "$as_me:$LINENO: checking for $ac_word" >&5
9520 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9521 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9522   echo $ECHO_N "(cached) $ECHO_C" >&6
9523 else
9524   if test -n "$LIPO_FOR_TARGET"; then
9525   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9526 else
9527 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9528 for as_dir in $PATH
9529 do
9530   IFS=$as_save_IFS
9531   test -z "$as_dir" && as_dir=.
9532   for ac_exec_ext in '' $ac_executable_extensions; do
9533   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9534     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9535     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9536     break 2
9537   fi
9538 done
9539 done
9540
9541 fi
9542 fi
9543 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9544 if test -n "$LIPO_FOR_TARGET"; then
9545   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9546 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9547 else
9548   echo "$as_me:$LINENO: result: no" >&5
9549 echo "${ECHO_T}no" >&6
9550 fi
9551
9552     fi
9553     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9554       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9555 set dummy ${ncn_progname}; ac_word=$2
9556 echo "$as_me:$LINENO: checking for $ac_word" >&5
9557 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9558 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9559   echo $ECHO_N "(cached) $ECHO_C" >&6
9560 else
9561   if test -n "$LIPO_FOR_TARGET"; then
9562   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9563 else
9564 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9565 for as_dir in $PATH
9566 do
9567   IFS=$as_save_IFS
9568   test -z "$as_dir" && as_dir=.
9569   for ac_exec_ext in '' $ac_executable_extensions; do
9570   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9571     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9572     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9573     break 2
9574   fi
9575 done
9576 done
9577
9578 fi
9579 fi
9580 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9581 if test -n "$LIPO_FOR_TARGET"; then
9582   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9583 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9584 else
9585   echo "$as_me:$LINENO: result: no" >&5
9586 echo "${ECHO_T}no" >&6
9587 fi
9588
9589     fi
9590     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9591   done
9592 fi
9593
9594 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9595   set dummy lipo
9596   if test $build = $target ; then
9597     LIPO_FOR_TARGET="$2"
9598   else
9599     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9600   fi
9601 fi
9602
9603 else
9604   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9605 fi
9606
9607
9608
9609
9610 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9611   if test -n "$with_build_time_tools"; then
9612     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9613 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9614     if test -x $with_build_time_tools/nm; then
9615       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9616       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9617       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9618 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9619     else
9620       echo "$as_me:$LINENO: result: no" >&5
9621 echo "${ECHO_T}no" >&6
9622     fi
9623   elif test $build != $host && test $have_gcc_for_target = yes; then
9624     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9625     test $NM_FOR_TARGET=nm && NM_FOR_TARGET=
9626     ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9627   fi
9628 fi
9629 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9630   # Extract the first word of "nm", so it can be a program name with args.
9631 set dummy nm; ac_word=$2
9632 echo "$as_me:$LINENO: checking for $ac_word" >&5
9633 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9634 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9635   echo $ECHO_N "(cached) $ECHO_C" >&6
9636 else
9637   case $NM_FOR_TARGET in
9638   [\\/]* | ?:[\\/]*)
9639   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9640   ;;
9641   *)
9642   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9643 for as_dir in $gcc_cv_tool_dirs
9644 do
9645   IFS=$as_save_IFS
9646   test -z "$as_dir" && as_dir=.
9647   for ac_exec_ext in '' $ac_executable_extensions; do
9648   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9649     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9650     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9651     break 2
9652   fi
9653 done
9654 done
9655
9656   ;;
9657 esac
9658 fi
9659 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9660
9661 if test -n "$NM_FOR_TARGET"; then
9662   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9663 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9664 else
9665   echo "$as_me:$LINENO: result: no" >&5
9666 echo "${ECHO_T}no" >&6
9667 fi
9668
9669 fi
9670 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9671
9672
9673 if test -n "$NM_FOR_TARGET"; then
9674   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9675 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9676   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9677 fi
9678
9679 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9680   for ncn_progname in nm; do
9681     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9682 set dummy ${ncn_progname}; ac_word=$2
9683 echo "$as_me:$LINENO: checking for $ac_word" >&5
9684 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9685 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9686   echo $ECHO_N "(cached) $ECHO_C" >&6
9687 else
9688   if test -n "$NM_FOR_TARGET"; then
9689   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9690 else
9691 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9692 for as_dir in $PATH
9693 do
9694   IFS=$as_save_IFS
9695   test -z "$as_dir" && as_dir=.
9696   for ac_exec_ext in '' $ac_executable_extensions; do
9697   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9698     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9699     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9700     break 2
9701   fi
9702 done
9703 done
9704
9705 fi
9706 fi
9707 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9708 if test -n "$NM_FOR_TARGET"; then
9709   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9710 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9711 else
9712   echo "$as_me:$LINENO: result: no" >&5
9713 echo "${ECHO_T}no" >&6
9714 fi
9715
9716   done
9717 fi
9718
9719 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
9720   for ncn_progname in nm; do
9721     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9722 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9723     if test -x $with_build_time_tools/${ncn_progname}; then
9724       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9725       echo "$as_me:$LINENO: result: yes" >&5
9726 echo "${ECHO_T}yes" >&6
9727       break
9728     else
9729       echo "$as_me:$LINENO: result: no" >&5
9730 echo "${ECHO_T}no" >&6
9731     fi
9732   done
9733 fi
9734
9735 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
9736   for ncn_progname in nm; do
9737     if test -n "$ncn_target_tool_prefix"; then
9738       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9739 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9740 echo "$as_me:$LINENO: checking for $ac_word" >&5
9741 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9742 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9743   echo $ECHO_N "(cached) $ECHO_C" >&6
9744 else
9745   if test -n "$NM_FOR_TARGET"; then
9746   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9747 else
9748 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9749 for as_dir in $PATH
9750 do
9751   IFS=$as_save_IFS
9752   test -z "$as_dir" && as_dir=.
9753   for ac_exec_ext in '' $ac_executable_extensions; do
9754   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9755     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9756     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9757     break 2
9758   fi
9759 done
9760 done
9761
9762 fi
9763 fi
9764 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9765 if test -n "$NM_FOR_TARGET"; then
9766   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9767 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9768 else
9769   echo "$as_me:$LINENO: result: no" >&5
9770 echo "${ECHO_T}no" >&6
9771 fi
9772
9773     fi
9774     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
9775       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9776 set dummy ${ncn_progname}; ac_word=$2
9777 echo "$as_me:$LINENO: checking for $ac_word" >&5
9778 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9779 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9780   echo $ECHO_N "(cached) $ECHO_C" >&6
9781 else
9782   if test -n "$NM_FOR_TARGET"; then
9783   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9784 else
9785 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9786 for as_dir in $PATH
9787 do
9788   IFS=$as_save_IFS
9789   test -z "$as_dir" && as_dir=.
9790   for ac_exec_ext in '' $ac_executable_extensions; do
9791   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9792     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9793     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9794     break 2
9795   fi
9796 done
9797 done
9798
9799 fi
9800 fi
9801 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9802 if test -n "$NM_FOR_TARGET"; then
9803   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9804 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9805 else
9806   echo "$as_me:$LINENO: result: no" >&5
9807 echo "${ECHO_T}no" >&6
9808 fi
9809
9810     fi
9811     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
9812   done
9813 fi
9814
9815 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
9816   set dummy nm
9817   if test $build = $target ; then
9818     NM_FOR_TARGET="$2"
9819   else
9820     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
9821   fi
9822 fi
9823
9824 else
9825   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9826 fi
9827
9828
9829
9830
9831 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
9832   if test -n "$with_build_time_tools"; then
9833     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
9834 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
9835     if test -x $with_build_time_tools/objdump; then
9836       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
9837       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9838       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
9839 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
9840     else
9841       echo "$as_me:$LINENO: result: no" >&5
9842 echo "${ECHO_T}no" >&6
9843     fi
9844   elif test $build != $host && test $have_gcc_for_target = yes; then
9845     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
9846     test $OBJDUMP_FOR_TARGET=objdump && OBJDUMP_FOR_TARGET=
9847     ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9848   fi
9849 fi
9850 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9851   # Extract the first word of "objdump", so it can be a program name with args.
9852 set dummy objdump; ac_word=$2
9853 echo "$as_me:$LINENO: checking for $ac_word" >&5
9854 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9855 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
9856   echo $ECHO_N "(cached) $ECHO_C" >&6
9857 else
9858   case $OBJDUMP_FOR_TARGET in
9859   [\\/]* | ?:[\\/]*)
9860   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
9861   ;;
9862   *)
9863   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9864 for as_dir in $gcc_cv_tool_dirs
9865 do
9866   IFS=$as_save_IFS
9867   test -z "$as_dir" && as_dir=.
9868   for ac_exec_ext in '' $ac_executable_extensions; do
9869   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9870     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9871     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9872     break 2
9873   fi
9874 done
9875 done
9876
9877   ;;
9878 esac
9879 fi
9880 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
9881
9882 if test -n "$OBJDUMP_FOR_TARGET"; then
9883   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
9884 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
9885 else
9886   echo "$as_me:$LINENO: result: no" >&5
9887 echo "${ECHO_T}no" >&6
9888 fi
9889
9890 fi
9891 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
9892
9893
9894 if test -n "$OBJDUMP_FOR_TARGET"; then
9895   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9896 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9897   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
9898 fi
9899
9900 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9901   for ncn_progname in objdump; do
9902     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9903 set dummy ${ncn_progname}; ac_word=$2
9904 echo "$as_me:$LINENO: checking for $ac_word" >&5
9905 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9906 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
9907   echo $ECHO_N "(cached) $ECHO_C" >&6
9908 else
9909   if test -n "$OBJDUMP_FOR_TARGET"; then
9910   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
9911 else
9912 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9913 for as_dir in $PATH
9914 do
9915   IFS=$as_save_IFS
9916   test -z "$as_dir" && as_dir=.
9917   for ac_exec_ext in '' $ac_executable_extensions; do
9918   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9919     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
9920     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9921     break 2
9922   fi
9923 done
9924 done
9925
9926 fi
9927 fi
9928 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
9929 if test -n "$OBJDUMP_FOR_TARGET"; then
9930   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
9931 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
9932 else
9933   echo "$as_me:$LINENO: result: no" >&5
9934 echo "${ECHO_T}no" >&6
9935 fi
9936
9937   done
9938 fi
9939
9940 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
9941   for ncn_progname in objdump; do
9942     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9943 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9944     if test -x $with_build_time_tools/${ncn_progname}; then
9945       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9946       echo "$as_me:$LINENO: result: yes" >&5
9947 echo "${ECHO_T}yes" >&6
9948       break
9949     else
9950       echo "$as_me:$LINENO: result: no" >&5
9951 echo "${ECHO_T}no" >&6
9952     fi
9953   done
9954 fi
9955
9956 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9957   for ncn_progname in objdump; do
9958     if test -n "$ncn_target_tool_prefix"; then
9959       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9960 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9961 echo "$as_me:$LINENO: checking for $ac_word" >&5
9962 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9963 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
9964   echo $ECHO_N "(cached) $ECHO_C" >&6
9965 else
9966   if test -n "$OBJDUMP_FOR_TARGET"; then
9967   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
9968 else
9969 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9970 for as_dir in $PATH
9971 do
9972   IFS=$as_save_IFS
9973   test -z "$as_dir" && as_dir=.
9974   for ac_exec_ext in '' $ac_executable_extensions; do
9975   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9976     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9977     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9978     break 2
9979   fi
9980 done
9981 done
9982
9983 fi
9984 fi
9985 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
9986 if test -n "$OBJDUMP_FOR_TARGET"; then
9987   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
9988 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
9989 else
9990   echo "$as_me:$LINENO: result: no" >&5
9991 echo "${ECHO_T}no" >&6
9992 fi
9993
9994     fi
9995     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
9996       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9997 set dummy ${ncn_progname}; ac_word=$2
9998 echo "$as_me:$LINENO: checking for $ac_word" >&5
9999 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10000 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10001   echo $ECHO_N "(cached) $ECHO_C" >&6
10002 else
10003   if test -n "$OBJDUMP_FOR_TARGET"; then
10004   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10005 else
10006 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10007 for as_dir in $PATH
10008 do
10009   IFS=$as_save_IFS
10010   test -z "$as_dir" && as_dir=.
10011   for ac_exec_ext in '' $ac_executable_extensions; do
10012   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10013     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10014     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10015     break 2
10016   fi
10017 done
10018 done
10019
10020 fi
10021 fi
10022 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10023 if test -n "$OBJDUMP_FOR_TARGET"; then
10024   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10025 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10026 else
10027   echo "$as_me:$LINENO: result: no" >&5
10028 echo "${ECHO_T}no" >&6
10029 fi
10030
10031     fi
10032     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10033   done
10034 fi
10035
10036 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10037   set dummy objdump
10038   if test $build = $target ; then
10039     OBJDUMP_FOR_TARGET="$2"
10040   else
10041     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10042   fi
10043 fi
10044
10045 else
10046   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10047 fi
10048
10049
10050
10051
10052 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10053   if test -n "$with_build_time_tools"; then
10054     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10055 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10056     if test -x $with_build_time_tools/ranlib; then
10057       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10058       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10059       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10060 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10061     else
10062       echo "$as_me:$LINENO: result: no" >&5
10063 echo "${ECHO_T}no" >&6
10064     fi
10065   elif test $build != $host && test $have_gcc_for_target = yes; then
10066     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10067     test $RANLIB_FOR_TARGET=ranlib && RANLIB_FOR_TARGET=
10068     ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10069   fi
10070 fi
10071 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10072   # Extract the first word of "ranlib", so it can be a program name with args.
10073 set dummy ranlib; ac_word=$2
10074 echo "$as_me:$LINENO: checking for $ac_word" >&5
10075 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10076 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10077   echo $ECHO_N "(cached) $ECHO_C" >&6
10078 else
10079   case $RANLIB_FOR_TARGET in
10080   [\\/]* | ?:[\\/]*)
10081   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10082   ;;
10083   *)
10084   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10085 for as_dir in $gcc_cv_tool_dirs
10086 do
10087   IFS=$as_save_IFS
10088   test -z "$as_dir" && as_dir=.
10089   for ac_exec_ext in '' $ac_executable_extensions; do
10090   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10091     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10092     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10093     break 2
10094   fi
10095 done
10096 done
10097
10098   ;;
10099 esac
10100 fi
10101 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10102
10103 if test -n "$RANLIB_FOR_TARGET"; then
10104   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10105 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10106 else
10107   echo "$as_me:$LINENO: result: no" >&5
10108 echo "${ECHO_T}no" >&6
10109 fi
10110
10111 fi
10112 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10113
10114
10115 if test -n "$RANLIB_FOR_TARGET"; then
10116   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10117 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10118   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10119 fi
10120
10121 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10122   for ncn_progname in ranlib; do
10123     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10124 set dummy ${ncn_progname}; ac_word=$2
10125 echo "$as_me:$LINENO: checking for $ac_word" >&5
10126 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10127 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10128   echo $ECHO_N "(cached) $ECHO_C" >&6
10129 else
10130   if test -n "$RANLIB_FOR_TARGET"; then
10131   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10132 else
10133 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10134 for as_dir in $PATH
10135 do
10136   IFS=$as_save_IFS
10137   test -z "$as_dir" && as_dir=.
10138   for ac_exec_ext in '' $ac_executable_extensions; do
10139   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10140     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10141     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10142     break 2
10143   fi
10144 done
10145 done
10146
10147 fi
10148 fi
10149 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10150 if test -n "$RANLIB_FOR_TARGET"; then
10151   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10152 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10153 else
10154   echo "$as_me:$LINENO: result: no" >&5
10155 echo "${ECHO_T}no" >&6
10156 fi
10157
10158   done
10159 fi
10160
10161 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10162   for ncn_progname in ranlib; do
10163     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10164 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10165     if test -x $with_build_time_tools/${ncn_progname}; then
10166       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10167       echo "$as_me:$LINENO: result: yes" >&5
10168 echo "${ECHO_T}yes" >&6
10169       break
10170     else
10171       echo "$as_me:$LINENO: result: no" >&5
10172 echo "${ECHO_T}no" >&6
10173     fi
10174   done
10175 fi
10176
10177 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10178   for ncn_progname in ranlib; do
10179     if test -n "$ncn_target_tool_prefix"; then
10180       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10181 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10182 echo "$as_me:$LINENO: checking for $ac_word" >&5
10183 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10184 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10185   echo $ECHO_N "(cached) $ECHO_C" >&6
10186 else
10187   if test -n "$RANLIB_FOR_TARGET"; then
10188   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10189 else
10190 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10191 for as_dir in $PATH
10192 do
10193   IFS=$as_save_IFS
10194   test -z "$as_dir" && as_dir=.
10195   for ac_exec_ext in '' $ac_executable_extensions; do
10196   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10197     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10198     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10199     break 2
10200   fi
10201 done
10202 done
10203
10204 fi
10205 fi
10206 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10207 if test -n "$RANLIB_FOR_TARGET"; then
10208   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10209 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10210 else
10211   echo "$as_me:$LINENO: result: no" >&5
10212 echo "${ECHO_T}no" >&6
10213 fi
10214
10215     fi
10216     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10217       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10218 set dummy ${ncn_progname}; ac_word=$2
10219 echo "$as_me:$LINENO: checking for $ac_word" >&5
10220 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10221 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10222   echo $ECHO_N "(cached) $ECHO_C" >&6
10223 else
10224   if test -n "$RANLIB_FOR_TARGET"; then
10225   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10226 else
10227 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10228 for as_dir in $PATH
10229 do
10230   IFS=$as_save_IFS
10231   test -z "$as_dir" && as_dir=.
10232   for ac_exec_ext in '' $ac_executable_extensions; do
10233   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10234     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10235     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10236     break 2
10237   fi
10238 done
10239 done
10240
10241 fi
10242 fi
10243 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10244 if test -n "$RANLIB_FOR_TARGET"; then
10245   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10246 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10247 else
10248   echo "$as_me:$LINENO: result: no" >&5
10249 echo "${ECHO_T}no" >&6
10250 fi
10251
10252     fi
10253     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10254   done
10255 fi
10256
10257 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10258   set dummy ranlib
10259   if test $build = $target ; then
10260     RANLIB_FOR_TARGET="$2"
10261   else
10262     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10263   fi
10264 fi
10265
10266 else
10267   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10268 fi
10269
10270
10271
10272
10273 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10274   if test -n "$with_build_time_tools"; then
10275     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10276 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10277     if test -x $with_build_time_tools/strip; then
10278       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10279       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10280       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10281 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10282     else
10283       echo "$as_me:$LINENO: result: no" >&5
10284 echo "${ECHO_T}no" >&6
10285     fi
10286   elif test $build != $host && test $have_gcc_for_target = yes; then
10287     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10288     test $STRIP_FOR_TARGET=strip && STRIP_FOR_TARGET=
10289     ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10290   fi
10291 fi
10292 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10293   # Extract the first word of "strip", so it can be a program name with args.
10294 set dummy strip; ac_word=$2
10295 echo "$as_me:$LINENO: checking for $ac_word" >&5
10296 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10297 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10298   echo $ECHO_N "(cached) $ECHO_C" >&6
10299 else
10300   case $STRIP_FOR_TARGET in
10301   [\\/]* | ?:[\\/]*)
10302   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10303   ;;
10304   *)
10305   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10306 for as_dir in $gcc_cv_tool_dirs
10307 do
10308   IFS=$as_save_IFS
10309   test -z "$as_dir" && as_dir=.
10310   for ac_exec_ext in '' $ac_executable_extensions; do
10311   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10312     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10313     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10314     break 2
10315   fi
10316 done
10317 done
10318
10319   ;;
10320 esac
10321 fi
10322 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10323
10324 if test -n "$STRIP_FOR_TARGET"; then
10325   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10326 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10327 else
10328   echo "$as_me:$LINENO: result: no" >&5
10329 echo "${ECHO_T}no" >&6
10330 fi
10331
10332 fi
10333 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10334
10335
10336 if test -n "$STRIP_FOR_TARGET"; then
10337   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10338 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10339   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10340 fi
10341
10342 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10343   for ncn_progname in strip; do
10344     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10345 set dummy ${ncn_progname}; ac_word=$2
10346 echo "$as_me:$LINENO: checking for $ac_word" >&5
10347 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10348 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10349   echo $ECHO_N "(cached) $ECHO_C" >&6
10350 else
10351   if test -n "$STRIP_FOR_TARGET"; then
10352   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10353 else
10354 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10355 for as_dir in $PATH
10356 do
10357   IFS=$as_save_IFS
10358   test -z "$as_dir" && as_dir=.
10359   for ac_exec_ext in '' $ac_executable_extensions; do
10360   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10361     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10362     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10363     break 2
10364   fi
10365 done
10366 done
10367
10368 fi
10369 fi
10370 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10371 if test -n "$STRIP_FOR_TARGET"; then
10372   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10373 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10374 else
10375   echo "$as_me:$LINENO: result: no" >&5
10376 echo "${ECHO_T}no" >&6
10377 fi
10378
10379   done
10380 fi
10381
10382 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10383   for ncn_progname in strip; do
10384     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10385 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10386     if test -x $with_build_time_tools/${ncn_progname}; then
10387       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10388       echo "$as_me:$LINENO: result: yes" >&5
10389 echo "${ECHO_T}yes" >&6
10390       break
10391     else
10392       echo "$as_me:$LINENO: result: no" >&5
10393 echo "${ECHO_T}no" >&6
10394     fi
10395   done
10396 fi
10397
10398 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10399   for ncn_progname in strip; do
10400     if test -n "$ncn_target_tool_prefix"; then
10401       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10402 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10403 echo "$as_me:$LINENO: checking for $ac_word" >&5
10404 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10405 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10406   echo $ECHO_N "(cached) $ECHO_C" >&6
10407 else
10408   if test -n "$STRIP_FOR_TARGET"; then
10409   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10410 else
10411 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10412 for as_dir in $PATH
10413 do
10414   IFS=$as_save_IFS
10415   test -z "$as_dir" && as_dir=.
10416   for ac_exec_ext in '' $ac_executable_extensions; do
10417   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10418     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10419     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10420     break 2
10421   fi
10422 done
10423 done
10424
10425 fi
10426 fi
10427 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10428 if test -n "$STRIP_FOR_TARGET"; then
10429   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10430 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10431 else
10432   echo "$as_me:$LINENO: result: no" >&5
10433 echo "${ECHO_T}no" >&6
10434 fi
10435
10436     fi
10437     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10438       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10439 set dummy ${ncn_progname}; ac_word=$2
10440 echo "$as_me:$LINENO: checking for $ac_word" >&5
10441 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10442 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10443   echo $ECHO_N "(cached) $ECHO_C" >&6
10444 else
10445   if test -n "$STRIP_FOR_TARGET"; then
10446   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10447 else
10448 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10449 for as_dir in $PATH
10450 do
10451   IFS=$as_save_IFS
10452   test -z "$as_dir" && as_dir=.
10453   for ac_exec_ext in '' $ac_executable_extensions; do
10454   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10455     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10456     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10457     break 2
10458   fi
10459 done
10460 done
10461
10462 fi
10463 fi
10464 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10465 if test -n "$STRIP_FOR_TARGET"; then
10466   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10467 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10468 else
10469   echo "$as_me:$LINENO: result: no" >&5
10470 echo "${ECHO_T}no" >&6
10471 fi
10472
10473     fi
10474     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10475   done
10476 fi
10477
10478 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10479   set dummy strip
10480   if test $build = $target ; then
10481     STRIP_FOR_TARGET="$2"
10482   else
10483     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10484   fi
10485 fi
10486
10487 else
10488   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10489 fi
10490
10491
10492
10493
10494 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10495   if test -n "$with_build_time_tools"; then
10496     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10497 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10498     if test -x $with_build_time_tools/windres; then
10499       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10500       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10501       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10502 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10503     else
10504       echo "$as_me:$LINENO: result: no" >&5
10505 echo "${ECHO_T}no" >&6
10506     fi
10507   elif test $build != $host && test $have_gcc_for_target = yes; then
10508     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10509     test $WINDRES_FOR_TARGET=windres && WINDRES_FOR_TARGET=
10510     ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10511   fi
10512 fi
10513 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10514   # Extract the first word of "windres", so it can be a program name with args.
10515 set dummy windres; ac_word=$2
10516 echo "$as_me:$LINENO: checking for $ac_word" >&5
10517 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10518 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10519   echo $ECHO_N "(cached) $ECHO_C" >&6
10520 else
10521   case $WINDRES_FOR_TARGET in
10522   [\\/]* | ?:[\\/]*)
10523   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10524   ;;
10525   *)
10526   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10527 for as_dir in $gcc_cv_tool_dirs
10528 do
10529   IFS=$as_save_IFS
10530   test -z "$as_dir" && as_dir=.
10531   for ac_exec_ext in '' $ac_executable_extensions; do
10532   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10533     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10534     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10535     break 2
10536   fi
10537 done
10538 done
10539
10540   ;;
10541 esac
10542 fi
10543 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10544
10545 if test -n "$WINDRES_FOR_TARGET"; then
10546   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10547 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10548 else
10549   echo "$as_me:$LINENO: result: no" >&5
10550 echo "${ECHO_T}no" >&6
10551 fi
10552
10553 fi
10554 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10555
10556
10557 if test -n "$WINDRES_FOR_TARGET"; then
10558   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10559 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10560   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10561 fi
10562
10563 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10564   for ncn_progname in windres; do
10565     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10566 set dummy ${ncn_progname}; ac_word=$2
10567 echo "$as_me:$LINENO: checking for $ac_word" >&5
10568 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10569 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10570   echo $ECHO_N "(cached) $ECHO_C" >&6
10571 else
10572   if test -n "$WINDRES_FOR_TARGET"; then
10573   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10574 else
10575 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10576 for as_dir in $PATH
10577 do
10578   IFS=$as_save_IFS
10579   test -z "$as_dir" && as_dir=.
10580   for ac_exec_ext in '' $ac_executable_extensions; do
10581   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10582     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10583     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10584     break 2
10585   fi
10586 done
10587 done
10588
10589 fi
10590 fi
10591 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10592 if test -n "$WINDRES_FOR_TARGET"; then
10593   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10594 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10595 else
10596   echo "$as_me:$LINENO: result: no" >&5
10597 echo "${ECHO_T}no" >&6
10598 fi
10599
10600   done
10601 fi
10602
10603 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10604   for ncn_progname in windres; do
10605     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10606 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10607     if test -x $with_build_time_tools/${ncn_progname}; then
10608       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10609       echo "$as_me:$LINENO: result: yes" >&5
10610 echo "${ECHO_T}yes" >&6
10611       break
10612     else
10613       echo "$as_me:$LINENO: result: no" >&5
10614 echo "${ECHO_T}no" >&6
10615     fi
10616   done
10617 fi
10618
10619 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10620   for ncn_progname in windres; do
10621     if test -n "$ncn_target_tool_prefix"; then
10622       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10623 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10624 echo "$as_me:$LINENO: checking for $ac_word" >&5
10625 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10626 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10627   echo $ECHO_N "(cached) $ECHO_C" >&6
10628 else
10629   if test -n "$WINDRES_FOR_TARGET"; then
10630   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10631 else
10632 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10633 for as_dir in $PATH
10634 do
10635   IFS=$as_save_IFS
10636   test -z "$as_dir" && as_dir=.
10637   for ac_exec_ext in '' $ac_executable_extensions; do
10638   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10639     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10640     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10641     break 2
10642   fi
10643 done
10644 done
10645
10646 fi
10647 fi
10648 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10649 if test -n "$WINDRES_FOR_TARGET"; then
10650   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10651 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10652 else
10653   echo "$as_me:$LINENO: result: no" >&5
10654 echo "${ECHO_T}no" >&6
10655 fi
10656
10657     fi
10658     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10659       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10660 set dummy ${ncn_progname}; ac_word=$2
10661 echo "$as_me:$LINENO: checking for $ac_word" >&5
10662 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10663 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10664   echo $ECHO_N "(cached) $ECHO_C" >&6
10665 else
10666   if test -n "$WINDRES_FOR_TARGET"; then
10667   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10668 else
10669 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10670 for as_dir in $PATH
10671 do
10672   IFS=$as_save_IFS
10673   test -z "$as_dir" && as_dir=.
10674   for ac_exec_ext in '' $ac_executable_extensions; do
10675   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10676     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10677     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10678     break 2
10679   fi
10680 done
10681 done
10682
10683 fi
10684 fi
10685 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10686 if test -n "$WINDRES_FOR_TARGET"; then
10687   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10688 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10689 else
10690   echo "$as_me:$LINENO: result: no" >&5
10691 echo "${ECHO_T}no" >&6
10692 fi
10693
10694     fi
10695     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10696   done
10697 fi
10698
10699 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10700   set dummy windres
10701   if test $build = $target ; then
10702     WINDRES_FOR_TARGET="$2"
10703   else
10704     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10705   fi
10706 fi
10707
10708 else
10709   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10710 fi
10711
10712
10713 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
10714
10715 echo "$as_me:$LINENO: checking where to find the target ar" >&5
10716 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
10717 if test "x${build}" != "x${host}" ; then
10718   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
10719     # We already found the complete path
10720     echo "$as_me:$LINENO: result: pre-installed in \`dirname $AR_FOR_TARGET\`" >&5
10721 echo "${ECHO_T}pre-installed in \`dirname $AR_FOR_TARGET\`" >&6
10722   else
10723     # Canadian cross, just use what we found
10724     echo "$as_me:$LINENO: result: pre-installed" >&5
10725 echo "${ECHO_T}pre-installed" >&6
10726   fi
10727 else
10728   ok=yes
10729   case " ${configdirs} " in
10730     *" binutils "*) ;;
10731     *) ok=no ;;
10732   esac
10733
10734   if test $ok = yes; then
10735     # An in-tree tool is available and we can use it
10736     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
10737     echo "$as_me:$LINENO: result: just compiled" >&5
10738 echo "${ECHO_T}just compiled" >&6
10739   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
10740     # We already found the complete path
10741     echo "$as_me:$LINENO: result: pre-installed in \`dirname $AR_FOR_TARGET\`" >&5
10742 echo "${ECHO_T}pre-installed in \`dirname $AR_FOR_TARGET\`" >&6
10743   elif test "x$target" = "x$host"; then
10744     # We can use an host tool
10745     AR_FOR_TARGET='$(AR)'
10746     echo "$as_me:$LINENO: result: host tool" >&5
10747 echo "${ECHO_T}host tool" >&6
10748   else
10749     # We need a cross tool
10750     echo "$as_me:$LINENO: result: pre-installed" >&5
10751 echo "${ECHO_T}pre-installed" >&6
10752   fi
10753 fi
10754
10755 echo "$as_me:$LINENO: checking where to find the target as" >&5
10756 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
10757 if test "x${build}" != "x${host}" ; then
10758   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
10759     # We already found the complete path
10760     echo "$as_me:$LINENO: result: pre-installed in \`dirname $AS_FOR_TARGET\`" >&5
10761 echo "${ECHO_T}pre-installed in \`dirname $AS_FOR_TARGET\`" >&6
10762   else
10763     # Canadian cross, just use what we found
10764     echo "$as_me:$LINENO: result: pre-installed" >&5
10765 echo "${ECHO_T}pre-installed" >&6
10766   fi
10767 else
10768   ok=yes
10769   case " ${configdirs} " in
10770     *" gas "*) ;;
10771     *) ok=no ;;
10772   esac
10773
10774   if test $ok = yes; then
10775     # An in-tree tool is available and we can use it
10776     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
10777     echo "$as_me:$LINENO: result: just compiled" >&5
10778 echo "${ECHO_T}just compiled" >&6
10779   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
10780     # We already found the complete path
10781     echo "$as_me:$LINENO: result: pre-installed in \`dirname $AS_FOR_TARGET\`" >&5
10782 echo "${ECHO_T}pre-installed in \`dirname $AS_FOR_TARGET\`" >&6
10783   elif test "x$target" = "x$host"; then
10784     # We can use an host tool
10785     AS_FOR_TARGET='$(AS)'
10786     echo "$as_me:$LINENO: result: host tool" >&5
10787 echo "${ECHO_T}host tool" >&6
10788   else
10789     # We need a cross tool
10790     echo "$as_me:$LINENO: result: pre-installed" >&5
10791 echo "${ECHO_T}pre-installed" >&6
10792   fi
10793 fi
10794
10795 echo "$as_me:$LINENO: checking where to find the target cc" >&5
10796 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
10797 if test "x${build}" != "x${host}" ; then
10798   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
10799     # We already found the complete path
10800     echo "$as_me:$LINENO: result: pre-installed in \`dirname $CC_FOR_TARGET\`" >&5
10801 echo "${ECHO_T}pre-installed in \`dirname $CC_FOR_TARGET\`" >&6
10802   else
10803     # Canadian cross, just use what we found
10804     echo "$as_me:$LINENO: result: pre-installed" >&5
10805 echo "${ECHO_T}pre-installed" >&6
10806   fi
10807 else
10808   ok=yes
10809   case " ${configdirs} " in
10810     *" gcc "*) ;;
10811     *) ok=no ;;
10812   esac
10813
10814   if test $ok = yes; then
10815     # An in-tree tool is available and we can use it
10816     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
10817     echo "$as_me:$LINENO: result: just compiled" >&5
10818 echo "${ECHO_T}just compiled" >&6
10819   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
10820     # We already found the complete path
10821     echo "$as_me:$LINENO: result: pre-installed in \`dirname $CC_FOR_TARGET\`" >&5
10822 echo "${ECHO_T}pre-installed in \`dirname $CC_FOR_TARGET\`" >&6
10823   elif test "x$target" = "x$host"; then
10824     # We can use an host tool
10825     CC_FOR_TARGET='$(CC)'
10826     echo "$as_me:$LINENO: result: host tool" >&5
10827 echo "${ECHO_T}host tool" >&6
10828   else
10829     # We need a cross tool
10830     echo "$as_me:$LINENO: result: pre-installed" >&5
10831 echo "${ECHO_T}pre-installed" >&6
10832   fi
10833 fi
10834
10835 echo "$as_me:$LINENO: checking where to find the target c++" >&5
10836 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
10837 if test "x${build}" != "x${host}" ; then
10838   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
10839     # We already found the complete path
10840     echo "$as_me:$LINENO: result: pre-installed in \`dirname $CXX_FOR_TARGET\`" >&5
10841 echo "${ECHO_T}pre-installed in \`dirname $CXX_FOR_TARGET\`" >&6
10842   else
10843     # Canadian cross, just use what we found
10844     echo "$as_me:$LINENO: result: pre-installed" >&5
10845 echo "${ECHO_T}pre-installed" >&6
10846   fi
10847 else
10848   ok=yes
10849   case " ${configdirs} " in
10850     *" gcc "*) ;;
10851     *) ok=no ;;
10852   esac
10853   case ,${enable_languages}, in
10854     *,c++,*) ;;
10855     *) ok=no ;;
10856   esac
10857   if test $ok = yes; then
10858     # An in-tree tool is available and we can use it
10859     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'
10860     echo "$as_me:$LINENO: result: just compiled" >&5
10861 echo "${ECHO_T}just compiled" >&6
10862   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
10863     # We already found the complete path
10864     echo "$as_me:$LINENO: result: pre-installed in \`dirname $CXX_FOR_TARGET\`" >&5
10865 echo "${ECHO_T}pre-installed in \`dirname $CXX_FOR_TARGET\`" >&6
10866   elif test "x$target" = "x$host"; then
10867     # We can use an host tool
10868     CXX_FOR_TARGET='$(CXX)'
10869     echo "$as_me:$LINENO: result: host tool" >&5
10870 echo "${ECHO_T}host tool" >&6
10871   else
10872     # We need a cross tool
10873     echo "$as_me:$LINENO: result: pre-installed" >&5
10874 echo "${ECHO_T}pre-installed" >&6
10875   fi
10876 fi
10877
10878 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
10879 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
10880 if test "x${build}" != "x${host}" ; then
10881   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
10882     # We already found the complete path
10883     echo "$as_me:$LINENO: result: pre-installed in \`dirname $RAW_CXX_FOR_TARGET\`" >&5
10884 echo "${ECHO_T}pre-installed in \`dirname $RAW_CXX_FOR_TARGET\`" >&6
10885   else
10886     # Canadian cross, just use what we found
10887     echo "$as_me:$LINENO: result: pre-installed" >&5
10888 echo "${ECHO_T}pre-installed" >&6
10889   fi
10890 else
10891   ok=yes
10892   case " ${configdirs} " in
10893     *" gcc "*) ;;
10894     *) ok=no ;;
10895   esac
10896   case ,${enable_languages}, in
10897     *,c++,*) ;;
10898     *) ok=no ;;
10899   esac
10900   if test $ok = yes; then
10901     # An in-tree tool is available and we can use it
10902     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'
10903     echo "$as_me:$LINENO: result: just compiled" >&5
10904 echo "${ECHO_T}just compiled" >&6
10905   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
10906     # We already found the complete path
10907     echo "$as_me:$LINENO: result: pre-installed in \`dirname $RAW_CXX_FOR_TARGET\`" >&5
10908 echo "${ECHO_T}pre-installed in \`dirname $RAW_CXX_FOR_TARGET\`" >&6
10909   elif test "x$target" = "x$host"; then
10910     # We can use an host tool
10911     RAW_CXX_FOR_TARGET='$(CXX)'
10912     echo "$as_me:$LINENO: result: host tool" >&5
10913 echo "${ECHO_T}host tool" >&6
10914   else
10915     # We need a cross tool
10916     echo "$as_me:$LINENO: result: pre-installed" >&5
10917 echo "${ECHO_T}pre-installed" >&6
10918   fi
10919 fi
10920
10921 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
10922 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
10923 if test "x${build}" != "x${host}" ; then
10924   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
10925     # We already found the complete path
10926     echo "$as_me:$LINENO: result: pre-installed in \`dirname $DLLTOOL_FOR_TARGET\`" >&5
10927 echo "${ECHO_T}pre-installed in \`dirname $DLLTOOL_FOR_TARGET\`" >&6
10928   else
10929     # Canadian cross, just use what we found
10930     echo "$as_me:$LINENO: result: pre-installed" >&5
10931 echo "${ECHO_T}pre-installed" >&6
10932   fi
10933 else
10934   ok=yes
10935   case " ${configdirs} " in
10936     *" binutils "*) ;;
10937     *) ok=no ;;
10938   esac
10939
10940   if test $ok = yes; then
10941     # An in-tree tool is available and we can use it
10942     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
10943     echo "$as_me:$LINENO: result: just compiled" >&5
10944 echo "${ECHO_T}just compiled" >&6
10945   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
10946     # We already found the complete path
10947     echo "$as_me:$LINENO: result: pre-installed in \`dirname $DLLTOOL_FOR_TARGET\`" >&5
10948 echo "${ECHO_T}pre-installed in \`dirname $DLLTOOL_FOR_TARGET\`" >&6
10949   elif test "x$target" = "x$host"; then
10950     # We can use an host tool
10951     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
10952     echo "$as_me:$LINENO: result: host tool" >&5
10953 echo "${ECHO_T}host tool" >&6
10954   else
10955     # We need a cross tool
10956     echo "$as_me:$LINENO: result: pre-installed" >&5
10957 echo "${ECHO_T}pre-installed" >&6
10958   fi
10959 fi
10960
10961 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
10962 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
10963 if test "x${build}" != "x${host}" ; then
10964   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
10965     # We already found the complete path
10966     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GCC_FOR_TARGET\`" >&5
10967 echo "${ECHO_T}pre-installed in \`dirname $GCC_FOR_TARGET\`" >&6
10968   else
10969     # Canadian cross, just use what we found
10970     echo "$as_me:$LINENO: result: pre-installed" >&5
10971 echo "${ECHO_T}pre-installed" >&6
10972   fi
10973 else
10974   ok=yes
10975   case " ${configdirs} " in
10976     *" gcc "*) ;;
10977     *) ok=no ;;
10978   esac
10979
10980   if test $ok = yes; then
10981     # An in-tree tool is available and we can use it
10982     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
10983     echo "$as_me:$LINENO: result: just compiled" >&5
10984 echo "${ECHO_T}just compiled" >&6
10985   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
10986     # We already found the complete path
10987     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GCC_FOR_TARGET\`" >&5
10988 echo "${ECHO_T}pre-installed in \`dirname $GCC_FOR_TARGET\`" >&6
10989   elif test "x$target" = "x$host"; then
10990     # We can use an host tool
10991     GCC_FOR_TARGET='$()'
10992     echo "$as_me:$LINENO: result: host tool" >&5
10993 echo "${ECHO_T}host tool" >&6
10994   else
10995     # We need a cross tool
10996     echo "$as_me:$LINENO: result: pre-installed" >&5
10997 echo "${ECHO_T}pre-installed" >&6
10998   fi
10999 fi
11000
11001 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11002 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11003 if test "x${build}" != "x${host}" ; then
11004   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11005     # We already found the complete path
11006     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GCJ_FOR_TARGET\`" >&5
11007 echo "${ECHO_T}pre-installed in \`dirname $GCJ_FOR_TARGET\`" >&6
11008   else
11009     # Canadian cross, just use what we found
11010     echo "$as_me:$LINENO: result: pre-installed" >&5
11011 echo "${ECHO_T}pre-installed" >&6
11012   fi
11013 else
11014   ok=yes
11015   case " ${configdirs} " in
11016     *" gcc "*) ;;
11017     *) ok=no ;;
11018   esac
11019   case ,${enable_languages}, in
11020     *,java,*) ;;
11021     *) ok=no ;;
11022   esac
11023   if test $ok = yes; then
11024     # An in-tree tool is available and we can use it
11025     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11026     echo "$as_me:$LINENO: result: just compiled" >&5
11027 echo "${ECHO_T}just compiled" >&6
11028   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11029     # We already found the complete path
11030     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GCJ_FOR_TARGET\`" >&5
11031 echo "${ECHO_T}pre-installed in \`dirname $GCJ_FOR_TARGET\`" >&6
11032   elif test "x$target" = "x$host"; then
11033     # We can use an host tool
11034     GCJ_FOR_TARGET='$(GCJ)'
11035     echo "$as_me:$LINENO: result: host tool" >&5
11036 echo "${ECHO_T}host tool" >&6
11037   else
11038     # We need a cross tool
11039     echo "$as_me:$LINENO: result: pre-installed" >&5
11040 echo "${ECHO_T}pre-installed" >&6
11041   fi
11042 fi
11043
11044 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11045 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11046 if test "x${build}" != "x${host}" ; then
11047   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11048     # We already found the complete path
11049     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GFORTRAN_FOR_TARGET\`" >&5
11050 echo "${ECHO_T}pre-installed in \`dirname $GFORTRAN_FOR_TARGET\`" >&6
11051   else
11052     # Canadian cross, just use what we found
11053     echo "$as_me:$LINENO: result: pre-installed" >&5
11054 echo "${ECHO_T}pre-installed" >&6
11055   fi
11056 else
11057   ok=yes
11058   case " ${configdirs} " in
11059     *" gcc "*) ;;
11060     *) ok=no ;;
11061   esac
11062   case ,${enable_languages}, in
11063     *,fortran,*) ;;
11064     *) ok=no ;;
11065   esac
11066   if test $ok = yes; then
11067     # An in-tree tool is available and we can use it
11068     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11069     echo "$as_me:$LINENO: result: just compiled" >&5
11070 echo "${ECHO_T}just compiled" >&6
11071   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11072     # We already found the complete path
11073     echo "$as_me:$LINENO: result: pre-installed in \`dirname $GFORTRAN_FOR_TARGET\`" >&5
11074 echo "${ECHO_T}pre-installed in \`dirname $GFORTRAN_FOR_TARGET\`" >&6
11075   elif test "x$target" = "x$host"; then
11076     # We can use an host tool
11077     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11078     echo "$as_me:$LINENO: result: host tool" >&5
11079 echo "${ECHO_T}host tool" >&6
11080   else
11081     # We need a cross tool
11082     echo "$as_me:$LINENO: result: pre-installed" >&5
11083 echo "${ECHO_T}pre-installed" >&6
11084   fi
11085 fi
11086
11087 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11088 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11089 if test "x${build}" != "x${host}" ; then
11090   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11091     # We already found the complete path
11092     echo "$as_me:$LINENO: result: pre-installed in \`dirname $LD_FOR_TARGET\`" >&5
11093 echo "${ECHO_T}pre-installed in \`dirname $LD_FOR_TARGET\`" >&6
11094   else
11095     # Canadian cross, just use what we found
11096     echo "$as_me:$LINENO: result: pre-installed" >&5
11097 echo "${ECHO_T}pre-installed" >&6
11098   fi
11099 else
11100   ok=yes
11101   case " ${configdirs} " in
11102     *" ld "*) ;;
11103     *) ok=no ;;
11104   esac
11105
11106   if test $ok = yes; then
11107     # An in-tree tool is available and we can use it
11108     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11109     echo "$as_me:$LINENO: result: just compiled" >&5
11110 echo "${ECHO_T}just compiled" >&6
11111   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11112     # We already found the complete path
11113     echo "$as_me:$LINENO: result: pre-installed in \`dirname $LD_FOR_TARGET\`" >&5
11114 echo "${ECHO_T}pre-installed in \`dirname $LD_FOR_TARGET\`" >&6
11115   elif test "x$target" = "x$host"; then
11116     # We can use an host tool
11117     LD_FOR_TARGET='$(LD)'
11118     echo "$as_me:$LINENO: result: host tool" >&5
11119 echo "${ECHO_T}host tool" >&6
11120   else
11121     # We need a cross tool
11122     echo "$as_me:$LINENO: result: pre-installed" >&5
11123 echo "${ECHO_T}pre-installed" >&6
11124   fi
11125 fi
11126
11127 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11128 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11129 if test "x${build}" != "x${host}" ; then
11130   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11131     # We already found the complete path
11132     echo "$as_me:$LINENO: result: pre-installed in \`dirname $LIPO_FOR_TARGET\`" >&5
11133 echo "${ECHO_T}pre-installed in \`dirname $LIPO_FOR_TARGET\`" >&6
11134   else
11135     # Canadian cross, just use what we found
11136     echo "$as_me:$LINENO: result: pre-installed" >&5
11137 echo "${ECHO_T}pre-installed" >&6
11138   fi
11139 else
11140   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11141     # We already found the complete path
11142     echo "$as_me:$LINENO: result: pre-installed in \`dirname $LIPO_FOR_TARGET\`" >&5
11143 echo "${ECHO_T}pre-installed in \`dirname $LIPO_FOR_TARGET\`" >&6
11144   elif test "x$target" = "x$host"; then
11145     # We can use an host tool
11146     LIPO_FOR_TARGET='$(LIPO)'
11147     echo "$as_me:$LINENO: result: host tool" >&5
11148 echo "${ECHO_T}host tool" >&6
11149   else
11150     # We need a cross tool
11151     echo "$as_me:$LINENO: result: pre-installed" >&5
11152 echo "${ECHO_T}pre-installed" >&6
11153   fi
11154 fi
11155
11156 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11157 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11158 if test "x${build}" != "x${host}" ; then
11159   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11160     # We already found the complete path
11161     echo "$as_me:$LINENO: result: pre-installed in \`dirname $NM_FOR_TARGET\`" >&5
11162 echo "${ECHO_T}pre-installed in \`dirname $NM_FOR_TARGET\`" >&6
11163   else
11164     # Canadian cross, just use what we found
11165     echo "$as_me:$LINENO: result: pre-installed" >&5
11166 echo "${ECHO_T}pre-installed" >&6
11167   fi
11168 else
11169   ok=yes
11170   case " ${configdirs} " in
11171     *" binutils "*) ;;
11172     *) ok=no ;;
11173   esac
11174
11175   if test $ok = yes; then
11176     # An in-tree tool is available and we can use it
11177     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11178     echo "$as_me:$LINENO: result: just compiled" >&5
11179 echo "${ECHO_T}just compiled" >&6
11180   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11181     # We already found the complete path
11182     echo "$as_me:$LINENO: result: pre-installed in \`dirname $NM_FOR_TARGET\`" >&5
11183 echo "${ECHO_T}pre-installed in \`dirname $NM_FOR_TARGET\`" >&6
11184   elif test "x$target" = "x$host"; then
11185     # We can use an host tool
11186     NM_FOR_TARGET='$(NM)'
11187     echo "$as_me:$LINENO: result: host tool" >&5
11188 echo "${ECHO_T}host tool" >&6
11189   else
11190     # We need a cross tool
11191     echo "$as_me:$LINENO: result: pre-installed" >&5
11192 echo "${ECHO_T}pre-installed" >&6
11193   fi
11194 fi
11195
11196 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11197 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11198 if test "x${build}" != "x${host}" ; then
11199   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11200     # We already found the complete path
11201     echo "$as_me:$LINENO: result: pre-installed in \`dirname $OBJDUMP_FOR_TARGET\`" >&5
11202 echo "${ECHO_T}pre-installed in \`dirname $OBJDUMP_FOR_TARGET\`" >&6
11203   else
11204     # Canadian cross, just use what we found
11205     echo "$as_me:$LINENO: result: pre-installed" >&5
11206 echo "${ECHO_T}pre-installed" >&6
11207   fi
11208 else
11209   ok=yes
11210   case " ${configdirs} " in
11211     *" binutils "*) ;;
11212     *) ok=no ;;
11213   esac
11214
11215   if test $ok = yes; then
11216     # An in-tree tool is available and we can use it
11217     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11218     echo "$as_me:$LINENO: result: just compiled" >&5
11219 echo "${ECHO_T}just compiled" >&6
11220   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11221     # We already found the complete path
11222     echo "$as_me:$LINENO: result: pre-installed in \`dirname $OBJDUMP_FOR_TARGET\`" >&5
11223 echo "${ECHO_T}pre-installed in \`dirname $OBJDUMP_FOR_TARGET\`" >&6
11224   elif test "x$target" = "x$host"; then
11225     # We can use an host tool
11226     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11227     echo "$as_me:$LINENO: result: host tool" >&5
11228 echo "${ECHO_T}host tool" >&6
11229   else
11230     # We need a cross tool
11231     echo "$as_me:$LINENO: result: pre-installed" >&5
11232 echo "${ECHO_T}pre-installed" >&6
11233   fi
11234 fi
11235
11236 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11237 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11238 if test "x${build}" != "x${host}" ; then
11239   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11240     # We already found the complete path
11241     echo "$as_me:$LINENO: result: pre-installed in \`dirname $RANLIB_FOR_TARGET\`" >&5
11242 echo "${ECHO_T}pre-installed in \`dirname $RANLIB_FOR_TARGET\`" >&6
11243   else
11244     # Canadian cross, just use what we found
11245     echo "$as_me:$LINENO: result: pre-installed" >&5
11246 echo "${ECHO_T}pre-installed" >&6
11247   fi
11248 else
11249   ok=yes
11250   case " ${configdirs} " in
11251     *" binutils "*) ;;
11252     *) ok=no ;;
11253   esac
11254
11255   if test $ok = yes; then
11256     # An in-tree tool is available and we can use it
11257     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11258     echo "$as_me:$LINENO: result: just compiled" >&5
11259 echo "${ECHO_T}just compiled" >&6
11260   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11261     # We already found the complete path
11262     echo "$as_me:$LINENO: result: pre-installed in \`dirname $RANLIB_FOR_TARGET\`" >&5
11263 echo "${ECHO_T}pre-installed in \`dirname $RANLIB_FOR_TARGET\`" >&6
11264   elif test "x$target" = "x$host"; then
11265     # We can use an host tool
11266     RANLIB_FOR_TARGET='$(RANLIB)'
11267     echo "$as_me:$LINENO: result: host tool" >&5
11268 echo "${ECHO_T}host tool" >&6
11269   else
11270     # We need a cross tool
11271     echo "$as_me:$LINENO: result: pre-installed" >&5
11272 echo "${ECHO_T}pre-installed" >&6
11273   fi
11274 fi
11275
11276 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11277 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11278 if test "x${build}" != "x${host}" ; then
11279   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11280     # We already found the complete path
11281     echo "$as_me:$LINENO: result: pre-installed in \`dirname $STRIP_FOR_TARGET\`" >&5
11282 echo "${ECHO_T}pre-installed in \`dirname $STRIP_FOR_TARGET\`" >&6
11283   else
11284     # Canadian cross, just use what we found
11285     echo "$as_me:$LINENO: result: pre-installed" >&5
11286 echo "${ECHO_T}pre-installed" >&6
11287   fi
11288 else
11289   ok=yes
11290   case " ${configdirs} " in
11291     *" binutils "*) ;;
11292     *) ok=no ;;
11293   esac
11294
11295   if test $ok = yes; then
11296     # An in-tree tool is available and we can use it
11297     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11298     echo "$as_me:$LINENO: result: just compiled" >&5
11299 echo "${ECHO_T}just compiled" >&6
11300   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11301     # We already found the complete path
11302     echo "$as_me:$LINENO: result: pre-installed in \`dirname $STRIP_FOR_TARGET\`" >&5
11303 echo "${ECHO_T}pre-installed in \`dirname $STRIP_FOR_TARGET\`" >&6
11304   elif test "x$target" = "x$host"; then
11305     # We can use an host tool
11306     STRIP_FOR_TARGET='$(STRIP)'
11307     echo "$as_me:$LINENO: result: host tool" >&5
11308 echo "${ECHO_T}host tool" >&6
11309   else
11310     # We need a cross tool
11311     echo "$as_me:$LINENO: result: pre-installed" >&5
11312 echo "${ECHO_T}pre-installed" >&6
11313   fi
11314 fi
11315
11316 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11317 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11318 if test "x${build}" != "x${host}" ; then
11319   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11320     # We already found the complete path
11321     echo "$as_me:$LINENO: result: pre-installed in \`dirname $WINDRES_FOR_TARGET\`" >&5
11322 echo "${ECHO_T}pre-installed in \`dirname $WINDRES_FOR_TARGET\`" >&6
11323   else
11324     # Canadian cross, just use what we found
11325     echo "$as_me:$LINENO: result: pre-installed" >&5
11326 echo "${ECHO_T}pre-installed" >&6
11327   fi
11328 else
11329   ok=yes
11330   case " ${configdirs} " in
11331     *" binutils "*) ;;
11332     *) ok=no ;;
11333   esac
11334
11335   if test $ok = yes; then
11336     # An in-tree tool is available and we can use it
11337     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11338     echo "$as_me:$LINENO: result: just compiled" >&5
11339 echo "${ECHO_T}just compiled" >&6
11340   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11341     # We already found the complete path
11342     echo "$as_me:$LINENO: result: pre-installed in \`dirname $WINDRES_FOR_TARGET\`" >&5
11343 echo "${ECHO_T}pre-installed in \`dirname $WINDRES_FOR_TARGET\`" >&6
11344   elif test "x$target" = "x$host"; then
11345     # We can use an host tool
11346     WINDRES_FOR_TARGET='$(WINDRES)'
11347     echo "$as_me:$LINENO: result: host tool" >&5
11348 echo "${ECHO_T}host tool" >&6
11349   else
11350     # We need a cross tool
11351     echo "$as_me:$LINENO: result: pre-installed" >&5
11352 echo "${ECHO_T}pre-installed" >&6
11353   fi
11354 fi
11355
11356
11357
11358
11359
11360 # Certain tools may need extra flags.
11361 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11362 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11363 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11364
11365 # When building target libraries, except in a Canadian cross, we use
11366 # the same toolchain as the compiler we just built.
11367 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11368 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11369 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11370 if test $host = $build; then
11371   case " $configdirs " in
11372     *" gcc "*)
11373       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11374       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11375       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11376       ;;
11377   esac
11378 fi
11379
11380
11381
11382
11383
11384 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11385 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11386 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11387 if test "${enable_maintainer_mode+set}" = set; then
11388   enableval="$enable_maintainer_mode"
11389   USE_MAINTAINER_MODE=$enableval
11390 else
11391   USE_MAINTAINER_MODE=no
11392 fi;
11393 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11394 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11395
11396
11397 if test "$USE_MAINTAINER_MODE" = yes; then
11398   MAINTAINER_MODE_TRUE=
11399   MAINTAINER_MODE_FALSE='#'
11400 else
11401   MAINTAINER_MODE_TRUE='#'
11402   MAINTAINER_MODE_FALSE=
11403 fi
11404 MAINT=$MAINTAINER_MODE_TRUE
11405
11406 # ---------------------
11407 # GCC bootstrap support
11408 # ---------------------
11409
11410 # Stage specific cflags for build.
11411 stage1_cflags="-g"
11412 case $build in
11413   vax-*-*)
11414     case ${GCC} in
11415       yes) stage1_cflags="-g -Wa,-J" ;;
11416       *) stage1_cflags="-g -J" ;;
11417     esac ;;
11418 esac
11419
11420 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
11421 if test "$GCC" = yes; then
11422   saved_CFLAGS="$CFLAGS"
11423
11424   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
11425   CFLAGS="$CFLAGS -fkeep-inline-functions"
11426   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
11427 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
11428   cat >conftest.$ac_ext <<_ACEOF
11429 /* confdefs.h.  */
11430 _ACEOF
11431 cat confdefs.h >>conftest.$ac_ext
11432 cat >>conftest.$ac_ext <<_ACEOF
11433 /* end confdefs.h.  */
11434
11435 int
11436 main ()
11437 {
11438
11439   ;
11440   return 0;
11441 }
11442 _ACEOF
11443 rm -f conftest.$ac_objext
11444 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11445   (eval $ac_compile) 2>conftest.er1
11446   ac_status=$?
11447   grep -v '^ *+' conftest.er1 >conftest.err
11448   rm -f conftest.er1
11449   cat conftest.err >&5
11450   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11451   (exit $ac_status); } &&
11452          { ac_try='test -z "$ac_c_werror_flag"
11453                          || test ! -s conftest.err'
11454   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11455   (eval $ac_try) 2>&5
11456   ac_status=$?
11457   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11458   (exit $ac_status); }; } &&
11459          { ac_try='test -s conftest.$ac_objext'
11460   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11461   (eval $ac_try) 2>&5
11462   ac_status=$?
11463   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11464   (exit $ac_status); }; }; then
11465   echo "$as_me:$LINENO: result: yes" >&5
11466 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
11467 else
11468   echo "$as_me: failed program was:" >&5
11469 sed 's/^/| /' conftest.$ac_ext >&5
11470
11471 echo "$as_me:$LINENO: result: no" >&5
11472 echo "${ECHO_T}no" >&6
11473 fi
11474 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11475
11476   CFLAGS="$saved_CFLAGS"
11477 fi
11478
11479
11480
11481 # Enable --enable-checking in stage1 of the compiler.
11482 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
11483 if test "${enable_stage1_checking+set}" = set; then
11484   enableval="$enable_stage1_checking"
11485   stage1_checking=--enable-checking=${enable_stage1_checking}
11486 else
11487   if test "x$enable_checking" = xno; then
11488   stage1_checking=--enable-checking
11489 else
11490   stage1_checking=--enable-checking${enable_checking+=}$enable_checking
11491 fi
11492 fi;
11493
11494
11495 # Enable -Werror in bootstrap stage2 and later.
11496 # Check whether --enable-werror or --disable-werror was given.
11497 if test "${enable_werror+set}" = set; then
11498   enableval="$enable_werror"
11499
11500 else
11501   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
11502   enable_werror=yes
11503 else
11504   enable_werror=no
11505 fi
11506 fi;
11507 case ${enable_werror} in
11508   yes) stage2_werror_flag="--enable-werror-always" ;;
11509   *) stage2_werror_flag="" ;;
11510 esac
11511
11512
11513 # Flags needed to enable html installing and building
11514
11515 # Check whether --with-datarootdir or --without-datarootdir was given.
11516 if test "${with_datarootdir+set}" = set; then
11517   withval="$with_datarootdir"
11518   datarootdir="\${prefix}/${withval}"
11519 else
11520   datarootdir="\${prefix}/share"
11521 fi;
11522
11523
11524 # Check whether --with-docdir or --without-docdir was given.
11525 if test "${with_docdir+set}" = set; then
11526   withval="$with_docdir"
11527   docdir="\${prefix}/${withval}"
11528 else
11529   docdir="\${datarootdir}/doc"
11530 fi;
11531
11532
11533 # Check whether --with-pdfdir or --without-pdfdir was given.
11534 if test "${with_pdfdir+set}" = set; then
11535   withval="$with_pdfdir"
11536   pdfdir="\${prefix}/${withval}"
11537 else
11538   pdfdir="\${docdir}"
11539 fi;
11540
11541
11542 # Check whether --with-htmldir or --without-htmldir was given.
11543 if test "${with_htmldir+set}" = set; then
11544   withval="$with_htmldir"
11545   htmldir="\${prefix}/${withval}"
11546 else
11547   htmldir="\${docdir}"
11548 fi;
11549
11550
11551
11552
11553
11554           ac_config_files="$ac_config_files Makefile"
11555 cat >confcache <<\_ACEOF
11556 # This file is a shell script that caches the results of configure
11557 # tests run on this system so they can be shared between configure
11558 # scripts and configure runs, see configure's option --config-cache.
11559 # It is not useful on other systems.  If it contains results you don't
11560 # want to keep, you may remove or edit it.
11561 #
11562 # config.status only pays attention to the cache file if you give it
11563 # the --recheck option to rerun configure.
11564 #
11565 # `ac_cv_env_foo' variables (set or unset) will be overridden when
11566 # loading this file, other *unset* `ac_cv_foo' will be assigned the
11567 # following values.
11568
11569 _ACEOF
11570
11571 # The following way of writing the cache mishandles newlines in values,
11572 # but we know of no workaround that is simple, portable, and efficient.
11573 # So, don't put newlines in cache variables' values.
11574 # Ultrix sh set writes to stderr and can't be redirected directly,
11575 # and sets the high bit in the cache file unless we assign to the vars.
11576 {
11577   (set) 2>&1 |
11578     case `(ac_space=' '; set | grep ac_space) 2>&1` in
11579     *ac_space=\ *)
11580       # `set' does not quote correctly, so add quotes (double-quote
11581       # substitution turns \\\\ into \\, and sed turns \\ into \).
11582       sed -n \
11583         "s/'/'\\\\''/g;
11584           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
11585       ;;
11586     *)
11587       # `set' quotes correctly as required by POSIX, so do not add quotes.
11588       sed -n \
11589         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
11590       ;;
11591     esac;
11592 } |
11593   sed '
11594      t clear
11595      : clear
11596      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
11597      t end
11598      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
11599      : end' >>confcache
11600 if diff $cache_file confcache >/dev/null 2>&1; then :; else
11601   if test -w $cache_file; then
11602     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
11603     cat confcache >$cache_file
11604   else
11605     echo "not updating unwritable cache $cache_file"
11606   fi
11607 fi
11608 rm -f confcache
11609
11610 test "x$prefix" = xNONE && prefix=$ac_default_prefix
11611 # Let make expand exec_prefix.
11612 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
11613
11614 # VPATH may cause trouble with some makes, so we remove $(srcdir),
11615 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
11616 # trailing colons and then remove the whole line if VPATH becomes empty
11617 # (actually we leave an empty line to preserve line numbers).
11618 if test "x$srcdir" = x.; then
11619   ac_vpsub='/^[  ]*VPATH[        ]*=/{
11620 s/:*\$(srcdir):*/:/;
11621 s/:*\${srcdir}:*/:/;
11622 s/:*@srcdir@:*/:/;
11623 s/^\([^=]*=[     ]*\):*/\1/;
11624 s/:*$//;
11625 s/^[^=]*=[       ]*$//;
11626 }'
11627 fi
11628
11629 # Transform confdefs.h into DEFS.
11630 # Protect against shell expansion while executing Makefile rules.
11631 # Protect against Makefile macro expansion.
11632 #
11633 # If the first sed substitution is executed (which looks for macros that
11634 # take arguments), then we branch to the quote section.  Otherwise,
11635 # look for a macro that doesn't take arguments.
11636 cat >confdef2opt.sed <<\_ACEOF
11637 t clear
11638 : clear
11639 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
11640 t quote
11641 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
11642 t quote
11643 d
11644 : quote
11645 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
11646 s,\[,\\&,g
11647 s,\],\\&,g
11648 s,\$,$$,g
11649 p
11650 _ACEOF
11651 # We use echo to avoid assuming a particular line-breaking character.
11652 # The extra dot is to prevent the shell from consuming trailing
11653 # line-breaks from the sub-command output.  A line-break within
11654 # single-quotes doesn't work because, if this script is created in a
11655 # platform that uses two characters for line-breaks (e.g., DOS), tr
11656 # would break.
11657 ac_LF_and_DOT=`echo; echo .`
11658 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
11659 rm -f confdef2opt.sed
11660
11661
11662 ac_libobjs=
11663 ac_ltlibobjs=
11664 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
11665   # 1. Remove the extension, and $U if already installed.
11666   ac_i=`echo "$ac_i" |
11667          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
11668   # 2. Add them.
11669   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
11670   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
11671 done
11672 LIBOBJS=$ac_libobjs
11673
11674 LTLIBOBJS=$ac_ltlibobjs
11675
11676
11677
11678 : ${CONFIG_STATUS=./config.status}
11679 ac_clean_files_save=$ac_clean_files
11680 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
11681 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
11682 echo "$as_me: creating $CONFIG_STATUS" >&6;}
11683 cat >$CONFIG_STATUS <<_ACEOF
11684 #! $SHELL
11685 # Generated by $as_me.
11686 # Run this file to recreate the current configuration.
11687 # Compiler output produced by configure, useful for debugging
11688 # configure, is in config.log if it exists.
11689
11690 debug=false
11691 ac_cs_recheck=false
11692 ac_cs_silent=false
11693 SHELL=\${CONFIG_SHELL-$SHELL}
11694 _ACEOF
11695
11696 cat >>$CONFIG_STATUS <<\_ACEOF
11697 ## --------------------- ##
11698 ## M4sh Initialization.  ##
11699 ## --------------------- ##
11700
11701 # Be Bourne compatible
11702 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
11703   emulate sh
11704   NULLCMD=:
11705   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
11706   # is contrary to our usage.  Disable this feature.
11707   alias -g '${1+"$@"}'='"$@"'
11708 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
11709   set -o posix
11710 fi
11711 DUALCASE=1; export DUALCASE # for MKS sh
11712
11713 # Support unset when possible.
11714 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
11715   as_unset=unset
11716 else
11717   as_unset=false
11718 fi
11719
11720
11721 # Work around bugs in pre-3.0 UWIN ksh.
11722 $as_unset ENV MAIL MAILPATH
11723 PS1='$ '
11724 PS2='> '
11725 PS4='+ '
11726
11727 # NLS nuisances.
11728 for as_var in \
11729   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
11730   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
11731   LC_TELEPHONE LC_TIME
11732 do
11733   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
11734     eval $as_var=C; export $as_var
11735   else
11736     $as_unset $as_var
11737   fi
11738 done
11739
11740 # Required to use basename.
11741 if expr a : '\(a\)' >/dev/null 2>&1; then
11742   as_expr=expr
11743 else
11744   as_expr=false
11745 fi
11746
11747 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
11748   as_basename=basename
11749 else
11750   as_basename=false
11751 fi
11752
11753
11754 # Name of the executable.
11755 as_me=`$as_basename "$0" ||
11756 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
11757          X"$0" : 'X\(//\)$' \| \
11758          X"$0" : 'X\(/\)$' \| \
11759          .     : '\(.\)' 2>/dev/null ||
11760 echo X/"$0" |
11761     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
11762           /^X\/\(\/\/\)$/{ s//\1/; q; }
11763           /^X\/\(\/\).*/{ s//\1/; q; }
11764           s/.*/./; q'`
11765
11766
11767 # PATH needs CR, and LINENO needs CR and PATH.
11768 # Avoid depending upon Character Ranges.
11769 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
11770 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
11771 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
11772 as_cr_digits='0123456789'
11773 as_cr_alnum=$as_cr_Letters$as_cr_digits
11774
11775 # The user is always right.
11776 if test "${PATH_SEPARATOR+set}" != set; then
11777   echo "#! /bin/sh" >conf$$.sh
11778   echo  "exit 0"   >>conf$$.sh
11779   chmod +x conf$$.sh
11780   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
11781     PATH_SEPARATOR=';'
11782   else
11783     PATH_SEPARATOR=:
11784   fi
11785   rm -f conf$$.sh
11786 fi
11787
11788
11789   as_lineno_1=$LINENO
11790   as_lineno_2=$LINENO
11791   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
11792   test "x$as_lineno_1" != "x$as_lineno_2" &&
11793   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
11794   # Find who we are.  Look in the path if we contain no path at all
11795   # relative or not.
11796   case $0 in
11797     *[\\/]* ) as_myself=$0 ;;
11798     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11799 for as_dir in $PATH
11800 do
11801   IFS=$as_save_IFS
11802   test -z "$as_dir" && as_dir=.
11803   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
11804 done
11805
11806        ;;
11807   esac
11808   # We did not find ourselves, most probably we were run as `sh COMMAND'
11809   # in which case we are not to be found in the path.
11810   if test "x$as_myself" = x; then
11811     as_myself=$0
11812   fi
11813   if test ! -f "$as_myself"; then
11814     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
11815 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
11816    { (exit 1); exit 1; }; }
11817   fi
11818   case $CONFIG_SHELL in
11819   '')
11820     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11821 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
11822 do
11823   IFS=$as_save_IFS
11824   test -z "$as_dir" && as_dir=.
11825   for as_base in sh bash ksh sh5; do
11826          case $as_dir in
11827          /*)
11828            if ("$as_dir/$as_base" -c '
11829   as_lineno_1=$LINENO
11830   as_lineno_2=$LINENO
11831   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
11832   test "x$as_lineno_1" != "x$as_lineno_2" &&
11833   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
11834              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
11835              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
11836              CONFIG_SHELL=$as_dir/$as_base
11837              export CONFIG_SHELL
11838              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
11839            fi;;
11840          esac
11841        done
11842 done
11843 ;;
11844   esac
11845
11846   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
11847   # uniformly replaced by the line number.  The first 'sed' inserts a
11848   # line-number line before each line; the second 'sed' does the real
11849   # work.  The second script uses 'N' to pair each line-number line
11850   # with the numbered line, and appends trailing '-' during
11851   # substitution so that $LINENO is not a special case at line end.
11852   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
11853   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
11854   sed '=' <$as_myself |
11855     sed '
11856       N
11857       s,$,-,
11858       : loop
11859       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
11860       t loop
11861       s,-$,,
11862       s,^['$as_cr_digits']*\n,,
11863     ' >$as_me.lineno &&
11864   chmod +x $as_me.lineno ||
11865     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
11866 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
11867    { (exit 1); exit 1; }; }
11868
11869   # Don't try to exec as it changes $[0], causing all sort of problems
11870   # (the dirname of $[0] is not the place where we might find the
11871   # original and so on.  Autoconf is especially sensible to this).
11872   . ./$as_me.lineno
11873   # Exit status is that of the last command.
11874   exit
11875 }
11876
11877
11878 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
11879   *c*,-n*) ECHO_N= ECHO_C='
11880 ' ECHO_T='      ' ;;
11881   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
11882   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
11883 esac
11884
11885 if expr a : '\(a\)' >/dev/null 2>&1; then
11886   as_expr=expr
11887 else
11888   as_expr=false
11889 fi
11890
11891 rm -f conf$$ conf$$.exe conf$$.file
11892 echo >conf$$.file
11893 if ln -s conf$$.file conf$$ 2>/dev/null; then
11894   # We could just check for DJGPP; but this test a) works b) is more generic
11895   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
11896   if test -f conf$$.exe; then
11897     # Don't use ln at all; we don't have any links
11898     as_ln_s='cp -p'
11899   else
11900     as_ln_s='ln -s'
11901   fi
11902 elif ln conf$$.file conf$$ 2>/dev/null; then
11903   as_ln_s=ln
11904 else
11905   as_ln_s='cp -p'
11906 fi
11907 rm -f conf$$ conf$$.exe conf$$.file
11908
11909 if mkdir -p . 2>/dev/null; then
11910   as_mkdir_p=:
11911 else
11912   test -d ./-p && rmdir ./-p
11913   as_mkdir_p=false
11914 fi
11915
11916 as_executable_p="test -f"
11917
11918 # Sed expression to map a string onto a valid CPP name.
11919 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
11920
11921 # Sed expression to map a string onto a valid variable name.
11922 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
11923
11924
11925 # IFS
11926 # We need space, tab and new line, in precisely that order.
11927 as_nl='
11928 '
11929 IFS="   $as_nl"
11930
11931 # CDPATH.
11932 $as_unset CDPATH
11933
11934 exec 6>&1
11935
11936 # Open the log real soon, to keep \$[0] and so on meaningful, and to
11937 # report actual input values of CONFIG_FILES etc. instead of their
11938 # values after options handling.  Logging --version etc. is OK.
11939 exec 5>>config.log
11940 {
11941   echo
11942   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
11943 ## Running $as_me. ##
11944 _ASBOX
11945 } >&5
11946 cat >&5 <<_CSEOF
11947
11948 This file was extended by $as_me, which was
11949 generated by GNU Autoconf 2.59.  Invocation command line was
11950
11951   CONFIG_FILES    = $CONFIG_FILES
11952   CONFIG_HEADERS  = $CONFIG_HEADERS
11953   CONFIG_LINKS    = $CONFIG_LINKS
11954   CONFIG_COMMANDS = $CONFIG_COMMANDS
11955   $ $0 $@
11956
11957 _CSEOF
11958 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
11959 echo >&5
11960 _ACEOF
11961
11962 # Files that config.status was made for.
11963 if test -n "$ac_config_files"; then
11964   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
11965 fi
11966
11967 if test -n "$ac_config_headers"; then
11968   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
11969 fi
11970
11971 if test -n "$ac_config_links"; then
11972   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
11973 fi
11974
11975 if test -n "$ac_config_commands"; then
11976   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
11977 fi
11978
11979 cat >>$CONFIG_STATUS <<\_ACEOF
11980
11981 ac_cs_usage="\
11982 \`$as_me' instantiates files from templates according to the
11983 current configuration.
11984
11985 Usage: $0 [OPTIONS] [FILE]...
11986
11987   -h, --help       print this help, then exit
11988   -V, --version    print version number, then exit
11989   -q, --quiet      do not print progress messages
11990   -d, --debug      don't remove temporary files
11991       --recheck    update $as_me by reconfiguring in the same conditions
11992   --file=FILE[:TEMPLATE]
11993                    instantiate the configuration file FILE
11994
11995 Configuration files:
11996 $config_files
11997
11998 Report bugs to <bug-autoconf@gnu.org>."
11999 _ACEOF
12000
12001 cat >>$CONFIG_STATUS <<_ACEOF
12002 ac_cs_version="\\
12003 config.status
12004 configured by $0, generated by GNU Autoconf 2.59,
12005   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12006
12007 Copyright (C) 2003 Free Software Foundation, Inc.
12008 This config.status script is free software; the Free Software Foundation
12009 gives unlimited permission to copy, distribute and modify it."
12010 srcdir=$srcdir
12011 INSTALL="$INSTALL"
12012 _ACEOF
12013
12014 cat >>$CONFIG_STATUS <<\_ACEOF
12015 # If no file are specified by the user, then we need to provide default
12016 # value.  By we need to know if files were specified by the user.
12017 ac_need_defaults=:
12018 while test $# != 0
12019 do
12020   case $1 in
12021   --*=*)
12022     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12023     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12024     ac_shift=:
12025     ;;
12026   -*)
12027     ac_option=$1
12028     ac_optarg=$2
12029     ac_shift=shift
12030     ;;
12031   *) # This is not an option, so the user has probably given explicit
12032      # arguments.
12033      ac_option=$1
12034      ac_need_defaults=false;;
12035   esac
12036
12037   case $ac_option in
12038   # Handling of the options.
12039 _ACEOF
12040 cat >>$CONFIG_STATUS <<\_ACEOF
12041   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12042     ac_cs_recheck=: ;;
12043   --version | --vers* | -V )
12044     echo "$ac_cs_version"; exit 0 ;;
12045   --he | --h)
12046     # Conflict between --help and --header
12047     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12048 Try \`$0 --help' for more information." >&5
12049 echo "$as_me: error: ambiguous option: $1
12050 Try \`$0 --help' for more information." >&2;}
12051    { (exit 1); exit 1; }; };;
12052   --help | --hel | -h )
12053     echo "$ac_cs_usage"; exit 0 ;;
12054   --debug | --d* | -d )
12055     debug=: ;;
12056   --file | --fil | --fi | --f )
12057     $ac_shift
12058     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12059     ac_need_defaults=false;;
12060   --header | --heade | --head | --hea )
12061     $ac_shift
12062     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12063     ac_need_defaults=false;;
12064   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12065   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12066     ac_cs_silent=: ;;
12067
12068   # This is an error.
12069   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12070 Try \`$0 --help' for more information." >&5
12071 echo "$as_me: error: unrecognized option: $1
12072 Try \`$0 --help' for more information." >&2;}
12073    { (exit 1); exit 1; }; } ;;
12074
12075   *) ac_config_targets="$ac_config_targets $1" ;;
12076
12077   esac
12078   shift
12079 done
12080
12081 ac_configure_extra_args=
12082
12083 if $ac_cs_silent; then
12084   exec 6>/dev/null
12085   ac_configure_extra_args="$ac_configure_extra_args --silent"
12086 fi
12087
12088 _ACEOF
12089 cat >>$CONFIG_STATUS <<_ACEOF
12090 if \$ac_cs_recheck; then
12091   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12092   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12093 fi
12094
12095 _ACEOF
12096
12097
12098
12099
12100
12101 cat >>$CONFIG_STATUS <<\_ACEOF
12102 for ac_config_target in $ac_config_targets
12103 do
12104   case "$ac_config_target" in
12105   # Handling of arguments.
12106   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12107   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12108 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12109    { (exit 1); exit 1; }; };;
12110   esac
12111 done
12112
12113 # If the user did not use the arguments to specify the items to instantiate,
12114 # then the envvar interface is used.  Set only those that are not.
12115 # We use the long form for the default assignment because of an extremely
12116 # bizarre bug on SunOS 4.1.3.
12117 if $ac_need_defaults; then
12118   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12119 fi
12120
12121 # Have a temporary directory for convenience.  Make it in the build tree
12122 # simply because there is no reason to put it here, and in addition,
12123 # creating and moving files from /tmp can sometimes cause problems.
12124 # Create a temporary directory, and hook for its removal unless debugging.
12125 $debug ||
12126 {
12127   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12128   trap '{ (exit 1); exit 1; }' 1 2 13 15
12129 }
12130
12131 # Create a (secure) tmp directory for tmp files.
12132
12133 {
12134   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12135   test -n "$tmp" && test -d "$tmp"
12136 }  ||
12137 {
12138   tmp=./confstat$$-$RANDOM
12139   (umask 077 && mkdir $tmp)
12140 } ||
12141 {
12142    echo "$me: cannot create a temporary directory in ." >&2
12143    { (exit 1); exit 1; }
12144 }
12145
12146 _ACEOF
12147
12148 cat >>$CONFIG_STATUS <<_ACEOF
12149
12150 #
12151 # CONFIG_FILES section.
12152 #
12153
12154 # No need to generate the scripts if there are no CONFIG_FILES.
12155 # This happens for instance when ./config.status config.h
12156 if test -n "\$CONFIG_FILES"; then
12157   # Protect against being on the right side of a sed subst in config.status.
12158   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12159    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12160 s,@SHELL@,$SHELL,;t t
12161 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12162 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12163 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12164 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12165 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12166 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12167 s,@exec_prefix@,$exec_prefix,;t t
12168 s,@prefix@,$prefix,;t t
12169 s,@program_transform_name@,$program_transform_name,;t t
12170 s,@bindir@,$bindir,;t t
12171 s,@sbindir@,$sbindir,;t t
12172 s,@libexecdir@,$libexecdir,;t t
12173 s,@datadir@,$datadir,;t t
12174 s,@sysconfdir@,$sysconfdir,;t t
12175 s,@sharedstatedir@,$sharedstatedir,;t t
12176 s,@localstatedir@,$localstatedir,;t t
12177 s,@libdir@,$libdir,;t t
12178 s,@includedir@,$includedir,;t t
12179 s,@oldincludedir@,$oldincludedir,;t t
12180 s,@infodir@,$infodir,;t t
12181 s,@mandir@,$mandir,;t t
12182 s,@build_alias@,$build_alias,;t t
12183 s,@host_alias@,$host_alias,;t t
12184 s,@target_alias@,$target_alias,;t t
12185 s,@DEFS@,$DEFS,;t t
12186 s,@ECHO_C@,$ECHO_C,;t t
12187 s,@ECHO_N@,$ECHO_N,;t t
12188 s,@ECHO_T@,$ECHO_T,;t t
12189 s,@LIBS@,$LIBS,;t t
12190 s,@build@,$build,;t t
12191 s,@build_cpu@,$build_cpu,;t t
12192 s,@build_vendor@,$build_vendor,;t t
12193 s,@build_os@,$build_os,;t t
12194 s,@build_noncanonical@,$build_noncanonical,;t t
12195 s,@host_noncanonical@,$host_noncanonical,;t t
12196 s,@target_noncanonical@,$target_noncanonical,;t t
12197 s,@host@,$host,;t t
12198 s,@host_cpu@,$host_cpu,;t t
12199 s,@host_vendor@,$host_vendor,;t t
12200 s,@host_os@,$host_os,;t t
12201 s,@target@,$target,;t t
12202 s,@target_cpu@,$target_cpu,;t t
12203 s,@target_vendor@,$target_vendor,;t t
12204 s,@target_os@,$target_os,;t t
12205 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12206 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12207 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12208 s,@LN@,$LN,;t t
12209 s,@LN_S@,$LN_S,;t t
12210 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12211 s,@build_libsubdir@,$build_libsubdir,;t t
12212 s,@build_subdir@,$build_subdir,;t t
12213 s,@host_subdir@,$host_subdir,;t t
12214 s,@target_subdir@,$target_subdir,;t t
12215 s,@CC@,$CC,;t t
12216 s,@CFLAGS@,$CFLAGS,;t t
12217 s,@LDFLAGS@,$LDFLAGS,;t t
12218 s,@CPPFLAGS@,$CPPFLAGS,;t t
12219 s,@ac_ct_CC@,$ac_ct_CC,;t t
12220 s,@EXEEXT@,$EXEEXT,;t t
12221 s,@OBJEXT@,$OBJEXT,;t t
12222 s,@CXX@,$CXX,;t t
12223 s,@CXXFLAGS@,$CXXFLAGS,;t t
12224 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12225 s,@GNATBIND@,$GNATBIND,;t t
12226 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12227 s,@GNATMAKE@,$GNATMAKE,;t t
12228 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12229 s,@do_compare@,$do_compare,;t t
12230 s,@gmplibs@,$gmplibs,;t t
12231 s,@gmpinc@,$gmpinc,;t t
12232 s,@stage1_languages@,$stage1_languages,;t t
12233 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12234 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12235 s,@tooldir@,$tooldir,;t t
12236 s,@build_tooldir@,$build_tooldir,;t t
12237 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12238 s,@GDB_TK@,$GDB_TK,;t t
12239 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12240 s,@build_configargs@,$build_configargs,;t t
12241 s,@build_configdirs@,$build_configdirs,;t t
12242 s,@host_configargs@,$host_configargs,;t t
12243 s,@configdirs@,$configdirs,;t t
12244 s,@target_configargs@,$target_configargs,;t t
12245 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12246 s,@config_shell@,$config_shell,;t t
12247 s,@YACC@,$YACC,;t t
12248 s,@BISON@,$BISON,;t t
12249 s,@M4@,$M4,;t t
12250 s,@LEX@,$LEX,;t t
12251 s,@FLEX@,$FLEX,;t t
12252 s,@MAKEINFO@,$MAKEINFO,;t t
12253 s,@EXPECT@,$EXPECT,;t t
12254 s,@RUNTEST@,$RUNTEST,;t t
12255 s,@AR@,$AR,;t t
12256 s,@AS@,$AS,;t t
12257 s,@DLLTOOL@,$DLLTOOL,;t t
12258 s,@LD@,$LD,;t t
12259 s,@LIPO@,$LIPO,;t t
12260 s,@NM@,$NM,;t t
12261 s,@RANLIB@,$RANLIB,;t t
12262 s,@STRIP@,$STRIP,;t t
12263 s,@WINDRES@,$WINDRES,;t t
12264 s,@OBJCOPY@,$OBJCOPY,;t t
12265 s,@OBJDUMP@,$OBJDUMP,;t t
12266 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12267 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12268 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12269 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12270 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12271 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12272 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12273 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12274 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12275 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12276 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12277 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12278 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12279 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12280 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12281 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12282 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12283 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12284 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12285 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12286 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12287 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12288 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12289 s,@MAINT@,$MAINT,;t t
12290 s,@stage1_cflags@,$stage1_cflags,;t t
12291 s,@stage1_checking@,$stage1_checking,;t t
12292 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12293 s,@datarootdir@,$datarootdir,;t t
12294 s,@docdir@,$docdir,;t t
12295 s,@pdfdir@,$pdfdir,;t t
12296 s,@htmldir@,$htmldir,;t t
12297 s,@LIBOBJS@,$LIBOBJS,;t t
12298 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12299 /@serialization_dependencies@/r $serialization_dependencies
12300 s,@serialization_dependencies@,,;t t
12301 /@host_makefile_frag@/r $host_makefile_frag
12302 s,@host_makefile_frag@,,;t t
12303 /@target_makefile_frag@/r $target_makefile_frag
12304 s,@target_makefile_frag@,,;t t
12305 /@alphaieee_frag@/r $alphaieee_frag
12306 s,@alphaieee_frag@,,;t t
12307 /@ospace_frag@/r $ospace_frag
12308 s,@ospace_frag@,,;t t
12309 CEOF
12310
12311 _ACEOF
12312
12313   cat >>$CONFIG_STATUS <<\_ACEOF
12314   # Split the substitutions into bite-sized pieces for seds with
12315   # small command number limits, like on Digital OSF/1 and HP-UX.
12316   ac_max_sed_lines=48
12317   ac_sed_frag=1 # Number of current file.
12318   ac_beg=1 # First line for current file.
12319   ac_end=$ac_max_sed_lines # Line after last line for current file.
12320   ac_more_lines=:
12321   ac_sed_cmds=
12322   while $ac_more_lines; do
12323     if test $ac_beg -gt 1; then
12324       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12325     else
12326       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12327     fi
12328     if test ! -s $tmp/subs.frag; then
12329       ac_more_lines=false
12330     else
12331       # The purpose of the label and of the branching condition is to
12332       # speed up the sed processing (if there are no `@' at all, there
12333       # is no need to browse any of the substitutions).
12334       # These are the two extra sed commands mentioned above.
12335       (echo ':t
12336   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12337       if test -z "$ac_sed_cmds"; then
12338         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12339       else
12340         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12341       fi
12342       ac_sed_frag=`expr $ac_sed_frag + 1`
12343       ac_beg=$ac_end
12344       ac_end=`expr $ac_end + $ac_max_sed_lines`
12345     fi
12346   done
12347   if test -z "$ac_sed_cmds"; then
12348     ac_sed_cmds=cat
12349   fi
12350 fi # test -n "$CONFIG_FILES"
12351
12352 _ACEOF
12353 cat >>$CONFIG_STATUS <<\_ACEOF
12354 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12355   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12356   case $ac_file in
12357   - | *:- | *:-:* ) # input from stdin
12358         cat >$tmp/stdin
12359         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12360         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12361   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12362         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12363   * )   ac_file_in=$ac_file.in ;;
12364   esac
12365
12366   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12367   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12368 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12369          X"$ac_file" : 'X\(//\)[^/]' \| \
12370          X"$ac_file" : 'X\(//\)$' \| \
12371          X"$ac_file" : 'X\(/\)' \| \
12372          .     : '\(.\)' 2>/dev/null ||
12373 echo X"$ac_file" |
12374     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12375           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12376           /^X\(\/\/\)$/{ s//\1/; q; }
12377           /^X\(\/\).*/{ s//\1/; q; }
12378           s/.*/./; q'`
12379   { if $as_mkdir_p; then
12380     mkdir -p "$ac_dir"
12381   else
12382     as_dir="$ac_dir"
12383     as_dirs=
12384     while test ! -d "$as_dir"; do
12385       as_dirs="$as_dir $as_dirs"
12386       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12387 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12388          X"$as_dir" : 'X\(//\)[^/]' \| \
12389          X"$as_dir" : 'X\(//\)$' \| \
12390          X"$as_dir" : 'X\(/\)' \| \
12391          .     : '\(.\)' 2>/dev/null ||
12392 echo X"$as_dir" |
12393     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12394           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12395           /^X\(\/\/\)$/{ s//\1/; q; }
12396           /^X\(\/\).*/{ s//\1/; q; }
12397           s/.*/./; q'`
12398     done
12399     test ! -n "$as_dirs" || mkdir $as_dirs
12400   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
12401 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
12402    { (exit 1); exit 1; }; }; }
12403
12404   ac_builddir=.
12405
12406 if test "$ac_dir" != .; then
12407   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
12408   # A "../" for each directory in $ac_dir_suffix.
12409   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
12410 else
12411   ac_dir_suffix= ac_top_builddir=
12412 fi
12413
12414 case $srcdir in
12415   .)  # No --srcdir option.  We are building in place.
12416     ac_srcdir=.
12417     if test -z "$ac_top_builddir"; then
12418        ac_top_srcdir=.
12419     else
12420        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
12421     fi ;;
12422   [\\/]* | ?:[\\/]* )  # Absolute path.
12423     ac_srcdir=$srcdir$ac_dir_suffix;
12424     ac_top_srcdir=$srcdir ;;
12425   *) # Relative path.
12426     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
12427     ac_top_srcdir=$ac_top_builddir$srcdir ;;
12428 esac
12429
12430 # Do not use `cd foo && pwd` to compute absolute paths, because
12431 # the directories may not exist.
12432 case `pwd` in
12433 .) ac_abs_builddir="$ac_dir";;
12434 *)
12435   case "$ac_dir" in
12436   .) ac_abs_builddir=`pwd`;;
12437   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
12438   *) ac_abs_builddir=`pwd`/"$ac_dir";;
12439   esac;;
12440 esac
12441 case $ac_abs_builddir in
12442 .) ac_abs_top_builddir=${ac_top_builddir}.;;
12443 *)
12444   case ${ac_top_builddir}. in
12445   .) ac_abs_top_builddir=$ac_abs_builddir;;
12446   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
12447   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
12448   esac;;
12449 esac
12450 case $ac_abs_builddir in
12451 .) ac_abs_srcdir=$ac_srcdir;;
12452 *)
12453   case $ac_srcdir in
12454   .) ac_abs_srcdir=$ac_abs_builddir;;
12455   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
12456   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
12457   esac;;
12458 esac
12459 case $ac_abs_builddir in
12460 .) ac_abs_top_srcdir=$ac_top_srcdir;;
12461 *)
12462   case $ac_top_srcdir in
12463   .) ac_abs_top_srcdir=$ac_abs_builddir;;
12464   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
12465   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
12466   esac;;
12467 esac
12468
12469
12470   case $INSTALL in
12471   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
12472   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
12473   esac
12474
12475   if test x"$ac_file" != x-; then
12476     { echo "$as_me:$LINENO: creating $ac_file" >&5
12477 echo "$as_me: creating $ac_file" >&6;}
12478     rm -f "$ac_file"
12479   fi
12480   # Let's still pretend it is `configure' which instantiates (i.e., don't
12481   # use $as_me), people would be surprised to read:
12482   #    /* config.h.  Generated by config.status.  */
12483   if test x"$ac_file" = x-; then
12484     configure_input=
12485   else
12486     configure_input="$ac_file.  "
12487   fi
12488   configure_input=$configure_input"Generated from `echo $ac_file_in |
12489                                      sed 's,.*/,,'` by configure."
12490
12491   # First look for the input files in the build tree, otherwise in the
12492   # src tree.
12493   ac_file_inputs=`IFS=:
12494     for f in $ac_file_in; do
12495       case $f in
12496       -) echo $tmp/stdin ;;
12497       [\\/$]*)
12498          # Absolute (can't be DOS-style, as IFS=:)
12499          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
12500 echo "$as_me: error: cannot find input file: $f" >&2;}
12501    { (exit 1); exit 1; }; }
12502          echo "$f";;
12503       *) # Relative
12504          if test -f "$f"; then
12505            # Build tree
12506            echo "$f"
12507          elif test -f "$srcdir/$f"; then
12508            # Source tree
12509            echo "$srcdir/$f"
12510          else
12511            # /dev/null tree
12512            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
12513 echo "$as_me: error: cannot find input file: $f" >&2;}
12514    { (exit 1); exit 1; }; }
12515          fi;;
12516       esac
12517     done` || { (exit 1); exit 1; }
12518 _ACEOF
12519 cat >>$CONFIG_STATUS <<_ACEOF
12520   sed "$ac_vpsub
12521 $extrasub
12522 _ACEOF
12523 cat >>$CONFIG_STATUS <<\_ACEOF
12524 :t
12525 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
12526 s,@configure_input@,$configure_input,;t t
12527 s,@srcdir@,$ac_srcdir,;t t
12528 s,@abs_srcdir@,$ac_abs_srcdir,;t t
12529 s,@top_srcdir@,$ac_top_srcdir,;t t
12530 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
12531 s,@builddir@,$ac_builddir,;t t
12532 s,@abs_builddir@,$ac_abs_builddir,;t t
12533 s,@top_builddir@,$ac_top_builddir,;t t
12534 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
12535 s,@INSTALL@,$ac_INSTALL,;t t
12536 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
12537   rm -f $tmp/stdin
12538   if test x"$ac_file" != x-; then
12539     mv $tmp/out $ac_file
12540   else
12541     cat $tmp/out
12542     rm -f $tmp/out
12543   fi
12544
12545 done
12546 _ACEOF
12547
12548 cat >>$CONFIG_STATUS <<\_ACEOF
12549
12550 { (exit 0); exit 0; }
12551 _ACEOF
12552 chmod +x $CONFIG_STATUS
12553 ac_clean_files=$ac_clean_files_save
12554
12555
12556 # configure is writing to config.log, and then calls config.status.
12557 # config.status does its own redirection, appending to config.log.
12558 # Unfortunately, on DOS this fails, as config.log is still kept open
12559 # by configure, so config.status won't be able to write to it; its
12560 # output is simply discarded.  So we exec the FD to /dev/null,
12561 # effectively closing config.log, so it can be properly (re)opened and
12562 # appended to by config.status.  When coming back to configure, we
12563 # need to make the FD available again.
12564 if test "$no_create" != yes; then
12565   ac_cs_success=:
12566   ac_config_status_args=
12567   test "$silent" = yes &&
12568     ac_config_status_args="$ac_config_status_args --quiet"
12569   exec 5>/dev/null
12570   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
12571   exec 5>>config.log
12572   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
12573   # would make configure fail if this is the last instruction.
12574   $ac_cs_success || { (exit 1); exit 1; }
12575 fi
12576