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 | bfin*-*-uclinux*)
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     case ${with_newlib} in
2231       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2232     esac
2233     ;;
2234   arm*-*-symbianelf*)
2235     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2236     ;;
2237   arm-*-pe*)
2238     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2239     ;;
2240   thumb-*-coff)
2241     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2242     ;;
2243   thumb-*-elf)
2244     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2245     ;;
2246   thumb-*-pe)
2247     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2248     ;;
2249   arm-*-riscix*)
2250     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2251     ;;
2252   avr-*-*)
2253     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2254     ;;
2255   bfin-*-*)
2256     noconfigdirs="$noconfigdirs gdb"
2257     if test x${is_cross_compiler} != xno ; then
2258       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2259     fi
2260     ;;
2261   c4x-*-* | tic4x-*-*)
2262     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2263     ;;
2264   c54x*-*-* | tic54x-*-*)
2265     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2266     ;;
2267   cris-*-* | crisv32-*-*)
2268     unsupported_languages="$unsupported_languages java"
2269     case "${target}" in
2270       *-*-aout)
2271         unsupported_languages="$unsupported_languages fortran"
2272         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2273       *-*-elf)
2274         unsupported_languages="$unsupported_languages fortran"
2275         noconfigdirs="$noconfigdirs target-boehm-gc";;
2276       *-*-linux*)
2277         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2278       *)
2279         unsupported_languages="$unsupported_languages fortran"
2280         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2281     esac
2282     ;;
2283   crx-*-*)
2284     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2285     ;;
2286   d10v-*-*)
2287     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2288     ;;
2289   d30v-*-*)
2290     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2291     ;;
2292   fr30-*-elf*)
2293     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2294     ;;
2295   frv-*-*)
2296     noconfigdirs="$noconfigdirs ${libgcj}"
2297     ;;
2298   h8300*-*-*)
2299     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2300     ;;
2301   h8500-*-*)
2302     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2303     ;;
2304   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2305     ;;
2306   hppa*64*-*-linux* | parisc*64*-*-linux*)
2307     # In this case, it's because the hppa64-linux target is for
2308     # the kernel only at this point and has no libc, and thus no
2309     # headers, crt*.o, etc., all of which are needed by these.
2310     noconfigdirs="$noconfigdirs target-zlib"
2311     ;;
2312   parisc*-*-linux* | hppa*-*-linux*)
2313     ;;
2314   hppa*-*-*elf* | \
2315   hppa*-*-lites* | \
2316   hppa*-*-openbsd* | \
2317   hppa*64*-*-*)
2318     noconfigdirs="$noconfigdirs ${libgcj}"
2319     ;;
2320   hppa*-hp-hpux11*)
2321     noconfigdirs="$noconfigdirs ld shellutils"
2322     ;;
2323   hppa*-*-*)
2324     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2325     # build on HP-UX 10.20.
2326     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2327     ;;
2328   i960-*-*)
2329     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2330     ;;
2331   ia64*-*-elf*)
2332     # No gdb support yet.
2333     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2334     ;;
2335   ia64*-**-hpux*)
2336     # No gdb or ld support yet.
2337     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2338     ;;
2339   i370-*-opened*)
2340     ;;
2341   i[3456789]86-*-coff | i[3456789]86-*-elf)
2342     noconfigdirs="$noconfigdirs ${libgcj}"
2343     ;;
2344   i[3456789]86-*-linux*)
2345     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2346     # not build java stuff by default.
2347     case "${target}" in
2348       *-*-*libc1*)
2349         noconfigdirs="$noconfigdirs ${libgcj}";;
2350     esac
2351
2352     # This section makes it possible to build newlib natively on linux.
2353     # If we are using a cross compiler then don't configure newlib.
2354     if test x${is_cross_compiler} != xno ; then
2355       noconfigdirs="$noconfigdirs target-newlib"
2356     fi
2357     noconfigdirs="$noconfigdirs target-libgloss"
2358     # If we are not using a cross compiler, do configure newlib.
2359     # Note however, that newlib will only be configured in this situation
2360     # if the --with-newlib option has been given, because otherwise
2361     # 'target-newlib' will appear in skipdirs.
2362     ;;
2363   i[3456789]86-*-mingw32*)
2364     target_configdirs="$target_configdirs target-winsup"
2365     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2366     ;;
2367   x86_64-*-mingw*)
2368     target_configdirs="$target_configdirs target-winsup"
2369     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2370     ;;
2371   *-*-cygwin*)
2372     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2373     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2374     # always build newlib if winsup directory is present.
2375     if test -d "$srcdir/winsup/cygwin"; then
2376       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2377     elif test -d "$srcdir/newlib"; then
2378       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2379     fi
2380     ;;
2381   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2382   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2383     ;;
2384   i[3456789]86-*-pe)
2385     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2386     ;;
2387   i[3456789]86-*-sco3.2v5*)
2388     # The linker does not yet know about weak symbols in COFF,
2389     # and is not configured to handle mixed ELF and COFF.
2390     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2391     ;;
2392   i[3456789]86-*-sco*)
2393     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2394     ;;
2395   i[3456789]86-*-solaris2*)
2396     noconfigdirs="$noconfigdirs target-libgloss"
2397     ;;
2398   i[3456789]86-*-sysv4*)
2399     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2400     ;;
2401   i[3456789]86-*-beos*)
2402     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2403     ;;
2404   i[3456789]86-*-rdos*)
2405     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2406     ;;
2407   m32r-*-*)
2408     noconfigdirs="$noconfigdirs ${libgcj}"
2409     ;;
2410   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2411     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2412     ;;
2413   m68k-*-elf*)
2414     noconfigdirs="$noconfigdirs ${libgcj}"
2415     ;;
2416   m68k-*-coff*)
2417     noconfigdirs="$noconfigdirs ${libgcj}"
2418     ;;
2419   mcore-*-pe*)
2420   # The EPOC C++ environment does not support exceptions or rtti,
2421   # and so building libstdc++-v3 tends not to always work.
2422     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2423     ;;
2424   mmix-*-*)
2425     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2426     unsupported_languages="$unsupported_languages fortran java"
2427     ;;
2428   mn10200-*-*)
2429     noconfigdirs="$noconfigdirs ${libgcj}"
2430     ;;
2431   mn10300-*-*)
2432     noconfigdirs="$noconfigdirs ${libgcj}"
2433     ;;
2434   mt-*-*)
2435     noconfigdirs="$noconfigdirs sim"
2436     ;;
2437   powerpc-*-aix*)
2438     # copied from rs6000-*-* entry
2439     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2440     ;;
2441   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2442     target_configdirs="$target_configdirs target-winsup"
2443     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2444     # always build newlib.
2445     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2446     ;;
2447     # This is temporary until we can link against shared libraries
2448   powerpcle-*-solaris*)
2449     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2450     ;;
2451   powerpc-*-beos*)
2452     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2453     ;;
2454   powerpc-*-eabi)
2455     noconfigdirs="$noconfigdirs ${libgcj}"
2456     ;;
2457   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2458     ;;
2459   rs6000-*-lynxos*)
2460     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2461     ;;
2462   rs6000-*-aix*)
2463     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2464     ;;
2465   rs6000-*-*)
2466     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2467     ;;
2468   m68k-apollo-*)
2469     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2470     ;;
2471   mips*-*-irix5*)
2472     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2473     ;;
2474   mips*-*-irix6*)
2475     # Linking libjava exceeds command-line length limits on at least
2476     # IRIX 6.2, but not on IRIX 6.5.
2477     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2478     # <oldham@codesourcery.com>
2479     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2480     ;;
2481   mips*-*-bsd*)
2482     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2483     ;;
2484   mips64*-*-linux*)
2485     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2486     ;;
2487   mips*-*-linux*)
2488     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2489     ;;
2490   mips*-*-*)
2491     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2492     ;;
2493   romp-*-*)
2494     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2495     ;;
2496   sh-*-* | sh64-*-*)
2497     case "${host}" in
2498       i[3456789]86-*-vsta) ;; # don't add gprof back in
2499       i[3456789]86-*-go32*) ;; # don't add gprof back in
2500       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2501       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2502     esac
2503     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2504     ;;
2505   sparc-*-elf*)
2506     noconfigdirs="$noconfigdirs ${libgcj}"
2507     ;;
2508   sparc64-*-elf*)
2509     noconfigdirs="$noconfigdirs ${libgcj}"
2510     ;;
2511   sparclite-*-*)
2512     noconfigdirs="$noconfigdirs ${libgcj}"
2513     ;;
2514   sparc-*-sunos4*)
2515     noconfigdirs="$noconfigdirs ${libgcj}"
2516     if test x${is_cross_compiler} != xno ; then
2517            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2518     else
2519            use_gnu_ld=no
2520     fi
2521     ;;
2522   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2523     noconfigdirs="$noconfigdirs ${libgcj}"
2524     ;;
2525   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2526     ;;
2527   spu-*-*)
2528     skipdirs="target-libssp"
2529     ;;
2530   v810-*-*)
2531     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2532     ;;
2533   v850-*-*)
2534     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2535     ;;
2536   v850e-*-*)
2537     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2538     ;;
2539   v850ea-*-*)
2540     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2541     ;;
2542   vax-*-vms)
2543     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2544     ;;
2545   vax-*-*)
2546     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2547     ;;
2548   xtensa-*-*)
2549     noconfigdirs="$noconfigdirs ${libgcj}"
2550     ;;
2551   ip2k-*-*)
2552     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2553     ;;
2554   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2555     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2556     ;;
2557   *-*-lynxos*)
2558     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2559     ;;
2560   *-*-*)
2561     noconfigdirs="$noconfigdirs ${libgcj}"
2562     ;;
2563 esac
2564
2565 # If we aren't building newlib, then don't build libgloss, since libgloss
2566 # depends upon some newlib header files.
2567 case "${noconfigdirs}" in
2568   *target-libgloss*) ;;
2569   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2570 esac
2571
2572 # Work in distributions that contain no compiler tools, like Autoconf.
2573 tentative_cc=""
2574 host_makefile_frag=/dev/null
2575 if test -d ${srcdir}/config ; then
2576 case "${host}" in
2577   m68k-hp-hpux*)
2578     # Avoid "too much defining" errors from HPUX compiler.
2579     tentative_cc="cc -Wp,-H256000"
2580     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2581     # If it's HP/UX ar, this should be harmless.
2582     RANLIB="ar ts"
2583     ;;
2584   m68k-apollo-sysv*)
2585     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2586     ;;
2587   m68k-apollo-bsd*)
2588     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2589     # chokes on bfd, the compiler won't let you assign integers to enums, and
2590     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2591     # the apollo compiler" (the preferred version of GCC could be called cc,
2592     # or whatever), but I'm not sure leaving CC as cc is any better...
2593     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2594     # Used to have BISON=yacc.
2595     tentative_cc=gcc
2596     ;;
2597   m88k-dg-dgux*)
2598     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2599     ;;
2600   m88k-harris-cxux*)
2601     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2602     tentative_cc="cc -Xa"
2603     host_makefile_frag="config/mh-cxux"
2604     ;;
2605   m88k-motorola-sysv*)
2606     ;;
2607   mips*-dec-ultrix*)
2608     tentative_cc="cc -Wf,-XNg1000"
2609     host_makefile_frag="config/mh-decstation"
2610     ;;
2611   mips*-nec-sysv4*)
2612     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2613     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2614     host_makefile_frag="config/mh-necv4"
2615     ;;
2616   mips*-sgi-irix4*)
2617     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2618     # environment.  Also bump switch table size so that cp-parse will
2619     # compile.  Bump string length limit so linker builds.
2620     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2621     ;;
2622   mips*-*-sysv4*)
2623     host_makefile_frag="config/mh-sysv4"
2624     ;;
2625   mips*-*-sysv*)
2626     # This is for a MIPS running RISC/os 4.52C.
2627
2628     # This is needed for GDB, but needs to be in the top-level make because
2629     # if a library is compiled with the bsd headers and gets linked with the
2630     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2631     # a different size).
2632     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2633     # known except to select the sysv environment.  Could we use /proc instead?
2634     # These "sysv environments" and "bsd environments" often end up being a pain.
2635     #
2636     # This is not part of CFLAGS because perhaps not all C compilers have this
2637     # option.
2638     tentative_cc="cc -systype sysv"
2639     ;;
2640   i370-ibm-opened*)
2641     tentative_cc="c89"
2642     ;;
2643   i[3456789]86-*-sysv5*)
2644     host_makefile_frag="config/mh-sysv5"
2645     ;;
2646   i[3456789]86-*-dgux*)
2647     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2648     host_makefile_frag="config/mh-dgux386"
2649     ;;
2650   i[3456789]86-ncr-sysv4.3*)
2651     # The MetaWare compiler will generate a copyright message unless you
2652     # turn it off by adding the -Hnocopyr flag.
2653     tentative_cc="cc -Hnocopyr"
2654     ;;
2655   i[3456789]86-ncr-sysv4*)
2656     # for an NCR 3000 (i486/SVR4) system.
2657     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2658     # This compiler not only emits obnoxious copyright messages every time
2659     # you run it, but it chokes and dies on a whole bunch of GNU source
2660     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2661     tentative_cc="/usr/ccs/ATT/cc"
2662     host_makefile_frag="config/mh-ncr3000"
2663     ;;
2664   i[3456789]86-*-sco3.2v5*)
2665     ;;
2666   i[3456789]86-*-sco*)
2667     # The native C compiler botches some simple uses of const.  Unfortunately,
2668     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2669     tentative_cc="cc -Dconst="
2670     host_makefile_frag="config/mh-sco"
2671     ;;
2672   i[3456789]86-*-udk*)
2673     host_makefile_frag="config/mh-sysv5"
2674     ;;
2675   i[3456789]86-*-solaris2*)
2676     host_makefile_frag="config/mh-sysv4"
2677     ;;
2678   i[3456789]86-*-msdosdjgpp*)
2679     host_makefile_frag="config/mh-djgpp"
2680     ;;
2681   *-cygwin*)
2682     host_makefile_frag="config/mh-cygwin"
2683     ;;
2684   *-mingw32*)
2685     ;;
2686   *-mingw64*)
2687     ;;
2688   *-interix*)
2689     host_makefile_frag="config/mh-interix"
2690     ;;
2691   vax-*-ultrix2*)
2692     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2693     tentative_cc=gcc
2694     ;;
2695   *-*-solaris2*)
2696     host_makefile_frag="config/mh-solaris"
2697     ;;
2698   m68k-sun-sunos*)
2699     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2700     # without overflowing the jump tables (-J says to use a 32 bit table)
2701     tentative_cc="cc -J"
2702     ;;
2703   *-hp-hpux*)
2704     tentative_cc="cc -Wp,-H256000"
2705     ;;
2706   *-*-hiux*)
2707     tentative_cc="cc -Wp,-H256000"
2708     ;;
2709   rs6000-*-lynxos*)
2710     # /bin/cc is less than useful for our purposes.  Always use GCC
2711     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2712     host_makefile_frag="config/mh-lynxrs6k"
2713     ;;
2714   powerpc-*-darwin*)
2715     host_makefile_frag="config/mh-ppc-darwin"
2716     ;;
2717   powerpc-*-aix*)
2718     host_makefile_frag="config/mh-ppc-aix"
2719     ;;
2720   rs6000-*-aix*)
2721     host_makefile_frag="config/mh-ppc-aix"
2722     ;;
2723   *-*-lynxos*)
2724     # /bin/cc is less than useful for our purposes.  Always use GCC
2725     tentative_cc="/bin/gcc"
2726     ;;
2727   *-*-sysv4*)
2728     host_makefile_frag="config/mh-sysv4"
2729     ;;
2730   # This is placed last to prevent interfering with the cases above.
2731   i[3456789]86-*-*)
2732     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2733     host_makefile_frag="config/mh-x86omitfp"
2734     ;;
2735 esac
2736 fi
2737
2738 # If we aren't going to be using gcc, see if we can extract a definition
2739 # of CC from the fragment.
2740 # Actually, use the 'pre-extracted' version above.
2741 if test -z "${CC}" && test "${build}" = "${host}" ; then
2742   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2743   found=
2744   for dir in $PATH; do
2745     test -z "$dir" && dir=.
2746     if test -f $dir/gcc; then
2747       found=yes
2748       break
2749     fi
2750   done
2751   IFS="$save_ifs"
2752   if test -z "${found}" && test -n "${tentative_cc}" ; then
2753     CC=$tentative_cc
2754   fi
2755 fi
2756
2757 if test "${build}" != "${host}" ; then
2758   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2759 else
2760   CC_FOR_BUILD="\$(CC)"
2761 fi
2762
2763 ac_ext=c
2764 ac_cpp='$CPP $CPPFLAGS'
2765 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2766 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2767 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2768 if test -n "$ac_tool_prefix"; then
2769   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2770 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2771 echo "$as_me:$LINENO: checking for $ac_word" >&5
2772 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2773 if test "${ac_cv_prog_CC+set}" = set; then
2774   echo $ECHO_N "(cached) $ECHO_C" >&6
2775 else
2776   if test -n "$CC"; then
2777   ac_cv_prog_CC="$CC" # Let the user override the test.
2778 else
2779 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2780 for as_dir in $PATH
2781 do
2782   IFS=$as_save_IFS
2783   test -z "$as_dir" && as_dir=.
2784   for ac_exec_ext in '' $ac_executable_extensions; do
2785   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2786     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2787     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2788     break 2
2789   fi
2790 done
2791 done
2792
2793 fi
2794 fi
2795 CC=$ac_cv_prog_CC
2796 if test -n "$CC"; then
2797   echo "$as_me:$LINENO: result: $CC" >&5
2798 echo "${ECHO_T}$CC" >&6
2799 else
2800   echo "$as_me:$LINENO: result: no" >&5
2801 echo "${ECHO_T}no" >&6
2802 fi
2803
2804 fi
2805 if test -z "$ac_cv_prog_CC"; then
2806   ac_ct_CC=$CC
2807   # Extract the first word of "gcc", so it can be a program name with args.
2808 set dummy gcc; ac_word=$2
2809 echo "$as_me:$LINENO: checking for $ac_word" >&5
2810 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2811 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2812   echo $ECHO_N "(cached) $ECHO_C" >&6
2813 else
2814   if test -n "$ac_ct_CC"; then
2815   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2816 else
2817 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2818 for as_dir in $PATH
2819 do
2820   IFS=$as_save_IFS
2821   test -z "$as_dir" && as_dir=.
2822   for ac_exec_ext in '' $ac_executable_extensions; do
2823   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2824     ac_cv_prog_ac_ct_CC="gcc"
2825     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2826     break 2
2827   fi
2828 done
2829 done
2830
2831 fi
2832 fi
2833 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2834 if test -n "$ac_ct_CC"; then
2835   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2836 echo "${ECHO_T}$ac_ct_CC" >&6
2837 else
2838   echo "$as_me:$LINENO: result: no" >&5
2839 echo "${ECHO_T}no" >&6
2840 fi
2841
2842   CC=$ac_ct_CC
2843 else
2844   CC="$ac_cv_prog_CC"
2845 fi
2846
2847 if test -z "$CC"; then
2848   if test -n "$ac_tool_prefix"; then
2849   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2850 set dummy ${ac_tool_prefix}cc; ac_word=$2
2851 echo "$as_me:$LINENO: checking for $ac_word" >&5
2852 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2853 if test "${ac_cv_prog_CC+set}" = set; then
2854   echo $ECHO_N "(cached) $ECHO_C" >&6
2855 else
2856   if test -n "$CC"; then
2857   ac_cv_prog_CC="$CC" # Let the user override the test.
2858 else
2859 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2860 for as_dir in $PATH
2861 do
2862   IFS=$as_save_IFS
2863   test -z "$as_dir" && as_dir=.
2864   for ac_exec_ext in '' $ac_executable_extensions; do
2865   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2866     ac_cv_prog_CC="${ac_tool_prefix}cc"
2867     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2868     break 2
2869   fi
2870 done
2871 done
2872
2873 fi
2874 fi
2875 CC=$ac_cv_prog_CC
2876 if test -n "$CC"; then
2877   echo "$as_me:$LINENO: result: $CC" >&5
2878 echo "${ECHO_T}$CC" >&6
2879 else
2880   echo "$as_me:$LINENO: result: no" >&5
2881 echo "${ECHO_T}no" >&6
2882 fi
2883
2884 fi
2885 if test -z "$ac_cv_prog_CC"; then
2886   ac_ct_CC=$CC
2887   # Extract the first word of "cc", so it can be a program name with args.
2888 set dummy cc; ac_word=$2
2889 echo "$as_me:$LINENO: checking for $ac_word" >&5
2890 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2891 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2892   echo $ECHO_N "(cached) $ECHO_C" >&6
2893 else
2894   if test -n "$ac_ct_CC"; then
2895   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2896 else
2897 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2898 for as_dir in $PATH
2899 do
2900   IFS=$as_save_IFS
2901   test -z "$as_dir" && as_dir=.
2902   for ac_exec_ext in '' $ac_executable_extensions; do
2903   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2904     ac_cv_prog_ac_ct_CC="cc"
2905     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2906     break 2
2907   fi
2908 done
2909 done
2910
2911 fi
2912 fi
2913 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2914 if test -n "$ac_ct_CC"; then
2915   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2916 echo "${ECHO_T}$ac_ct_CC" >&6
2917 else
2918   echo "$as_me:$LINENO: result: no" >&5
2919 echo "${ECHO_T}no" >&6
2920 fi
2921
2922   CC=$ac_ct_CC
2923 else
2924   CC="$ac_cv_prog_CC"
2925 fi
2926
2927 fi
2928 if test -z "$CC"; then
2929   # Extract the first word of "cc", so it can be a program name with args.
2930 set dummy cc; ac_word=$2
2931 echo "$as_me:$LINENO: checking for $ac_word" >&5
2932 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2933 if test "${ac_cv_prog_CC+set}" = set; then
2934   echo $ECHO_N "(cached) $ECHO_C" >&6
2935 else
2936   if test -n "$CC"; then
2937   ac_cv_prog_CC="$CC" # Let the user override the test.
2938 else
2939   ac_prog_rejected=no
2940 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2941 for as_dir in $PATH
2942 do
2943   IFS=$as_save_IFS
2944   test -z "$as_dir" && as_dir=.
2945   for ac_exec_ext in '' $ac_executable_extensions; do
2946   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2947     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2948        ac_prog_rejected=yes
2949        continue
2950      fi
2951     ac_cv_prog_CC="cc"
2952     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2953     break 2
2954   fi
2955 done
2956 done
2957
2958 if test $ac_prog_rejected = yes; then
2959   # We found a bogon in the path, so make sure we never use it.
2960   set dummy $ac_cv_prog_CC
2961   shift
2962   if test $# != 0; then
2963     # We chose a different compiler from the bogus one.
2964     # However, it has the same basename, so the bogon will be chosen
2965     # first if we set CC to just the basename; use the full file name.
2966     shift
2967     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
2968   fi
2969 fi
2970 fi
2971 fi
2972 CC=$ac_cv_prog_CC
2973 if test -n "$CC"; then
2974   echo "$as_me:$LINENO: result: $CC" >&5
2975 echo "${ECHO_T}$CC" >&6
2976 else
2977   echo "$as_me:$LINENO: result: no" >&5
2978 echo "${ECHO_T}no" >&6
2979 fi
2980
2981 fi
2982 if test -z "$CC"; then
2983   if test -n "$ac_tool_prefix"; then
2984   for ac_prog in cl
2985   do
2986     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2987 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2988 echo "$as_me:$LINENO: checking for $ac_word" >&5
2989 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2990 if test "${ac_cv_prog_CC+set}" = set; then
2991   echo $ECHO_N "(cached) $ECHO_C" >&6
2992 else
2993   if test -n "$CC"; then
2994   ac_cv_prog_CC="$CC" # Let the user override the test.
2995 else
2996 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2997 for as_dir in $PATH
2998 do
2999   IFS=$as_save_IFS
3000   test -z "$as_dir" && as_dir=.
3001   for ac_exec_ext in '' $ac_executable_extensions; do
3002   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3003     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3004     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3005     break 2
3006   fi
3007 done
3008 done
3009
3010 fi
3011 fi
3012 CC=$ac_cv_prog_CC
3013 if test -n "$CC"; then
3014   echo "$as_me:$LINENO: result: $CC" >&5
3015 echo "${ECHO_T}$CC" >&6
3016 else
3017   echo "$as_me:$LINENO: result: no" >&5
3018 echo "${ECHO_T}no" >&6
3019 fi
3020
3021     test -n "$CC" && break
3022   done
3023 fi
3024 if test -z "$CC"; then
3025   ac_ct_CC=$CC
3026   for ac_prog in cl
3027 do
3028   # Extract the first word of "$ac_prog", so it can be a program name with args.
3029 set dummy $ac_prog; ac_word=$2
3030 echo "$as_me:$LINENO: checking for $ac_word" >&5
3031 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3032 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3033   echo $ECHO_N "(cached) $ECHO_C" >&6
3034 else
3035   if test -n "$ac_ct_CC"; then
3036   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3037 else
3038 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3039 for as_dir in $PATH
3040 do
3041   IFS=$as_save_IFS
3042   test -z "$as_dir" && as_dir=.
3043   for ac_exec_ext in '' $ac_executable_extensions; do
3044   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3045     ac_cv_prog_ac_ct_CC="$ac_prog"
3046     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3047     break 2
3048   fi
3049 done
3050 done
3051
3052 fi
3053 fi
3054 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3055 if test -n "$ac_ct_CC"; then
3056   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3057 echo "${ECHO_T}$ac_ct_CC" >&6
3058 else
3059   echo "$as_me:$LINENO: result: no" >&5
3060 echo "${ECHO_T}no" >&6
3061 fi
3062
3063   test -n "$ac_ct_CC" && break
3064 done
3065
3066   CC=$ac_ct_CC
3067 fi
3068
3069 fi
3070
3071
3072 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3073 See \`config.log' for more details." >&5
3074 echo "$as_me: error: no acceptable C compiler found in \$PATH
3075 See \`config.log' for more details." >&2;}
3076    { (exit 1); exit 1; }; }
3077
3078 # Provide some information about the compiler.
3079 echo "$as_me:$LINENO:" \
3080      "checking for C compiler version" >&5
3081 ac_compiler=`set X $ac_compile; echo $2`
3082 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3083   (eval $ac_compiler --version </dev/null >&5) 2>&5
3084   ac_status=$?
3085   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3086   (exit $ac_status); }
3087 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3088   (eval $ac_compiler -v </dev/null >&5) 2>&5
3089   ac_status=$?
3090   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3091   (exit $ac_status); }
3092 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3093   (eval $ac_compiler -V </dev/null >&5) 2>&5
3094   ac_status=$?
3095   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3096   (exit $ac_status); }
3097
3098 cat >conftest.$ac_ext <<_ACEOF
3099 /* confdefs.h.  */
3100 _ACEOF
3101 cat confdefs.h >>conftest.$ac_ext
3102 cat >>conftest.$ac_ext <<_ACEOF
3103 /* end confdefs.h.  */
3104
3105 int
3106 main ()
3107 {
3108
3109   ;
3110   return 0;
3111 }
3112 _ACEOF
3113 ac_clean_files_save=$ac_clean_files
3114 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3115 # Try to create an executable without -o first, disregard a.out.
3116 # It will help us diagnose broken compilers, and finding out an intuition
3117 # of exeext.
3118 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3119 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3120 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3121 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3122   (eval $ac_link_default) 2>&5
3123   ac_status=$?
3124   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3125   (exit $ac_status); }; then
3126   # Find the output, starting from the most likely.  This scheme is
3127 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3128 # resort.
3129
3130 # Be careful to initialize this variable, since it used to be cached.
3131 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3132 ac_cv_exeext=
3133 # b.out is created by i960 compilers.
3134 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3135 do
3136   test -f "$ac_file" || continue
3137   case $ac_file in
3138     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3139         ;;
3140     conftest.$ac_ext )
3141         # This is the source file.
3142         ;;
3143     [ab].out )
3144         # We found the default executable, but exeext='' is most
3145         # certainly right.
3146         break;;
3147     *.* )
3148         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3149         # FIXME: I believe we export ac_cv_exeext for Libtool,
3150         # but it would be cool to find out if it's true.  Does anybody
3151         # maintain Libtool? --akim.
3152         export ac_cv_exeext
3153         break;;
3154     * )
3155         break;;
3156   esac
3157 done
3158 else
3159   echo "$as_me: failed program was:" >&5
3160 sed 's/^/| /' conftest.$ac_ext >&5
3161
3162 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3163 See \`config.log' for more details." >&5
3164 echo "$as_me: error: C compiler cannot create executables
3165 See \`config.log' for more details." >&2;}
3166    { (exit 77); exit 77; }; }
3167 fi
3168
3169 ac_exeext=$ac_cv_exeext
3170 echo "$as_me:$LINENO: result: $ac_file" >&5
3171 echo "${ECHO_T}$ac_file" >&6
3172
3173 # Check the compiler produces executables we can run.  If not, either
3174 # the compiler is broken, or we cross compile.
3175 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3176 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3177 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3178 # If not cross compiling, check that we can run a simple program.
3179 if test "$cross_compiling" != yes; then
3180   if { ac_try='./$ac_file'
3181   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3182   (eval $ac_try) 2>&5
3183   ac_status=$?
3184   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3185   (exit $ac_status); }; }; then
3186     cross_compiling=no
3187   else
3188     if test "$cross_compiling" = maybe; then
3189         cross_compiling=yes
3190     else
3191         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3192 If you meant to cross compile, use \`--host'.
3193 See \`config.log' for more details." >&5
3194 echo "$as_me: error: cannot run C compiled programs.
3195 If you meant to cross compile, use \`--host'.
3196 See \`config.log' for more details." >&2;}
3197    { (exit 1); exit 1; }; }
3198     fi
3199   fi
3200 fi
3201 echo "$as_me:$LINENO: result: yes" >&5
3202 echo "${ECHO_T}yes" >&6
3203
3204 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3205 ac_clean_files=$ac_clean_files_save
3206 # Check the compiler produces executables we can run.  If not, either
3207 # the compiler is broken, or we cross compile.
3208 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3209 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3210 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3211 echo "${ECHO_T}$cross_compiling" >&6
3212
3213 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3214 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3215 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3216   (eval $ac_link) 2>&5
3217   ac_status=$?
3218   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3219   (exit $ac_status); }; then
3220   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3221 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3222 # work properly (i.e., refer to `conftest.exe'), while it won't with
3223 # `rm'.
3224 for ac_file in conftest.exe conftest conftest.*; do
3225   test -f "$ac_file" || continue
3226   case $ac_file in
3227     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3228     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3229           export ac_cv_exeext
3230           break;;
3231     * ) break;;
3232   esac
3233 done
3234 else
3235   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3236 See \`config.log' for more details." >&5
3237 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3238 See \`config.log' for more details." >&2;}
3239    { (exit 1); exit 1; }; }
3240 fi
3241
3242 rm -f conftest$ac_cv_exeext
3243 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3244 echo "${ECHO_T}$ac_cv_exeext" >&6
3245
3246 rm -f conftest.$ac_ext
3247 EXEEXT=$ac_cv_exeext
3248 ac_exeext=$EXEEXT
3249 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3250 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3251 if test "${ac_cv_objext+set}" = set; then
3252   echo $ECHO_N "(cached) $ECHO_C" >&6
3253 else
3254   cat >conftest.$ac_ext <<_ACEOF
3255 /* confdefs.h.  */
3256 _ACEOF
3257 cat confdefs.h >>conftest.$ac_ext
3258 cat >>conftest.$ac_ext <<_ACEOF
3259 /* end confdefs.h.  */
3260
3261 int
3262 main ()
3263 {
3264
3265   ;
3266   return 0;
3267 }
3268 _ACEOF
3269 rm -f conftest.o conftest.obj
3270 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3271   (eval $ac_compile) 2>&5
3272   ac_status=$?
3273   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3274   (exit $ac_status); }; then
3275   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3276   case $ac_file in
3277     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3278     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3279        break;;
3280   esac
3281 done
3282 else
3283   echo "$as_me: failed program was:" >&5
3284 sed 's/^/| /' conftest.$ac_ext >&5
3285
3286 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3287 See \`config.log' for more details." >&5
3288 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3289 See \`config.log' for more details." >&2;}
3290    { (exit 1); exit 1; }; }
3291 fi
3292
3293 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3294 fi
3295 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3296 echo "${ECHO_T}$ac_cv_objext" >&6
3297 OBJEXT=$ac_cv_objext
3298 ac_objext=$OBJEXT
3299 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3300 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3301 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3302   echo $ECHO_N "(cached) $ECHO_C" >&6
3303 else
3304   cat >conftest.$ac_ext <<_ACEOF
3305 /* confdefs.h.  */
3306 _ACEOF
3307 cat confdefs.h >>conftest.$ac_ext
3308 cat >>conftest.$ac_ext <<_ACEOF
3309 /* end confdefs.h.  */
3310
3311 int
3312 main ()
3313 {
3314 #ifndef __GNUC__
3315        choke me
3316 #endif
3317
3318   ;
3319   return 0;
3320 }
3321 _ACEOF
3322 rm -f conftest.$ac_objext
3323 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3324   (eval $ac_compile) 2>conftest.er1
3325   ac_status=$?
3326   grep -v '^ *+' conftest.er1 >conftest.err
3327   rm -f conftest.er1
3328   cat conftest.err >&5
3329   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3330   (exit $ac_status); } &&
3331          { ac_try='test -z "$ac_c_werror_flag"
3332                          || test ! -s conftest.err'
3333   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3334   (eval $ac_try) 2>&5
3335   ac_status=$?
3336   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3337   (exit $ac_status); }; } &&
3338          { ac_try='test -s conftest.$ac_objext'
3339   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3340   (eval $ac_try) 2>&5
3341   ac_status=$?
3342   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3343   (exit $ac_status); }; }; then
3344   ac_compiler_gnu=yes
3345 else
3346   echo "$as_me: failed program was:" >&5
3347 sed 's/^/| /' conftest.$ac_ext >&5
3348
3349 ac_compiler_gnu=no
3350 fi
3351 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3352 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3353
3354 fi
3355 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3356 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3357 GCC=`test $ac_compiler_gnu = yes && echo yes`
3358 ac_test_CFLAGS=${CFLAGS+set}
3359 ac_save_CFLAGS=$CFLAGS
3360 CFLAGS="-g"
3361 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3362 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3363 if test "${ac_cv_prog_cc_g+set}" = set; then
3364   echo $ECHO_N "(cached) $ECHO_C" >&6
3365 else
3366   cat >conftest.$ac_ext <<_ACEOF
3367 /* confdefs.h.  */
3368 _ACEOF
3369 cat confdefs.h >>conftest.$ac_ext
3370 cat >>conftest.$ac_ext <<_ACEOF
3371 /* end confdefs.h.  */
3372
3373 int
3374 main ()
3375 {
3376
3377   ;
3378   return 0;
3379 }
3380 _ACEOF
3381 rm -f conftest.$ac_objext
3382 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3383   (eval $ac_compile) 2>conftest.er1
3384   ac_status=$?
3385   grep -v '^ *+' conftest.er1 >conftest.err
3386   rm -f conftest.er1
3387   cat conftest.err >&5
3388   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3389   (exit $ac_status); } &&
3390          { ac_try='test -z "$ac_c_werror_flag"
3391                          || test ! -s conftest.err'
3392   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3393   (eval $ac_try) 2>&5
3394   ac_status=$?
3395   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3396   (exit $ac_status); }; } &&
3397          { ac_try='test -s conftest.$ac_objext'
3398   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3399   (eval $ac_try) 2>&5
3400   ac_status=$?
3401   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3402   (exit $ac_status); }; }; then
3403   ac_cv_prog_cc_g=yes
3404 else
3405   echo "$as_me: failed program was:" >&5
3406 sed 's/^/| /' conftest.$ac_ext >&5
3407
3408 ac_cv_prog_cc_g=no
3409 fi
3410 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3411 fi
3412 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3413 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3414 if test "$ac_test_CFLAGS" = set; then
3415   CFLAGS=$ac_save_CFLAGS
3416 elif test $ac_cv_prog_cc_g = yes; then
3417   if test "$GCC" = yes; then
3418     CFLAGS="-g -O2"
3419   else
3420     CFLAGS="-g"
3421   fi
3422 else
3423   if test "$GCC" = yes; then
3424     CFLAGS="-O2"
3425   else
3426     CFLAGS=
3427   fi
3428 fi
3429 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3430 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3431 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3432   echo $ECHO_N "(cached) $ECHO_C" >&6
3433 else
3434   ac_cv_prog_cc_stdc=no
3435 ac_save_CC=$CC
3436 cat >conftest.$ac_ext <<_ACEOF
3437 /* confdefs.h.  */
3438 _ACEOF
3439 cat confdefs.h >>conftest.$ac_ext
3440 cat >>conftest.$ac_ext <<_ACEOF
3441 /* end confdefs.h.  */
3442 #include <stdarg.h>
3443 #include <stdio.h>
3444 #include <sys/types.h>
3445 #include <sys/stat.h>
3446 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3447 struct buf { int x; };
3448 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3449 static char *e (p, i)
3450      char **p;
3451      int i;
3452 {
3453   return p[i];
3454 }
3455 static char *f (char * (*g) (char **, int), char **p, ...)
3456 {
3457   char *s;
3458   va_list v;
3459   va_start (v,p);
3460   s = g (p, va_arg (v,int));
3461   va_end (v);
3462   return s;
3463 }
3464
3465 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3466    function prototypes and stuff, but not '\xHH' hex character constants.
3467    These don't provoke an error unfortunately, instead are silently treated
3468    as 'x'.  The following induces an error, until -std1 is added to get
3469    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3470    array size at least.  It's necessary to write '\x00'==0 to get something
3471    that's true only with -std1.  */
3472 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3473
3474 int test (int i, double x);
3475 struct s1 {int (*f) (int a);};
3476 struct s2 {int (*f) (double a);};
3477 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3478 int argc;
3479 char **argv;
3480 int
3481 main ()
3482 {
3483 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3484   ;
3485   return 0;
3486 }
3487 _ACEOF
3488 # Don't try gcc -ansi; that turns off useful extensions and
3489 # breaks some systems' header files.
3490 # AIX                   -qlanglvl=ansi
3491 # Ultrix and OSF/1      -std1
3492 # HP-UX 10.20 and later -Ae
3493 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3494 # SVR4                  -Xc -D__EXTENSIONS__
3495 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3496 do
3497   CC="$ac_save_CC $ac_arg"
3498   rm -f conftest.$ac_objext
3499 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3500   (eval $ac_compile) 2>conftest.er1
3501   ac_status=$?
3502   grep -v '^ *+' conftest.er1 >conftest.err
3503   rm -f conftest.er1
3504   cat conftest.err >&5
3505   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3506   (exit $ac_status); } &&
3507          { ac_try='test -z "$ac_c_werror_flag"
3508                          || test ! -s conftest.err'
3509   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3510   (eval $ac_try) 2>&5
3511   ac_status=$?
3512   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3513   (exit $ac_status); }; } &&
3514          { ac_try='test -s conftest.$ac_objext'
3515   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3516   (eval $ac_try) 2>&5
3517   ac_status=$?
3518   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3519   (exit $ac_status); }; }; then
3520   ac_cv_prog_cc_stdc=$ac_arg
3521 break
3522 else
3523   echo "$as_me: failed program was:" >&5
3524 sed 's/^/| /' conftest.$ac_ext >&5
3525
3526 fi
3527 rm -f conftest.err conftest.$ac_objext
3528 done
3529 rm -f conftest.$ac_ext conftest.$ac_objext
3530 CC=$ac_save_CC
3531
3532 fi
3533
3534 case "x$ac_cv_prog_cc_stdc" in
3535   x|xno)
3536     echo "$as_me:$LINENO: result: none needed" >&5
3537 echo "${ECHO_T}none needed" >&6 ;;
3538   *)
3539     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3540 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3541     CC="$CC $ac_cv_prog_cc_stdc" ;;
3542 esac
3543
3544 # Some people use a C++ compiler to compile C.  Since we use `exit',
3545 # in C++ we need to declare it.  In case someone uses the same compiler
3546 # for both compiling C and C++ we need to have the C++ compiler decide
3547 # the declaration of exit, since it's the most demanding environment.
3548 cat >conftest.$ac_ext <<_ACEOF
3549 #ifndef __cplusplus
3550   choke me
3551 #endif
3552 _ACEOF
3553 rm -f conftest.$ac_objext
3554 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3555   (eval $ac_compile) 2>conftest.er1
3556   ac_status=$?
3557   grep -v '^ *+' conftest.er1 >conftest.err
3558   rm -f conftest.er1
3559   cat conftest.err >&5
3560   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3561   (exit $ac_status); } &&
3562          { ac_try='test -z "$ac_c_werror_flag"
3563                          || test ! -s conftest.err'
3564   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3565   (eval $ac_try) 2>&5
3566   ac_status=$?
3567   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3568   (exit $ac_status); }; } &&
3569          { ac_try='test -s conftest.$ac_objext'
3570   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3571   (eval $ac_try) 2>&5
3572   ac_status=$?
3573   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3574   (exit $ac_status); }; }; then
3575   for ac_declaration in \
3576    '' \
3577    'extern "C" void std::exit (int) throw (); using std::exit;' \
3578    'extern "C" void std::exit (int); using std::exit;' \
3579    'extern "C" void exit (int) throw ();' \
3580    'extern "C" void exit (int);' \
3581    'void exit (int);'
3582 do
3583   cat >conftest.$ac_ext <<_ACEOF
3584 /* confdefs.h.  */
3585 _ACEOF
3586 cat confdefs.h >>conftest.$ac_ext
3587 cat >>conftest.$ac_ext <<_ACEOF
3588 /* end confdefs.h.  */
3589 $ac_declaration
3590 #include <stdlib.h>
3591 int
3592 main ()
3593 {
3594 exit (42);
3595   ;
3596   return 0;
3597 }
3598 _ACEOF
3599 rm -f conftest.$ac_objext
3600 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3601   (eval $ac_compile) 2>conftest.er1
3602   ac_status=$?
3603   grep -v '^ *+' conftest.er1 >conftest.err
3604   rm -f conftest.er1
3605   cat conftest.err >&5
3606   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3607   (exit $ac_status); } &&
3608          { ac_try='test -z "$ac_c_werror_flag"
3609                          || test ! -s conftest.err'
3610   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3611   (eval $ac_try) 2>&5
3612   ac_status=$?
3613   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3614   (exit $ac_status); }; } &&
3615          { ac_try='test -s conftest.$ac_objext'
3616   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3617   (eval $ac_try) 2>&5
3618   ac_status=$?
3619   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3620   (exit $ac_status); }; }; then
3621   :
3622 else
3623   echo "$as_me: failed program was:" >&5
3624 sed 's/^/| /' conftest.$ac_ext >&5
3625
3626 continue
3627 fi
3628 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3629   cat >conftest.$ac_ext <<_ACEOF
3630 /* confdefs.h.  */
3631 _ACEOF
3632 cat confdefs.h >>conftest.$ac_ext
3633 cat >>conftest.$ac_ext <<_ACEOF
3634 /* end confdefs.h.  */
3635 $ac_declaration
3636 int
3637 main ()
3638 {
3639 exit (42);
3640   ;
3641   return 0;
3642 }
3643 _ACEOF
3644 rm -f conftest.$ac_objext
3645 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3646   (eval $ac_compile) 2>conftest.er1
3647   ac_status=$?
3648   grep -v '^ *+' conftest.er1 >conftest.err
3649   rm -f conftest.er1
3650   cat conftest.err >&5
3651   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3652   (exit $ac_status); } &&
3653          { ac_try='test -z "$ac_c_werror_flag"
3654                          || test ! -s conftest.err'
3655   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3656   (eval $ac_try) 2>&5
3657   ac_status=$?
3658   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3659   (exit $ac_status); }; } &&
3660          { ac_try='test -s conftest.$ac_objext'
3661   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3662   (eval $ac_try) 2>&5
3663   ac_status=$?
3664   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3665   (exit $ac_status); }; }; then
3666   break
3667 else
3668   echo "$as_me: failed program was:" >&5
3669 sed 's/^/| /' conftest.$ac_ext >&5
3670
3671 fi
3672 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3673 done
3674 rm -f conftest*
3675 if test -n "$ac_declaration"; then
3676   echo '#ifdef __cplusplus' >>confdefs.h
3677   echo $ac_declaration      >>confdefs.h
3678   echo '#endif'             >>confdefs.h
3679 fi
3680
3681 else
3682   echo "$as_me: failed program was:" >&5
3683 sed 's/^/| /' conftest.$ac_ext >&5
3684
3685 fi
3686 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3687 ac_ext=c
3688 ac_cpp='$CPP $CPPFLAGS'
3689 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3690 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3691 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3692
3693 ac_ext=cc
3694 ac_cpp='$CXXCPP $CPPFLAGS'
3695 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3696 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3697 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3698 if test -n "$ac_tool_prefix"; then
3699   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3700   do
3701     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3702 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3703 echo "$as_me:$LINENO: checking for $ac_word" >&5
3704 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3705 if test "${ac_cv_prog_CXX+set}" = set; then
3706   echo $ECHO_N "(cached) $ECHO_C" >&6
3707 else
3708   if test -n "$CXX"; then
3709   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3710 else
3711 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3712 for as_dir in $PATH
3713 do
3714   IFS=$as_save_IFS
3715   test -z "$as_dir" && as_dir=.
3716   for ac_exec_ext in '' $ac_executable_extensions; do
3717   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3718     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3719     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3720     break 2
3721   fi
3722 done
3723 done
3724
3725 fi
3726 fi
3727 CXX=$ac_cv_prog_CXX
3728 if test -n "$CXX"; then
3729   echo "$as_me:$LINENO: result: $CXX" >&5
3730 echo "${ECHO_T}$CXX" >&6
3731 else
3732   echo "$as_me:$LINENO: result: no" >&5
3733 echo "${ECHO_T}no" >&6
3734 fi
3735
3736     test -n "$CXX" && break
3737   done
3738 fi
3739 if test -z "$CXX"; then
3740   ac_ct_CXX=$CXX
3741   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3742 do
3743   # Extract the first word of "$ac_prog", so it can be a program name with args.
3744 set dummy $ac_prog; ac_word=$2
3745 echo "$as_me:$LINENO: checking for $ac_word" >&5
3746 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3747 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3748   echo $ECHO_N "(cached) $ECHO_C" >&6
3749 else
3750   if test -n "$ac_ct_CXX"; then
3751   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3752 else
3753 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3754 for as_dir in $PATH
3755 do
3756   IFS=$as_save_IFS
3757   test -z "$as_dir" && as_dir=.
3758   for ac_exec_ext in '' $ac_executable_extensions; do
3759   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3760     ac_cv_prog_ac_ct_CXX="$ac_prog"
3761     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3762     break 2
3763   fi
3764 done
3765 done
3766
3767 fi
3768 fi
3769 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3770 if test -n "$ac_ct_CXX"; then
3771   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3772 echo "${ECHO_T}$ac_ct_CXX" >&6
3773 else
3774   echo "$as_me:$LINENO: result: no" >&5
3775 echo "${ECHO_T}no" >&6
3776 fi
3777
3778   test -n "$ac_ct_CXX" && break
3779 done
3780 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3781
3782   CXX=$ac_ct_CXX
3783 fi
3784
3785
3786 # Provide some information about the compiler.
3787 echo "$as_me:$LINENO:" \
3788      "checking for C++ compiler version" >&5
3789 ac_compiler=`set X $ac_compile; echo $2`
3790 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3791   (eval $ac_compiler --version </dev/null >&5) 2>&5
3792   ac_status=$?
3793   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3794   (exit $ac_status); }
3795 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3796   (eval $ac_compiler -v </dev/null >&5) 2>&5
3797   ac_status=$?
3798   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3799   (exit $ac_status); }
3800 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3801   (eval $ac_compiler -V </dev/null >&5) 2>&5
3802   ac_status=$?
3803   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3804   (exit $ac_status); }
3805
3806 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3807 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3808 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3809   echo $ECHO_N "(cached) $ECHO_C" >&6
3810 else
3811   cat >conftest.$ac_ext <<_ACEOF
3812 /* confdefs.h.  */
3813 _ACEOF
3814 cat confdefs.h >>conftest.$ac_ext
3815 cat >>conftest.$ac_ext <<_ACEOF
3816 /* end confdefs.h.  */
3817
3818 int
3819 main ()
3820 {
3821 #ifndef __GNUC__
3822        choke me
3823 #endif
3824
3825   ;
3826   return 0;
3827 }
3828 _ACEOF
3829 rm -f conftest.$ac_objext
3830 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3831   (eval $ac_compile) 2>conftest.er1
3832   ac_status=$?
3833   grep -v '^ *+' conftest.er1 >conftest.err
3834   rm -f conftest.er1
3835   cat conftest.err >&5
3836   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3837   (exit $ac_status); } &&
3838          { ac_try='test -z "$ac_cxx_werror_flag"
3839                          || test ! -s conftest.err'
3840   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3841   (eval $ac_try) 2>&5
3842   ac_status=$?
3843   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3844   (exit $ac_status); }; } &&
3845          { ac_try='test -s conftest.$ac_objext'
3846   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3847   (eval $ac_try) 2>&5
3848   ac_status=$?
3849   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3850   (exit $ac_status); }; }; then
3851   ac_compiler_gnu=yes
3852 else
3853   echo "$as_me: failed program was:" >&5
3854 sed 's/^/| /' conftest.$ac_ext >&5
3855
3856 ac_compiler_gnu=no
3857 fi
3858 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3859 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3860
3861 fi
3862 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3863 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3864 GXX=`test $ac_compiler_gnu = yes && echo yes`
3865 ac_test_CXXFLAGS=${CXXFLAGS+set}
3866 ac_save_CXXFLAGS=$CXXFLAGS
3867 CXXFLAGS="-g"
3868 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3869 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3870 if test "${ac_cv_prog_cxx_g+set}" = set; then
3871   echo $ECHO_N "(cached) $ECHO_C" >&6
3872 else
3873   cat >conftest.$ac_ext <<_ACEOF
3874 /* confdefs.h.  */
3875 _ACEOF
3876 cat confdefs.h >>conftest.$ac_ext
3877 cat >>conftest.$ac_ext <<_ACEOF
3878 /* end confdefs.h.  */
3879
3880 int
3881 main ()
3882 {
3883
3884   ;
3885   return 0;
3886 }
3887 _ACEOF
3888 rm -f conftest.$ac_objext
3889 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3890   (eval $ac_compile) 2>conftest.er1
3891   ac_status=$?
3892   grep -v '^ *+' conftest.er1 >conftest.err
3893   rm -f conftest.er1
3894   cat conftest.err >&5
3895   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3896   (exit $ac_status); } &&
3897          { ac_try='test -z "$ac_cxx_werror_flag"
3898                          || test ! -s conftest.err'
3899   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3900   (eval $ac_try) 2>&5
3901   ac_status=$?
3902   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3903   (exit $ac_status); }; } &&
3904          { ac_try='test -s conftest.$ac_objext'
3905   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3906   (eval $ac_try) 2>&5
3907   ac_status=$?
3908   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3909   (exit $ac_status); }; }; then
3910   ac_cv_prog_cxx_g=yes
3911 else
3912   echo "$as_me: failed program was:" >&5
3913 sed 's/^/| /' conftest.$ac_ext >&5
3914
3915 ac_cv_prog_cxx_g=no
3916 fi
3917 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3918 fi
3919 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3920 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
3921 if test "$ac_test_CXXFLAGS" = set; then
3922   CXXFLAGS=$ac_save_CXXFLAGS
3923 elif test $ac_cv_prog_cxx_g = yes; then
3924   if test "$GXX" = yes; then
3925     CXXFLAGS="-g -O2"
3926   else
3927     CXXFLAGS="-g"
3928   fi
3929 else
3930   if test "$GXX" = yes; then
3931     CXXFLAGS="-O2"
3932   else
3933     CXXFLAGS=
3934   fi
3935 fi
3936 for ac_declaration in \
3937    '' \
3938    'extern "C" void std::exit (int) throw (); using std::exit;' \
3939    'extern "C" void std::exit (int); using std::exit;' \
3940    'extern "C" void exit (int) throw ();' \
3941    'extern "C" void exit (int);' \
3942    'void exit (int);'
3943 do
3944   cat >conftest.$ac_ext <<_ACEOF
3945 /* confdefs.h.  */
3946 _ACEOF
3947 cat confdefs.h >>conftest.$ac_ext
3948 cat >>conftest.$ac_ext <<_ACEOF
3949 /* end confdefs.h.  */
3950 $ac_declaration
3951 #include <stdlib.h>
3952 int
3953 main ()
3954 {
3955 exit (42);
3956   ;
3957   return 0;
3958 }
3959 _ACEOF
3960 rm -f conftest.$ac_objext
3961 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3962   (eval $ac_compile) 2>conftest.er1
3963   ac_status=$?
3964   grep -v '^ *+' conftest.er1 >conftest.err
3965   rm -f conftest.er1
3966   cat conftest.err >&5
3967   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3968   (exit $ac_status); } &&
3969          { ac_try='test -z "$ac_cxx_werror_flag"
3970                          || test ! -s conftest.err'
3971   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3972   (eval $ac_try) 2>&5
3973   ac_status=$?
3974   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3975   (exit $ac_status); }; } &&
3976          { ac_try='test -s conftest.$ac_objext'
3977   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3978   (eval $ac_try) 2>&5
3979   ac_status=$?
3980   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3981   (exit $ac_status); }; }; then
3982   :
3983 else
3984   echo "$as_me: failed program was:" >&5
3985 sed 's/^/| /' conftest.$ac_ext >&5
3986
3987 continue
3988 fi
3989 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3990   cat >conftest.$ac_ext <<_ACEOF
3991 /* confdefs.h.  */
3992 _ACEOF
3993 cat confdefs.h >>conftest.$ac_ext
3994 cat >>conftest.$ac_ext <<_ACEOF
3995 /* end confdefs.h.  */
3996 $ac_declaration
3997 int
3998 main ()
3999 {
4000 exit (42);
4001   ;
4002   return 0;
4003 }
4004 _ACEOF
4005 rm -f conftest.$ac_objext
4006 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4007   (eval $ac_compile) 2>conftest.er1
4008   ac_status=$?
4009   grep -v '^ *+' conftest.er1 >conftest.err
4010   rm -f conftest.er1
4011   cat conftest.err >&5
4012   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4013   (exit $ac_status); } &&
4014          { ac_try='test -z "$ac_cxx_werror_flag"
4015                          || test ! -s conftest.err'
4016   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4017   (eval $ac_try) 2>&5
4018   ac_status=$?
4019   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4020   (exit $ac_status); }; } &&
4021          { ac_try='test -s conftest.$ac_objext'
4022   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4023   (eval $ac_try) 2>&5
4024   ac_status=$?
4025   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4026   (exit $ac_status); }; }; then
4027   break
4028 else
4029   echo "$as_me: failed program was:" >&5
4030 sed 's/^/| /' conftest.$ac_ext >&5
4031
4032 fi
4033 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4034 done
4035 rm -f conftest*
4036 if test -n "$ac_declaration"; then
4037   echo '#ifdef __cplusplus' >>confdefs.h
4038   echo $ac_declaration      >>confdefs.h
4039   echo '#endif'             >>confdefs.h
4040 fi
4041
4042 ac_ext=c
4043 ac_cpp='$CPP $CPPFLAGS'
4044 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4045 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4046 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4047
4048
4049 # We must set the default linker to the linker used by gcc for the correct
4050 # operation of libtool.  If LD is not defined and we are using gcc, try to
4051 # set the LD default to the ld used by gcc.
4052 if test -z "$LD"; then
4053   if test "$GCC" = yes; then
4054     case $build in
4055     *-*-mingw*)
4056       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4057     *)
4058       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4059     esac
4060     case $gcc_prog_ld in
4061     # Accept absolute paths.
4062     [\\/]* | [A-Za-z]:[\\/]*)
4063       LD="$gcc_prog_ld" ;;
4064     esac
4065   fi
4066 fi
4067
4068
4069
4070
4071 if test -n "$ac_tool_prefix"; then
4072   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4073 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4074 echo "$as_me:$LINENO: checking for $ac_word" >&5
4075 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4076 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4077   echo $ECHO_N "(cached) $ECHO_C" >&6
4078 else
4079   if test -n "$GNATBIND"; then
4080   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4081 else
4082 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4083 for as_dir in $PATH
4084 do
4085   IFS=$as_save_IFS
4086   test -z "$as_dir" && as_dir=.
4087   for ac_exec_ext in '' $ac_executable_extensions; do
4088   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4089     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4090     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4091     break 2
4092   fi
4093 done
4094 done
4095
4096 fi
4097 fi
4098 GNATBIND=$ac_cv_prog_GNATBIND
4099 if test -n "$GNATBIND"; then
4100   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4101 echo "${ECHO_T}$GNATBIND" >&6
4102 else
4103   echo "$as_me:$LINENO: result: no" >&5
4104 echo "${ECHO_T}no" >&6
4105 fi
4106
4107 fi
4108 if test -z "$ac_cv_prog_GNATBIND"; then
4109   ac_ct_GNATBIND=$GNATBIND
4110   # Extract the first word of "gnatbind", so it can be a program name with args.
4111 set dummy gnatbind; ac_word=$2
4112 echo "$as_me:$LINENO: checking for $ac_word" >&5
4113 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4114 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4115   echo $ECHO_N "(cached) $ECHO_C" >&6
4116 else
4117   if test -n "$ac_ct_GNATBIND"; then
4118   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4119 else
4120 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4121 for as_dir in $PATH
4122 do
4123   IFS=$as_save_IFS
4124   test -z "$as_dir" && as_dir=.
4125   for ac_exec_ext in '' $ac_executable_extensions; do
4126   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4127     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4128     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4129     break 2
4130   fi
4131 done
4132 done
4133
4134   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4135 fi
4136 fi
4137 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4138 if test -n "$ac_ct_GNATBIND"; then
4139   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4140 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4141 else
4142   echo "$as_me:$LINENO: result: no" >&5
4143 echo "${ECHO_T}no" >&6
4144 fi
4145
4146   GNATBIND=$ac_ct_GNATBIND
4147 else
4148   GNATBIND="$ac_cv_prog_GNATBIND"
4149 fi
4150
4151 if test -n "$ac_tool_prefix"; then
4152   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4153 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4154 echo "$as_me:$LINENO: checking for $ac_word" >&5
4155 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4156 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4157   echo $ECHO_N "(cached) $ECHO_C" >&6
4158 else
4159   if test -n "$GNATMAKE"; then
4160   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4161 else
4162 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4163 for as_dir in $PATH
4164 do
4165   IFS=$as_save_IFS
4166   test -z "$as_dir" && as_dir=.
4167   for ac_exec_ext in '' $ac_executable_extensions; do
4168   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4169     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4170     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4171     break 2
4172   fi
4173 done
4174 done
4175
4176 fi
4177 fi
4178 GNATMAKE=$ac_cv_prog_GNATMAKE
4179 if test -n "$GNATMAKE"; then
4180   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4181 echo "${ECHO_T}$GNATMAKE" >&6
4182 else
4183   echo "$as_me:$LINENO: result: no" >&5
4184 echo "${ECHO_T}no" >&6
4185 fi
4186
4187 fi
4188 if test -z "$ac_cv_prog_GNATMAKE"; then
4189   ac_ct_GNATMAKE=$GNATMAKE
4190   # Extract the first word of "gnatmake", so it can be a program name with args.
4191 set dummy gnatmake; ac_word=$2
4192 echo "$as_me:$LINENO: checking for $ac_word" >&5
4193 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4194 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4195   echo $ECHO_N "(cached) $ECHO_C" >&6
4196 else
4197   if test -n "$ac_ct_GNATMAKE"; then
4198   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4199 else
4200 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4201 for as_dir in $PATH
4202 do
4203   IFS=$as_save_IFS
4204   test -z "$as_dir" && as_dir=.
4205   for ac_exec_ext in '' $ac_executable_extensions; do
4206   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4207     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4208     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4209     break 2
4210   fi
4211 done
4212 done
4213
4214   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4215 fi
4216 fi
4217 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4218 if test -n "$ac_ct_GNATMAKE"; then
4219   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4220 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4221 else
4222   echo "$as_me:$LINENO: result: no" >&5
4223 echo "${ECHO_T}no" >&6
4224 fi
4225
4226   GNATMAKE=$ac_ct_GNATMAKE
4227 else
4228   GNATMAKE="$ac_cv_prog_GNATMAKE"
4229 fi
4230
4231 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4232 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4233 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4234   echo $ECHO_N "(cached) $ECHO_C" >&6
4235 else
4236   cat >conftest.adb <<EOF
4237 procedure conftest is begin null; end conftest;
4238 EOF
4239 acx_cv_cc_gcc_supports_ada=no
4240 # There is a bug in old released versions of GCC which causes the
4241 # driver to exit successfully when the appropriate language module
4242 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4243 # Therefore we must check for the error message as well as an
4244 # unsuccessful exit.
4245 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4246 # given a .adb file, but produce no object file.  So we must check
4247 # if an object file was really produced to guard against this.
4248 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4249 if test x"$errors" = x && test -f conftest.$ac_objext; then
4250   acx_cv_cc_gcc_supports_ada=yes
4251 fi
4252 rm -f conftest.*
4253 fi
4254 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4255 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4256
4257 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4258   have_gnat=yes
4259 else
4260   have_gnat=no
4261 fi
4262
4263 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4264 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4265 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4266   echo $ECHO_N "(cached) $ECHO_C" >&6
4267 else
4268    echo abfoo >t1
4269   echo cdfoo >t2
4270   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4271   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4272     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4273       :
4274     else
4275       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4276     fi
4277   fi
4278   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4279     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4280       :
4281     else
4282       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4283     fi
4284   fi
4285   rm t1 t2
4286
4287 fi
4288 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4289 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4290 do_compare="$gcc_cv_prog_cmp_skip"
4291
4292
4293
4294 # Check for GMP and MPFR
4295 gmplibs="-lmpfr -lgmp"
4296 gmpinc=
4297 have_gmp=no
4298
4299 # Specify a location for mpfr
4300 # check for this first so it ends up on the link line before gmp.
4301
4302 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4303 if test "${with_mpfr_dir+set}" = set; then
4304   withval="$with_mpfr_dir"
4305   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4306 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4307 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4308 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4309    { (exit 1); exit 1; }; }
4310 fi;
4311
4312
4313 # Check whether --with-mpfr or --without-mpfr was given.
4314 if test "${with_mpfr+set}" = set; then
4315   withval="$with_mpfr"
4316
4317 fi;
4318
4319 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4320 if test "${with_mpfr_include+set}" = set; then
4321   withval="$with_mpfr_include"
4322
4323 fi;
4324
4325 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4326 if test "${with_mpfr_lib+set}" = set; then
4327   withval="$with_mpfr_lib"
4328
4329 fi;
4330
4331 if test "x$with_mpfr" != x; then
4332   gmplibs="-L$with_mpfr/lib $gmplibs"
4333   gmpinc="-I$with_mpfr/include"
4334 fi
4335 if test "x$with_mpfr_include" != x; then
4336   gmpinc="-I$with_mpfr_include"
4337 fi
4338 if test "x$with_mpfr_lib" != x; then
4339   gmplibs="-L$with_mpfr_lib $gmplibs"
4340 fi
4341 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4342   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4343   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4344   # Do not test the mpfr version.  Assume that it is sufficient, since
4345   # it is in the source tree, and the library has not been built yet
4346   # but it would be included on the link line in the version check below
4347   # hence making the test fail.
4348   have_gmp=yes
4349 fi
4350
4351 # Specify a location for gmp
4352
4353 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4354 if test "${with_gmp_dir+set}" = set; then
4355   withval="$with_gmp_dir"
4356   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4357 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4358 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4359 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4360    { (exit 1); exit 1; }; }
4361 fi;
4362
4363
4364 # Check whether --with-gmp or --without-gmp was given.
4365 if test "${with_gmp+set}" = set; then
4366   withval="$with_gmp"
4367
4368 fi;
4369
4370 # Check whether --with-gmp_include or --without-gmp_include was given.
4371 if test "${with_gmp_include+set}" = set; then
4372   withval="$with_gmp_include"
4373
4374 fi;
4375
4376 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4377 if test "${with_gmp_lib+set}" = set; then
4378   withval="$with_gmp_lib"
4379
4380 fi;
4381
4382
4383 if test "x$with_gmp" != x; then
4384   gmplibs="-L$with_gmp/lib $gmplibs"
4385   gmpinc="-I$with_gmp/include $gmpinc"
4386 fi
4387 if test "x$with_gmp_include" != x; then
4388   gmpinc="-I$with_gmp_include $gmpinc"
4389 fi
4390 if test "x$with_gmp_lib" != x; then
4391   gmplibs="-L$with_gmp_lib $gmplibs"
4392 fi
4393 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4394   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4395   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4396   # Do not test the gmp version.  Assume that it is sufficient, since
4397   # it is in the source tree, and the library has not been built yet
4398   # but it would be included on the link line in the version check below
4399   # hence making the test fail.
4400   have_gmp=yes
4401 fi
4402
4403 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4404   have_gmp=yes
4405   saved_CFLAGS="$CFLAGS"
4406   CFLAGS="$CFLAGS $gmpinc"
4407   # Check GMP actually works
4408   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4409 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4410
4411 cat >conftest.$ac_ext <<_ACEOF
4412 /* confdefs.h.  */
4413 _ACEOF
4414 cat confdefs.h >>conftest.$ac_ext
4415 cat >>conftest.$ac_ext <<_ACEOF
4416 /* end confdefs.h.  */
4417 #include "gmp.h"
4418 int
4419 main ()
4420 {
4421
4422   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4423   choke me
4424   #endif
4425
4426   ;
4427   return 0;
4428 }
4429 _ACEOF
4430 rm -f conftest.$ac_objext
4431 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4432   (eval $ac_compile) 2>conftest.er1
4433   ac_status=$?
4434   grep -v '^ *+' conftest.er1 >conftest.err
4435   rm -f conftest.er1
4436   cat conftest.err >&5
4437   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4438   (exit $ac_status); } &&
4439          { ac_try='test -z "$ac_c_werror_flag"
4440                          || test ! -s conftest.err'
4441   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4442   (eval $ac_try) 2>&5
4443   ac_status=$?
4444   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4445   (exit $ac_status); }; } &&
4446          { ac_try='test -s conftest.$ac_objext'
4447   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4448   (eval $ac_try) 2>&5
4449   ac_status=$?
4450   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4451   (exit $ac_status); }; }; then
4452   echo "$as_me:$LINENO: result: yes" >&5
4453 echo "${ECHO_T}yes" >&6
4454 else
4455   echo "$as_me: failed program was:" >&5
4456 sed 's/^/| /' conftest.$ac_ext >&5
4457
4458 echo "$as_me:$LINENO: result: no" >&5
4459 echo "${ECHO_T}no" >&6; have_gmp=no
4460 fi
4461 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4462
4463   if test x"$have_gmp" = xyes; then
4464     saved_LIBS="$LIBS"
4465     LIBS="$LIBS $gmplibs"
4466         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4467 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4468     cat >conftest.$ac_ext <<_ACEOF
4469 /* confdefs.h.  */
4470 _ACEOF
4471 cat confdefs.h >>conftest.$ac_ext
4472 cat >>conftest.$ac_ext <<_ACEOF
4473 /* end confdefs.h.  */
4474 #include <gmp.h>
4475     #include <mpfr.h>
4476 int
4477 main ()
4478 {
4479
4480     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,0)
4481     choke me
4482     #endif
4483     mpfr_t n;
4484     mpfr_t x;
4485     int t;
4486     mpfr_init (n);
4487     mpfr_init (x);
4488     mpfr_atan2 (n, n, x, GMP_RNDN);
4489     mpfr_erfc (n, x, GMP_RNDN);
4490     mpfr_subnormalize (x, t, GMP_RNDN);
4491
4492   ;
4493   return 0;
4494 }
4495 _ACEOF
4496 rm -f conftest.$ac_objext conftest$ac_exeext
4497 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4498   (eval $ac_link) 2>conftest.er1
4499   ac_status=$?
4500   grep -v '^ *+' conftest.er1 >conftest.err
4501   rm -f conftest.er1
4502   cat conftest.err >&5
4503   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4504   (exit $ac_status); } &&
4505          { ac_try='test -z "$ac_c_werror_flag"
4506                          || test ! -s conftest.err'
4507   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4508   (eval $ac_try) 2>&5
4509   ac_status=$?
4510   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4511   (exit $ac_status); }; } &&
4512          { ac_try='test -s conftest$ac_exeext'
4513   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4514   (eval $ac_try) 2>&5
4515   ac_status=$?
4516   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4517   (exit $ac_status); }; }; then
4518   cat >conftest.$ac_ext <<_ACEOF
4519 /* confdefs.h.  */
4520 _ACEOF
4521 cat confdefs.h >>conftest.$ac_ext
4522 cat >>conftest.$ac_ext <<_ACEOF
4523 /* end confdefs.h.  */
4524 #include <gmp.h>
4525     #include <mpfr.h>
4526 int
4527 main ()
4528 {
4529
4530     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4531     choke me
4532     #endif
4533     mpfr_t n; mpfr_init(n);
4534
4535   ;
4536   return 0;
4537 }
4538 _ACEOF
4539 rm -f conftest.$ac_objext conftest$ac_exeext
4540 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4541   (eval $ac_link) 2>conftest.er1
4542   ac_status=$?
4543   grep -v '^ *+' conftest.er1 >conftest.err
4544   rm -f conftest.er1
4545   cat conftest.err >&5
4546   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4547   (exit $ac_status); } &&
4548          { ac_try='test -z "$ac_c_werror_flag"
4549                          || test ! -s conftest.err'
4550   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4551   (eval $ac_try) 2>&5
4552   ac_status=$?
4553   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4554   (exit $ac_status); }; } &&
4555          { ac_try='test -s conftest$ac_exeext'
4556   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4557   (eval $ac_try) 2>&5
4558   ac_status=$?
4559   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4560   (exit $ac_status); }; }; then
4561   echo "$as_me:$LINENO: result: yes" >&5
4562 echo "${ECHO_T}yes" >&6
4563 else
4564   echo "$as_me: failed program was:" >&5
4565 sed 's/^/| /' conftest.$ac_ext >&5
4566
4567 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4568 echo "${ECHO_T}buggy but acceptable" >&6
4569 fi
4570 rm -f conftest.err conftest.$ac_objext \
4571       conftest$ac_exeext conftest.$ac_ext
4572 else
4573   echo "$as_me: failed program was:" >&5
4574 sed 's/^/| /' conftest.$ac_ext >&5
4575
4576 echo "$as_me:$LINENO: result: no" >&5
4577 echo "${ECHO_T}no" >&6; have_gmp=no
4578 fi
4579 rm -f conftest.err conftest.$ac_objext \
4580       conftest$ac_exeext conftest.$ac_ext
4581       LIBS="$saved_LIBS"
4582   fi
4583   CFLAGS="$saved_CFLAGS"
4584
4585   if test x$have_gmp != xyes; then
4586     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4587 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4588 Copies of these libraries' source code can be found at their respective
4589 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4590 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4591 If you obtained GMP and/or MPFR from a vendor distribution package, make
4592 sure that you have installed both the libraries and the header files.
4593 They may be located in separate packages." >&5
4594 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4595 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4596 Copies of these libraries' source code can be found at their respective
4597 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4598 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4599 If you obtained GMP and/or MPFR from a vendor distribution package, make
4600 sure that you have installed both the libraries and the header files.
4601 They may be located in separate packages." >&2;}
4602    { (exit 1); exit 1; }; }
4603   fi
4604 fi
4605
4606 # Flags needed for both GMP and/or MPFR
4607
4608
4609
4610 # By default, C is the only stage 1 language.
4611 stage1_languages=,c,
4612
4613 # Figure out what language subdirectories are present.
4614 # Look if the user specified --enable-languages="..."; if not, use
4615 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4616 # go away some day.
4617 # NB:  embedded tabs in this IF block -- do not untabify
4618 if test -d ${srcdir}/gcc; then
4619   if test x"${enable_languages+set}" != xset; then
4620     if test x"${LANGUAGES+set}" = xset; then
4621       enable_languages="${LANGUAGES}"
4622         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4623     else
4624       enable_languages=all
4625     fi
4626   else
4627     if test x"${enable_languages}" = x ||
4628        test x"${enable_languages}" = xyes;
4629        then
4630       echo configure.in: --enable-languages needs at least one language argument 1>&2
4631       exit 1
4632     fi
4633   fi
4634   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4635
4636   # 'f95' is the old name for the 'fortran' language. We issue a warning
4637   # and make the substitution.
4638   case ,${enable_languages}, in
4639     *,f95,*)
4640       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4641       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4642       ;;
4643   esac
4644
4645   # First scan to see if an enabled language requires some other language.
4646   # We assume that a given config-lang.in will list all the language
4647   # front ends it requires, even if some are required indirectly.
4648   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4649     case ${lang_frag} in
4650       ..) ;;
4651       # The odd quoting in the next line works around
4652       # an apparent bug in bash 1.12 on linux.
4653       ${srcdir}/gcc/[*]/config-lang.in) ;;
4654       *)
4655         # From the config-lang.in, get $language, $lang_requires
4656         language=
4657         lang_requires=
4658         . ${lang_frag}
4659         for other in ${lang_requires} ; do
4660           case ,${enable_languages}, in
4661             *,$other,*) ;;
4662             *,all,*) ;;
4663             *,$language,*)
4664               echo " \`$other' language required by \`$language'; enabling" 1>&2
4665               enable_languages="${enable_languages},${other}"
4666               ;;
4667           esac
4668         done
4669         ;;
4670     esac
4671   done
4672
4673   new_enable_languages=,c,
4674   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4675   potential_languages=,c,
4676
4677   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4678     case ${lang_frag} in
4679       ..) ;;
4680       # The odd quoting in the next line works around
4681       # an apparent bug in bash 1.12 on linux.
4682       ${srcdir}/gcc/[*]/config-lang.in) ;;
4683       *)
4684         # From the config-lang.in, get $language, $target_libs,
4685         # $lang_dirs, $boot_language, and $build_by_default
4686         language=
4687         target_libs=
4688         lang_dirs=
4689         subdir_requires=
4690         boot_language=no
4691         build_by_default=yes
4692         . ${lang_frag}
4693         if test x${language} = x; then
4694           echo "${lang_frag} doesn't set \$language." 1>&2
4695           exit 1
4696         fi
4697
4698         case ,${enable_languages}, in
4699           *,${language},*)
4700             # Language was explicitly selected; include it.
4701             add_this_lang=yes
4702             ;;
4703           *,all,*)
4704             # 'all' was selected, select it if it is a default language
4705             add_this_lang=${build_by_default}
4706             ;;
4707           *)
4708             add_this_lang=no
4709             ;;
4710         esac
4711
4712         # Disable languages that need other directories if these aren't available.
4713         for i in $subdir_requires; do
4714           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4715           case ,${enable_languages}, in
4716             *,${language},*)
4717               # Specifically requested language; tell them.
4718               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4719 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4720    { (exit 1); exit 1; }; }
4721               ;;
4722             *)
4723               # Silently disable.
4724               add_this_lang=unsupported
4725               ;;
4726           esac
4727         done
4728
4729         # Disable Ada if no preexisting GNAT is available.
4730         case ,${enable_languages},:${language}:${have_gnat} in
4731           *,${language},*:ada:no)
4732             # Specifically requested language; tell them.
4733             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4734 echo "$as_me: error: GNAT is required to build $language" >&2;}
4735    { (exit 1); exit 1; }; }
4736             ;;
4737           *:ada:no)
4738             # Silently disable.
4739             add_this_lang=unsupported
4740             ;;
4741         esac
4742
4743         # Disable a language that is unsupported by the target.
4744         case " $unsupported_languages " in
4745           *" $language "*)
4746             add_this_lang=unsupported
4747             ;;
4748         esac
4749
4750         case $add_this_lang in
4751           unsupported)
4752             # Remove language-dependent dirs.
4753             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4754             ;;
4755           no)
4756             # Remove language-dependent dirs; still show language as supported.
4757             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4758             potential_languages="${potential_languages}${language},"
4759             ;;
4760           yes)
4761             new_enable_languages="${new_enable_languages}${language},"
4762             potential_languages="${potential_languages}${language},"
4763             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4764             case ${boot_language} in
4765               yes)
4766                 # Add to (comma-separated) list of stage 1 languages.
4767                 stage1_languages="${stage1_languages}${language},"
4768                 ;;
4769             esac
4770             ;;
4771         esac
4772         ;;
4773     esac
4774   done
4775
4776   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4777 if test "${enable_stage1_languages+set}" = set; then
4778   enableval="$enable_stage1_languages"
4779   case ,${enable_stage1_languages}, in
4780     ,no,|,,)
4781       # Set it to something that will have no effect in the loop below
4782       enable_stage1_languages=c ;;
4783     ,yes,)
4784       enable_stage1_languages=`echo $new_enable_languages | \
4785         sed -e "s/^,//" -e "s/,$//" ` ;;
4786     *,all,*)
4787       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4788         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4789   esac
4790
4791   # Add "good" languages from enable_stage1_languages to stage1_languages,
4792   # while "bad" languages go in missing_languages.  Leave no duplicates.
4793   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4794     case $potential_languages in
4795       *,$i,*)
4796         case $stage1_languages in
4797           *,$i,*) ;;
4798           *) stage1_languages="$stage1_languages$i," ;;
4799         esac ;;
4800       *)
4801         case $missing_languages in
4802           *,$i,*) ;;
4803           *) missing_languages="$missing_languages$i," ;;
4804         esac ;;
4805      esac
4806   done
4807 fi;
4808
4809   # Remove leading/trailing commas that were added for simplicity
4810   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4811   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4812   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4813   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4814
4815   if test "x$missing_languages" != x; then
4816     { { echo "$as_me:$LINENO: error:
4817 The following requested languages could not be built: ${missing_languages}
4818 Supported languages are: ${potential_languages}" >&5
4819 echo "$as_me: error:
4820 The following requested languages could not be built: ${missing_languages}
4821 Supported languages are: ${potential_languages}" >&2;}
4822    { (exit 1); exit 1; }; }
4823   fi
4824   if test "x$new_enable_languages" != "x$enable_languages"; then
4825     echo The following languages will be built: ${new_enable_languages}
4826     enable_languages="$new_enable_languages"
4827   fi
4828
4829
4830   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4831 fi
4832
4833 # Handle --disable-<component> generically.
4834 for dir in $configdirs $build_configdirs $target_configdirs ; do
4835   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4836   if eval test x\${enable_${dirname}} "=" xno ; then
4837     noconfigdirs="$noconfigdirs $dir"
4838   fi
4839 done
4840
4841 # Check for Boehm's garbage collector
4842 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4843 if test "${enable_objc_gc+set}" = set; then
4844   enableval="$enable_objc_gc"
4845   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4846   *,objc,*:*:yes:*target-boehm-gc*)
4847     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4848 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4849    { (exit 1); exit 1; }; }
4850     ;;
4851 esac
4852 fi;
4853
4854 # Make sure we only build Boehm's garbage collector if required.
4855 case ,${enable_languages},:${enable_objc_gc} in
4856   *,objc,*:yes)
4857     # Keep target-boehm-gc if requested for Objective-C.
4858     ;;
4859   *)
4860     # Otherwise remove target-boehm-gc depending on target-libjava.
4861     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4862       noconfigdirs="$noconfigdirs target-boehm-gc"
4863     fi
4864     ;;
4865 esac
4866
4867 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4868 # $build_configdirs and $target_configdirs.
4869 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4870
4871 notsupp=""
4872 for dir in . $skipdirs $noconfigdirs ; do
4873   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4874   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4875     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4876     if test -r $srcdir/$dirname/configure ; then
4877       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4878         true
4879       else
4880         notsupp="$notsupp $dir"
4881       fi
4882     fi
4883   fi
4884   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4885     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4886     if test -r $srcdir/$dirname/configure ; then
4887       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4888         true
4889       else
4890         notsupp="$notsupp $dir"
4891       fi
4892     fi
4893   fi
4894   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4895     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4896     if test -r $srcdir/$dirname/configure ; then
4897       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4898         true
4899       else
4900         notsupp="$notsupp $dir"
4901       fi
4902     fi
4903   fi
4904 done
4905
4906 # Sometimes the tools are distributed with libiberty but with no other
4907 # libraries.  In that case, we don't want to build target-libiberty.
4908 # Don't let libgcc imply libiberty either.
4909 if test -n "${target_configdirs}" ; then
4910   libgcc=
4911   others=
4912   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
4913     if test "$i" = "libgcc"; then
4914       libgcc=target-libgcc
4915     elif test "$i" != "libiberty" ; then
4916       if test -r $srcdir/$i/configure ; then
4917         others=yes;
4918         break;
4919       fi
4920     fi
4921   done
4922   if test -z "${others}" ; then
4923     target_configdirs=$libgcc
4924   fi
4925 fi
4926
4927 # Quietly strip out all directories which aren't configurable in this tree.
4928 # This relies on all configurable subdirectories being autoconfiscated, which
4929 # is now the case.
4930 build_configdirs_all="$build_configdirs"
4931 build_configdirs=
4932 for i in ${build_configdirs_all} ; do
4933   j=`echo $i | sed -e s/build-//g`
4934   if test -f ${srcdir}/$j/configure ; then
4935     build_configdirs="${build_configdirs} $i"
4936   fi
4937 done
4938
4939 configdirs_all="$configdirs"
4940 configdirs=
4941 for i in ${configdirs_all} ; do
4942   if test -f ${srcdir}/$i/configure ; then
4943     configdirs="${configdirs} $i"
4944   fi
4945 done
4946
4947 target_configdirs_all="$target_configdirs"
4948 target_configdirs=
4949 for i in ${target_configdirs_all} ; do
4950   j=`echo $i | sed -e s/target-//g`
4951   if test -f ${srcdir}/$j/configure ; then
4952     target_configdirs="${target_configdirs} $i"
4953   fi
4954 done
4955
4956 # Produce a warning message for the subdirs we can't configure.
4957 # This isn't especially interesting in the Cygnus tree, but in the individual
4958 # FSF releases, it's important to let people know when their machine isn't
4959 # supported by the one or two programs in a package.
4960
4961 if test -n "${notsupp}" && test -z "${norecursion}" ; then
4962   # If $appdirs is non-empty, at least one of those directories must still
4963   # be configured, or we error out.  (E.g., if the gas release supports a
4964   # specified target in some subdirs but not the gas subdir, we shouldn't
4965   # pretend that all is well.)
4966   if test -n "$appdirs" ; then
4967     for dir in $appdirs ; do
4968       if test -r $dir/Makefile.in ; then
4969         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4970           appdirs=""
4971           break
4972         fi
4973         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
4974           appdirs=""
4975           break
4976         fi
4977       fi
4978     done
4979     if test -n "$appdirs" ; then
4980       echo "*** This configuration is not supported by this package." 1>&2
4981       exit 1
4982     fi
4983   fi
4984   # Okay, some application will build, or we don't care to check.  Still
4985   # notify of subdirs not getting built.
4986   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
4987   echo "    ${notsupp}" 1>&2
4988   echo "    (Any other directories should still work fine.)" 1>&2
4989 fi
4990
4991 case "$host" in
4992   *msdosdjgpp*)
4993     enable_gdbtk=no ;;
4994 esac
4995
4996 # To find our prefix, in gcc_cv_tool_prefix.
4997
4998 # The user is always right.
4999 if test "${PATH_SEPARATOR+set}" != set; then
5000   echo "#! /bin/sh" >conf$$.sh
5001   echo  "exit 0"   >>conf$$.sh
5002   chmod +x conf$$.sh
5003   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5004     PATH_SEPARATOR=';'
5005   else
5006     PATH_SEPARATOR=:
5007   fi
5008   rm -f conf$$.sh
5009 fi
5010
5011
5012
5013 if test "x$exec_prefix" = xNONE; then
5014         if test "x$prefix" = xNONE; then
5015                 gcc_cv_tool_prefix=$ac_default_prefix
5016         else
5017                 gcc_cv_tool_prefix=$prefix
5018         fi
5019 else
5020         gcc_cv_tool_prefix=$exec_prefix
5021 fi
5022
5023 # If there is no compiler in the tree, use the PATH only.  In any
5024 # case, if there is no compiler in the tree nobody should use
5025 # AS_FOR_TARGET and LD_FOR_TARGET.
5026 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5027     gcc_version=`cat $srcdir/gcc/BASE-VER`
5028     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5029     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5030     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5031     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5032     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5033     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5034 else
5035     gcc_cv_tool_dirs=
5036 fi
5037
5038 if test x$build = x$target && test -n "$md_exec_prefix"; then
5039         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5040 fi
5041
5042
5043
5044 copy_dirs=
5045
5046
5047 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5048 if test "${with_build_sysroot+set}" = set; then
5049   withval="$with_build_sysroot"
5050   if test x"$withval" != x ; then
5051      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5052    fi
5053 else
5054   SYSROOT_CFLAGS_FOR_TARGET=
5055 fi;
5056
5057
5058 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5059 # the named directory are copied to $(tooldir)/sys-include.
5060 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5061   if test x${is_cross_compiler} = xno ; then
5062     echo 1>&2 '***' --with-headers is only supported when cross compiling
5063     exit 1
5064   fi
5065   if test x"${with_headers}" != xyes ; then
5066     x=${gcc_cv_tool_prefix}
5067     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5068   fi
5069 fi
5070
5071 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5072 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5073 # are permitted.
5074 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5075   if test x${is_cross_compiler} = xno ; then
5076     echo 1>&2 '***' --with-libs is only supported when cross compiling
5077     exit 1
5078   fi
5079   if test x"${with_libs}" != xyes ; then
5080     # Copy the libraries in reverse order, so that files in the first named
5081     # library override files in subsequent libraries.
5082     x=${gcc_cv_tool_prefix}
5083     for l in ${with_libs}; do
5084       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5085     done
5086   fi
5087 fi
5088
5089 # Set with_gnu_as and with_gnu_ld as appropriate.
5090 #
5091 # This is done by determining whether or not the appropriate directory
5092 # is available, and by checking whether or not specific configurations
5093 # have requested that this magic not happen.
5094 #
5095 # The command line options always override the explicit settings in
5096 # configure.in, and the settings in configure.in override this magic.
5097 #
5098 # If the default for a toolchain is to use GNU as and ld, and you don't
5099 # want to do that, then you should use the --without-gnu-as and
5100 # --without-gnu-ld options for the configure script.
5101
5102 if test x${use_gnu_as} = x &&
5103    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5104   with_gnu_as=yes
5105   extra_host_args="$extra_host_args --with-gnu-as"
5106 fi
5107
5108 if test x${use_gnu_ld} = x &&
5109    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5110   with_gnu_ld=yes
5111   extra_host_args="$extra_host_args --with-gnu-ld"
5112 fi
5113
5114 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5115 # can detect this case.
5116
5117 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5118   with_newlib=yes
5119   extra_host_args="$extra_host_args --with-newlib"
5120 fi
5121
5122 # Handle ${copy_dirs}
5123 set fnord ${copy_dirs}
5124 shift
5125 while test $# != 0 ; do
5126   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5127     :
5128   else
5129     echo Copying $1 to $2
5130
5131     # Use the install script to create the directory and all required
5132     # parent directories.
5133     if test -d $2 ; then
5134       :
5135     else
5136       echo >config.temp
5137       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5138     fi
5139
5140     # Copy the directory, assuming we have tar.
5141     # FIXME: Should we use B in the second tar?  Not all systems support it.
5142     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5143
5144     # It is the responsibility of the user to correctly adjust all
5145     # symlinks.  If somebody can figure out how to handle them correctly
5146     # here, feel free to add the code.
5147
5148     echo $1 > $2/COPIED
5149   fi
5150   shift; shift
5151 done
5152
5153 # Determine a target-dependent exec_prefix that the installed
5154 # gcc will search in.  Keep this list sorted by triplet, with
5155 # the *-*-osname triplets last.
5156 md_exec_prefix=
5157 case "${target}" in
5158   alpha*-*-*vms*)
5159     md_exec_prefix=/gnu/lib/gcc-lib
5160     ;;
5161   i3456786-pc-msdosdjgpp*)
5162     md_exec_prefix=/dev/env/DJDIR/bin
5163     ;;
5164   i3456786-*-sco3.2v5*)
5165     if test $with_gnu_as = yes; then
5166       md_exec_prefix=/usr/gnu/bin
5167     else
5168       md_exec_prefix=/usr/ccs/bin/elf
5169     fi
5170     ;;
5171
5172   mn10300-*-* | \
5173   powerpc-*-chorusos* | \
5174   powerpc*-*-eabi* | \
5175   powerpc*-*-sysv* | \
5176   powerpc*-*-kaos* | \
5177   s390x-ibm-tpf*)
5178     md_exec_prefix=/usr/ccs/bin
5179     ;;
5180   sparc64-*-elf*)
5181     ;;
5182   v850*-*-*)
5183     md_exec_prefix=/usr/ccs/bin
5184     ;;
5185   xtensa-*-elf*)
5186     ;;
5187
5188   *-*-beos* | \
5189   *-*-elf* | \
5190   *-*-hpux* | \
5191   *-*-netware* | \
5192   *-*-nto-qnx* | \
5193   *-*-rtems* | \
5194   *-*-solaris2* | \
5195   *-*-sysv45* | \
5196   *-*-vxworks* | \
5197   *-wrs-windiss)
5198     md_exec_prefix=/usr/ccs/bin
5199     ;;
5200 esac
5201
5202 extra_arflags_for_target=
5203 extra_nmflags_for_target=
5204 extra_ranlibflags_for_target=
5205 target_makefile_frag=/dev/null
5206 case "${target}" in
5207   mep*-*-*)
5208     target_makefile_frag="config/mt-mep"
5209     ;;
5210   spu-*-*)
5211     target_makefile_frag="config/mt-spu"
5212     ;;
5213   *-*-netware*)
5214     target_makefile_frag="config/mt-netware"
5215     ;;
5216   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5217     target_makefile_frag="config/mt-gnu"
5218     ;;
5219   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5220     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5221     # commands to handle both 32-bit and 64-bit objects.  These flags are
5222     # harmless if we're using GNU nm or ar.
5223     extra_arflags_for_target=" -X32_64"
5224     extra_nmflags_for_target=" -B -X32_64"
5225     ;;
5226   *-*-darwin*)
5227     # ranlib from Darwin requires the -c flag to look at common symbols.
5228     extra_ranlibflags_for_target=" -c"
5229     ;;
5230   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5231     target_makefile_frag="config/mt-wince"
5232     ;;
5233 esac
5234
5235 alphaieee_frag=/dev/null
5236 case $target in
5237   alpha*-*-*)
5238     # This just makes sure to use the -mieee option to build target libs.
5239     # This should probably be set individually by each library.
5240     alphaieee_frag="config/mt-alphaieee"
5241     ;;
5242 esac
5243
5244 # If --enable-target-optspace always use -Os instead of -O2 to build
5245 # the target libraries, similarly if it is not specified, use -Os
5246 # on selected platforms.
5247 ospace_frag=/dev/null
5248 case "${enable_target_optspace}:${target}" in
5249   yes:*)
5250     ospace_frag="config/mt-ospace"
5251     ;;
5252   :d30v-*)
5253     ospace_frag="config/mt-d30v"
5254     ;;
5255   :m32r-* | :d10v-* | :fr30-*)
5256     ospace_frag="config/mt-ospace"
5257     ;;
5258   no:* | :*)
5259     ;;
5260   *)
5261     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5262     ;;
5263 esac
5264
5265 # Default to using --with-stabs for certain targets.
5266 if test x${with_stabs} = x ; then
5267   case "${target}" in
5268   mips*-*-irix[56]*)
5269     ;;
5270   mips*-*-* | alpha*-*-osf*)
5271     with_stabs=yes;
5272     extra_host_args="${extra_host_args} --with-stabs"
5273     ;;
5274   esac
5275 fi
5276
5277 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5278 # them automatically.
5279 case "${host}" in
5280   hppa*64*-*-hpux11*)
5281     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5282     ;;
5283 esac
5284
5285 # Some systems (e.g., one of the i386-aix systems the gas testers are
5286 # using) don't handle "\$" correctly, so don't use it here.
5287 tooldir='${exec_prefix}'/${target_noncanonical}
5288 build_tooldir=${tooldir}
5289
5290 # Create a .gdbinit file which runs the one in srcdir
5291 # and tells GDB to look there for source files.
5292
5293 if test -r ${srcdir}/.gdbinit ; then
5294   case ${srcdir} in
5295     .) ;;
5296     *) cat > ./.gdbinit <<EOF
5297 # ${NO_EDIT}
5298 dir ${srcdir}
5299 dir .
5300 source ${srcdir}/.gdbinit
5301 EOF
5302     ;;
5303   esac
5304 fi
5305
5306 # Make sure that the compiler is able to generate an executable.  If it
5307 # can't, we are probably in trouble.  We don't care whether we can run the
5308 # executable--we might be using a cross compiler--we only care whether it
5309 # can be created.  At this point the main configure script has set CC.
5310 we_are_ok=no
5311 echo "int main () { return 0; }" > conftest.c
5312 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5313 if test $? = 0 ; then
5314   if test -s conftest || test -s conftest.exe ; then
5315     we_are_ok=yes
5316   fi
5317 fi
5318 case $we_are_ok in
5319   no)
5320     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5321     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5322     rm -f conftest*
5323     exit 1
5324     ;;
5325 esac
5326 rm -f conftest*
5327
5328 # The Solaris /usr/ucb/cc compiler does not appear to work.
5329 case "${host}" in
5330   sparc-sun-solaris2*)
5331       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5332       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5333           could_use=
5334           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5335           if test -d /opt/cygnus/bin ; then
5336               if test "$could_use" = "" ; then
5337                   could_use="/opt/cygnus/bin"
5338               else
5339                   could_use="$could_use or /opt/cygnus/bin"
5340               fi
5341           fi
5342         if test "$could_use" = "" ; then
5343             echo "Warning: compilation may fail because you're using"
5344             echo "/usr/ucb/cc.  You should change your PATH or CC "
5345             echo "variable and rerun configure."
5346         else
5347             echo "Warning: compilation may fail because you're using"
5348             echo "/usr/ucb/cc, when you should use the C compiler from"
5349             echo "$could_use.  You should change your"
5350             echo "PATH or CC variable and rerun configure."
5351         fi
5352       fi
5353   ;;
5354 esac
5355
5356 case "${host}" in
5357   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5358   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5359   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5360 esac
5361
5362 # Record target_configdirs and the configure arguments for target and
5363 # build configuration in Makefile.
5364 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5365 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5366
5367 # Determine whether gdb needs tk/tcl or not.
5368 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5369 # and in that case we want gdb to be built without tk.  Ugh!
5370 # In fact I believe gdb is the *only* package directly dependent on tk,
5371 # so we should be able to put the 'maybe's in unconditionally and
5372 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5373 # 100% sure that that's safe though.
5374
5375 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5376 case "$enable_gdbtk" in
5377   no)
5378     GDB_TK="" ;;
5379   yes)
5380     GDB_TK="${gdb_tk}" ;;
5381   *)
5382     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5383     # distro.  Eventually someone will fix this and move Insight, nee
5384     # gdbtk to a separate directory.
5385     if test -d ${srcdir}/gdb/gdbtk ; then
5386       GDB_TK="${gdb_tk}"
5387     else
5388       GDB_TK=""
5389     fi
5390     ;;
5391 esac
5392 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5393 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5394
5395 # Strip out unwanted targets.
5396
5397 # While at that, we remove Makefiles if we were started for recursive
5398 # configuration, so that the top-level Makefile reconfigures them,
5399 # like we used to do when configure itself was recursive.
5400
5401 # Loop over modules.  $extrasub must be used with care, limiting as
5402 # much as possible the usage of range addresses.  That's because autoconf
5403 # splits the sed script to overcome limits in the number of commands,
5404 # and relying on carefully-timed sed passes may turn out to be very hard
5405 # to maintain later.  In this particular case, you just have to be careful
5406 # not to nest @if/@endif pairs, because configure will not warn you at all.
5407
5408 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5409 if test "${enable_bootstrap+set}" = set; then
5410   enableval="$enable_bootstrap"
5411
5412 else
5413   enable_bootstrap=default
5414 fi;
5415
5416 # Issue errors and warnings for invalid/strange bootstrap combinations.
5417 case "$configdirs" in
5418   *gcc*) have_compiler=yes ;;
5419   *) have_compiler=no ;;
5420 esac
5421
5422 case "$have_compiler:$host:$target:$enable_bootstrap" in
5423   *:*:*:no) ;;
5424
5425   # Default behavior.  Enable bootstrap if we have a compiler
5426   # and we are in a native configuration.
5427   yes:$build:$build:default)
5428     enable_bootstrap=yes ;;
5429
5430   *:*:*:default)
5431     enable_bootstrap=no ;;
5432
5433   # We have a compiler and we are in a native configuration, bootstrap is ok
5434   yes:$build:$build:yes)
5435     ;;
5436
5437   # Other configurations, but we have a compiler.  Assume the user knows
5438   # what he's doing.
5439   yes:*:*:yes)
5440     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5441 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5442     ;;
5443
5444   # No compiler: if they passed --enable-bootstrap explicitly, fail
5445   no:*:*:yes)
5446     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5447 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5448    { (exit 1); exit 1; }; } ;;
5449
5450   # Fail if wrong command line
5451   *)
5452     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5453 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5454    { (exit 1); exit 1; }; }
5455     ;;
5456 esac
5457
5458 # Adjust the toplevel makefile according to whether bootstrap was selected.
5459 case "$enable_bootstrap" in
5460   yes)
5461     bootstrap_suffix=bootstrap ;;
5462   no)
5463     bootstrap_suffix=no-bootstrap ;;
5464 esac
5465
5466 for module in ${build_configdirs} ; do
5467   if test -z "${no_recursion}" \
5468      && test -f ${build_subdir}/${module}/Makefile; then
5469     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5470     rm -f ${build_subdir}/${module}/Makefile
5471   fi
5472   extrasub="$extrasub
5473 /^@if build-$module\$/d
5474 /^@endif build-$module\$/d
5475 /^@if build-$module-$bootstrap_suffix\$/d
5476 /^@endif build-$module-$bootstrap_suffix\$/d"
5477 done
5478 for module in ${configdirs} ; do
5479   if test -z "${no_recursion}"; then
5480     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5481       if test -f ${file}; then
5482         echo 1>&2 "*** removing ${file} to force reconfigure"
5483         rm -f ${file}
5484       fi
5485     done
5486   fi
5487   extrasub="$extrasub
5488 /^@if $module\$/d
5489 /^@endif $module\$/d
5490 /^@if $module-$bootstrap_suffix\$/d
5491 /^@endif $module-$bootstrap_suffix\$/d"
5492 done
5493 for module in ${target_configdirs} ; do
5494   if test -z "${no_recursion}" \
5495      && test -f ${target_subdir}/${module}/Makefile; then
5496     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5497     rm -f ${target_subdir}/${module}/Makefile
5498   fi
5499   extrasub="$extrasub
5500 /^@if target-$module\$/d
5501 /^@endif target-$module\$/d
5502 /^@if target-$module-$bootstrap_suffix\$/d
5503 /^@endif target-$module-$bootstrap_suffix\$/d"
5504 done
5505
5506 extrasub="$extrasub
5507 /^@if /,/^@endif /d"
5508
5509 # Create the serialization dependencies.  This uses a temporary file.
5510
5511 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5512 if test "${enable_serial_configure+set}" = set; then
5513   enableval="$enable_serial_configure"
5514
5515 fi;
5516
5517 case ${enable_serial_configure} in
5518   yes)
5519     enable_serial_build_configure=yes
5520     enable_serial_host_configure=yes
5521     enable_serial_target_configure=yes
5522     ;;
5523 esac
5524
5525 # These force 'configure's to be done one at a time, to avoid problems
5526 # with contention over a shared config.cache.
5527 rm -f serdep.tmp
5528 echo '# serdep.tmp' > serdep.tmp
5529 olditem=
5530 test "x${enable_serial_build_configure}" = xyes &&
5531 for item in ${build_configdirs} ; do
5532   case ${olditem} in
5533     "") ;;
5534     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5535   esac
5536   olditem=${item}
5537 done
5538 olditem=
5539 test "x${enable_serial_host_configure}" = xyes &&
5540 for item in ${configdirs} ; do
5541   case ${olditem} in
5542     "") ;;
5543     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5544   esac
5545   olditem=${item}
5546 done
5547 olditem=
5548 test "x${enable_serial_target_configure}" = xyes &&
5549 for item in ${target_configdirs} ; do
5550   case ${olditem} in
5551     "") ;;
5552     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5553   esac
5554   olditem=${item}
5555 done
5556 serialization_dependencies=serdep.tmp
5557
5558
5559 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5560 # target, nonopt, and variable assignments.  These are the ones we
5561 # might not want to pass down to subconfigures.  Also strip
5562 # program-prefix, program-suffix, and program-transform-name, so that
5563 # we can pass down a consistent program-transform-name.
5564 baseargs=
5565 keep_next=no
5566 skip_next=no
5567 eval "set -- $ac_configure_args"
5568 for ac_arg
5569 do
5570   if test X"$skip_next" = X"yes"; then
5571     skip_next=no
5572     continue
5573   fi
5574   if test X"$keep_next" = X"yes"; then
5575     case $ac_arg in
5576       *\'*)
5577         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5578     esac
5579     baseargs="$baseargs '$ac_arg'"
5580     keep_next=no
5581     continue
5582   fi
5583
5584   # Handle separated arguments.  Based on the logic generated by
5585   # autoconf 2.59.
5586   case $ac_arg in
5587     *=* | --config-cache | -C | -disable-* | --disable-* \
5588       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5589       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5590       | -with-* | --with-* | -without-* | --without-* | --x)
5591       separate_arg=no
5592       ;;
5593     -*)
5594       separate_arg=yes
5595       ;;
5596     *)
5597       separate_arg=no
5598       ;;
5599   esac
5600
5601   case "$ac_arg" in
5602     --no*)
5603       continue
5604       ;;
5605     --c* | \
5606     --sr* | \
5607     --ho* | \
5608     --bu* | \
5609     --t* | \
5610     --program-* | \
5611     -cache_file* | \
5612     -srcdir* | \
5613     -host* | \
5614     -build* | \
5615     -target* | \
5616     -program-prefix* | \
5617     -program-suffix* | \
5618     -program-transform-name* )
5619       skip_next=$separate_arg
5620       continue
5621       ;;
5622     -*)
5623       # An option.  Add it.
5624       case $ac_arg in
5625         *\'*)
5626           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5627       esac
5628       baseargs="$baseargs '$ac_arg'"
5629       keep_next=$separate_arg
5630       ;;
5631     *)
5632       # Either a variable assignment, or a nonopt (triplet).  Don't
5633       # pass it down; let the Makefile handle this.
5634       continue
5635       ;;
5636   esac
5637 done
5638 # Remove the initial space we just introduced and, as these will be
5639 # expanded by make, quote '$'.
5640 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5641
5642 # Add in --program-transform-name, after --program-prefix and
5643 # --program-suffix have been applied to it.  Autoconf has already
5644 # doubled dollar signs and backslashes in program_transform_name; we want
5645 # the backslashes un-doubled, and then the entire thing wrapped in single
5646 # quotes, because this will be expanded first by make and then by the shell.
5647 # Also, because we want to override the logic in subdir configure scripts to
5648 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5649 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5650 ${program_transform_name}
5651 EOF_SED
5652 gcc_transform_name=`cat conftestsed.out`
5653 rm -f conftestsed.out
5654 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5655
5656 # For the build-side libraries, we just need to pretend we're native,
5657 # and not use the same cache file.  Multilibs are neither needed nor
5658 # desired.
5659 build_configargs="--cache-file=../config.cache ${baseargs}"
5660
5661 # For host modules, accept cache file option, or specification as blank.
5662 case "${cache_file}" in
5663 "") # empty
5664   cache_file_option="" ;;
5665 /* | [A-Za-z]:[\\/]* ) # absolute path
5666   cache_file_option="--cache-file=${cache_file}" ;;
5667 *) # relative path
5668   cache_file_option="--cache-file=../${cache_file}" ;;
5669 esac
5670
5671 # Host dirs don't like to share a cache file either, horribly enough.
5672 # This seems to be due to autoconf 2.5x stupidity.
5673 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5674
5675 target_configargs=${baseargs}
5676
5677 # Passing a --with-cross-host argument lets the target libraries know
5678 # whether they are being built with a cross-compiler or being built
5679 # native.  However, it would be better to use other mechanisms to make the
5680 # sorts of decisions they want to make on this basis.  Please consider
5681 # this option to be deprecated.  FIXME.
5682 if test x${is_cross_compiler} = xyes ; then
5683   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5684 fi
5685
5686 # Default to --enable-multilib.
5687 if test x${enable_multilib} = x ; then
5688   target_configargs="--enable-multilib ${target_configargs}"
5689 fi
5690
5691 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5692 # changed from the earlier setting of with_newlib.
5693 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5694   target_configargs="--with-newlib ${target_configargs}"
5695 fi
5696
5697 # Different target subdirs use different values of certain variables
5698 # (notably CXX).  Worse, multilibs use *lots* of different values.
5699 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5700 # it doesn't automatically accept command-line overrides of them.
5701 # This means it's not safe for target subdirs to share a cache file,
5702 # which is disgusting, but there you have it.  Hopefully this can be
5703 # fixed in future.  It's still worthwhile to use a cache file for each
5704 # directory.  I think.
5705
5706 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5707 # We need to pass --target, as newer autoconf's requires consistency
5708 # for target_alias and gcc doesn't manage it consistently.
5709 target_configargs="--cache-file=./config.cache ${target_configargs}"
5710
5711 FLAGS_FOR_TARGET=
5712 case " $target_configdirs " in
5713  *" newlib "*)
5714   case " $target_configargs " in
5715   *" --with-newlib "*)
5716    case "$target" in
5717    *-cygwin*)
5718      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' ;;
5719    esac
5720
5721    # If we're not building GCC, don't discard standard headers.
5722    if test -d ${srcdir}/gcc; then
5723      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5724
5725      if test "${build}" != "${host}"; then
5726        # On Canadian crosses, CC_FOR_TARGET will have already been set
5727        # by `configure', so we won't have an opportunity to add -Bgcc/
5728        # to it.  This is right: we don't want to search that directory
5729        # for binaries, but we want the header files in there, so add
5730        # them explicitly.
5731        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5732
5733        # Someone might think of using the pre-installed headers on
5734        # Canadian crosses, in case the installed compiler is not fully
5735        # compatible with the compiler being built.  In this case, it
5736        # would be better to flag an error than risking having
5737        # incompatible object files being constructed.  We can't
5738        # guarantee that an error will be flagged, but let's hope the
5739        # compiler will do it, when presented with incompatible header
5740        # files.
5741      fi
5742    fi
5743
5744    case "${target}-${is_cross_compiler}" in
5745    i[3456789]86-*-linux*-no)
5746       # Here host == target, so we don't need to build gcc,
5747       # so we don't want to discard standard headers.
5748       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5749       ;;
5750    *)
5751       # If we're building newlib, use its generic headers last, but search
5752       # for any libc-related directories first (so make it the last -B
5753       # switch).
5754       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5755       ;;
5756    esac
5757    ;;
5758   esac
5759   ;;
5760 esac
5761 case "$target" in
5762 *-mingw*)
5763   # Can't be handled as Cygwin above since Mingw does not use newlib.
5764   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' ;;
5765 esac
5766
5767 # Allow the user to override the flags for
5768 # our build compiler if desired.
5769 CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5770
5771 # On Canadian crosses, we'll be searching the right directories for
5772 # the previously-installed cross compiler, so don't bother to add
5773 # flags for directories within the install tree of the compiler
5774 # being built; programs in there won't even run.
5775 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5776   # Search for pre-installed headers if nothing else fits.
5777   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5778 fi
5779
5780 if test "x${use_gnu_ld}" = x &&
5781    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5782   # Arrange for us to find uninstalled linker scripts.
5783   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5784 fi
5785
5786 # Search for other target-specific linker scripts and such.
5787 case "${target}" in
5788   m32c-*-* )
5789     if test -d ${srcdir}/libgloss/m32c; then
5790       # This is for crt0.o
5791       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5792       # This is for r8c.ld
5793       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5794       # This is for libnosys.a
5795       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5796     fi
5797     ;;
5798   mep*)
5799     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5800     ;;
5801 esac
5802
5803 # Makefile fragments.
5804 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5805 do
5806   eval fragval=\$$frag
5807   if test $fragval != /dev/null; then
5808     eval $frag=${srcdir}/$fragval
5809   fi
5810 done
5811
5812
5813
5814
5815
5816 # Miscellanea: directories, flags, etc.
5817
5818
5819
5820
5821
5822
5823
5824 # Build module lists & subconfigure args.
5825
5826
5827
5828 # Host module lists & subconfigure args.
5829
5830
5831
5832 # Target module lists & subconfigure args.
5833
5834
5835
5836 # Build tools.
5837
5838
5839
5840 # Generate default definitions for YACC, M4, LEX and other programs that run
5841 # on the build machine.  These are used if the Makefile can't locate these
5842 # programs in objdir.
5843 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5844
5845 for ac_prog in 'bison -y' byacc yacc
5846 do
5847   # Extract the first word of "$ac_prog", so it can be a program name with args.
5848 set dummy $ac_prog; ac_word=$2
5849 echo "$as_me:$LINENO: checking for $ac_word" >&5
5850 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5851 if test "${ac_cv_prog_YACC+set}" = set; then
5852   echo $ECHO_N "(cached) $ECHO_C" >&6
5853 else
5854   if test -n "$YACC"; then
5855   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5856 else
5857 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5858 for as_dir in $PATH
5859 do
5860   IFS=$as_save_IFS
5861   test -z "$as_dir" && as_dir=.
5862   for ac_exec_ext in '' $ac_executable_extensions; do
5863   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5864     ac_cv_prog_YACC="$ac_prog"
5865     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5866     break 2
5867   fi
5868 done
5869 done
5870
5871 fi
5872 fi
5873 YACC=$ac_cv_prog_YACC
5874 if test -n "$YACC"; then
5875   echo "$as_me:$LINENO: result: $YACC" >&5
5876 echo "${ECHO_T}$YACC" >&6
5877 else
5878   echo "$as_me:$LINENO: result: no" >&5
5879 echo "${ECHO_T}no" >&6
5880 fi
5881
5882   test -n "$YACC" && break
5883 done
5884 test -n "$YACC" || YACC="$MISSING bison -y"
5885
5886 case " $build_configdirs " in
5887   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
5888   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
5889 esac
5890
5891 for ac_prog in bison
5892 do
5893   # Extract the first word of "$ac_prog", so it can be a program name with args.
5894 set dummy $ac_prog; ac_word=$2
5895 echo "$as_me:$LINENO: checking for $ac_word" >&5
5896 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5897 if test "${ac_cv_prog_BISON+set}" = set; then
5898   echo $ECHO_N "(cached) $ECHO_C" >&6
5899 else
5900   if test -n "$BISON"; then
5901   ac_cv_prog_BISON="$BISON" # Let the user override the test.
5902 else
5903 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5904 for as_dir in $PATH
5905 do
5906   IFS=$as_save_IFS
5907   test -z "$as_dir" && as_dir=.
5908   for ac_exec_ext in '' $ac_executable_extensions; do
5909   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5910     ac_cv_prog_BISON="$ac_prog"
5911     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5912     break 2
5913   fi
5914 done
5915 done
5916
5917 fi
5918 fi
5919 BISON=$ac_cv_prog_BISON
5920 if test -n "$BISON"; then
5921   echo "$as_me:$LINENO: result: $BISON" >&5
5922 echo "${ECHO_T}$BISON" >&6
5923 else
5924   echo "$as_me:$LINENO: result: no" >&5
5925 echo "${ECHO_T}no" >&6
5926 fi
5927
5928   test -n "$BISON" && break
5929 done
5930 test -n "$BISON" || BISON="$MISSING bison"
5931
5932 case " $build_configdirs " in
5933   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
5934 esac
5935
5936 for ac_prog in gm4 gnum4 m4
5937 do
5938   # Extract the first word of "$ac_prog", so it can be a program name with args.
5939 set dummy $ac_prog; ac_word=$2
5940 echo "$as_me:$LINENO: checking for $ac_word" >&5
5941 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5942 if test "${ac_cv_prog_M4+set}" = set; then
5943   echo $ECHO_N "(cached) $ECHO_C" >&6
5944 else
5945   if test -n "$M4"; then
5946   ac_cv_prog_M4="$M4" # Let the user override the test.
5947 else
5948 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5949 for as_dir in $PATH
5950 do
5951   IFS=$as_save_IFS
5952   test -z "$as_dir" && as_dir=.
5953   for ac_exec_ext in '' $ac_executable_extensions; do
5954   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5955     ac_cv_prog_M4="$ac_prog"
5956     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5957     break 2
5958   fi
5959 done
5960 done
5961
5962 fi
5963 fi
5964 M4=$ac_cv_prog_M4
5965 if test -n "$M4"; then
5966   echo "$as_me:$LINENO: result: $M4" >&5
5967 echo "${ECHO_T}$M4" >&6
5968 else
5969   echo "$as_me:$LINENO: result: no" >&5
5970 echo "${ECHO_T}no" >&6
5971 fi
5972
5973   test -n "$M4" && break
5974 done
5975 test -n "$M4" || M4="$MISSING m4"
5976
5977 case " $build_configdirs " in
5978   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
5979 esac
5980
5981 for ac_prog in flex lex
5982 do
5983   # Extract the first word of "$ac_prog", so it can be a program name with args.
5984 set dummy $ac_prog; ac_word=$2
5985 echo "$as_me:$LINENO: checking for $ac_word" >&5
5986 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5987 if test "${ac_cv_prog_LEX+set}" = set; then
5988   echo $ECHO_N "(cached) $ECHO_C" >&6
5989 else
5990   if test -n "$LEX"; then
5991   ac_cv_prog_LEX="$LEX" # Let the user override the test.
5992 else
5993 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5994 for as_dir in $PATH
5995 do
5996   IFS=$as_save_IFS
5997   test -z "$as_dir" && as_dir=.
5998   for ac_exec_ext in '' $ac_executable_extensions; do
5999   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6000     ac_cv_prog_LEX="$ac_prog"
6001     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6002     break 2
6003   fi
6004 done
6005 done
6006
6007 fi
6008 fi
6009 LEX=$ac_cv_prog_LEX
6010 if test -n "$LEX"; then
6011   echo "$as_me:$LINENO: result: $LEX" >&5
6012 echo "${ECHO_T}$LEX" >&6
6013 else
6014   echo "$as_me:$LINENO: result: no" >&5
6015 echo "${ECHO_T}no" >&6
6016 fi
6017
6018   test -n "$LEX" && break
6019 done
6020 test -n "$LEX" || LEX="$MISSING flex"
6021
6022 case " $build_configdirs " in
6023   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6024   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6025 esac
6026
6027 for ac_prog in flex
6028 do
6029   # Extract the first word of "$ac_prog", so it can be a program name with args.
6030 set dummy $ac_prog; ac_word=$2
6031 echo "$as_me:$LINENO: checking for $ac_word" >&5
6032 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6033 if test "${ac_cv_prog_FLEX+set}" = set; then
6034   echo $ECHO_N "(cached) $ECHO_C" >&6
6035 else
6036   if test -n "$FLEX"; then
6037   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6038 else
6039 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6040 for as_dir in $PATH
6041 do
6042   IFS=$as_save_IFS
6043   test -z "$as_dir" && as_dir=.
6044   for ac_exec_ext in '' $ac_executable_extensions; do
6045   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6046     ac_cv_prog_FLEX="$ac_prog"
6047     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6048     break 2
6049   fi
6050 done
6051 done
6052
6053 fi
6054 fi
6055 FLEX=$ac_cv_prog_FLEX
6056 if test -n "$FLEX"; then
6057   echo "$as_me:$LINENO: result: $FLEX" >&5
6058 echo "${ECHO_T}$FLEX" >&6
6059 else
6060   echo "$as_me:$LINENO: result: no" >&5
6061 echo "${ECHO_T}no" >&6
6062 fi
6063
6064   test -n "$FLEX" && break
6065 done
6066 test -n "$FLEX" || FLEX="$MISSING flex"
6067
6068 case " $build_configdirs " in
6069   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6070 esac
6071
6072 for ac_prog in makeinfo
6073 do
6074   # Extract the first word of "$ac_prog", so it can be a program name with args.
6075 set dummy $ac_prog; ac_word=$2
6076 echo "$as_me:$LINENO: checking for $ac_word" >&5
6077 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6078 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6079   echo $ECHO_N "(cached) $ECHO_C" >&6
6080 else
6081   if test -n "$MAKEINFO"; then
6082   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6083 else
6084 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6085 for as_dir in $PATH
6086 do
6087   IFS=$as_save_IFS
6088   test -z "$as_dir" && as_dir=.
6089   for ac_exec_ext in '' $ac_executable_extensions; do
6090   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6091     ac_cv_prog_MAKEINFO="$ac_prog"
6092     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6093     break 2
6094   fi
6095 done
6096 done
6097
6098 fi
6099 fi
6100 MAKEINFO=$ac_cv_prog_MAKEINFO
6101 if test -n "$MAKEINFO"; then
6102   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6103 echo "${ECHO_T}$MAKEINFO" >&6
6104 else
6105   echo "$as_me:$LINENO: result: no" >&5
6106 echo "${ECHO_T}no" >&6
6107 fi
6108
6109   test -n "$MAKEINFO" && break
6110 done
6111 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6112
6113 case " $build_configdirs " in
6114   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6115   *)
6116
6117     # For an installed makeinfo, we require it to be from texinfo 4.4 or
6118     # higher, else we use the "missing" dummy.
6119     if ${MAKEINFO} --version \
6120        | egrep 'texinfo[^0-9]*([1-3][0-9]|4\.[4-9]|[5-9])' >/dev/null 2>&1; then
6121       :
6122     else
6123       MAKEINFO="$MISSING makeinfo"
6124     fi
6125     ;;
6126
6127 esac
6128
6129 # FIXME: expect and dejagnu may become build tools?
6130
6131 for ac_prog in expect
6132 do
6133   # Extract the first word of "$ac_prog", so it can be a program name with args.
6134 set dummy $ac_prog; ac_word=$2
6135 echo "$as_me:$LINENO: checking for $ac_word" >&5
6136 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6137 if test "${ac_cv_prog_EXPECT+set}" = set; then
6138   echo $ECHO_N "(cached) $ECHO_C" >&6
6139 else
6140   if test -n "$EXPECT"; then
6141   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6142 else
6143 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6144 for as_dir in $PATH
6145 do
6146   IFS=$as_save_IFS
6147   test -z "$as_dir" && as_dir=.
6148   for ac_exec_ext in '' $ac_executable_extensions; do
6149   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6150     ac_cv_prog_EXPECT="$ac_prog"
6151     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6152     break 2
6153   fi
6154 done
6155 done
6156
6157 fi
6158 fi
6159 EXPECT=$ac_cv_prog_EXPECT
6160 if test -n "$EXPECT"; then
6161   echo "$as_me:$LINENO: result: $EXPECT" >&5
6162 echo "${ECHO_T}$EXPECT" >&6
6163 else
6164   echo "$as_me:$LINENO: result: no" >&5
6165 echo "${ECHO_T}no" >&6
6166 fi
6167
6168   test -n "$EXPECT" && break
6169 done
6170 test -n "$EXPECT" || EXPECT="expect"
6171
6172 case " $configdirs " in
6173   *" expect "*)
6174     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6175     ;;
6176 esac
6177
6178 for ac_prog in runtest
6179 do
6180   # Extract the first word of "$ac_prog", so it can be a program name with args.
6181 set dummy $ac_prog; ac_word=$2
6182 echo "$as_me:$LINENO: checking for $ac_word" >&5
6183 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6184 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6185   echo $ECHO_N "(cached) $ECHO_C" >&6
6186 else
6187   if test -n "$RUNTEST"; then
6188   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6189 else
6190 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6191 for as_dir in $PATH
6192 do
6193   IFS=$as_save_IFS
6194   test -z "$as_dir" && as_dir=.
6195   for ac_exec_ext in '' $ac_executable_extensions; do
6196   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6197     ac_cv_prog_RUNTEST="$ac_prog"
6198     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6199     break 2
6200   fi
6201 done
6202 done
6203
6204 fi
6205 fi
6206 RUNTEST=$ac_cv_prog_RUNTEST
6207 if test -n "$RUNTEST"; then
6208   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6209 echo "${ECHO_T}$RUNTEST" >&6
6210 else
6211   echo "$as_me:$LINENO: result: no" >&5
6212 echo "${ECHO_T}no" >&6
6213 fi
6214
6215   test -n "$RUNTEST" && break
6216 done
6217 test -n "$RUNTEST" || RUNTEST="runtest"
6218
6219 case " $configdirs " in
6220   *" dejagnu "*)
6221     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6222     ;;
6223 esac
6224
6225
6226 # Host tools.
6227 ncn_tool_prefix=
6228 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6229 ncn_target_tool_prefix=
6230 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6231
6232
6233
6234 if test -n "$AR"; then
6235   ac_cv_prog_AR=$AR
6236 elif test -n "$ac_cv_prog_AR"; then
6237   AR=$ac_cv_prog_AR
6238 fi
6239
6240 if test -n "$ac_cv_prog_AR"; then
6241   for ncn_progname in ar; do
6242     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6243 set dummy ${ncn_progname}; ac_word=$2
6244 echo "$as_me:$LINENO: checking for $ac_word" >&5
6245 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6246 if test "${ac_cv_prog_AR+set}" = set; then
6247   echo $ECHO_N "(cached) $ECHO_C" >&6
6248 else
6249   if test -n "$AR"; then
6250   ac_cv_prog_AR="$AR" # Let the user override the test.
6251 else
6252 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6253 for as_dir in $PATH
6254 do
6255   IFS=$as_save_IFS
6256   test -z "$as_dir" && as_dir=.
6257   for ac_exec_ext in '' $ac_executable_extensions; do
6258   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6259     ac_cv_prog_AR="${ncn_progname}"
6260     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6261     break 2
6262   fi
6263 done
6264 done
6265
6266 fi
6267 fi
6268 AR=$ac_cv_prog_AR
6269 if test -n "$AR"; then
6270   echo "$as_me:$LINENO: result: $AR" >&5
6271 echo "${ECHO_T}$AR" >&6
6272 else
6273   echo "$as_me:$LINENO: result: no" >&5
6274 echo "${ECHO_T}no" >&6
6275 fi
6276
6277   done
6278 fi
6279
6280 for ncn_progname in ar; do
6281   if test -n "$ncn_tool_prefix"; then
6282     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6283 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6284 echo "$as_me:$LINENO: checking for $ac_word" >&5
6285 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6286 if test "${ac_cv_prog_AR+set}" = set; then
6287   echo $ECHO_N "(cached) $ECHO_C" >&6
6288 else
6289   if test -n "$AR"; then
6290   ac_cv_prog_AR="$AR" # Let the user override the test.
6291 else
6292 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6293 for as_dir in $PATH
6294 do
6295   IFS=$as_save_IFS
6296   test -z "$as_dir" && as_dir=.
6297   for ac_exec_ext in '' $ac_executable_extensions; do
6298   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6299     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6300     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6301     break 2
6302   fi
6303 done
6304 done
6305
6306 fi
6307 fi
6308 AR=$ac_cv_prog_AR
6309 if test -n "$AR"; then
6310   echo "$as_me:$LINENO: result: $AR" >&5
6311 echo "${ECHO_T}$AR" >&6
6312 else
6313   echo "$as_me:$LINENO: result: no" >&5
6314 echo "${ECHO_T}no" >&6
6315 fi
6316
6317   fi
6318   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6319     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6320 set dummy ${ncn_progname}; ac_word=$2
6321 echo "$as_me:$LINENO: checking for $ac_word" >&5
6322 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6323 if test "${ac_cv_prog_AR+set}" = set; then
6324   echo $ECHO_N "(cached) $ECHO_C" >&6
6325 else
6326   if test -n "$AR"; then
6327   ac_cv_prog_AR="$AR" # Let the user override the test.
6328 else
6329 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6330 for as_dir in $PATH
6331 do
6332   IFS=$as_save_IFS
6333   test -z "$as_dir" && as_dir=.
6334   for ac_exec_ext in '' $ac_executable_extensions; do
6335   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6336     ac_cv_prog_AR="${ncn_progname}"
6337     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6338     break 2
6339   fi
6340 done
6341 done
6342
6343 fi
6344 fi
6345 AR=$ac_cv_prog_AR
6346 if test -n "$AR"; then
6347   echo "$as_me:$LINENO: result: $AR" >&5
6348 echo "${ECHO_T}$AR" >&6
6349 else
6350   echo "$as_me:$LINENO: result: no" >&5
6351 echo "${ECHO_T}no" >&6
6352 fi
6353
6354   fi
6355   test -n "$ac_cv_prog_AR" && break
6356 done
6357
6358 if test -z "$ac_cv_prog_AR" ; then
6359   set dummy ar
6360   if test $build = $host ; then
6361     AR="$2"
6362   else
6363     AR="${ncn_tool_prefix}$2"
6364   fi
6365 fi
6366
6367
6368
6369 if test -n "$AS"; then
6370   ac_cv_prog_AS=$AS
6371 elif test -n "$ac_cv_prog_AS"; then
6372   AS=$ac_cv_prog_AS
6373 fi
6374
6375 if test -n "$ac_cv_prog_AS"; then
6376   for ncn_progname in as; do
6377     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6378 set dummy ${ncn_progname}; ac_word=$2
6379 echo "$as_me:$LINENO: checking for $ac_word" >&5
6380 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6381 if test "${ac_cv_prog_AS+set}" = set; then
6382   echo $ECHO_N "(cached) $ECHO_C" >&6
6383 else
6384   if test -n "$AS"; then
6385   ac_cv_prog_AS="$AS" # Let the user override the test.
6386 else
6387 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6388 for as_dir in $PATH
6389 do
6390   IFS=$as_save_IFS
6391   test -z "$as_dir" && as_dir=.
6392   for ac_exec_ext in '' $ac_executable_extensions; do
6393   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6394     ac_cv_prog_AS="${ncn_progname}"
6395     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6396     break 2
6397   fi
6398 done
6399 done
6400
6401 fi
6402 fi
6403 AS=$ac_cv_prog_AS
6404 if test -n "$AS"; then
6405   echo "$as_me:$LINENO: result: $AS" >&5
6406 echo "${ECHO_T}$AS" >&6
6407 else
6408   echo "$as_me:$LINENO: result: no" >&5
6409 echo "${ECHO_T}no" >&6
6410 fi
6411
6412   done
6413 fi
6414
6415 for ncn_progname in as; do
6416   if test -n "$ncn_tool_prefix"; then
6417     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6418 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6419 echo "$as_me:$LINENO: checking for $ac_word" >&5
6420 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6421 if test "${ac_cv_prog_AS+set}" = set; then
6422   echo $ECHO_N "(cached) $ECHO_C" >&6
6423 else
6424   if test -n "$AS"; then
6425   ac_cv_prog_AS="$AS" # Let the user override the test.
6426 else
6427 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6428 for as_dir in $PATH
6429 do
6430   IFS=$as_save_IFS
6431   test -z "$as_dir" && as_dir=.
6432   for ac_exec_ext in '' $ac_executable_extensions; do
6433   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6434     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6435     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6436     break 2
6437   fi
6438 done
6439 done
6440
6441 fi
6442 fi
6443 AS=$ac_cv_prog_AS
6444 if test -n "$AS"; then
6445   echo "$as_me:$LINENO: result: $AS" >&5
6446 echo "${ECHO_T}$AS" >&6
6447 else
6448   echo "$as_me:$LINENO: result: no" >&5
6449 echo "${ECHO_T}no" >&6
6450 fi
6451
6452   fi
6453   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6454     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6455 set dummy ${ncn_progname}; ac_word=$2
6456 echo "$as_me:$LINENO: checking for $ac_word" >&5
6457 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6458 if test "${ac_cv_prog_AS+set}" = set; then
6459   echo $ECHO_N "(cached) $ECHO_C" >&6
6460 else
6461   if test -n "$AS"; then
6462   ac_cv_prog_AS="$AS" # Let the user override the test.
6463 else
6464 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6465 for as_dir in $PATH
6466 do
6467   IFS=$as_save_IFS
6468   test -z "$as_dir" && as_dir=.
6469   for ac_exec_ext in '' $ac_executable_extensions; do
6470   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6471     ac_cv_prog_AS="${ncn_progname}"
6472     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6473     break 2
6474   fi
6475 done
6476 done
6477
6478 fi
6479 fi
6480 AS=$ac_cv_prog_AS
6481 if test -n "$AS"; then
6482   echo "$as_me:$LINENO: result: $AS" >&5
6483 echo "${ECHO_T}$AS" >&6
6484 else
6485   echo "$as_me:$LINENO: result: no" >&5
6486 echo "${ECHO_T}no" >&6
6487 fi
6488
6489   fi
6490   test -n "$ac_cv_prog_AS" && break
6491 done
6492
6493 if test -z "$ac_cv_prog_AS" ; then
6494   set dummy as
6495   if test $build = $host ; then
6496     AS="$2"
6497   else
6498     AS="${ncn_tool_prefix}$2"
6499   fi
6500 fi
6501
6502
6503
6504 if test -n "$DLLTOOL"; then
6505   ac_cv_prog_DLLTOOL=$DLLTOOL
6506 elif test -n "$ac_cv_prog_DLLTOOL"; then
6507   DLLTOOL=$ac_cv_prog_DLLTOOL
6508 fi
6509
6510 if test -n "$ac_cv_prog_DLLTOOL"; then
6511   for ncn_progname in dlltool; do
6512     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6513 set dummy ${ncn_progname}; ac_word=$2
6514 echo "$as_me:$LINENO: checking for $ac_word" >&5
6515 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6516 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6517   echo $ECHO_N "(cached) $ECHO_C" >&6
6518 else
6519   if test -n "$DLLTOOL"; then
6520   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6521 else
6522 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6523 for as_dir in $PATH
6524 do
6525   IFS=$as_save_IFS
6526   test -z "$as_dir" && as_dir=.
6527   for ac_exec_ext in '' $ac_executable_extensions; do
6528   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6529     ac_cv_prog_DLLTOOL="${ncn_progname}"
6530     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6531     break 2
6532   fi
6533 done
6534 done
6535
6536 fi
6537 fi
6538 DLLTOOL=$ac_cv_prog_DLLTOOL
6539 if test -n "$DLLTOOL"; then
6540   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6541 echo "${ECHO_T}$DLLTOOL" >&6
6542 else
6543   echo "$as_me:$LINENO: result: no" >&5
6544 echo "${ECHO_T}no" >&6
6545 fi
6546
6547   done
6548 fi
6549
6550 for ncn_progname in dlltool; do
6551   if test -n "$ncn_tool_prefix"; then
6552     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6553 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6554 echo "$as_me:$LINENO: checking for $ac_word" >&5
6555 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6556 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6557   echo $ECHO_N "(cached) $ECHO_C" >&6
6558 else
6559   if test -n "$DLLTOOL"; then
6560   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6561 else
6562 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6563 for as_dir in $PATH
6564 do
6565   IFS=$as_save_IFS
6566   test -z "$as_dir" && as_dir=.
6567   for ac_exec_ext in '' $ac_executable_extensions; do
6568   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6569     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6570     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6571     break 2
6572   fi
6573 done
6574 done
6575
6576 fi
6577 fi
6578 DLLTOOL=$ac_cv_prog_DLLTOOL
6579 if test -n "$DLLTOOL"; then
6580   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6581 echo "${ECHO_T}$DLLTOOL" >&6
6582 else
6583   echo "$as_me:$LINENO: result: no" >&5
6584 echo "${ECHO_T}no" >&6
6585 fi
6586
6587   fi
6588   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6589     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6590 set dummy ${ncn_progname}; ac_word=$2
6591 echo "$as_me:$LINENO: checking for $ac_word" >&5
6592 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6593 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6594   echo $ECHO_N "(cached) $ECHO_C" >&6
6595 else
6596   if test -n "$DLLTOOL"; then
6597   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6598 else
6599 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6600 for as_dir in $PATH
6601 do
6602   IFS=$as_save_IFS
6603   test -z "$as_dir" && as_dir=.
6604   for ac_exec_ext in '' $ac_executable_extensions; do
6605   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6606     ac_cv_prog_DLLTOOL="${ncn_progname}"
6607     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6608     break 2
6609   fi
6610 done
6611 done
6612
6613 fi
6614 fi
6615 DLLTOOL=$ac_cv_prog_DLLTOOL
6616 if test -n "$DLLTOOL"; then
6617   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6618 echo "${ECHO_T}$DLLTOOL" >&6
6619 else
6620   echo "$as_me:$LINENO: result: no" >&5
6621 echo "${ECHO_T}no" >&6
6622 fi
6623
6624   fi
6625   test -n "$ac_cv_prog_DLLTOOL" && break
6626 done
6627
6628 if test -z "$ac_cv_prog_DLLTOOL" ; then
6629   set dummy dlltool
6630   if test $build = $host ; then
6631     DLLTOOL="$2"
6632   else
6633     DLLTOOL="${ncn_tool_prefix}$2"
6634   fi
6635 fi
6636
6637
6638
6639 if test -n "$LD"; then
6640   ac_cv_prog_LD=$LD
6641 elif test -n "$ac_cv_prog_LD"; then
6642   LD=$ac_cv_prog_LD
6643 fi
6644
6645 if test -n "$ac_cv_prog_LD"; then
6646   for ncn_progname in ld; do
6647     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6648 set dummy ${ncn_progname}; ac_word=$2
6649 echo "$as_me:$LINENO: checking for $ac_word" >&5
6650 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6651 if test "${ac_cv_prog_LD+set}" = set; then
6652   echo $ECHO_N "(cached) $ECHO_C" >&6
6653 else
6654   if test -n "$LD"; then
6655   ac_cv_prog_LD="$LD" # Let the user override the test.
6656 else
6657 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6658 for as_dir in $PATH
6659 do
6660   IFS=$as_save_IFS
6661   test -z "$as_dir" && as_dir=.
6662   for ac_exec_ext in '' $ac_executable_extensions; do
6663   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6664     ac_cv_prog_LD="${ncn_progname}"
6665     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6666     break 2
6667   fi
6668 done
6669 done
6670
6671 fi
6672 fi
6673 LD=$ac_cv_prog_LD
6674 if test -n "$LD"; then
6675   echo "$as_me:$LINENO: result: $LD" >&5
6676 echo "${ECHO_T}$LD" >&6
6677 else
6678   echo "$as_me:$LINENO: result: no" >&5
6679 echo "${ECHO_T}no" >&6
6680 fi
6681
6682   done
6683 fi
6684
6685 for ncn_progname in ld; do
6686   if test -n "$ncn_tool_prefix"; then
6687     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6688 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6689 echo "$as_me:$LINENO: checking for $ac_word" >&5
6690 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6691 if test "${ac_cv_prog_LD+set}" = set; then
6692   echo $ECHO_N "(cached) $ECHO_C" >&6
6693 else
6694   if test -n "$LD"; then
6695   ac_cv_prog_LD="$LD" # Let the user override the test.
6696 else
6697 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6698 for as_dir in $PATH
6699 do
6700   IFS=$as_save_IFS
6701   test -z "$as_dir" && as_dir=.
6702   for ac_exec_ext in '' $ac_executable_extensions; do
6703   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6704     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6705     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6706     break 2
6707   fi
6708 done
6709 done
6710
6711 fi
6712 fi
6713 LD=$ac_cv_prog_LD
6714 if test -n "$LD"; then
6715   echo "$as_me:$LINENO: result: $LD" >&5
6716 echo "${ECHO_T}$LD" >&6
6717 else
6718   echo "$as_me:$LINENO: result: no" >&5
6719 echo "${ECHO_T}no" >&6
6720 fi
6721
6722   fi
6723   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6724     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6725 set dummy ${ncn_progname}; ac_word=$2
6726 echo "$as_me:$LINENO: checking for $ac_word" >&5
6727 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6728 if test "${ac_cv_prog_LD+set}" = set; then
6729   echo $ECHO_N "(cached) $ECHO_C" >&6
6730 else
6731   if test -n "$LD"; then
6732   ac_cv_prog_LD="$LD" # Let the user override the test.
6733 else
6734 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6735 for as_dir in $PATH
6736 do
6737   IFS=$as_save_IFS
6738   test -z "$as_dir" && as_dir=.
6739   for ac_exec_ext in '' $ac_executable_extensions; do
6740   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6741     ac_cv_prog_LD="${ncn_progname}"
6742     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6743     break 2
6744   fi
6745 done
6746 done
6747
6748 fi
6749 fi
6750 LD=$ac_cv_prog_LD
6751 if test -n "$LD"; then
6752   echo "$as_me:$LINENO: result: $LD" >&5
6753 echo "${ECHO_T}$LD" >&6
6754 else
6755   echo "$as_me:$LINENO: result: no" >&5
6756 echo "${ECHO_T}no" >&6
6757 fi
6758
6759   fi
6760   test -n "$ac_cv_prog_LD" && break
6761 done
6762
6763 if test -z "$ac_cv_prog_LD" ; then
6764   set dummy ld
6765   if test $build = $host ; then
6766     LD="$2"
6767   else
6768     LD="${ncn_tool_prefix}$2"
6769   fi
6770 fi
6771
6772
6773
6774 if test -n "$LIPO"; then
6775   ac_cv_prog_LIPO=$LIPO
6776 elif test -n "$ac_cv_prog_LIPO"; then
6777   LIPO=$ac_cv_prog_LIPO
6778 fi
6779
6780 if test -n "$ac_cv_prog_LIPO"; then
6781   for ncn_progname in lipo; do
6782     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6783 set dummy ${ncn_progname}; ac_word=$2
6784 echo "$as_me:$LINENO: checking for $ac_word" >&5
6785 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6786 if test "${ac_cv_prog_LIPO+set}" = set; then
6787   echo $ECHO_N "(cached) $ECHO_C" >&6
6788 else
6789   if test -n "$LIPO"; then
6790   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6791 else
6792 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6793 for as_dir in $PATH
6794 do
6795   IFS=$as_save_IFS
6796   test -z "$as_dir" && as_dir=.
6797   for ac_exec_ext in '' $ac_executable_extensions; do
6798   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6799     ac_cv_prog_LIPO="${ncn_progname}"
6800     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6801     break 2
6802   fi
6803 done
6804 done
6805
6806 fi
6807 fi
6808 LIPO=$ac_cv_prog_LIPO
6809 if test -n "$LIPO"; then
6810   echo "$as_me:$LINENO: result: $LIPO" >&5
6811 echo "${ECHO_T}$LIPO" >&6
6812 else
6813   echo "$as_me:$LINENO: result: no" >&5
6814 echo "${ECHO_T}no" >&6
6815 fi
6816
6817   done
6818 fi
6819
6820 for ncn_progname in lipo; do
6821   if test -n "$ncn_tool_prefix"; then
6822     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6823 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6824 echo "$as_me:$LINENO: checking for $ac_word" >&5
6825 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6826 if test "${ac_cv_prog_LIPO+set}" = set; then
6827   echo $ECHO_N "(cached) $ECHO_C" >&6
6828 else
6829   if test -n "$LIPO"; then
6830   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6831 else
6832 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6833 for as_dir in $PATH
6834 do
6835   IFS=$as_save_IFS
6836   test -z "$as_dir" && as_dir=.
6837   for ac_exec_ext in '' $ac_executable_extensions; do
6838   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6839     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6840     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6841     break 2
6842   fi
6843 done
6844 done
6845
6846 fi
6847 fi
6848 LIPO=$ac_cv_prog_LIPO
6849 if test -n "$LIPO"; then
6850   echo "$as_me:$LINENO: result: $LIPO" >&5
6851 echo "${ECHO_T}$LIPO" >&6
6852 else
6853   echo "$as_me:$LINENO: result: no" >&5
6854 echo "${ECHO_T}no" >&6
6855 fi
6856
6857   fi
6858   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6859     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6860 set dummy ${ncn_progname}; ac_word=$2
6861 echo "$as_me:$LINENO: checking for $ac_word" >&5
6862 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6863 if test "${ac_cv_prog_LIPO+set}" = set; then
6864   echo $ECHO_N "(cached) $ECHO_C" >&6
6865 else
6866   if test -n "$LIPO"; then
6867   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6868 else
6869 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6870 for as_dir in $PATH
6871 do
6872   IFS=$as_save_IFS
6873   test -z "$as_dir" && as_dir=.
6874   for ac_exec_ext in '' $ac_executable_extensions; do
6875   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6876     ac_cv_prog_LIPO="${ncn_progname}"
6877     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6878     break 2
6879   fi
6880 done
6881 done
6882
6883 fi
6884 fi
6885 LIPO=$ac_cv_prog_LIPO
6886 if test -n "$LIPO"; then
6887   echo "$as_me:$LINENO: result: $LIPO" >&5
6888 echo "${ECHO_T}$LIPO" >&6
6889 else
6890   echo "$as_me:$LINENO: result: no" >&5
6891 echo "${ECHO_T}no" >&6
6892 fi
6893
6894   fi
6895   test -n "$ac_cv_prog_LIPO" && break
6896 done
6897
6898 if test -z "$ac_cv_prog_LIPO" ; then
6899   set dummy lipo
6900   if test $build = $host ; then
6901     LIPO="$2"
6902   else
6903     LIPO="${ncn_tool_prefix}$2"
6904   fi
6905 fi
6906
6907
6908
6909 if test -n "$NM"; then
6910   ac_cv_prog_NM=$NM
6911 elif test -n "$ac_cv_prog_NM"; then
6912   NM=$ac_cv_prog_NM
6913 fi
6914
6915 if test -n "$ac_cv_prog_NM"; then
6916   for ncn_progname in nm; do
6917     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6918 set dummy ${ncn_progname}; ac_word=$2
6919 echo "$as_me:$LINENO: checking for $ac_word" >&5
6920 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6921 if test "${ac_cv_prog_NM+set}" = set; then
6922   echo $ECHO_N "(cached) $ECHO_C" >&6
6923 else
6924   if test -n "$NM"; then
6925   ac_cv_prog_NM="$NM" # Let the user override the test.
6926 else
6927 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6928 for as_dir in $PATH
6929 do
6930   IFS=$as_save_IFS
6931   test -z "$as_dir" && as_dir=.
6932   for ac_exec_ext in '' $ac_executable_extensions; do
6933   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6934     ac_cv_prog_NM="${ncn_progname}"
6935     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6936     break 2
6937   fi
6938 done
6939 done
6940
6941 fi
6942 fi
6943 NM=$ac_cv_prog_NM
6944 if test -n "$NM"; then
6945   echo "$as_me:$LINENO: result: $NM" >&5
6946 echo "${ECHO_T}$NM" >&6
6947 else
6948   echo "$as_me:$LINENO: result: no" >&5
6949 echo "${ECHO_T}no" >&6
6950 fi
6951
6952   done
6953 fi
6954
6955 for ncn_progname in nm; do
6956   if test -n "$ncn_tool_prefix"; then
6957     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6958 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6959 echo "$as_me:$LINENO: checking for $ac_word" >&5
6960 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6961 if test "${ac_cv_prog_NM+set}" = set; then
6962   echo $ECHO_N "(cached) $ECHO_C" >&6
6963 else
6964   if test -n "$NM"; then
6965   ac_cv_prog_NM="$NM" # Let the user override the test.
6966 else
6967 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6968 for as_dir in $PATH
6969 do
6970   IFS=$as_save_IFS
6971   test -z "$as_dir" && as_dir=.
6972   for ac_exec_ext in '' $ac_executable_extensions; do
6973   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6974     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
6975     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6976     break 2
6977   fi
6978 done
6979 done
6980
6981 fi
6982 fi
6983 NM=$ac_cv_prog_NM
6984 if test -n "$NM"; then
6985   echo "$as_me:$LINENO: result: $NM" >&5
6986 echo "${ECHO_T}$NM" >&6
6987 else
6988   echo "$as_me:$LINENO: result: no" >&5
6989 echo "${ECHO_T}no" >&6
6990 fi
6991
6992   fi
6993   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
6994     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6995 set dummy ${ncn_progname}; ac_word=$2
6996 echo "$as_me:$LINENO: checking for $ac_word" >&5
6997 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6998 if test "${ac_cv_prog_NM+set}" = set; then
6999   echo $ECHO_N "(cached) $ECHO_C" >&6
7000 else
7001   if test -n "$NM"; then
7002   ac_cv_prog_NM="$NM" # Let the user override the test.
7003 else
7004 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7005 for as_dir in $PATH
7006 do
7007   IFS=$as_save_IFS
7008   test -z "$as_dir" && as_dir=.
7009   for ac_exec_ext in '' $ac_executable_extensions; do
7010   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7011     ac_cv_prog_NM="${ncn_progname}"
7012     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7013     break 2
7014   fi
7015 done
7016 done
7017
7018 fi
7019 fi
7020 NM=$ac_cv_prog_NM
7021 if test -n "$NM"; then
7022   echo "$as_me:$LINENO: result: $NM" >&5
7023 echo "${ECHO_T}$NM" >&6
7024 else
7025   echo "$as_me:$LINENO: result: no" >&5
7026 echo "${ECHO_T}no" >&6
7027 fi
7028
7029   fi
7030   test -n "$ac_cv_prog_NM" && break
7031 done
7032
7033 if test -z "$ac_cv_prog_NM" ; then
7034   set dummy nm
7035   if test $build = $host ; then
7036     NM="$2"
7037   else
7038     NM="${ncn_tool_prefix}$2"
7039   fi
7040 fi
7041
7042
7043
7044 if test -n "$RANLIB"; then
7045   ac_cv_prog_RANLIB=$RANLIB
7046 elif test -n "$ac_cv_prog_RANLIB"; then
7047   RANLIB=$ac_cv_prog_RANLIB
7048 fi
7049
7050 if test -n "$ac_cv_prog_RANLIB"; then
7051   for ncn_progname in ranlib; do
7052     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7053 set dummy ${ncn_progname}; ac_word=$2
7054 echo "$as_me:$LINENO: checking for $ac_word" >&5
7055 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7056 if test "${ac_cv_prog_RANLIB+set}" = set; then
7057   echo $ECHO_N "(cached) $ECHO_C" >&6
7058 else
7059   if test -n "$RANLIB"; then
7060   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7061 else
7062 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7063 for as_dir in $PATH
7064 do
7065   IFS=$as_save_IFS
7066   test -z "$as_dir" && as_dir=.
7067   for ac_exec_ext in '' $ac_executable_extensions; do
7068   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7069     ac_cv_prog_RANLIB="${ncn_progname}"
7070     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7071     break 2
7072   fi
7073 done
7074 done
7075
7076 fi
7077 fi
7078 RANLIB=$ac_cv_prog_RANLIB
7079 if test -n "$RANLIB"; then
7080   echo "$as_me:$LINENO: result: $RANLIB" >&5
7081 echo "${ECHO_T}$RANLIB" >&6
7082 else
7083   echo "$as_me:$LINENO: result: no" >&5
7084 echo "${ECHO_T}no" >&6
7085 fi
7086
7087   done
7088 fi
7089
7090 for ncn_progname in ranlib; do
7091   if test -n "$ncn_tool_prefix"; then
7092     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7093 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7094 echo "$as_me:$LINENO: checking for $ac_word" >&5
7095 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7096 if test "${ac_cv_prog_RANLIB+set}" = set; then
7097   echo $ECHO_N "(cached) $ECHO_C" >&6
7098 else
7099   if test -n "$RANLIB"; then
7100   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7101 else
7102 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7103 for as_dir in $PATH
7104 do
7105   IFS=$as_save_IFS
7106   test -z "$as_dir" && as_dir=.
7107   for ac_exec_ext in '' $ac_executable_extensions; do
7108   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7109     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7110     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7111     break 2
7112   fi
7113 done
7114 done
7115
7116 fi
7117 fi
7118 RANLIB=$ac_cv_prog_RANLIB
7119 if test -n "$RANLIB"; then
7120   echo "$as_me:$LINENO: result: $RANLIB" >&5
7121 echo "${ECHO_T}$RANLIB" >&6
7122 else
7123   echo "$as_me:$LINENO: result: no" >&5
7124 echo "${ECHO_T}no" >&6
7125 fi
7126
7127   fi
7128   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7129     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7130 set dummy ${ncn_progname}; ac_word=$2
7131 echo "$as_me:$LINENO: checking for $ac_word" >&5
7132 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7133 if test "${ac_cv_prog_RANLIB+set}" = set; then
7134   echo $ECHO_N "(cached) $ECHO_C" >&6
7135 else
7136   if test -n "$RANLIB"; then
7137   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7138 else
7139 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7140 for as_dir in $PATH
7141 do
7142   IFS=$as_save_IFS
7143   test -z "$as_dir" && as_dir=.
7144   for ac_exec_ext in '' $ac_executable_extensions; do
7145   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7146     ac_cv_prog_RANLIB="${ncn_progname}"
7147     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7148     break 2
7149   fi
7150 done
7151 done
7152
7153 fi
7154 fi
7155 RANLIB=$ac_cv_prog_RANLIB
7156 if test -n "$RANLIB"; then
7157   echo "$as_me:$LINENO: result: $RANLIB" >&5
7158 echo "${ECHO_T}$RANLIB" >&6
7159 else
7160   echo "$as_me:$LINENO: result: no" >&5
7161 echo "${ECHO_T}no" >&6
7162 fi
7163
7164   fi
7165   test -n "$ac_cv_prog_RANLIB" && break
7166 done
7167
7168 if test -z "$ac_cv_prog_RANLIB" ; then
7169   RANLIB=":"
7170 fi
7171
7172
7173
7174 if test -n "$STRIP"; then
7175   ac_cv_prog_STRIP=$STRIP
7176 elif test -n "$ac_cv_prog_STRIP"; then
7177   STRIP=$ac_cv_prog_STRIP
7178 fi
7179
7180 if test -n "$ac_cv_prog_STRIP"; then
7181   for ncn_progname in strip; do
7182     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7183 set dummy ${ncn_progname}; ac_word=$2
7184 echo "$as_me:$LINENO: checking for $ac_word" >&5
7185 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7186 if test "${ac_cv_prog_STRIP+set}" = set; then
7187   echo $ECHO_N "(cached) $ECHO_C" >&6
7188 else
7189   if test -n "$STRIP"; then
7190   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7191 else
7192 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7193 for as_dir in $PATH
7194 do
7195   IFS=$as_save_IFS
7196   test -z "$as_dir" && as_dir=.
7197   for ac_exec_ext in '' $ac_executable_extensions; do
7198   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7199     ac_cv_prog_STRIP="${ncn_progname}"
7200     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7201     break 2
7202   fi
7203 done
7204 done
7205
7206 fi
7207 fi
7208 STRIP=$ac_cv_prog_STRIP
7209 if test -n "$STRIP"; then
7210   echo "$as_me:$LINENO: result: $STRIP" >&5
7211 echo "${ECHO_T}$STRIP" >&6
7212 else
7213   echo "$as_me:$LINENO: result: no" >&5
7214 echo "${ECHO_T}no" >&6
7215 fi
7216
7217   done
7218 fi
7219
7220 for ncn_progname in strip; do
7221   if test -n "$ncn_tool_prefix"; then
7222     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7223 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7224 echo "$as_me:$LINENO: checking for $ac_word" >&5
7225 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7226 if test "${ac_cv_prog_STRIP+set}" = set; then
7227   echo $ECHO_N "(cached) $ECHO_C" >&6
7228 else
7229   if test -n "$STRIP"; then
7230   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7231 else
7232 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7233 for as_dir in $PATH
7234 do
7235   IFS=$as_save_IFS
7236   test -z "$as_dir" && as_dir=.
7237   for ac_exec_ext in '' $ac_executable_extensions; do
7238   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7239     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7240     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7241     break 2
7242   fi
7243 done
7244 done
7245
7246 fi
7247 fi
7248 STRIP=$ac_cv_prog_STRIP
7249 if test -n "$STRIP"; then
7250   echo "$as_me:$LINENO: result: $STRIP" >&5
7251 echo "${ECHO_T}$STRIP" >&6
7252 else
7253   echo "$as_me:$LINENO: result: no" >&5
7254 echo "${ECHO_T}no" >&6
7255 fi
7256
7257   fi
7258   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7259     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7260 set dummy ${ncn_progname}; ac_word=$2
7261 echo "$as_me:$LINENO: checking for $ac_word" >&5
7262 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7263 if test "${ac_cv_prog_STRIP+set}" = set; then
7264   echo $ECHO_N "(cached) $ECHO_C" >&6
7265 else
7266   if test -n "$STRIP"; then
7267   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7268 else
7269 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7270 for as_dir in $PATH
7271 do
7272   IFS=$as_save_IFS
7273   test -z "$as_dir" && as_dir=.
7274   for ac_exec_ext in '' $ac_executable_extensions; do
7275   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7276     ac_cv_prog_STRIP="${ncn_progname}"
7277     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7278     break 2
7279   fi
7280 done
7281 done
7282
7283 fi
7284 fi
7285 STRIP=$ac_cv_prog_STRIP
7286 if test -n "$STRIP"; then
7287   echo "$as_me:$LINENO: result: $STRIP" >&5
7288 echo "${ECHO_T}$STRIP" >&6
7289 else
7290   echo "$as_me:$LINENO: result: no" >&5
7291 echo "${ECHO_T}no" >&6
7292 fi
7293
7294   fi
7295   test -n "$ac_cv_prog_STRIP" && break
7296 done
7297
7298 if test -z "$ac_cv_prog_STRIP" ; then
7299   STRIP=":"
7300 fi
7301
7302
7303
7304 if test -n "$WINDRES"; then
7305   ac_cv_prog_WINDRES=$WINDRES
7306 elif test -n "$ac_cv_prog_WINDRES"; then
7307   WINDRES=$ac_cv_prog_WINDRES
7308 fi
7309
7310 if test -n "$ac_cv_prog_WINDRES"; then
7311   for ncn_progname in windres; do
7312     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7313 set dummy ${ncn_progname}; ac_word=$2
7314 echo "$as_me:$LINENO: checking for $ac_word" >&5
7315 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7316 if test "${ac_cv_prog_WINDRES+set}" = set; then
7317   echo $ECHO_N "(cached) $ECHO_C" >&6
7318 else
7319   if test -n "$WINDRES"; then
7320   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7321 else
7322 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7323 for as_dir in $PATH
7324 do
7325   IFS=$as_save_IFS
7326   test -z "$as_dir" && as_dir=.
7327   for ac_exec_ext in '' $ac_executable_extensions; do
7328   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7329     ac_cv_prog_WINDRES="${ncn_progname}"
7330     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7331     break 2
7332   fi
7333 done
7334 done
7335
7336 fi
7337 fi
7338 WINDRES=$ac_cv_prog_WINDRES
7339 if test -n "$WINDRES"; then
7340   echo "$as_me:$LINENO: result: $WINDRES" >&5
7341 echo "${ECHO_T}$WINDRES" >&6
7342 else
7343   echo "$as_me:$LINENO: result: no" >&5
7344 echo "${ECHO_T}no" >&6
7345 fi
7346
7347   done
7348 fi
7349
7350 for ncn_progname in windres; do
7351   if test -n "$ncn_tool_prefix"; then
7352     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7353 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7354 echo "$as_me:$LINENO: checking for $ac_word" >&5
7355 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7356 if test "${ac_cv_prog_WINDRES+set}" = set; then
7357   echo $ECHO_N "(cached) $ECHO_C" >&6
7358 else
7359   if test -n "$WINDRES"; then
7360   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7361 else
7362 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7363 for as_dir in $PATH
7364 do
7365   IFS=$as_save_IFS
7366   test -z "$as_dir" && as_dir=.
7367   for ac_exec_ext in '' $ac_executable_extensions; do
7368   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7369     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7370     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7371     break 2
7372   fi
7373 done
7374 done
7375
7376 fi
7377 fi
7378 WINDRES=$ac_cv_prog_WINDRES
7379 if test -n "$WINDRES"; then
7380   echo "$as_me:$LINENO: result: $WINDRES" >&5
7381 echo "${ECHO_T}$WINDRES" >&6
7382 else
7383   echo "$as_me:$LINENO: result: no" >&5
7384 echo "${ECHO_T}no" >&6
7385 fi
7386
7387   fi
7388   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7389     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7390 set dummy ${ncn_progname}; ac_word=$2
7391 echo "$as_me:$LINENO: checking for $ac_word" >&5
7392 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7393 if test "${ac_cv_prog_WINDRES+set}" = set; then
7394   echo $ECHO_N "(cached) $ECHO_C" >&6
7395 else
7396   if test -n "$WINDRES"; then
7397   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7398 else
7399 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7400 for as_dir in $PATH
7401 do
7402   IFS=$as_save_IFS
7403   test -z "$as_dir" && as_dir=.
7404   for ac_exec_ext in '' $ac_executable_extensions; do
7405   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7406     ac_cv_prog_WINDRES="${ncn_progname}"
7407     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7408     break 2
7409   fi
7410 done
7411 done
7412
7413 fi
7414 fi
7415 WINDRES=$ac_cv_prog_WINDRES
7416 if test -n "$WINDRES"; then
7417   echo "$as_me:$LINENO: result: $WINDRES" >&5
7418 echo "${ECHO_T}$WINDRES" >&6
7419 else
7420   echo "$as_me:$LINENO: result: no" >&5
7421 echo "${ECHO_T}no" >&6
7422 fi
7423
7424   fi
7425   test -n "$ac_cv_prog_WINDRES" && break
7426 done
7427
7428 if test -z "$ac_cv_prog_WINDRES" ; then
7429   set dummy windres
7430   if test $build = $host ; then
7431     WINDRES="$2"
7432   else
7433     WINDRES="${ncn_tool_prefix}$2"
7434   fi
7435 fi
7436
7437
7438
7439 if test -n "$OBJCOPY"; then
7440   ac_cv_prog_OBJCOPY=$OBJCOPY
7441 elif test -n "$ac_cv_prog_OBJCOPY"; then
7442   OBJCOPY=$ac_cv_prog_OBJCOPY
7443 fi
7444
7445 if test -n "$ac_cv_prog_OBJCOPY"; then
7446   for ncn_progname in objcopy; do
7447     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7448 set dummy ${ncn_progname}; ac_word=$2
7449 echo "$as_me:$LINENO: checking for $ac_word" >&5
7450 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7451 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7452   echo $ECHO_N "(cached) $ECHO_C" >&6
7453 else
7454   if test -n "$OBJCOPY"; then
7455   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7456 else
7457 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7458 for as_dir in $PATH
7459 do
7460   IFS=$as_save_IFS
7461   test -z "$as_dir" && as_dir=.
7462   for ac_exec_ext in '' $ac_executable_extensions; do
7463   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7464     ac_cv_prog_OBJCOPY="${ncn_progname}"
7465     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7466     break 2
7467   fi
7468 done
7469 done
7470
7471 fi
7472 fi
7473 OBJCOPY=$ac_cv_prog_OBJCOPY
7474 if test -n "$OBJCOPY"; then
7475   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7476 echo "${ECHO_T}$OBJCOPY" >&6
7477 else
7478   echo "$as_me:$LINENO: result: no" >&5
7479 echo "${ECHO_T}no" >&6
7480 fi
7481
7482   done
7483 fi
7484
7485 for ncn_progname in objcopy; do
7486   if test -n "$ncn_tool_prefix"; then
7487     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7488 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7489 echo "$as_me:$LINENO: checking for $ac_word" >&5
7490 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7491 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7492   echo $ECHO_N "(cached) $ECHO_C" >&6
7493 else
7494   if test -n "$OBJCOPY"; then
7495   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7496 else
7497 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7498 for as_dir in $PATH
7499 do
7500   IFS=$as_save_IFS
7501   test -z "$as_dir" && as_dir=.
7502   for ac_exec_ext in '' $ac_executable_extensions; do
7503   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7504     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7505     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7506     break 2
7507   fi
7508 done
7509 done
7510
7511 fi
7512 fi
7513 OBJCOPY=$ac_cv_prog_OBJCOPY
7514 if test -n "$OBJCOPY"; then
7515   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7516 echo "${ECHO_T}$OBJCOPY" >&6
7517 else
7518   echo "$as_me:$LINENO: result: no" >&5
7519 echo "${ECHO_T}no" >&6
7520 fi
7521
7522   fi
7523   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7524     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7525 set dummy ${ncn_progname}; ac_word=$2
7526 echo "$as_me:$LINENO: checking for $ac_word" >&5
7527 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7528 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7529   echo $ECHO_N "(cached) $ECHO_C" >&6
7530 else
7531   if test -n "$OBJCOPY"; then
7532   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7533 else
7534 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7535 for as_dir in $PATH
7536 do
7537   IFS=$as_save_IFS
7538   test -z "$as_dir" && as_dir=.
7539   for ac_exec_ext in '' $ac_executable_extensions; do
7540   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7541     ac_cv_prog_OBJCOPY="${ncn_progname}"
7542     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7543     break 2
7544   fi
7545 done
7546 done
7547
7548 fi
7549 fi
7550 OBJCOPY=$ac_cv_prog_OBJCOPY
7551 if test -n "$OBJCOPY"; then
7552   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7553 echo "${ECHO_T}$OBJCOPY" >&6
7554 else
7555   echo "$as_me:$LINENO: result: no" >&5
7556 echo "${ECHO_T}no" >&6
7557 fi
7558
7559   fi
7560   test -n "$ac_cv_prog_OBJCOPY" && break
7561 done
7562
7563 if test -z "$ac_cv_prog_OBJCOPY" ; then
7564   set dummy objcopy
7565   if test $build = $host ; then
7566     OBJCOPY="$2"
7567   else
7568     OBJCOPY="${ncn_tool_prefix}$2"
7569   fi
7570 fi
7571
7572
7573
7574 if test -n "$OBJDUMP"; then
7575   ac_cv_prog_OBJDUMP=$OBJDUMP
7576 elif test -n "$ac_cv_prog_OBJDUMP"; then
7577   OBJDUMP=$ac_cv_prog_OBJDUMP
7578 fi
7579
7580 if test -n "$ac_cv_prog_OBJDUMP"; then
7581   for ncn_progname in objdump; do
7582     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7583 set dummy ${ncn_progname}; ac_word=$2
7584 echo "$as_me:$LINENO: checking for $ac_word" >&5
7585 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7586 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7587   echo $ECHO_N "(cached) $ECHO_C" >&6
7588 else
7589   if test -n "$OBJDUMP"; then
7590   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7591 else
7592 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7593 for as_dir in $PATH
7594 do
7595   IFS=$as_save_IFS
7596   test -z "$as_dir" && as_dir=.
7597   for ac_exec_ext in '' $ac_executable_extensions; do
7598   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7599     ac_cv_prog_OBJDUMP="${ncn_progname}"
7600     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7601     break 2
7602   fi
7603 done
7604 done
7605
7606 fi
7607 fi
7608 OBJDUMP=$ac_cv_prog_OBJDUMP
7609 if test -n "$OBJDUMP"; then
7610   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7611 echo "${ECHO_T}$OBJDUMP" >&6
7612 else
7613   echo "$as_me:$LINENO: result: no" >&5
7614 echo "${ECHO_T}no" >&6
7615 fi
7616
7617   done
7618 fi
7619
7620 for ncn_progname in objdump; do
7621   if test -n "$ncn_tool_prefix"; then
7622     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7623 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7624 echo "$as_me:$LINENO: checking for $ac_word" >&5
7625 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7626 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7627   echo $ECHO_N "(cached) $ECHO_C" >&6
7628 else
7629   if test -n "$OBJDUMP"; then
7630   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7631 else
7632 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7633 for as_dir in $PATH
7634 do
7635   IFS=$as_save_IFS
7636   test -z "$as_dir" && as_dir=.
7637   for ac_exec_ext in '' $ac_executable_extensions; do
7638   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7639     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7640     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7641     break 2
7642   fi
7643 done
7644 done
7645
7646 fi
7647 fi
7648 OBJDUMP=$ac_cv_prog_OBJDUMP
7649 if test -n "$OBJDUMP"; then
7650   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7651 echo "${ECHO_T}$OBJDUMP" >&6
7652 else
7653   echo "$as_me:$LINENO: result: no" >&5
7654 echo "${ECHO_T}no" >&6
7655 fi
7656
7657   fi
7658   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7659     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7660 set dummy ${ncn_progname}; ac_word=$2
7661 echo "$as_me:$LINENO: checking for $ac_word" >&5
7662 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7663 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7664   echo $ECHO_N "(cached) $ECHO_C" >&6
7665 else
7666   if test -n "$OBJDUMP"; then
7667   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7668 else
7669 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7670 for as_dir in $PATH
7671 do
7672   IFS=$as_save_IFS
7673   test -z "$as_dir" && as_dir=.
7674   for ac_exec_ext in '' $ac_executable_extensions; do
7675   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7676     ac_cv_prog_OBJDUMP="${ncn_progname}"
7677     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7678     break 2
7679   fi
7680 done
7681 done
7682
7683 fi
7684 fi
7685 OBJDUMP=$ac_cv_prog_OBJDUMP
7686 if test -n "$OBJDUMP"; then
7687   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7688 echo "${ECHO_T}$OBJDUMP" >&6
7689 else
7690   echo "$as_me:$LINENO: result: no" >&5
7691 echo "${ECHO_T}no" >&6
7692 fi
7693
7694   fi
7695   test -n "$ac_cv_prog_OBJDUMP" && break
7696 done
7697
7698 if test -z "$ac_cv_prog_OBJDUMP" ; then
7699   set dummy objdump
7700   if test $build = $host ; then
7701     OBJDUMP="$2"
7702   else
7703     OBJDUMP="${ncn_tool_prefix}$2"
7704   fi
7705 fi
7706
7707
7708
7709
7710
7711
7712
7713 # Target tools.
7714
7715 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7716 if test "${with_build_time_tools+set}" = set; then
7717   withval="$with_build_time_tools"
7718   case x"$withval" in
7719      x/*) ;;
7720      *)
7721        with_build_time_tools=
7722        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7723 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7724        ;;
7725    esac
7726 else
7727   with_build_time_tools=
7728 fi;
7729
7730
7731
7732 if test -n "$CC_FOR_TARGET"; then
7733   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7734 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7735   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7736 fi
7737
7738 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7739   for ncn_progname in cc gcc; do
7740     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7741 set dummy ${ncn_progname}; ac_word=$2
7742 echo "$as_me:$LINENO: checking for $ac_word" >&5
7743 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7744 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7745   echo $ECHO_N "(cached) $ECHO_C" >&6
7746 else
7747   if test -n "$CC_FOR_TARGET"; then
7748   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7749 else
7750 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7751 for as_dir in $PATH
7752 do
7753   IFS=$as_save_IFS
7754   test -z "$as_dir" && as_dir=.
7755   for ac_exec_ext in '' $ac_executable_extensions; do
7756   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7757     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7758     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7759     break 2
7760   fi
7761 done
7762 done
7763
7764 fi
7765 fi
7766 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7767 if test -n "$CC_FOR_TARGET"; then
7768   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7769 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7770 else
7771   echo "$as_me:$LINENO: result: no" >&5
7772 echo "${ECHO_T}no" >&6
7773 fi
7774
7775   done
7776 fi
7777
7778 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
7779   for ncn_progname in cc gcc; do
7780     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7781 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7782     if test -x $with_build_time_tools/${ncn_progname}; then
7783       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7784       echo "$as_me:$LINENO: result: yes" >&5
7785 echo "${ECHO_T}yes" >&6
7786       break
7787     else
7788       echo "$as_me:$LINENO: result: no" >&5
7789 echo "${ECHO_T}no" >&6
7790     fi
7791   done
7792 fi
7793
7794 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
7795   for ncn_progname in cc gcc; do
7796     if test -n "$ncn_target_tool_prefix"; then
7797       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
7798 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
7799 echo "$as_me:$LINENO: checking for $ac_word" >&5
7800 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7801 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7802   echo $ECHO_N "(cached) $ECHO_C" >&6
7803 else
7804   if test -n "$CC_FOR_TARGET"; then
7805   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7806 else
7807 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7808 for as_dir in $PATH
7809 do
7810   IFS=$as_save_IFS
7811   test -z "$as_dir" && as_dir=.
7812   for ac_exec_ext in '' $ac_executable_extensions; do
7813   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7814     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
7815     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7816     break 2
7817   fi
7818 done
7819 done
7820
7821 fi
7822 fi
7823 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7824 if test -n "$CC_FOR_TARGET"; then
7825   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7826 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7827 else
7828   echo "$as_me:$LINENO: result: no" >&5
7829 echo "${ECHO_T}no" >&6
7830 fi
7831
7832     fi
7833     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
7834       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7835 set dummy ${ncn_progname}; ac_word=$2
7836 echo "$as_me:$LINENO: checking for $ac_word" >&5
7837 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7838 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7839   echo $ECHO_N "(cached) $ECHO_C" >&6
7840 else
7841   if test -n "$CC_FOR_TARGET"; then
7842   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7843 else
7844 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7845 for as_dir in $PATH
7846 do
7847   IFS=$as_save_IFS
7848   test -z "$as_dir" && as_dir=.
7849   for ac_exec_ext in '' $ac_executable_extensions; do
7850   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7851     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7852     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7853     break 2
7854   fi
7855 done
7856 done
7857
7858 fi
7859 fi
7860 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7861 if test -n "$CC_FOR_TARGET"; then
7862   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7863 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7864 else
7865   echo "$as_me:$LINENO: result: no" >&5
7866 echo "${ECHO_T}no" >&6
7867 fi
7868
7869     fi
7870     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
7871   done
7872 fi
7873
7874 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
7875   set dummy cc gcc
7876   if test $build = $target ; then
7877     CC_FOR_TARGET="$2"
7878   else
7879     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
7880   fi
7881 else
7882   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
7883 fi
7884
7885
7886
7887 if test -n "$CXX_FOR_TARGET"; then
7888   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
7889 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
7890   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7891 fi
7892
7893 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
7894   for ncn_progname in c++ g++ cxx gxx; do
7895     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7896 set dummy ${ncn_progname}; ac_word=$2
7897 echo "$as_me:$LINENO: checking for $ac_word" >&5
7898 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7899 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
7900   echo $ECHO_N "(cached) $ECHO_C" >&6
7901 else
7902   if test -n "$CXX_FOR_TARGET"; then
7903   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
7904 else
7905 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7906 for as_dir in $PATH
7907 do
7908   IFS=$as_save_IFS
7909   test -z "$as_dir" && as_dir=.
7910   for ac_exec_ext in '' $ac_executable_extensions; do
7911   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7912     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
7913     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7914     break 2
7915   fi
7916 done
7917 done
7918
7919 fi
7920 fi
7921 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7922 if test -n "$CXX_FOR_TARGET"; then
7923   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
7924 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
7925 else
7926   echo "$as_me:$LINENO: result: no" >&5
7927 echo "${ECHO_T}no" >&6
7928 fi
7929
7930   done
7931 fi
7932
7933 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
7934   for ncn_progname in c++ g++ cxx gxx; do
7935     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7936 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7937     if test -x $with_build_time_tools/${ncn_progname}; then
7938       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7939       echo "$as_me:$LINENO: result: yes" >&5
7940 echo "${ECHO_T}yes" >&6
7941       break
7942     else
7943       echo "$as_me:$LINENO: result: no" >&5
7944 echo "${ECHO_T}no" >&6
7945     fi
7946   done
7947 fi
7948
7949 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
7950   for ncn_progname in c++ g++ cxx gxx; do
7951     if test -n "$ncn_target_tool_prefix"; then
7952       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
7953 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
7954 echo "$as_me:$LINENO: checking for $ac_word" >&5
7955 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7956 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
7957   echo $ECHO_N "(cached) $ECHO_C" >&6
7958 else
7959   if test -n "$CXX_FOR_TARGET"; then
7960   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
7961 else
7962 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7963 for as_dir in $PATH
7964 do
7965   IFS=$as_save_IFS
7966   test -z "$as_dir" && as_dir=.
7967   for ac_exec_ext in '' $ac_executable_extensions; do
7968   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7969     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
7970     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7971     break 2
7972   fi
7973 done
7974 done
7975
7976 fi
7977 fi
7978 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
7979 if test -n "$CXX_FOR_TARGET"; then
7980   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
7981 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
7982 else
7983   echo "$as_me:$LINENO: result: no" >&5
7984 echo "${ECHO_T}no" >&6
7985 fi
7986
7987     fi
7988     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
7989       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7990 set dummy ${ncn_progname}; ac_word=$2
7991 echo "$as_me:$LINENO: checking for $ac_word" >&5
7992 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7993 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
7994   echo $ECHO_N "(cached) $ECHO_C" >&6
7995 else
7996   if test -n "$CXX_FOR_TARGET"; then
7997   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
7998 else
7999 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8000 for as_dir in $PATH
8001 do
8002   IFS=$as_save_IFS
8003   test -z "$as_dir" && as_dir=.
8004   for ac_exec_ext in '' $ac_executable_extensions; do
8005   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8006     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8007     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8008     break 2
8009   fi
8010 done
8011 done
8012
8013 fi
8014 fi
8015 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8016 if test -n "$CXX_FOR_TARGET"; then
8017   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8018 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8019 else
8020   echo "$as_me:$LINENO: result: no" >&5
8021 echo "${ECHO_T}no" >&6
8022 fi
8023
8024     fi
8025     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8026   done
8027 fi
8028
8029 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8030   set dummy c++ g++ cxx gxx
8031   if test $build = $target ; then
8032     CXX_FOR_TARGET="$2"
8033   else
8034     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8035   fi
8036 else
8037   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8038 fi
8039
8040
8041
8042 if test -n "$GCC_FOR_TARGET"; then
8043   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8044 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8045   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8046 fi
8047
8048 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8049   for ncn_progname in gcc; do
8050     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8051 set dummy ${ncn_progname}; ac_word=$2
8052 echo "$as_me:$LINENO: checking for $ac_word" >&5
8053 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8054 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8055   echo $ECHO_N "(cached) $ECHO_C" >&6
8056 else
8057   if test -n "$GCC_FOR_TARGET"; then
8058   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8059 else
8060 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8061 for as_dir in $PATH
8062 do
8063   IFS=$as_save_IFS
8064   test -z "$as_dir" && as_dir=.
8065   for ac_exec_ext in '' $ac_executable_extensions; do
8066   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8067     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8068     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8069     break 2
8070   fi
8071 done
8072 done
8073
8074 fi
8075 fi
8076 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8077 if test -n "$GCC_FOR_TARGET"; then
8078   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8079 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8080 else
8081   echo "$as_me:$LINENO: result: no" >&5
8082 echo "${ECHO_T}no" >&6
8083 fi
8084
8085   done
8086 fi
8087
8088 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8089   for ncn_progname in gcc; do
8090     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8091 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8092     if test -x $with_build_time_tools/${ncn_progname}; then
8093       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8094       echo "$as_me:$LINENO: result: yes" >&5
8095 echo "${ECHO_T}yes" >&6
8096       break
8097     else
8098       echo "$as_me:$LINENO: result: no" >&5
8099 echo "${ECHO_T}no" >&6
8100     fi
8101   done
8102 fi
8103
8104 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8105   for ncn_progname in gcc; do
8106     if test -n "$ncn_target_tool_prefix"; then
8107       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8108 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8109 echo "$as_me:$LINENO: checking for $ac_word" >&5
8110 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8111 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8112   echo $ECHO_N "(cached) $ECHO_C" >&6
8113 else
8114   if test -n "$GCC_FOR_TARGET"; then
8115   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8116 else
8117 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8118 for as_dir in $PATH
8119 do
8120   IFS=$as_save_IFS
8121   test -z "$as_dir" && as_dir=.
8122   for ac_exec_ext in '' $ac_executable_extensions; do
8123   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8124     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8125     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8126     break 2
8127   fi
8128 done
8129 done
8130
8131 fi
8132 fi
8133 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8134 if test -n "$GCC_FOR_TARGET"; then
8135   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8136 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8137 else
8138   echo "$as_me:$LINENO: result: no" >&5
8139 echo "${ECHO_T}no" >&6
8140 fi
8141
8142     fi
8143     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8144       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8145 set dummy ${ncn_progname}; ac_word=$2
8146 echo "$as_me:$LINENO: checking for $ac_word" >&5
8147 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8148 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8149   echo $ECHO_N "(cached) $ECHO_C" >&6
8150 else
8151   if test -n "$GCC_FOR_TARGET"; then
8152   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8153 else
8154 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8155 for as_dir in $PATH
8156 do
8157   IFS=$as_save_IFS
8158   test -z "$as_dir" && as_dir=.
8159   for ac_exec_ext in '' $ac_executable_extensions; do
8160   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8161     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8162     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8163     break 2
8164   fi
8165 done
8166 done
8167
8168 fi
8169 fi
8170 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8171 if test -n "$GCC_FOR_TARGET"; then
8172   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8173 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8174 else
8175   echo "$as_me:$LINENO: result: no" >&5
8176 echo "${ECHO_T}no" >&6
8177 fi
8178
8179     fi
8180     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8181   done
8182 fi
8183
8184 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8185   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8186 else
8187   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8188 fi
8189
8190
8191
8192 if test -n "$GCJ_FOR_TARGET"; then
8193   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8194 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8195   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8196 fi
8197
8198 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8199   for ncn_progname in gcj; do
8200     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8201 set dummy ${ncn_progname}; ac_word=$2
8202 echo "$as_me:$LINENO: checking for $ac_word" >&5
8203 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8204 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8205   echo $ECHO_N "(cached) $ECHO_C" >&6
8206 else
8207   if test -n "$GCJ_FOR_TARGET"; then
8208   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8209 else
8210 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8211 for as_dir in $PATH
8212 do
8213   IFS=$as_save_IFS
8214   test -z "$as_dir" && as_dir=.
8215   for ac_exec_ext in '' $ac_executable_extensions; do
8216   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8217     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8218     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8219     break 2
8220   fi
8221 done
8222 done
8223
8224 fi
8225 fi
8226 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8227 if test -n "$GCJ_FOR_TARGET"; then
8228   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8229 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8230 else
8231   echo "$as_me:$LINENO: result: no" >&5
8232 echo "${ECHO_T}no" >&6
8233 fi
8234
8235   done
8236 fi
8237
8238 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8239   for ncn_progname in gcj; do
8240     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8241 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8242     if test -x $with_build_time_tools/${ncn_progname}; then
8243       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8244       echo "$as_me:$LINENO: result: yes" >&5
8245 echo "${ECHO_T}yes" >&6
8246       break
8247     else
8248       echo "$as_me:$LINENO: result: no" >&5
8249 echo "${ECHO_T}no" >&6
8250     fi
8251   done
8252 fi
8253
8254 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8255   for ncn_progname in gcj; do
8256     if test -n "$ncn_target_tool_prefix"; then
8257       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8258 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8259 echo "$as_me:$LINENO: checking for $ac_word" >&5
8260 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8261 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8262   echo $ECHO_N "(cached) $ECHO_C" >&6
8263 else
8264   if test -n "$GCJ_FOR_TARGET"; then
8265   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8266 else
8267 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8268 for as_dir in $PATH
8269 do
8270   IFS=$as_save_IFS
8271   test -z "$as_dir" && as_dir=.
8272   for ac_exec_ext in '' $ac_executable_extensions; do
8273   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8274     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8275     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8276     break 2
8277   fi
8278 done
8279 done
8280
8281 fi
8282 fi
8283 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8284 if test -n "$GCJ_FOR_TARGET"; then
8285   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8286 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8287 else
8288   echo "$as_me:$LINENO: result: no" >&5
8289 echo "${ECHO_T}no" >&6
8290 fi
8291
8292     fi
8293     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8294       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8295 set dummy ${ncn_progname}; ac_word=$2
8296 echo "$as_me:$LINENO: checking for $ac_word" >&5
8297 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8298 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8299   echo $ECHO_N "(cached) $ECHO_C" >&6
8300 else
8301   if test -n "$GCJ_FOR_TARGET"; then
8302   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8303 else
8304 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8305 for as_dir in $PATH
8306 do
8307   IFS=$as_save_IFS
8308   test -z "$as_dir" && as_dir=.
8309   for ac_exec_ext in '' $ac_executable_extensions; do
8310   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8311     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8312     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8313     break 2
8314   fi
8315 done
8316 done
8317
8318 fi
8319 fi
8320 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8321 if test -n "$GCJ_FOR_TARGET"; then
8322   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8323 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8324 else
8325   echo "$as_me:$LINENO: result: no" >&5
8326 echo "${ECHO_T}no" >&6
8327 fi
8328
8329     fi
8330     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8331   done
8332 fi
8333
8334 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8335   set dummy gcj
8336   if test $build = $target ; then
8337     GCJ_FOR_TARGET="$2"
8338   else
8339     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8340   fi
8341 else
8342   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8343 fi
8344
8345
8346
8347 if test -n "$GFORTRAN_FOR_TARGET"; then
8348   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8349 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8350   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8351 fi
8352
8353 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8354   for ncn_progname in gfortran; do
8355     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8356 set dummy ${ncn_progname}; ac_word=$2
8357 echo "$as_me:$LINENO: checking for $ac_word" >&5
8358 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8359 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8360   echo $ECHO_N "(cached) $ECHO_C" >&6
8361 else
8362   if test -n "$GFORTRAN_FOR_TARGET"; then
8363   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8364 else
8365 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8366 for as_dir in $PATH
8367 do
8368   IFS=$as_save_IFS
8369   test -z "$as_dir" && as_dir=.
8370   for ac_exec_ext in '' $ac_executable_extensions; do
8371   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8372     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8373     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8374     break 2
8375   fi
8376 done
8377 done
8378
8379 fi
8380 fi
8381 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8382 if test -n "$GFORTRAN_FOR_TARGET"; then
8383   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8384 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8385 else
8386   echo "$as_me:$LINENO: result: no" >&5
8387 echo "${ECHO_T}no" >&6
8388 fi
8389
8390   done
8391 fi
8392
8393 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8394   for ncn_progname in gfortran; do
8395     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8396 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8397     if test -x $with_build_time_tools/${ncn_progname}; then
8398       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8399       echo "$as_me:$LINENO: result: yes" >&5
8400 echo "${ECHO_T}yes" >&6
8401       break
8402     else
8403       echo "$as_me:$LINENO: result: no" >&5
8404 echo "${ECHO_T}no" >&6
8405     fi
8406   done
8407 fi
8408
8409 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8410   for ncn_progname in gfortran; do
8411     if test -n "$ncn_target_tool_prefix"; then
8412       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8413 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8414 echo "$as_me:$LINENO: checking for $ac_word" >&5
8415 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8416 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8417   echo $ECHO_N "(cached) $ECHO_C" >&6
8418 else
8419   if test -n "$GFORTRAN_FOR_TARGET"; then
8420   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8421 else
8422 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8423 for as_dir in $PATH
8424 do
8425   IFS=$as_save_IFS
8426   test -z "$as_dir" && as_dir=.
8427   for ac_exec_ext in '' $ac_executable_extensions; do
8428   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8429     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8430     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8431     break 2
8432   fi
8433 done
8434 done
8435
8436 fi
8437 fi
8438 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8439 if test -n "$GFORTRAN_FOR_TARGET"; then
8440   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8441 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8442 else
8443   echo "$as_me:$LINENO: result: no" >&5
8444 echo "${ECHO_T}no" >&6
8445 fi
8446
8447     fi
8448     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8449       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8450 set dummy ${ncn_progname}; ac_word=$2
8451 echo "$as_me:$LINENO: checking for $ac_word" >&5
8452 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8453 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8454   echo $ECHO_N "(cached) $ECHO_C" >&6
8455 else
8456   if test -n "$GFORTRAN_FOR_TARGET"; then
8457   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8458 else
8459 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8460 for as_dir in $PATH
8461 do
8462   IFS=$as_save_IFS
8463   test -z "$as_dir" && as_dir=.
8464   for ac_exec_ext in '' $ac_executable_extensions; do
8465   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8466     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8467     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8468     break 2
8469   fi
8470 done
8471 done
8472
8473 fi
8474 fi
8475 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8476 if test -n "$GFORTRAN_FOR_TARGET"; then
8477   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8478 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8479 else
8480   echo "$as_me:$LINENO: result: no" >&5
8481 echo "${ECHO_T}no" >&6
8482 fi
8483
8484     fi
8485     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8486   done
8487 fi
8488
8489 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8490   set dummy gfortran
8491   if test $build = $target ; then
8492     GFORTRAN_FOR_TARGET="$2"
8493   else
8494     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8495   fi
8496 else
8497   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8498 fi
8499
8500
8501
8502 cat > conftest.c << \EOF
8503 #ifdef __GNUC__
8504   gcc_yay;
8505 #endif
8506 EOF
8507 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8508   have_gcc_for_target=yes
8509 else
8510   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8511   have_gcc_for_target=no
8512 fi
8513 rm conftest.c
8514
8515
8516
8517
8518 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8519   if test -n "$with_build_time_tools"; then
8520     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8521 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8522     if test -x $with_build_time_tools/ar; then
8523       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8524       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8525       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8526 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8527     else
8528       echo "$as_me:$LINENO: result: no" >&5
8529 echo "${ECHO_T}no" >&6
8530     fi
8531   elif test $build != $host && test $have_gcc_for_target = yes; then
8532     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8533     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8534     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8535   fi
8536 fi
8537 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8538   # Extract the first word of "ar", so it can be a program name with args.
8539 set dummy ar; ac_word=$2
8540 echo "$as_me:$LINENO: checking for $ac_word" >&5
8541 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8542 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8543   echo $ECHO_N "(cached) $ECHO_C" >&6
8544 else
8545   case $AR_FOR_TARGET in
8546   [\\/]* | ?:[\\/]*)
8547   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8548   ;;
8549   *)
8550   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8551 for as_dir in $gcc_cv_tool_dirs
8552 do
8553   IFS=$as_save_IFS
8554   test -z "$as_dir" && as_dir=.
8555   for ac_exec_ext in '' $ac_executable_extensions; do
8556   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8557     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8558     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8559     break 2
8560   fi
8561 done
8562 done
8563
8564   ;;
8565 esac
8566 fi
8567 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8568
8569 if test -n "$AR_FOR_TARGET"; then
8570   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8571 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8572 else
8573   echo "$as_me:$LINENO: result: no" >&5
8574 echo "${ECHO_T}no" >&6
8575 fi
8576
8577 fi
8578 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8579
8580
8581 if test -n "$AR_FOR_TARGET"; then
8582   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8583 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8584   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8585 fi
8586
8587 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8588   for ncn_progname in ar; do
8589     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8590 set dummy ${ncn_progname}; ac_word=$2
8591 echo "$as_me:$LINENO: checking for $ac_word" >&5
8592 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8593 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8594   echo $ECHO_N "(cached) $ECHO_C" >&6
8595 else
8596   if test -n "$AR_FOR_TARGET"; then
8597   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8598 else
8599 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8600 for as_dir in $PATH
8601 do
8602   IFS=$as_save_IFS
8603   test -z "$as_dir" && as_dir=.
8604   for ac_exec_ext in '' $ac_executable_extensions; do
8605   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8606     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8607     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8608     break 2
8609   fi
8610 done
8611 done
8612
8613 fi
8614 fi
8615 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8616 if test -n "$AR_FOR_TARGET"; then
8617   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8618 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8619 else
8620   echo "$as_me:$LINENO: result: no" >&5
8621 echo "${ECHO_T}no" >&6
8622 fi
8623
8624   done
8625 fi
8626
8627 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8628   for ncn_progname in ar; do
8629     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8630 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8631     if test -x $with_build_time_tools/${ncn_progname}; then
8632       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8633       echo "$as_me:$LINENO: result: yes" >&5
8634 echo "${ECHO_T}yes" >&6
8635       break
8636     else
8637       echo "$as_me:$LINENO: result: no" >&5
8638 echo "${ECHO_T}no" >&6
8639     fi
8640   done
8641 fi
8642
8643 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8644   for ncn_progname in ar; do
8645     if test -n "$ncn_target_tool_prefix"; then
8646       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8647 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8648 echo "$as_me:$LINENO: checking for $ac_word" >&5
8649 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8650 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8651   echo $ECHO_N "(cached) $ECHO_C" >&6
8652 else
8653   if test -n "$AR_FOR_TARGET"; then
8654   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8655 else
8656 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8657 for as_dir in $PATH
8658 do
8659   IFS=$as_save_IFS
8660   test -z "$as_dir" && as_dir=.
8661   for ac_exec_ext in '' $ac_executable_extensions; do
8662   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8663     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8664     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8665     break 2
8666   fi
8667 done
8668 done
8669
8670 fi
8671 fi
8672 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8673 if test -n "$AR_FOR_TARGET"; then
8674   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8675 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8676 else
8677   echo "$as_me:$LINENO: result: no" >&5
8678 echo "${ECHO_T}no" >&6
8679 fi
8680
8681     fi
8682     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8683       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8684 set dummy ${ncn_progname}; ac_word=$2
8685 echo "$as_me:$LINENO: checking for $ac_word" >&5
8686 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8687 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8688   echo $ECHO_N "(cached) $ECHO_C" >&6
8689 else
8690   if test -n "$AR_FOR_TARGET"; then
8691   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8692 else
8693 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8694 for as_dir in $PATH
8695 do
8696   IFS=$as_save_IFS
8697   test -z "$as_dir" && as_dir=.
8698   for ac_exec_ext in '' $ac_executable_extensions; do
8699   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8700     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8701     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8702     break 2
8703   fi
8704 done
8705 done
8706
8707 fi
8708 fi
8709 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8710 if test -n "$AR_FOR_TARGET"; then
8711   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8712 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8713 else
8714   echo "$as_me:$LINENO: result: no" >&5
8715 echo "${ECHO_T}no" >&6
8716 fi
8717
8718     fi
8719     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8720   done
8721 fi
8722
8723 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8724   set dummy ar
8725   if test $build = $target ; then
8726     AR_FOR_TARGET="$2"
8727   else
8728     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8729   fi
8730 else
8731   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
8732 fi
8733
8734 else
8735   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8736 fi
8737
8738
8739
8740
8741 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8742   if test -n "$with_build_time_tools"; then
8743     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
8744 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
8745     if test -x $with_build_time_tools/as; then
8746       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
8747       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8748       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
8749 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
8750     else
8751       echo "$as_me:$LINENO: result: no" >&5
8752 echo "${ECHO_T}no" >&6
8753     fi
8754   elif test $build != $host && test $have_gcc_for_target = yes; then
8755     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
8756     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
8757     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8758   fi
8759 fi
8760 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8761   # Extract the first word of "as", so it can be a program name with args.
8762 set dummy as; ac_word=$2
8763 echo "$as_me:$LINENO: checking for $ac_word" >&5
8764 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8765 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
8766   echo $ECHO_N "(cached) $ECHO_C" >&6
8767 else
8768   case $AS_FOR_TARGET in
8769   [\\/]* | ?:[\\/]*)
8770   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
8771   ;;
8772   *)
8773   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8774 for as_dir in $gcc_cv_tool_dirs
8775 do
8776   IFS=$as_save_IFS
8777   test -z "$as_dir" && as_dir=.
8778   for ac_exec_ext in '' $ac_executable_extensions; do
8779   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8780     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8781     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8782     break 2
8783   fi
8784 done
8785 done
8786
8787   ;;
8788 esac
8789 fi
8790 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8791
8792 if test -n "$AS_FOR_TARGET"; then
8793   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8794 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8795 else
8796   echo "$as_me:$LINENO: result: no" >&5
8797 echo "${ECHO_T}no" >&6
8798 fi
8799
8800 fi
8801 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8802
8803
8804 if test -n "$AS_FOR_TARGET"; then
8805   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
8806 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8807   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8808 fi
8809
8810 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8811   for ncn_progname in as; do
8812     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8813 set dummy ${ncn_progname}; ac_word=$2
8814 echo "$as_me:$LINENO: checking for $ac_word" >&5
8815 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8816 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8817   echo $ECHO_N "(cached) $ECHO_C" >&6
8818 else
8819   if test -n "$AS_FOR_TARGET"; then
8820   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8821 else
8822 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8823 for as_dir in $PATH
8824 do
8825   IFS=$as_save_IFS
8826   test -z "$as_dir" && as_dir=.
8827   for ac_exec_ext in '' $ac_executable_extensions; do
8828   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8829     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
8830     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8831     break 2
8832   fi
8833 done
8834 done
8835
8836 fi
8837 fi
8838 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8839 if test -n "$AS_FOR_TARGET"; then
8840   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8841 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8842 else
8843   echo "$as_me:$LINENO: result: no" >&5
8844 echo "${ECHO_T}no" >&6
8845 fi
8846
8847   done
8848 fi
8849
8850 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
8851   for ncn_progname in as; do
8852     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8853 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8854     if test -x $with_build_time_tools/${ncn_progname}; then
8855       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8856       echo "$as_me:$LINENO: result: yes" >&5
8857 echo "${ECHO_T}yes" >&6
8858       break
8859     else
8860       echo "$as_me:$LINENO: result: no" >&5
8861 echo "${ECHO_T}no" >&6
8862     fi
8863   done
8864 fi
8865
8866 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
8867   for ncn_progname in as; do
8868     if test -n "$ncn_target_tool_prefix"; then
8869       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8870 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8871 echo "$as_me:$LINENO: checking for $ac_word" >&5
8872 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8873 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8874   echo $ECHO_N "(cached) $ECHO_C" >&6
8875 else
8876   if test -n "$AS_FOR_TARGET"; then
8877   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8878 else
8879 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8880 for as_dir in $PATH
8881 do
8882   IFS=$as_save_IFS
8883   test -z "$as_dir" && as_dir=.
8884   for ac_exec_ext in '' $ac_executable_extensions; do
8885   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8886     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8887     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8888     break 2
8889   fi
8890 done
8891 done
8892
8893 fi
8894 fi
8895 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8896 if test -n "$AS_FOR_TARGET"; then
8897   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8898 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8899 else
8900   echo "$as_me:$LINENO: result: no" >&5
8901 echo "${ECHO_T}no" >&6
8902 fi
8903
8904     fi
8905     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
8906       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8907 set dummy ${ncn_progname}; ac_word=$2
8908 echo "$as_me:$LINENO: checking for $ac_word" >&5
8909 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8910 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8911   echo $ECHO_N "(cached) $ECHO_C" >&6
8912 else
8913   if test -n "$AS_FOR_TARGET"; then
8914   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8915 else
8916 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8917 for as_dir in $PATH
8918 do
8919   IFS=$as_save_IFS
8920   test -z "$as_dir" && as_dir=.
8921   for ac_exec_ext in '' $ac_executable_extensions; do
8922   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8923     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
8924     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8925     break 2
8926   fi
8927 done
8928 done
8929
8930 fi
8931 fi
8932 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8933 if test -n "$AS_FOR_TARGET"; then
8934   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8935 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8936 else
8937   echo "$as_me:$LINENO: result: no" >&5
8938 echo "${ECHO_T}no" >&6
8939 fi
8940
8941     fi
8942     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
8943   done
8944 fi
8945
8946 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
8947   set dummy as
8948   if test $build = $target ; then
8949     AS_FOR_TARGET="$2"
8950   else
8951     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
8952   fi
8953 else
8954   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
8955 fi
8956
8957 else
8958   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8959 fi
8960
8961
8962
8963
8964 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
8965   if test -n "$with_build_time_tools"; then
8966     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
8967 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
8968     if test -x $with_build_time_tools/dlltool; then
8969       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
8970       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
8971       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
8972 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
8973     else
8974       echo "$as_me:$LINENO: result: no" >&5
8975 echo "${ECHO_T}no" >&6
8976     fi
8977   elif test $build != $host && test $have_gcc_for_target = yes; then
8978     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
8979     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
8980     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
8981   fi
8982 fi
8983 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8984   # Extract the first word of "dlltool", so it can be a program name with args.
8985 set dummy dlltool; ac_word=$2
8986 echo "$as_me:$LINENO: checking for $ac_word" >&5
8987 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8988 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
8989   echo $ECHO_N "(cached) $ECHO_C" >&6
8990 else
8991   case $DLLTOOL_FOR_TARGET in
8992   [\\/]* | ?:[\\/]*)
8993   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
8994   ;;
8995   *)
8996   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8997 for as_dir in $gcc_cv_tool_dirs
8998 do
8999   IFS=$as_save_IFS
9000   test -z "$as_dir" && as_dir=.
9001   for ac_exec_ext in '' $ac_executable_extensions; do
9002   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9003     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9004     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9005     break 2
9006   fi
9007 done
9008 done
9009
9010   ;;
9011 esac
9012 fi
9013 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9014
9015 if test -n "$DLLTOOL_FOR_TARGET"; then
9016   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9017 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9018 else
9019   echo "$as_me:$LINENO: result: no" >&5
9020 echo "${ECHO_T}no" >&6
9021 fi
9022
9023 fi
9024 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9025
9026
9027 if test -n "$DLLTOOL_FOR_TARGET"; then
9028   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9029 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9030   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9031 fi
9032
9033 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9034   for ncn_progname in dlltool; do
9035     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9036 set dummy ${ncn_progname}; ac_word=$2
9037 echo "$as_me:$LINENO: checking for $ac_word" >&5
9038 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9039 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9040   echo $ECHO_N "(cached) $ECHO_C" >&6
9041 else
9042   if test -n "$DLLTOOL_FOR_TARGET"; then
9043   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9044 else
9045 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9046 for as_dir in $PATH
9047 do
9048   IFS=$as_save_IFS
9049   test -z "$as_dir" && as_dir=.
9050   for ac_exec_ext in '' $ac_executable_extensions; do
9051   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9052     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9053     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9054     break 2
9055   fi
9056 done
9057 done
9058
9059 fi
9060 fi
9061 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9062 if test -n "$DLLTOOL_FOR_TARGET"; then
9063   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9064 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9065 else
9066   echo "$as_me:$LINENO: result: no" >&5
9067 echo "${ECHO_T}no" >&6
9068 fi
9069
9070   done
9071 fi
9072
9073 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9074   for ncn_progname in dlltool; do
9075     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9076 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9077     if test -x $with_build_time_tools/${ncn_progname}; then
9078       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9079       echo "$as_me:$LINENO: result: yes" >&5
9080 echo "${ECHO_T}yes" >&6
9081       break
9082     else
9083       echo "$as_me:$LINENO: result: no" >&5
9084 echo "${ECHO_T}no" >&6
9085     fi
9086   done
9087 fi
9088
9089 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9090   for ncn_progname in dlltool; do
9091     if test -n "$ncn_target_tool_prefix"; then
9092       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9093 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9094 echo "$as_me:$LINENO: checking for $ac_word" >&5
9095 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9096 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9097   echo $ECHO_N "(cached) $ECHO_C" >&6
9098 else
9099   if test -n "$DLLTOOL_FOR_TARGET"; then
9100   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9101 else
9102 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9103 for as_dir in $PATH
9104 do
9105   IFS=$as_save_IFS
9106   test -z "$as_dir" && as_dir=.
9107   for ac_exec_ext in '' $ac_executable_extensions; do
9108   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9109     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9110     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9111     break 2
9112   fi
9113 done
9114 done
9115
9116 fi
9117 fi
9118 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9119 if test -n "$DLLTOOL_FOR_TARGET"; then
9120   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9121 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9122 else
9123   echo "$as_me:$LINENO: result: no" >&5
9124 echo "${ECHO_T}no" >&6
9125 fi
9126
9127     fi
9128     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9129       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9130 set dummy ${ncn_progname}; ac_word=$2
9131 echo "$as_me:$LINENO: checking for $ac_word" >&5
9132 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9133 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9134   echo $ECHO_N "(cached) $ECHO_C" >&6
9135 else
9136   if test -n "$DLLTOOL_FOR_TARGET"; then
9137   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9138 else
9139 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9140 for as_dir in $PATH
9141 do
9142   IFS=$as_save_IFS
9143   test -z "$as_dir" && as_dir=.
9144   for ac_exec_ext in '' $ac_executable_extensions; do
9145   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9146     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9147     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9148     break 2
9149   fi
9150 done
9151 done
9152
9153 fi
9154 fi
9155 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9156 if test -n "$DLLTOOL_FOR_TARGET"; then
9157   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9158 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9159 else
9160   echo "$as_me:$LINENO: result: no" >&5
9161 echo "${ECHO_T}no" >&6
9162 fi
9163
9164     fi
9165     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9166   done
9167 fi
9168
9169 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9170   set dummy dlltool
9171   if test $build = $target ; then
9172     DLLTOOL_FOR_TARGET="$2"
9173   else
9174     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9175   fi
9176 else
9177   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9178 fi
9179
9180 else
9181   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9182 fi
9183
9184
9185
9186
9187 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9188   if test -n "$with_build_time_tools"; then
9189     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9190 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9191     if test -x $with_build_time_tools/ld; then
9192       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9193       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9194       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9195 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9196     else
9197       echo "$as_me:$LINENO: result: no" >&5
9198 echo "${ECHO_T}no" >&6
9199     fi
9200   elif test $build != $host && test $have_gcc_for_target = yes; then
9201     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9202     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9203     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9204   fi
9205 fi
9206 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9207   # Extract the first word of "ld", so it can be a program name with args.
9208 set dummy ld; ac_word=$2
9209 echo "$as_me:$LINENO: checking for $ac_word" >&5
9210 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9211 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9212   echo $ECHO_N "(cached) $ECHO_C" >&6
9213 else
9214   case $LD_FOR_TARGET in
9215   [\\/]* | ?:[\\/]*)
9216   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9217   ;;
9218   *)
9219   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9220 for as_dir in $gcc_cv_tool_dirs
9221 do
9222   IFS=$as_save_IFS
9223   test -z "$as_dir" && as_dir=.
9224   for ac_exec_ext in '' $ac_executable_extensions; do
9225   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9226     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9227     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9228     break 2
9229   fi
9230 done
9231 done
9232
9233   ;;
9234 esac
9235 fi
9236 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9237
9238 if test -n "$LD_FOR_TARGET"; then
9239   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9240 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9241 else
9242   echo "$as_me:$LINENO: result: no" >&5
9243 echo "${ECHO_T}no" >&6
9244 fi
9245
9246 fi
9247 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9248
9249
9250 if test -n "$LD_FOR_TARGET"; then
9251   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9252 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9253   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9254 fi
9255
9256 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9257   for ncn_progname in ld; do
9258     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9259 set dummy ${ncn_progname}; ac_word=$2
9260 echo "$as_me:$LINENO: checking for $ac_word" >&5
9261 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9262 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9263   echo $ECHO_N "(cached) $ECHO_C" >&6
9264 else
9265   if test -n "$LD_FOR_TARGET"; then
9266   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9267 else
9268 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9269 for as_dir in $PATH
9270 do
9271   IFS=$as_save_IFS
9272   test -z "$as_dir" && as_dir=.
9273   for ac_exec_ext in '' $ac_executable_extensions; do
9274   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9275     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9276     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9277     break 2
9278   fi
9279 done
9280 done
9281
9282 fi
9283 fi
9284 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9285 if test -n "$LD_FOR_TARGET"; then
9286   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9287 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9288 else
9289   echo "$as_me:$LINENO: result: no" >&5
9290 echo "${ECHO_T}no" >&6
9291 fi
9292
9293   done
9294 fi
9295
9296 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9297   for ncn_progname in ld; do
9298     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9299 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9300     if test -x $with_build_time_tools/${ncn_progname}; then
9301       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9302       echo "$as_me:$LINENO: result: yes" >&5
9303 echo "${ECHO_T}yes" >&6
9304       break
9305     else
9306       echo "$as_me:$LINENO: result: no" >&5
9307 echo "${ECHO_T}no" >&6
9308     fi
9309   done
9310 fi
9311
9312 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9313   for ncn_progname in ld; do
9314     if test -n "$ncn_target_tool_prefix"; then
9315       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9316 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9317 echo "$as_me:$LINENO: checking for $ac_word" >&5
9318 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9319 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9320   echo $ECHO_N "(cached) $ECHO_C" >&6
9321 else
9322   if test -n "$LD_FOR_TARGET"; then
9323   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9324 else
9325 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9326 for as_dir in $PATH
9327 do
9328   IFS=$as_save_IFS
9329   test -z "$as_dir" && as_dir=.
9330   for ac_exec_ext in '' $ac_executable_extensions; do
9331   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9332     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9333     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9334     break 2
9335   fi
9336 done
9337 done
9338
9339 fi
9340 fi
9341 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9342 if test -n "$LD_FOR_TARGET"; then
9343   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9344 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9345 else
9346   echo "$as_me:$LINENO: result: no" >&5
9347 echo "${ECHO_T}no" >&6
9348 fi
9349
9350     fi
9351     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9352       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9353 set dummy ${ncn_progname}; ac_word=$2
9354 echo "$as_me:$LINENO: checking for $ac_word" >&5
9355 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9356 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9357   echo $ECHO_N "(cached) $ECHO_C" >&6
9358 else
9359   if test -n "$LD_FOR_TARGET"; then
9360   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9361 else
9362 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9363 for as_dir in $PATH
9364 do
9365   IFS=$as_save_IFS
9366   test -z "$as_dir" && as_dir=.
9367   for ac_exec_ext in '' $ac_executable_extensions; do
9368   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9369     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9370     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9371     break 2
9372   fi
9373 done
9374 done
9375
9376 fi
9377 fi
9378 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9379 if test -n "$LD_FOR_TARGET"; then
9380   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9381 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9382 else
9383   echo "$as_me:$LINENO: result: no" >&5
9384 echo "${ECHO_T}no" >&6
9385 fi
9386
9387     fi
9388     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9389   done
9390 fi
9391
9392 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9393   set dummy ld
9394   if test $build = $target ; then
9395     LD_FOR_TARGET="$2"
9396   else
9397     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9398   fi
9399 else
9400   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9401 fi
9402
9403 else
9404   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9405 fi
9406
9407
9408
9409
9410 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9411   if test -n "$with_build_time_tools"; then
9412     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9413 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9414     if test -x $with_build_time_tools/lipo; then
9415       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9416       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9417       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9418 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9419     else
9420       echo "$as_me:$LINENO: result: no" >&5
9421 echo "${ECHO_T}no" >&6
9422     fi
9423   elif test $build != $host && test $have_gcc_for_target = yes; then
9424     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9425     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9426     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9427   fi
9428 fi
9429 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9430   # Extract the first word of "lipo", so it can be a program name with args.
9431 set dummy lipo; ac_word=$2
9432 echo "$as_me:$LINENO: checking for $ac_word" >&5
9433 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9434 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9435   echo $ECHO_N "(cached) $ECHO_C" >&6
9436 else
9437   case $LIPO_FOR_TARGET in
9438   [\\/]* | ?:[\\/]*)
9439   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9440   ;;
9441   *)
9442   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9443 for as_dir in $gcc_cv_tool_dirs
9444 do
9445   IFS=$as_save_IFS
9446   test -z "$as_dir" && as_dir=.
9447   for ac_exec_ext in '' $ac_executable_extensions; do
9448   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9449     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9450     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9451     break 2
9452   fi
9453 done
9454 done
9455
9456   ;;
9457 esac
9458 fi
9459 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9460
9461 if test -n "$LIPO_FOR_TARGET"; then
9462   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9463 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9464 else
9465   echo "$as_me:$LINENO: result: no" >&5
9466 echo "${ECHO_T}no" >&6
9467 fi
9468
9469 fi
9470 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9471
9472
9473 if test -n "$LIPO_FOR_TARGET"; then
9474   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9475 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9476   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9477 fi
9478
9479 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9480   for ncn_progname in lipo; do
9481     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9482 set dummy ${ncn_progname}; ac_word=$2
9483 echo "$as_me:$LINENO: checking for $ac_word" >&5
9484 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9485 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9486   echo $ECHO_N "(cached) $ECHO_C" >&6
9487 else
9488   if test -n "$LIPO_FOR_TARGET"; then
9489   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9490 else
9491 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9492 for as_dir in $PATH
9493 do
9494   IFS=$as_save_IFS
9495   test -z "$as_dir" && as_dir=.
9496   for ac_exec_ext in '' $ac_executable_extensions; do
9497   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9498     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9499     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9500     break 2
9501   fi
9502 done
9503 done
9504
9505 fi
9506 fi
9507 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9508 if test -n "$LIPO_FOR_TARGET"; then
9509   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9510 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9511 else
9512   echo "$as_me:$LINENO: result: no" >&5
9513 echo "${ECHO_T}no" >&6
9514 fi
9515
9516   done
9517 fi
9518
9519 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9520   for ncn_progname in lipo; do
9521     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9522 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9523     if test -x $with_build_time_tools/${ncn_progname}; then
9524       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9525       echo "$as_me:$LINENO: result: yes" >&5
9526 echo "${ECHO_T}yes" >&6
9527       break
9528     else
9529       echo "$as_me:$LINENO: result: no" >&5
9530 echo "${ECHO_T}no" >&6
9531     fi
9532   done
9533 fi
9534
9535 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9536   for ncn_progname in lipo; do
9537     if test -n "$ncn_target_tool_prefix"; then
9538       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9539 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9540 echo "$as_me:$LINENO: checking for $ac_word" >&5
9541 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9542 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9543   echo $ECHO_N "(cached) $ECHO_C" >&6
9544 else
9545   if test -n "$LIPO_FOR_TARGET"; then
9546   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9547 else
9548 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9549 for as_dir in $PATH
9550 do
9551   IFS=$as_save_IFS
9552   test -z "$as_dir" && as_dir=.
9553   for ac_exec_ext in '' $ac_executable_extensions; do
9554   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9555     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9556     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9557     break 2
9558   fi
9559 done
9560 done
9561
9562 fi
9563 fi
9564 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9565 if test -n "$LIPO_FOR_TARGET"; then
9566   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9567 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9568 else
9569   echo "$as_me:$LINENO: result: no" >&5
9570 echo "${ECHO_T}no" >&6
9571 fi
9572
9573     fi
9574     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9575       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9576 set dummy ${ncn_progname}; ac_word=$2
9577 echo "$as_me:$LINENO: checking for $ac_word" >&5
9578 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9579 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9580   echo $ECHO_N "(cached) $ECHO_C" >&6
9581 else
9582   if test -n "$LIPO_FOR_TARGET"; then
9583   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9584 else
9585 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9586 for as_dir in $PATH
9587 do
9588   IFS=$as_save_IFS
9589   test -z "$as_dir" && as_dir=.
9590   for ac_exec_ext in '' $ac_executable_extensions; do
9591   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9592     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9593     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9594     break 2
9595   fi
9596 done
9597 done
9598
9599 fi
9600 fi
9601 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9602 if test -n "$LIPO_FOR_TARGET"; then
9603   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9604 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9605 else
9606   echo "$as_me:$LINENO: result: no" >&5
9607 echo "${ECHO_T}no" >&6
9608 fi
9609
9610     fi
9611     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9612   done
9613 fi
9614
9615 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9616   set dummy lipo
9617   if test $build = $target ; then
9618     LIPO_FOR_TARGET="$2"
9619   else
9620     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9621   fi
9622 else
9623   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9624 fi
9625
9626 else
9627   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9628 fi
9629
9630
9631
9632
9633 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9634   if test -n "$with_build_time_tools"; then
9635     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9636 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9637     if test -x $with_build_time_tools/nm; then
9638       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9639       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9640       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9641 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9642     else
9643       echo "$as_me:$LINENO: result: no" >&5
9644 echo "${ECHO_T}no" >&6
9645     fi
9646   elif test $build != $host && test $have_gcc_for_target = yes; then
9647     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9648     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9649     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9650   fi
9651 fi
9652 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9653   # Extract the first word of "nm", so it can be a program name with args.
9654 set dummy nm; ac_word=$2
9655 echo "$as_me:$LINENO: checking for $ac_word" >&5
9656 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9657 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9658   echo $ECHO_N "(cached) $ECHO_C" >&6
9659 else
9660   case $NM_FOR_TARGET in
9661   [\\/]* | ?:[\\/]*)
9662   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9663   ;;
9664   *)
9665   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9666 for as_dir in $gcc_cv_tool_dirs
9667 do
9668   IFS=$as_save_IFS
9669   test -z "$as_dir" && as_dir=.
9670   for ac_exec_ext in '' $ac_executable_extensions; do
9671   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9672     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9673     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9674     break 2
9675   fi
9676 done
9677 done
9678
9679   ;;
9680 esac
9681 fi
9682 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9683
9684 if test -n "$NM_FOR_TARGET"; then
9685   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9686 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9687 else
9688   echo "$as_me:$LINENO: result: no" >&5
9689 echo "${ECHO_T}no" >&6
9690 fi
9691
9692 fi
9693 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9694
9695
9696 if test -n "$NM_FOR_TARGET"; then
9697   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9698 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9699   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9700 fi
9701
9702 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9703   for ncn_progname in nm; do
9704     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9705 set dummy ${ncn_progname}; ac_word=$2
9706 echo "$as_me:$LINENO: checking for $ac_word" >&5
9707 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9708 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9709   echo $ECHO_N "(cached) $ECHO_C" >&6
9710 else
9711   if test -n "$NM_FOR_TARGET"; then
9712   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9713 else
9714 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9715 for as_dir in $PATH
9716 do
9717   IFS=$as_save_IFS
9718   test -z "$as_dir" && as_dir=.
9719   for ac_exec_ext in '' $ac_executable_extensions; do
9720   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9721     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9722     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9723     break 2
9724   fi
9725 done
9726 done
9727
9728 fi
9729 fi
9730 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9731 if test -n "$NM_FOR_TARGET"; then
9732   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9733 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9734 else
9735   echo "$as_me:$LINENO: result: no" >&5
9736 echo "${ECHO_T}no" >&6
9737 fi
9738
9739   done
9740 fi
9741
9742 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
9743   for ncn_progname in nm; do
9744     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9745 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9746     if test -x $with_build_time_tools/${ncn_progname}; then
9747       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9748       echo "$as_me:$LINENO: result: yes" >&5
9749 echo "${ECHO_T}yes" >&6
9750       break
9751     else
9752       echo "$as_me:$LINENO: result: no" >&5
9753 echo "${ECHO_T}no" >&6
9754     fi
9755   done
9756 fi
9757
9758 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
9759   for ncn_progname in nm; do
9760     if test -n "$ncn_target_tool_prefix"; then
9761       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9762 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9763 echo "$as_me:$LINENO: checking for $ac_word" >&5
9764 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9765 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9766   echo $ECHO_N "(cached) $ECHO_C" >&6
9767 else
9768   if test -n "$NM_FOR_TARGET"; then
9769   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9770 else
9771 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9772 for as_dir in $PATH
9773 do
9774   IFS=$as_save_IFS
9775   test -z "$as_dir" && as_dir=.
9776   for ac_exec_ext in '' $ac_executable_extensions; do
9777   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9778     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9779     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9780     break 2
9781   fi
9782 done
9783 done
9784
9785 fi
9786 fi
9787 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9788 if test -n "$NM_FOR_TARGET"; then
9789   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9790 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9791 else
9792   echo "$as_me:$LINENO: result: no" >&5
9793 echo "${ECHO_T}no" >&6
9794 fi
9795
9796     fi
9797     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
9798       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9799 set dummy ${ncn_progname}; ac_word=$2
9800 echo "$as_me:$LINENO: checking for $ac_word" >&5
9801 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9802 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9803   echo $ECHO_N "(cached) $ECHO_C" >&6
9804 else
9805   if test -n "$NM_FOR_TARGET"; then
9806   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9807 else
9808 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9809 for as_dir in $PATH
9810 do
9811   IFS=$as_save_IFS
9812   test -z "$as_dir" && as_dir=.
9813   for ac_exec_ext in '' $ac_executable_extensions; do
9814   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9815     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9816     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9817     break 2
9818   fi
9819 done
9820 done
9821
9822 fi
9823 fi
9824 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9825 if test -n "$NM_FOR_TARGET"; then
9826   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9827 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9828 else
9829   echo "$as_me:$LINENO: result: no" >&5
9830 echo "${ECHO_T}no" >&6
9831 fi
9832
9833     fi
9834     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
9835   done
9836 fi
9837
9838 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
9839   set dummy nm
9840   if test $build = $target ; then
9841     NM_FOR_TARGET="$2"
9842   else
9843     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
9844   fi
9845 else
9846   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
9847 fi
9848
9849 else
9850   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9851 fi
9852
9853
9854
9855
9856 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
9857   if test -n "$with_build_time_tools"; then
9858     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
9859 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
9860     if test -x $with_build_time_tools/objdump; then
9861       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
9862       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9863       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
9864 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
9865     else
9866       echo "$as_me:$LINENO: result: no" >&5
9867 echo "${ECHO_T}no" >&6
9868     fi
9869   elif test $build != $host && test $have_gcc_for_target = yes; then
9870     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
9871     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
9872     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9873   fi
9874 fi
9875 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9876   # Extract the first word of "objdump", so it can be a program name with args.
9877 set dummy objdump; ac_word=$2
9878 echo "$as_me:$LINENO: checking for $ac_word" >&5
9879 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9880 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
9881   echo $ECHO_N "(cached) $ECHO_C" >&6
9882 else
9883   case $OBJDUMP_FOR_TARGET in
9884   [\\/]* | ?:[\\/]*)
9885   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
9886   ;;
9887   *)
9888   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9889 for as_dir in $gcc_cv_tool_dirs
9890 do
9891   IFS=$as_save_IFS
9892   test -z "$as_dir" && as_dir=.
9893   for ac_exec_ext in '' $ac_executable_extensions; do
9894   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9895     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9896     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9897     break 2
9898   fi
9899 done
9900 done
9901
9902   ;;
9903 esac
9904 fi
9905 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
9906
9907 if test -n "$OBJDUMP_FOR_TARGET"; then
9908   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
9909 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
9910 else
9911   echo "$as_me:$LINENO: result: no" >&5
9912 echo "${ECHO_T}no" >&6
9913 fi
9914
9915 fi
9916 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
9917
9918
9919 if test -n "$OBJDUMP_FOR_TARGET"; then
9920   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
9921 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9922   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
9923 fi
9924
9925 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9926   for ncn_progname in objdump; do
9927     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9928 set dummy ${ncn_progname}; ac_word=$2
9929 echo "$as_me:$LINENO: checking for $ac_word" >&5
9930 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9931 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
9932   echo $ECHO_N "(cached) $ECHO_C" >&6
9933 else
9934   if test -n "$OBJDUMP_FOR_TARGET"; then
9935   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
9936 else
9937 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9938 for as_dir in $PATH
9939 do
9940   IFS=$as_save_IFS
9941   test -z "$as_dir" && as_dir=.
9942   for ac_exec_ext in '' $ac_executable_extensions; do
9943   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9944     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
9945     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9946     break 2
9947   fi
9948 done
9949 done
9950
9951 fi
9952 fi
9953 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
9954 if test -n "$OBJDUMP_FOR_TARGET"; then
9955   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
9956 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
9957 else
9958   echo "$as_me:$LINENO: result: no" >&5
9959 echo "${ECHO_T}no" >&6
9960 fi
9961
9962   done
9963 fi
9964
9965 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
9966   for ncn_progname in objdump; do
9967     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9968 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9969     if test -x $with_build_time_tools/${ncn_progname}; then
9970       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9971       echo "$as_me:$LINENO: result: yes" >&5
9972 echo "${ECHO_T}yes" >&6
9973       break
9974     else
9975       echo "$as_me:$LINENO: result: no" >&5
9976 echo "${ECHO_T}no" >&6
9977     fi
9978   done
9979 fi
9980
9981 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
9982   for ncn_progname in objdump; do
9983     if test -n "$ncn_target_tool_prefix"; then
9984       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9985 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9986 echo "$as_me:$LINENO: checking for $ac_word" >&5
9987 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9988 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
9989   echo $ECHO_N "(cached) $ECHO_C" >&6
9990 else
9991   if test -n "$OBJDUMP_FOR_TARGET"; then
9992   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
9993 else
9994 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9995 for as_dir in $PATH
9996 do
9997   IFS=$as_save_IFS
9998   test -z "$as_dir" && as_dir=.
9999   for ac_exec_ext in '' $ac_executable_extensions; do
10000   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10001     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10002     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10003     break 2
10004   fi
10005 done
10006 done
10007
10008 fi
10009 fi
10010 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10011 if test -n "$OBJDUMP_FOR_TARGET"; then
10012   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10013 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10014 else
10015   echo "$as_me:$LINENO: result: no" >&5
10016 echo "${ECHO_T}no" >&6
10017 fi
10018
10019     fi
10020     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10021       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10022 set dummy ${ncn_progname}; ac_word=$2
10023 echo "$as_me:$LINENO: checking for $ac_word" >&5
10024 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10025 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10026   echo $ECHO_N "(cached) $ECHO_C" >&6
10027 else
10028   if test -n "$OBJDUMP_FOR_TARGET"; then
10029   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10030 else
10031 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10032 for as_dir in $PATH
10033 do
10034   IFS=$as_save_IFS
10035   test -z "$as_dir" && as_dir=.
10036   for ac_exec_ext in '' $ac_executable_extensions; do
10037   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10038     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10039     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10040     break 2
10041   fi
10042 done
10043 done
10044
10045 fi
10046 fi
10047 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10048 if test -n "$OBJDUMP_FOR_TARGET"; then
10049   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10050 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10051 else
10052   echo "$as_me:$LINENO: result: no" >&5
10053 echo "${ECHO_T}no" >&6
10054 fi
10055
10056     fi
10057     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10058   done
10059 fi
10060
10061 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10062   set dummy objdump
10063   if test $build = $target ; then
10064     OBJDUMP_FOR_TARGET="$2"
10065   else
10066     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10067   fi
10068 else
10069   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10070 fi
10071
10072 else
10073   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10074 fi
10075
10076
10077
10078
10079 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10080   if test -n "$with_build_time_tools"; then
10081     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10082 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10083     if test -x $with_build_time_tools/ranlib; then
10084       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10085       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10086       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10087 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10088     else
10089       echo "$as_me:$LINENO: result: no" >&5
10090 echo "${ECHO_T}no" >&6
10091     fi
10092   elif test $build != $host && test $have_gcc_for_target = yes; then
10093     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10094     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10095     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10096   fi
10097 fi
10098 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10099   # Extract the first word of "ranlib", so it can be a program name with args.
10100 set dummy ranlib; ac_word=$2
10101 echo "$as_me:$LINENO: checking for $ac_word" >&5
10102 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10103 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10104   echo $ECHO_N "(cached) $ECHO_C" >&6
10105 else
10106   case $RANLIB_FOR_TARGET in
10107   [\\/]* | ?:[\\/]*)
10108   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10109   ;;
10110   *)
10111   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10112 for as_dir in $gcc_cv_tool_dirs
10113 do
10114   IFS=$as_save_IFS
10115   test -z "$as_dir" && as_dir=.
10116   for ac_exec_ext in '' $ac_executable_extensions; do
10117   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10118     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10119     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10120     break 2
10121   fi
10122 done
10123 done
10124
10125   ;;
10126 esac
10127 fi
10128 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10129
10130 if test -n "$RANLIB_FOR_TARGET"; then
10131   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10132 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10133 else
10134   echo "$as_me:$LINENO: result: no" >&5
10135 echo "${ECHO_T}no" >&6
10136 fi
10137
10138 fi
10139 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10140
10141
10142 if test -n "$RANLIB_FOR_TARGET"; then
10143   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10144 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10145   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10146 fi
10147
10148 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10149   for ncn_progname in ranlib; do
10150     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10151 set dummy ${ncn_progname}; ac_word=$2
10152 echo "$as_me:$LINENO: checking for $ac_word" >&5
10153 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10154 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10155   echo $ECHO_N "(cached) $ECHO_C" >&6
10156 else
10157   if test -n "$RANLIB_FOR_TARGET"; then
10158   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10159 else
10160 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10161 for as_dir in $PATH
10162 do
10163   IFS=$as_save_IFS
10164   test -z "$as_dir" && as_dir=.
10165   for ac_exec_ext in '' $ac_executable_extensions; do
10166   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10167     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10168     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10169     break 2
10170   fi
10171 done
10172 done
10173
10174 fi
10175 fi
10176 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10177 if test -n "$RANLIB_FOR_TARGET"; then
10178   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10179 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10180 else
10181   echo "$as_me:$LINENO: result: no" >&5
10182 echo "${ECHO_T}no" >&6
10183 fi
10184
10185   done
10186 fi
10187
10188 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10189   for ncn_progname in ranlib; do
10190     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10191 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10192     if test -x $with_build_time_tools/${ncn_progname}; then
10193       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10194       echo "$as_me:$LINENO: result: yes" >&5
10195 echo "${ECHO_T}yes" >&6
10196       break
10197     else
10198       echo "$as_me:$LINENO: result: no" >&5
10199 echo "${ECHO_T}no" >&6
10200     fi
10201   done
10202 fi
10203
10204 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10205   for ncn_progname in ranlib; do
10206     if test -n "$ncn_target_tool_prefix"; then
10207       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10208 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10209 echo "$as_me:$LINENO: checking for $ac_word" >&5
10210 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10211 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10212   echo $ECHO_N "(cached) $ECHO_C" >&6
10213 else
10214   if test -n "$RANLIB_FOR_TARGET"; then
10215   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10216 else
10217 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10218 for as_dir in $PATH
10219 do
10220   IFS=$as_save_IFS
10221   test -z "$as_dir" && as_dir=.
10222   for ac_exec_ext in '' $ac_executable_extensions; do
10223   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10224     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10225     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10226     break 2
10227   fi
10228 done
10229 done
10230
10231 fi
10232 fi
10233 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10234 if test -n "$RANLIB_FOR_TARGET"; then
10235   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10236 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10237 else
10238   echo "$as_me:$LINENO: result: no" >&5
10239 echo "${ECHO_T}no" >&6
10240 fi
10241
10242     fi
10243     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10244       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10245 set dummy ${ncn_progname}; ac_word=$2
10246 echo "$as_me:$LINENO: checking for $ac_word" >&5
10247 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10248 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10249   echo $ECHO_N "(cached) $ECHO_C" >&6
10250 else
10251   if test -n "$RANLIB_FOR_TARGET"; then
10252   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10253 else
10254 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10255 for as_dir in $PATH
10256 do
10257   IFS=$as_save_IFS
10258   test -z "$as_dir" && as_dir=.
10259   for ac_exec_ext in '' $ac_executable_extensions; do
10260   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10261     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10262     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10263     break 2
10264   fi
10265 done
10266 done
10267
10268 fi
10269 fi
10270 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10271 if test -n "$RANLIB_FOR_TARGET"; then
10272   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10273 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10274 else
10275   echo "$as_me:$LINENO: result: no" >&5
10276 echo "${ECHO_T}no" >&6
10277 fi
10278
10279     fi
10280     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10281   done
10282 fi
10283
10284 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10285   set dummy ranlib
10286   if test $build = $target ; then
10287     RANLIB_FOR_TARGET="$2"
10288   else
10289     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10290   fi
10291 else
10292   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10293 fi
10294
10295 else
10296   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10297 fi
10298
10299
10300
10301
10302 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10303   if test -n "$with_build_time_tools"; then
10304     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10305 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10306     if test -x $with_build_time_tools/strip; then
10307       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10308       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10309       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10310 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10311     else
10312       echo "$as_me:$LINENO: result: no" >&5
10313 echo "${ECHO_T}no" >&6
10314     fi
10315   elif test $build != $host && test $have_gcc_for_target = yes; then
10316     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10317     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10318     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10319   fi
10320 fi
10321 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10322   # Extract the first word of "strip", so it can be a program name with args.
10323 set dummy strip; ac_word=$2
10324 echo "$as_me:$LINENO: checking for $ac_word" >&5
10325 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10326 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10327   echo $ECHO_N "(cached) $ECHO_C" >&6
10328 else
10329   case $STRIP_FOR_TARGET in
10330   [\\/]* | ?:[\\/]*)
10331   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10332   ;;
10333   *)
10334   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10335 for as_dir in $gcc_cv_tool_dirs
10336 do
10337   IFS=$as_save_IFS
10338   test -z "$as_dir" && as_dir=.
10339   for ac_exec_ext in '' $ac_executable_extensions; do
10340   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10341     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10342     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10343     break 2
10344   fi
10345 done
10346 done
10347
10348   ;;
10349 esac
10350 fi
10351 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10352
10353 if test -n "$STRIP_FOR_TARGET"; then
10354   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10355 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10356 else
10357   echo "$as_me:$LINENO: result: no" >&5
10358 echo "${ECHO_T}no" >&6
10359 fi
10360
10361 fi
10362 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10363
10364
10365 if test -n "$STRIP_FOR_TARGET"; then
10366   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10367 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10368   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10369 fi
10370
10371 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10372   for ncn_progname in strip; do
10373     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10374 set dummy ${ncn_progname}; ac_word=$2
10375 echo "$as_me:$LINENO: checking for $ac_word" >&5
10376 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10377 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10378   echo $ECHO_N "(cached) $ECHO_C" >&6
10379 else
10380   if test -n "$STRIP_FOR_TARGET"; then
10381   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10382 else
10383 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10384 for as_dir in $PATH
10385 do
10386   IFS=$as_save_IFS
10387   test -z "$as_dir" && as_dir=.
10388   for ac_exec_ext in '' $ac_executable_extensions; do
10389   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10390     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10391     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10392     break 2
10393   fi
10394 done
10395 done
10396
10397 fi
10398 fi
10399 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10400 if test -n "$STRIP_FOR_TARGET"; then
10401   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10402 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10403 else
10404   echo "$as_me:$LINENO: result: no" >&5
10405 echo "${ECHO_T}no" >&6
10406 fi
10407
10408   done
10409 fi
10410
10411 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10412   for ncn_progname in strip; do
10413     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10414 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10415     if test -x $with_build_time_tools/${ncn_progname}; then
10416       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10417       echo "$as_me:$LINENO: result: yes" >&5
10418 echo "${ECHO_T}yes" >&6
10419       break
10420     else
10421       echo "$as_me:$LINENO: result: no" >&5
10422 echo "${ECHO_T}no" >&6
10423     fi
10424   done
10425 fi
10426
10427 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10428   for ncn_progname in strip; do
10429     if test -n "$ncn_target_tool_prefix"; then
10430       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10431 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10432 echo "$as_me:$LINENO: checking for $ac_word" >&5
10433 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10434 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10435   echo $ECHO_N "(cached) $ECHO_C" >&6
10436 else
10437   if test -n "$STRIP_FOR_TARGET"; then
10438   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10439 else
10440 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10441 for as_dir in $PATH
10442 do
10443   IFS=$as_save_IFS
10444   test -z "$as_dir" && as_dir=.
10445   for ac_exec_ext in '' $ac_executable_extensions; do
10446   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10447     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10448     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10449     break 2
10450   fi
10451 done
10452 done
10453
10454 fi
10455 fi
10456 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10457 if test -n "$STRIP_FOR_TARGET"; then
10458   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10459 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10460 else
10461   echo "$as_me:$LINENO: result: no" >&5
10462 echo "${ECHO_T}no" >&6
10463 fi
10464
10465     fi
10466     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10467       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10468 set dummy ${ncn_progname}; ac_word=$2
10469 echo "$as_me:$LINENO: checking for $ac_word" >&5
10470 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10471 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10472   echo $ECHO_N "(cached) $ECHO_C" >&6
10473 else
10474   if test -n "$STRIP_FOR_TARGET"; then
10475   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10476 else
10477 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10478 for as_dir in $PATH
10479 do
10480   IFS=$as_save_IFS
10481   test -z "$as_dir" && as_dir=.
10482   for ac_exec_ext in '' $ac_executable_extensions; do
10483   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10484     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10485     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10486     break 2
10487   fi
10488 done
10489 done
10490
10491 fi
10492 fi
10493 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10494 if test -n "$STRIP_FOR_TARGET"; then
10495   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10496 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10497 else
10498   echo "$as_me:$LINENO: result: no" >&5
10499 echo "${ECHO_T}no" >&6
10500 fi
10501
10502     fi
10503     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10504   done
10505 fi
10506
10507 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10508   set dummy strip
10509   if test $build = $target ; then
10510     STRIP_FOR_TARGET="$2"
10511   else
10512     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10513   fi
10514 else
10515   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10516 fi
10517
10518 else
10519   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10520 fi
10521
10522
10523
10524
10525 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10526   if test -n "$with_build_time_tools"; then
10527     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10528 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10529     if test -x $with_build_time_tools/windres; then
10530       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10531       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10532       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10533 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10534     else
10535       echo "$as_me:$LINENO: result: no" >&5
10536 echo "${ECHO_T}no" >&6
10537     fi
10538   elif test $build != $host && test $have_gcc_for_target = yes; then
10539     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10540     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10541     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10542   fi
10543 fi
10544 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10545   # Extract the first word of "windres", so it can be a program name with args.
10546 set dummy windres; ac_word=$2
10547 echo "$as_me:$LINENO: checking for $ac_word" >&5
10548 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10549 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10550   echo $ECHO_N "(cached) $ECHO_C" >&6
10551 else
10552   case $WINDRES_FOR_TARGET in
10553   [\\/]* | ?:[\\/]*)
10554   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10555   ;;
10556   *)
10557   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10558 for as_dir in $gcc_cv_tool_dirs
10559 do
10560   IFS=$as_save_IFS
10561   test -z "$as_dir" && as_dir=.
10562   for ac_exec_ext in '' $ac_executable_extensions; do
10563   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10564     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10565     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10566     break 2
10567   fi
10568 done
10569 done
10570
10571   ;;
10572 esac
10573 fi
10574 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10575
10576 if test -n "$WINDRES_FOR_TARGET"; then
10577   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10578 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10579 else
10580   echo "$as_me:$LINENO: result: no" >&5
10581 echo "${ECHO_T}no" >&6
10582 fi
10583
10584 fi
10585 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10586
10587
10588 if test -n "$WINDRES_FOR_TARGET"; then
10589   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10590 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10591   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10592 fi
10593
10594 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10595   for ncn_progname in windres; do
10596     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10597 set dummy ${ncn_progname}; ac_word=$2
10598 echo "$as_me:$LINENO: checking for $ac_word" >&5
10599 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10600 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10601   echo $ECHO_N "(cached) $ECHO_C" >&6
10602 else
10603   if test -n "$WINDRES_FOR_TARGET"; then
10604   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10605 else
10606 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10607 for as_dir in $PATH
10608 do
10609   IFS=$as_save_IFS
10610   test -z "$as_dir" && as_dir=.
10611   for ac_exec_ext in '' $ac_executable_extensions; do
10612   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10613     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10614     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10615     break 2
10616   fi
10617 done
10618 done
10619
10620 fi
10621 fi
10622 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10623 if test -n "$WINDRES_FOR_TARGET"; then
10624   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10625 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10626 else
10627   echo "$as_me:$LINENO: result: no" >&5
10628 echo "${ECHO_T}no" >&6
10629 fi
10630
10631   done
10632 fi
10633
10634 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10635   for ncn_progname in windres; do
10636     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10637 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10638     if test -x $with_build_time_tools/${ncn_progname}; then
10639       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10640       echo "$as_me:$LINENO: result: yes" >&5
10641 echo "${ECHO_T}yes" >&6
10642       break
10643     else
10644       echo "$as_me:$LINENO: result: no" >&5
10645 echo "${ECHO_T}no" >&6
10646     fi
10647   done
10648 fi
10649
10650 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10651   for ncn_progname in windres; do
10652     if test -n "$ncn_target_tool_prefix"; then
10653       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10654 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10655 echo "$as_me:$LINENO: checking for $ac_word" >&5
10656 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10657 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10658   echo $ECHO_N "(cached) $ECHO_C" >&6
10659 else
10660   if test -n "$WINDRES_FOR_TARGET"; then
10661   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10662 else
10663 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10664 for as_dir in $PATH
10665 do
10666   IFS=$as_save_IFS
10667   test -z "$as_dir" && as_dir=.
10668   for ac_exec_ext in '' $ac_executable_extensions; do
10669   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10670     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10671     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10672     break 2
10673   fi
10674 done
10675 done
10676
10677 fi
10678 fi
10679 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10680 if test -n "$WINDRES_FOR_TARGET"; then
10681   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10682 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10683 else
10684   echo "$as_me:$LINENO: result: no" >&5
10685 echo "${ECHO_T}no" >&6
10686 fi
10687
10688     fi
10689     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10690       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10691 set dummy ${ncn_progname}; ac_word=$2
10692 echo "$as_me:$LINENO: checking for $ac_word" >&5
10693 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10694 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10695   echo $ECHO_N "(cached) $ECHO_C" >&6
10696 else
10697   if test -n "$WINDRES_FOR_TARGET"; then
10698   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10699 else
10700 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10701 for as_dir in $PATH
10702 do
10703   IFS=$as_save_IFS
10704   test -z "$as_dir" && as_dir=.
10705   for ac_exec_ext in '' $ac_executable_extensions; do
10706   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10707     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10708     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10709     break 2
10710   fi
10711 done
10712 done
10713
10714 fi
10715 fi
10716 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10717 if test -n "$WINDRES_FOR_TARGET"; then
10718   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10719 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10720 else
10721   echo "$as_me:$LINENO: result: no" >&5
10722 echo "${ECHO_T}no" >&6
10723 fi
10724
10725     fi
10726     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10727   done
10728 fi
10729
10730 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10731   set dummy windres
10732   if test $build = $target ; then
10733     WINDRES_FOR_TARGET="$2"
10734   else
10735     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10736   fi
10737 else
10738   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
10739 fi
10740
10741 else
10742   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10743 fi
10744
10745
10746 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
10747
10748 echo "$as_me:$LINENO: checking where to find the target ar" >&5
10749 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
10750 if test "x${build}" != "x${host}" ; then
10751   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
10752     # We already found the complete path
10753     ac_dir=`dirname $AR_FOR_TARGET`
10754     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10755 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10756   else
10757     # Canadian cross, just use what we found
10758     echo "$as_me:$LINENO: result: pre-installed" >&5
10759 echo "${ECHO_T}pre-installed" >&6
10760   fi
10761 else
10762   ok=yes
10763   case " ${configdirs} " in
10764     *" binutils "*) ;;
10765     *) ok=no ;;
10766   esac
10767
10768   if test $ok = yes; then
10769     # An in-tree tool is available and we can use it
10770     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
10771     echo "$as_me:$LINENO: result: just compiled" >&5
10772 echo "${ECHO_T}just compiled" >&6
10773   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
10774     # We already found the complete path
10775     ac_dir=`dirname $AR_FOR_TARGET`
10776     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10777 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10778   elif test "x$target" = "x$host"; then
10779     # We can use an host tool
10780     AR_FOR_TARGET='$(AR)'
10781     echo "$as_me:$LINENO: result: host tool" >&5
10782 echo "${ECHO_T}host tool" >&6
10783   else
10784     # We need a cross tool
10785     echo "$as_me:$LINENO: result: pre-installed" >&5
10786 echo "${ECHO_T}pre-installed" >&6
10787   fi
10788 fi
10789
10790 echo "$as_me:$LINENO: checking where to find the target as" >&5
10791 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
10792 if test "x${build}" != "x${host}" ; then
10793   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
10794     # We already found the complete path
10795     ac_dir=`dirname $AS_FOR_TARGET`
10796     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10797 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10798   else
10799     # Canadian cross, just use what we found
10800     echo "$as_me:$LINENO: result: pre-installed" >&5
10801 echo "${ECHO_T}pre-installed" >&6
10802   fi
10803 else
10804   ok=yes
10805   case " ${configdirs} " in
10806     *" gas "*) ;;
10807     *) ok=no ;;
10808   esac
10809
10810   if test $ok = yes; then
10811     # An in-tree tool is available and we can use it
10812     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
10813     echo "$as_me:$LINENO: result: just compiled" >&5
10814 echo "${ECHO_T}just compiled" >&6
10815   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
10816     # We already found the complete path
10817     ac_dir=`dirname $AS_FOR_TARGET`
10818     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10819 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10820   elif test "x$target" = "x$host"; then
10821     # We can use an host tool
10822     AS_FOR_TARGET='$(AS)'
10823     echo "$as_me:$LINENO: result: host tool" >&5
10824 echo "${ECHO_T}host tool" >&6
10825   else
10826     # We need a cross tool
10827     echo "$as_me:$LINENO: result: pre-installed" >&5
10828 echo "${ECHO_T}pre-installed" >&6
10829   fi
10830 fi
10831
10832 echo "$as_me:$LINENO: checking where to find the target cc" >&5
10833 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
10834 if test "x${build}" != "x${host}" ; then
10835   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
10836     # We already found the complete path
10837     ac_dir=`dirname $CC_FOR_TARGET`
10838     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10839 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10840   else
10841     # Canadian cross, just use what we found
10842     echo "$as_me:$LINENO: result: pre-installed" >&5
10843 echo "${ECHO_T}pre-installed" >&6
10844   fi
10845 else
10846   ok=yes
10847   case " ${configdirs} " in
10848     *" gcc "*) ;;
10849     *) ok=no ;;
10850   esac
10851
10852   if test $ok = yes; then
10853     # An in-tree tool is available and we can use it
10854     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
10855     echo "$as_me:$LINENO: result: just compiled" >&5
10856 echo "${ECHO_T}just compiled" >&6
10857   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
10858     # We already found the complete path
10859     ac_dir=`dirname $CC_FOR_TARGET`
10860     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10861 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10862   elif test "x$target" = "x$host"; then
10863     # We can use an host tool
10864     CC_FOR_TARGET='$(CC)'
10865     echo "$as_me:$LINENO: result: host tool" >&5
10866 echo "${ECHO_T}host tool" >&6
10867   else
10868     # We need a cross tool
10869     echo "$as_me:$LINENO: result: pre-installed" >&5
10870 echo "${ECHO_T}pre-installed" >&6
10871   fi
10872 fi
10873
10874 echo "$as_me:$LINENO: checking where to find the target c++" >&5
10875 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
10876 if test "x${build}" != "x${host}" ; then
10877   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
10878     # We already found the complete path
10879     ac_dir=`dirname $CXX_FOR_TARGET`
10880     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10881 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10882   else
10883     # Canadian cross, just use what we found
10884     echo "$as_me:$LINENO: result: pre-installed" >&5
10885 echo "${ECHO_T}pre-installed" >&6
10886   fi
10887 else
10888   ok=yes
10889   case " ${configdirs} " in
10890     *" gcc "*) ;;
10891     *) ok=no ;;
10892   esac
10893   case ,${enable_languages}, in
10894     *,c++,*) ;;
10895     *) ok=no ;;
10896   esac
10897   if test $ok = yes; then
10898     # An in-tree tool is available and we can use it
10899     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'
10900     echo "$as_me:$LINENO: result: just compiled" >&5
10901 echo "${ECHO_T}just compiled" >&6
10902   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
10903     # We already found the complete path
10904     ac_dir=`dirname $CXX_FOR_TARGET`
10905     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10906 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10907   elif test "x$target" = "x$host"; then
10908     # We can use an host tool
10909     CXX_FOR_TARGET='$(CXX)'
10910     echo "$as_me:$LINENO: result: host tool" >&5
10911 echo "${ECHO_T}host tool" >&6
10912   else
10913     # We need a cross tool
10914     echo "$as_me:$LINENO: result: pre-installed" >&5
10915 echo "${ECHO_T}pre-installed" >&6
10916   fi
10917 fi
10918
10919 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
10920 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
10921 if test "x${build}" != "x${host}" ; then
10922   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
10923     # We already found the complete path
10924     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
10925     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10926 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10927   else
10928     # Canadian cross, just use what we found
10929     echo "$as_me:$LINENO: result: pre-installed" >&5
10930 echo "${ECHO_T}pre-installed" >&6
10931   fi
10932 else
10933   ok=yes
10934   case " ${configdirs} " in
10935     *" gcc "*) ;;
10936     *) ok=no ;;
10937   esac
10938   case ,${enable_languages}, in
10939     *,c++,*) ;;
10940     *) ok=no ;;
10941   esac
10942   if test $ok = yes; then
10943     # An in-tree tool is available and we can use it
10944     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'
10945     echo "$as_me:$LINENO: result: just compiled" >&5
10946 echo "${ECHO_T}just compiled" >&6
10947   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
10948     # We already found the complete path
10949     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
10950     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10951 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10952   elif test "x$target" = "x$host"; then
10953     # We can use an host tool
10954     RAW_CXX_FOR_TARGET='$(CXX)'
10955     echo "$as_me:$LINENO: result: host tool" >&5
10956 echo "${ECHO_T}host tool" >&6
10957   else
10958     # We need a cross tool
10959     echo "$as_me:$LINENO: result: pre-installed" >&5
10960 echo "${ECHO_T}pre-installed" >&6
10961   fi
10962 fi
10963
10964 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
10965 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
10966 if test "x${build}" != "x${host}" ; then
10967   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
10968     # We already found the complete path
10969     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
10970     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10971 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10972   else
10973     # Canadian cross, just use what we found
10974     echo "$as_me:$LINENO: result: pre-installed" >&5
10975 echo "${ECHO_T}pre-installed" >&6
10976   fi
10977 else
10978   ok=yes
10979   case " ${configdirs} " in
10980     *" binutils "*) ;;
10981     *) ok=no ;;
10982   esac
10983
10984   if test $ok = yes; then
10985     # An in-tree tool is available and we can use it
10986     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
10987     echo "$as_me:$LINENO: result: just compiled" >&5
10988 echo "${ECHO_T}just compiled" >&6
10989   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
10990     # We already found the complete path
10991     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
10992     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
10993 echo "${ECHO_T}pre-installed in $ac_dir" >&6
10994   elif test "x$target" = "x$host"; then
10995     # We can use an host tool
10996     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
10997     echo "$as_me:$LINENO: result: host tool" >&5
10998 echo "${ECHO_T}host tool" >&6
10999   else
11000     # We need a cross tool
11001     echo "$as_me:$LINENO: result: pre-installed" >&5
11002 echo "${ECHO_T}pre-installed" >&6
11003   fi
11004 fi
11005
11006 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11007 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11008 if test "x${build}" != "x${host}" ; then
11009   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11010     # We already found the complete path
11011     ac_dir=`dirname $GCC_FOR_TARGET`
11012     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11013 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11014   else
11015     # Canadian cross, just use what we found
11016     echo "$as_me:$LINENO: result: pre-installed" >&5
11017 echo "${ECHO_T}pre-installed" >&6
11018   fi
11019 else
11020   ok=yes
11021   case " ${configdirs} " in
11022     *" gcc "*) ;;
11023     *) ok=no ;;
11024   esac
11025
11026   if test $ok = yes; then
11027     # An in-tree tool is available and we can use it
11028     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11029     echo "$as_me:$LINENO: result: just compiled" >&5
11030 echo "${ECHO_T}just compiled" >&6
11031   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11032     # We already found the complete path
11033     ac_dir=`dirname $GCC_FOR_TARGET`
11034     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11035 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11036   elif test "x$target" = "x$host"; then
11037     # We can use an host tool
11038     GCC_FOR_TARGET='$()'
11039     echo "$as_me:$LINENO: result: host tool" >&5
11040 echo "${ECHO_T}host tool" >&6
11041   else
11042     # We need a cross tool
11043     echo "$as_me:$LINENO: result: pre-installed" >&5
11044 echo "${ECHO_T}pre-installed" >&6
11045   fi
11046 fi
11047
11048 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11049 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11050 if test "x${build}" != "x${host}" ; then
11051   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11052     # We already found the complete path
11053     ac_dir=`dirname $GCJ_FOR_TARGET`
11054     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11055 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11056   else
11057     # Canadian cross, just use what we found
11058     echo "$as_me:$LINENO: result: pre-installed" >&5
11059 echo "${ECHO_T}pre-installed" >&6
11060   fi
11061 else
11062   ok=yes
11063   case " ${configdirs} " in
11064     *" gcc "*) ;;
11065     *) ok=no ;;
11066   esac
11067   case ,${enable_languages}, in
11068     *,java,*) ;;
11069     *) ok=no ;;
11070   esac
11071   if test $ok = yes; then
11072     # An in-tree tool is available and we can use it
11073     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11074     echo "$as_me:$LINENO: result: just compiled" >&5
11075 echo "${ECHO_T}just compiled" >&6
11076   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11077     # We already found the complete path
11078     ac_dir=`dirname $GCJ_FOR_TARGET`
11079     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11080 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11081   elif test "x$target" = "x$host"; then
11082     # We can use an host tool
11083     GCJ_FOR_TARGET='$(GCJ)'
11084     echo "$as_me:$LINENO: result: host tool" >&5
11085 echo "${ECHO_T}host tool" >&6
11086   else
11087     # We need a cross tool
11088     echo "$as_me:$LINENO: result: pre-installed" >&5
11089 echo "${ECHO_T}pre-installed" >&6
11090   fi
11091 fi
11092
11093 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11094 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11095 if test "x${build}" != "x${host}" ; then
11096   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11097     # We already found the complete path
11098     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11099     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11100 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11101   else
11102     # Canadian cross, just use what we found
11103     echo "$as_me:$LINENO: result: pre-installed" >&5
11104 echo "${ECHO_T}pre-installed" >&6
11105   fi
11106 else
11107   ok=yes
11108   case " ${configdirs} " in
11109     *" gcc "*) ;;
11110     *) ok=no ;;
11111   esac
11112   case ,${enable_languages}, in
11113     *,fortran,*) ;;
11114     *) ok=no ;;
11115   esac
11116   if test $ok = yes; then
11117     # An in-tree tool is available and we can use it
11118     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11119     echo "$as_me:$LINENO: result: just compiled" >&5
11120 echo "${ECHO_T}just compiled" >&6
11121   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11122     # We already found the complete path
11123     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11124     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11125 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11126   elif test "x$target" = "x$host"; then
11127     # We can use an host tool
11128     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11129     echo "$as_me:$LINENO: result: host tool" >&5
11130 echo "${ECHO_T}host tool" >&6
11131   else
11132     # We need a cross tool
11133     echo "$as_me:$LINENO: result: pre-installed" >&5
11134 echo "${ECHO_T}pre-installed" >&6
11135   fi
11136 fi
11137
11138 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11139 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11140 if test "x${build}" != "x${host}" ; then
11141   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11142     # We already found the complete path
11143     ac_dir=`dirname $LD_FOR_TARGET`
11144     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11145 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11146   else
11147     # Canadian cross, just use what we found
11148     echo "$as_me:$LINENO: result: pre-installed" >&5
11149 echo "${ECHO_T}pre-installed" >&6
11150   fi
11151 else
11152   ok=yes
11153   case " ${configdirs} " in
11154     *" ld "*) ;;
11155     *) ok=no ;;
11156   esac
11157
11158   if test $ok = yes; then
11159     # An in-tree tool is available and we can use it
11160     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11161     echo "$as_me:$LINENO: result: just compiled" >&5
11162 echo "${ECHO_T}just compiled" >&6
11163   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11164     # We already found the complete path
11165     ac_dir=`dirname $LD_FOR_TARGET`
11166     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11167 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11168   elif test "x$target" = "x$host"; then
11169     # We can use an host tool
11170     LD_FOR_TARGET='$(LD)'
11171     echo "$as_me:$LINENO: result: host tool" >&5
11172 echo "${ECHO_T}host tool" >&6
11173   else
11174     # We need a cross tool
11175     echo "$as_me:$LINENO: result: pre-installed" >&5
11176 echo "${ECHO_T}pre-installed" >&6
11177   fi
11178 fi
11179
11180 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11181 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11182 if test "x${build}" != "x${host}" ; then
11183   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11184     # We already found the complete path
11185     ac_dir=`dirname $LIPO_FOR_TARGET`
11186     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11187 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11188   else
11189     # Canadian cross, just use what we found
11190     echo "$as_me:$LINENO: result: pre-installed" >&5
11191 echo "${ECHO_T}pre-installed" >&6
11192   fi
11193 else
11194   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11195     # We already found the complete path
11196     ac_dir=`dirname $LIPO_FOR_TARGET`
11197     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11198 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11199   elif test "x$target" = "x$host"; then
11200     # We can use an host tool
11201     LIPO_FOR_TARGET='$(LIPO)'
11202     echo "$as_me:$LINENO: result: host tool" >&5
11203 echo "${ECHO_T}host tool" >&6
11204   else
11205     # We need a cross tool
11206     echo "$as_me:$LINENO: result: pre-installed" >&5
11207 echo "${ECHO_T}pre-installed" >&6
11208   fi
11209 fi
11210
11211 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11212 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11213 if test "x${build}" != "x${host}" ; then
11214   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11215     # We already found the complete path
11216     ac_dir=`dirname $NM_FOR_TARGET`
11217     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11218 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11219   else
11220     # Canadian cross, just use what we found
11221     echo "$as_me:$LINENO: result: pre-installed" >&5
11222 echo "${ECHO_T}pre-installed" >&6
11223   fi
11224 else
11225   ok=yes
11226   case " ${configdirs} " in
11227     *" binutils "*) ;;
11228     *) ok=no ;;
11229   esac
11230
11231   if test $ok = yes; then
11232     # An in-tree tool is available and we can use it
11233     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11234     echo "$as_me:$LINENO: result: just compiled" >&5
11235 echo "${ECHO_T}just compiled" >&6
11236   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11237     # We already found the complete path
11238     ac_dir=`dirname $NM_FOR_TARGET`
11239     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11240 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11241   elif test "x$target" = "x$host"; then
11242     # We can use an host tool
11243     NM_FOR_TARGET='$(NM)'
11244     echo "$as_me:$LINENO: result: host tool" >&5
11245 echo "${ECHO_T}host tool" >&6
11246   else
11247     # We need a cross tool
11248     echo "$as_me:$LINENO: result: pre-installed" >&5
11249 echo "${ECHO_T}pre-installed" >&6
11250   fi
11251 fi
11252
11253 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11254 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11255 if test "x${build}" != "x${host}" ; then
11256   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11257     # We already found the complete path
11258     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11259     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11260 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11261   else
11262     # Canadian cross, just use what we found
11263     echo "$as_me:$LINENO: result: pre-installed" >&5
11264 echo "${ECHO_T}pre-installed" >&6
11265   fi
11266 else
11267   ok=yes
11268   case " ${configdirs} " in
11269     *" binutils "*) ;;
11270     *) ok=no ;;
11271   esac
11272
11273   if test $ok = yes; then
11274     # An in-tree tool is available and we can use it
11275     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11276     echo "$as_me:$LINENO: result: just compiled" >&5
11277 echo "${ECHO_T}just compiled" >&6
11278   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11279     # We already found the complete path
11280     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11281     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11282 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11283   elif test "x$target" = "x$host"; then
11284     # We can use an host tool
11285     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11286     echo "$as_me:$LINENO: result: host tool" >&5
11287 echo "${ECHO_T}host tool" >&6
11288   else
11289     # We need a cross tool
11290     echo "$as_me:$LINENO: result: pre-installed" >&5
11291 echo "${ECHO_T}pre-installed" >&6
11292   fi
11293 fi
11294
11295 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11296 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11297 if test "x${build}" != "x${host}" ; then
11298   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11299     # We already found the complete path
11300     ac_dir=`dirname $RANLIB_FOR_TARGET`
11301     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11302 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11303   else
11304     # Canadian cross, just use what we found
11305     echo "$as_me:$LINENO: result: pre-installed" >&5
11306 echo "${ECHO_T}pre-installed" >&6
11307   fi
11308 else
11309   ok=yes
11310   case " ${configdirs} " in
11311     *" binutils "*) ;;
11312     *) ok=no ;;
11313   esac
11314
11315   if test $ok = yes; then
11316     # An in-tree tool is available and we can use it
11317     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11318     echo "$as_me:$LINENO: result: just compiled" >&5
11319 echo "${ECHO_T}just compiled" >&6
11320   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11321     # We already found the complete path
11322     ac_dir=`dirname $RANLIB_FOR_TARGET`
11323     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11324 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11325   elif test "x$target" = "x$host"; then
11326     # We can use an host tool
11327     RANLIB_FOR_TARGET='$(RANLIB)'
11328     echo "$as_me:$LINENO: result: host tool" >&5
11329 echo "${ECHO_T}host tool" >&6
11330   else
11331     # We need a cross tool
11332     echo "$as_me:$LINENO: result: pre-installed" >&5
11333 echo "${ECHO_T}pre-installed" >&6
11334   fi
11335 fi
11336
11337 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11338 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11339 if test "x${build}" != "x${host}" ; then
11340   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11341     # We already found the complete path
11342     ac_dir=`dirname $STRIP_FOR_TARGET`
11343     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11344 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11345   else
11346     # Canadian cross, just use what we found
11347     echo "$as_me:$LINENO: result: pre-installed" >&5
11348 echo "${ECHO_T}pre-installed" >&6
11349   fi
11350 else
11351   ok=yes
11352   case " ${configdirs} " in
11353     *" binutils "*) ;;
11354     *) ok=no ;;
11355   esac
11356
11357   if test $ok = yes; then
11358     # An in-tree tool is available and we can use it
11359     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11360     echo "$as_me:$LINENO: result: just compiled" >&5
11361 echo "${ECHO_T}just compiled" >&6
11362   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11363     # We already found the complete path
11364     ac_dir=`dirname $STRIP_FOR_TARGET`
11365     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11366 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11367   elif test "x$target" = "x$host"; then
11368     # We can use an host tool
11369     STRIP_FOR_TARGET='$(STRIP)'
11370     echo "$as_me:$LINENO: result: host tool" >&5
11371 echo "${ECHO_T}host tool" >&6
11372   else
11373     # We need a cross tool
11374     echo "$as_me:$LINENO: result: pre-installed" >&5
11375 echo "${ECHO_T}pre-installed" >&6
11376   fi
11377 fi
11378
11379 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11380 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11381 if test "x${build}" != "x${host}" ; then
11382   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11383     # We already found the complete path
11384     ac_dir=`dirname $WINDRES_FOR_TARGET`
11385     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11386 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11387   else
11388     # Canadian cross, just use what we found
11389     echo "$as_me:$LINENO: result: pre-installed" >&5
11390 echo "${ECHO_T}pre-installed" >&6
11391   fi
11392 else
11393   ok=yes
11394   case " ${configdirs} " in
11395     *" binutils "*) ;;
11396     *) ok=no ;;
11397   esac
11398
11399   if test $ok = yes; then
11400     # An in-tree tool is available and we can use it
11401     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11402     echo "$as_me:$LINENO: result: just compiled" >&5
11403 echo "${ECHO_T}just compiled" >&6
11404   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11405     # We already found the complete path
11406     ac_dir=`dirname $WINDRES_FOR_TARGET`
11407     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11408 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11409   elif test "x$target" = "x$host"; then
11410     # We can use an host tool
11411     WINDRES_FOR_TARGET='$(WINDRES)'
11412     echo "$as_me:$LINENO: result: host tool" >&5
11413 echo "${ECHO_T}host tool" >&6
11414   else
11415     # We need a cross tool
11416     echo "$as_me:$LINENO: result: pre-installed" >&5
11417 echo "${ECHO_T}pre-installed" >&6
11418   fi
11419 fi
11420
11421
11422
11423
11424
11425 # Certain tools may need extra flags.
11426 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11427 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11428 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11429
11430 # When building target libraries, except in a Canadian cross, we use
11431 # the same toolchain as the compiler we just built.
11432 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11433 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11434 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11435 if test $host = $build; then
11436   case " $configdirs " in
11437     *" gcc "*)
11438       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11439       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11440       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11441       ;;
11442   esac
11443 fi
11444
11445
11446
11447
11448
11449 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11450 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11451 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11452 if test "${enable_maintainer_mode+set}" = set; then
11453   enableval="$enable_maintainer_mode"
11454   USE_MAINTAINER_MODE=$enableval
11455 else
11456   USE_MAINTAINER_MODE=no
11457 fi;
11458 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11459 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11460
11461
11462 if test "$USE_MAINTAINER_MODE" = yes; then
11463   MAINTAINER_MODE_TRUE=
11464   MAINTAINER_MODE_FALSE='#'
11465 else
11466   MAINTAINER_MODE_TRUE='#'
11467   MAINTAINER_MODE_FALSE=
11468 fi
11469 MAINT=$MAINTAINER_MODE_TRUE
11470
11471 # ---------------------
11472 # GCC bootstrap support
11473 # ---------------------
11474
11475 # Stage specific cflags for build.
11476 stage1_cflags="-g"
11477 case $build in
11478   vax-*-*)
11479     case ${GCC} in
11480       yes) stage1_cflags="-g -Wa,-J" ;;
11481       *) stage1_cflags="-g -J" ;;
11482     esac ;;
11483 esac
11484
11485 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
11486 if test "$GCC" = yes; then
11487   saved_CFLAGS="$CFLAGS"
11488
11489   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
11490   CFLAGS="$CFLAGS -fkeep-inline-functions"
11491   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
11492 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
11493   cat >conftest.$ac_ext <<_ACEOF
11494 /* confdefs.h.  */
11495 _ACEOF
11496 cat confdefs.h >>conftest.$ac_ext
11497 cat >>conftest.$ac_ext <<_ACEOF
11498 /* end confdefs.h.  */
11499
11500 #if (__GNUC__ < 3) \
11501     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
11502                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
11503 #error http://gcc.gnu.org/PR29382
11504 #endif
11505
11506 int
11507 main ()
11508 {
11509
11510   ;
11511   return 0;
11512 }
11513 _ACEOF
11514 rm -f conftest.$ac_objext
11515 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11516   (eval $ac_compile) 2>conftest.er1
11517   ac_status=$?
11518   grep -v '^ *+' conftest.er1 >conftest.err
11519   rm -f conftest.er1
11520   cat conftest.err >&5
11521   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11522   (exit $ac_status); } &&
11523          { ac_try='test -z "$ac_c_werror_flag"
11524                          || test ! -s conftest.err'
11525   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11526   (eval $ac_try) 2>&5
11527   ac_status=$?
11528   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11529   (exit $ac_status); }; } &&
11530          { ac_try='test -s conftest.$ac_objext'
11531   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11532   (eval $ac_try) 2>&5
11533   ac_status=$?
11534   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11535   (exit $ac_status); }; }; then
11536   echo "$as_me:$LINENO: result: yes" >&5
11537 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
11538 else
11539   echo "$as_me: failed program was:" >&5
11540 sed 's/^/| /' conftest.$ac_ext >&5
11541
11542 echo "$as_me:$LINENO: result: no" >&5
11543 echo "${ECHO_T}no" >&6
11544 fi
11545 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11546
11547   CFLAGS="$saved_CFLAGS"
11548 fi
11549
11550
11551
11552 # Enable --enable-checking in stage1 of the compiler.
11553 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
11554 if test "${enable_stage1_checking+set}" = set; then
11555   enableval="$enable_stage1_checking"
11556   stage1_checking=--enable-checking=${enable_stage1_checking}
11557 else
11558   if test "x$enable_checking" = xno; then
11559   stage1_checking=--enable-checking
11560 else
11561   stage1_checking=--enable-checking${enable_checking+=}$enable_checking
11562 fi
11563 fi;
11564
11565
11566 # Enable -Werror in bootstrap stage2 and later.
11567 # Check whether --enable-werror or --disable-werror was given.
11568 if test "${enable_werror+set}" = set; then
11569   enableval="$enable_werror"
11570
11571 else
11572   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
11573   enable_werror=yes
11574 else
11575   enable_werror=no
11576 fi
11577 fi;
11578 case ${enable_werror} in
11579   yes) stage2_werror_flag="--enable-werror-always" ;;
11580   *) stage2_werror_flag="" ;;
11581 esac
11582
11583
11584 # Flags needed to enable html installing and building
11585
11586 # Check whether --with-datarootdir or --without-datarootdir was given.
11587 if test "${with_datarootdir+set}" = set; then
11588   withval="$with_datarootdir"
11589   datarootdir="\${prefix}/${withval}"
11590 else
11591   datarootdir="\${prefix}/share"
11592 fi;
11593
11594
11595 # Check whether --with-docdir or --without-docdir was given.
11596 if test "${with_docdir+set}" = set; then
11597   withval="$with_docdir"
11598   docdir="\${prefix}/${withval}"
11599 else
11600   docdir="\${datarootdir}/doc"
11601 fi;
11602
11603
11604 # Check whether --with-pdfdir or --without-pdfdir was given.
11605 if test "${with_pdfdir+set}" = set; then
11606   withval="$with_pdfdir"
11607   pdfdir="\${prefix}/${withval}"
11608 else
11609   pdfdir="\${docdir}"
11610 fi;
11611
11612
11613 # Check whether --with-htmldir or --without-htmldir was given.
11614 if test "${with_htmldir+set}" = set; then
11615   withval="$with_htmldir"
11616   htmldir="\${prefix}/${withval}"
11617 else
11618   htmldir="\${docdir}"
11619 fi;
11620
11621
11622
11623
11624
11625
11626           ac_config_files="$ac_config_files Makefile"
11627 cat >confcache <<\_ACEOF
11628 # This file is a shell script that caches the results of configure
11629 # tests run on this system so they can be shared between configure
11630 # scripts and configure runs, see configure's option --config-cache.
11631 # It is not useful on other systems.  If it contains results you don't
11632 # want to keep, you may remove or edit it.
11633 #
11634 # config.status only pays attention to the cache file if you give it
11635 # the --recheck option to rerun configure.
11636 #
11637 # `ac_cv_env_foo' variables (set or unset) will be overridden when
11638 # loading this file, other *unset* `ac_cv_foo' will be assigned the
11639 # following values.
11640
11641 _ACEOF
11642
11643 # The following way of writing the cache mishandles newlines in values,
11644 # but we know of no workaround that is simple, portable, and efficient.
11645 # So, don't put newlines in cache variables' values.
11646 # Ultrix sh set writes to stderr and can't be redirected directly,
11647 # and sets the high bit in the cache file unless we assign to the vars.
11648 {
11649   (set) 2>&1 |
11650     case `(ac_space=' '; set | grep ac_space) 2>&1` in
11651     *ac_space=\ *)
11652       # `set' does not quote correctly, so add quotes (double-quote
11653       # substitution turns \\\\ into \\, and sed turns \\ into \).
11654       sed -n \
11655         "s/'/'\\\\''/g;
11656           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
11657       ;;
11658     *)
11659       # `set' quotes correctly as required by POSIX, so do not add quotes.
11660       sed -n \
11661         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
11662       ;;
11663     esac;
11664 } |
11665   sed '
11666      t clear
11667      : clear
11668      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
11669      t end
11670      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
11671      : end' >>confcache
11672 if diff $cache_file confcache >/dev/null 2>&1; then :; else
11673   if test -w $cache_file; then
11674     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
11675     cat confcache >$cache_file
11676   else
11677     echo "not updating unwritable cache $cache_file"
11678   fi
11679 fi
11680 rm -f confcache
11681
11682 test "x$prefix" = xNONE && prefix=$ac_default_prefix
11683 # Let make expand exec_prefix.
11684 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
11685
11686 # VPATH may cause trouble with some makes, so we remove $(srcdir),
11687 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
11688 # trailing colons and then remove the whole line if VPATH becomes empty
11689 # (actually we leave an empty line to preserve line numbers).
11690 if test "x$srcdir" = x.; then
11691   ac_vpsub='/^[  ]*VPATH[        ]*=/{
11692 s/:*\$(srcdir):*/:/;
11693 s/:*\${srcdir}:*/:/;
11694 s/:*@srcdir@:*/:/;
11695 s/^\([^=]*=[     ]*\):*/\1/;
11696 s/:*$//;
11697 s/^[^=]*=[       ]*$//;
11698 }'
11699 fi
11700
11701 # Transform confdefs.h into DEFS.
11702 # Protect against shell expansion while executing Makefile rules.
11703 # Protect against Makefile macro expansion.
11704 #
11705 # If the first sed substitution is executed (which looks for macros that
11706 # take arguments), then we branch to the quote section.  Otherwise,
11707 # look for a macro that doesn't take arguments.
11708 cat >confdef2opt.sed <<\_ACEOF
11709 t clear
11710 : clear
11711 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
11712 t quote
11713 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
11714 t quote
11715 d
11716 : quote
11717 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
11718 s,\[,\\&,g
11719 s,\],\\&,g
11720 s,\$,$$,g
11721 p
11722 _ACEOF
11723 # We use echo to avoid assuming a particular line-breaking character.
11724 # The extra dot is to prevent the shell from consuming trailing
11725 # line-breaks from the sub-command output.  A line-break within
11726 # single-quotes doesn't work because, if this script is created in a
11727 # platform that uses two characters for line-breaks (e.g., DOS), tr
11728 # would break.
11729 ac_LF_and_DOT=`echo; echo .`
11730 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
11731 rm -f confdef2opt.sed
11732
11733
11734 ac_libobjs=
11735 ac_ltlibobjs=
11736 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
11737   # 1. Remove the extension, and $U if already installed.
11738   ac_i=`echo "$ac_i" |
11739          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
11740   # 2. Add them.
11741   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
11742   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
11743 done
11744 LIBOBJS=$ac_libobjs
11745
11746 LTLIBOBJS=$ac_ltlibobjs
11747
11748
11749
11750 : ${CONFIG_STATUS=./config.status}
11751 ac_clean_files_save=$ac_clean_files
11752 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
11753 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
11754 echo "$as_me: creating $CONFIG_STATUS" >&6;}
11755 cat >$CONFIG_STATUS <<_ACEOF
11756 #! $SHELL
11757 # Generated by $as_me.
11758 # Run this file to recreate the current configuration.
11759 # Compiler output produced by configure, useful for debugging
11760 # configure, is in config.log if it exists.
11761
11762 debug=false
11763 ac_cs_recheck=false
11764 ac_cs_silent=false
11765 SHELL=\${CONFIG_SHELL-$SHELL}
11766 _ACEOF
11767
11768 cat >>$CONFIG_STATUS <<\_ACEOF
11769 ## --------------------- ##
11770 ## M4sh Initialization.  ##
11771 ## --------------------- ##
11772
11773 # Be Bourne compatible
11774 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
11775   emulate sh
11776   NULLCMD=:
11777   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
11778   # is contrary to our usage.  Disable this feature.
11779   alias -g '${1+"$@"}'='"$@"'
11780 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
11781   set -o posix
11782 fi
11783 DUALCASE=1; export DUALCASE # for MKS sh
11784
11785 # Support unset when possible.
11786 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
11787   as_unset=unset
11788 else
11789   as_unset=false
11790 fi
11791
11792
11793 # Work around bugs in pre-3.0 UWIN ksh.
11794 $as_unset ENV MAIL MAILPATH
11795 PS1='$ '
11796 PS2='> '
11797 PS4='+ '
11798
11799 # NLS nuisances.
11800 for as_var in \
11801   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
11802   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
11803   LC_TELEPHONE LC_TIME
11804 do
11805   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
11806     eval $as_var=C; export $as_var
11807   else
11808     $as_unset $as_var
11809   fi
11810 done
11811
11812 # Required to use basename.
11813 if expr a : '\(a\)' >/dev/null 2>&1; then
11814   as_expr=expr
11815 else
11816   as_expr=false
11817 fi
11818
11819 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
11820   as_basename=basename
11821 else
11822   as_basename=false
11823 fi
11824
11825
11826 # Name of the executable.
11827 as_me=`$as_basename "$0" ||
11828 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
11829          X"$0" : 'X\(//\)$' \| \
11830          X"$0" : 'X\(/\)$' \| \
11831          .     : '\(.\)' 2>/dev/null ||
11832 echo X/"$0" |
11833     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
11834           /^X\/\(\/\/\)$/{ s//\1/; q; }
11835           /^X\/\(\/\).*/{ s//\1/; q; }
11836           s/.*/./; q'`
11837
11838
11839 # PATH needs CR, and LINENO needs CR and PATH.
11840 # Avoid depending upon Character Ranges.
11841 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
11842 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
11843 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
11844 as_cr_digits='0123456789'
11845 as_cr_alnum=$as_cr_Letters$as_cr_digits
11846
11847 # The user is always right.
11848 if test "${PATH_SEPARATOR+set}" != set; then
11849   echo "#! /bin/sh" >conf$$.sh
11850   echo  "exit 0"   >>conf$$.sh
11851   chmod +x conf$$.sh
11852   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
11853     PATH_SEPARATOR=';'
11854   else
11855     PATH_SEPARATOR=:
11856   fi
11857   rm -f conf$$.sh
11858 fi
11859
11860
11861   as_lineno_1=$LINENO
11862   as_lineno_2=$LINENO
11863   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
11864   test "x$as_lineno_1" != "x$as_lineno_2" &&
11865   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
11866   # Find who we are.  Look in the path if we contain no path at all
11867   # relative or not.
11868   case $0 in
11869     *[\\/]* ) as_myself=$0 ;;
11870     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11871 for as_dir in $PATH
11872 do
11873   IFS=$as_save_IFS
11874   test -z "$as_dir" && as_dir=.
11875   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
11876 done
11877
11878        ;;
11879   esac
11880   # We did not find ourselves, most probably we were run as `sh COMMAND'
11881   # in which case we are not to be found in the path.
11882   if test "x$as_myself" = x; then
11883     as_myself=$0
11884   fi
11885   if test ! -f "$as_myself"; then
11886     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
11887 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
11888    { (exit 1); exit 1; }; }
11889   fi
11890   case $CONFIG_SHELL in
11891   '')
11892     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11893 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
11894 do
11895   IFS=$as_save_IFS
11896   test -z "$as_dir" && as_dir=.
11897   for as_base in sh bash ksh sh5; do
11898          case $as_dir in
11899          /*)
11900            if ("$as_dir/$as_base" -c '
11901   as_lineno_1=$LINENO
11902   as_lineno_2=$LINENO
11903   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
11904   test "x$as_lineno_1" != "x$as_lineno_2" &&
11905   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
11906              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
11907              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
11908              CONFIG_SHELL=$as_dir/$as_base
11909              export CONFIG_SHELL
11910              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
11911            fi;;
11912          esac
11913        done
11914 done
11915 ;;
11916   esac
11917
11918   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
11919   # uniformly replaced by the line number.  The first 'sed' inserts a
11920   # line-number line before each line; the second 'sed' does the real
11921   # work.  The second script uses 'N' to pair each line-number line
11922   # with the numbered line, and appends trailing '-' during
11923   # substitution so that $LINENO is not a special case at line end.
11924   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
11925   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
11926   sed '=' <$as_myself |
11927     sed '
11928       N
11929       s,$,-,
11930       : loop
11931       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
11932       t loop
11933       s,-$,,
11934       s,^['$as_cr_digits']*\n,,
11935     ' >$as_me.lineno &&
11936   chmod +x $as_me.lineno ||
11937     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
11938 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
11939    { (exit 1); exit 1; }; }
11940
11941   # Don't try to exec as it changes $[0], causing all sort of problems
11942   # (the dirname of $[0] is not the place where we might find the
11943   # original and so on.  Autoconf is especially sensible to this).
11944   . ./$as_me.lineno
11945   # Exit status is that of the last command.
11946   exit
11947 }
11948
11949
11950 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
11951   *c*,-n*) ECHO_N= ECHO_C='
11952 ' ECHO_T='      ' ;;
11953   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
11954   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
11955 esac
11956
11957 if expr a : '\(a\)' >/dev/null 2>&1; then
11958   as_expr=expr
11959 else
11960   as_expr=false
11961 fi
11962
11963 rm -f conf$$ conf$$.exe conf$$.file
11964 echo >conf$$.file
11965 if ln -s conf$$.file conf$$ 2>/dev/null; then
11966   # We could just check for DJGPP; but this test a) works b) is more generic
11967   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
11968   if test -f conf$$.exe; then
11969     # Don't use ln at all; we don't have any links
11970     as_ln_s='cp -p'
11971   else
11972     as_ln_s='ln -s'
11973   fi
11974 elif ln conf$$.file conf$$ 2>/dev/null; then
11975   as_ln_s=ln
11976 else
11977   as_ln_s='cp -p'
11978 fi
11979 rm -f conf$$ conf$$.exe conf$$.file
11980
11981 if mkdir -p . 2>/dev/null; then
11982   as_mkdir_p=:
11983 else
11984   test -d ./-p && rmdir ./-p
11985   as_mkdir_p=false
11986 fi
11987
11988 as_executable_p="test -f"
11989
11990 # Sed expression to map a string onto a valid CPP name.
11991 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
11992
11993 # Sed expression to map a string onto a valid variable name.
11994 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
11995
11996
11997 # IFS
11998 # We need space, tab and new line, in precisely that order.
11999 as_nl='
12000 '
12001 IFS="   $as_nl"
12002
12003 # CDPATH.
12004 $as_unset CDPATH
12005
12006 exec 6>&1
12007
12008 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12009 # report actual input values of CONFIG_FILES etc. instead of their
12010 # values after options handling.  Logging --version etc. is OK.
12011 exec 5>>config.log
12012 {
12013   echo
12014   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12015 ## Running $as_me. ##
12016 _ASBOX
12017 } >&5
12018 cat >&5 <<_CSEOF
12019
12020 This file was extended by $as_me, which was
12021 generated by GNU Autoconf 2.59.  Invocation command line was
12022
12023   CONFIG_FILES    = $CONFIG_FILES
12024   CONFIG_HEADERS  = $CONFIG_HEADERS
12025   CONFIG_LINKS    = $CONFIG_LINKS
12026   CONFIG_COMMANDS = $CONFIG_COMMANDS
12027   $ $0 $@
12028
12029 _CSEOF
12030 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12031 echo >&5
12032 _ACEOF
12033
12034 # Files that config.status was made for.
12035 if test -n "$ac_config_files"; then
12036   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12037 fi
12038
12039 if test -n "$ac_config_headers"; then
12040   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12041 fi
12042
12043 if test -n "$ac_config_links"; then
12044   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12045 fi
12046
12047 if test -n "$ac_config_commands"; then
12048   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12049 fi
12050
12051 cat >>$CONFIG_STATUS <<\_ACEOF
12052
12053 ac_cs_usage="\
12054 \`$as_me' instantiates files from templates according to the
12055 current configuration.
12056
12057 Usage: $0 [OPTIONS] [FILE]...
12058
12059   -h, --help       print this help, then exit
12060   -V, --version    print version number, then exit
12061   -q, --quiet      do not print progress messages
12062   -d, --debug      don't remove temporary files
12063       --recheck    update $as_me by reconfiguring in the same conditions
12064   --file=FILE[:TEMPLATE]
12065                    instantiate the configuration file FILE
12066
12067 Configuration files:
12068 $config_files
12069
12070 Report bugs to <bug-autoconf@gnu.org>."
12071 _ACEOF
12072
12073 cat >>$CONFIG_STATUS <<_ACEOF
12074 ac_cs_version="\\
12075 config.status
12076 configured by $0, generated by GNU Autoconf 2.59,
12077   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12078
12079 Copyright (C) 2003 Free Software Foundation, Inc.
12080 This config.status script is free software; the Free Software Foundation
12081 gives unlimited permission to copy, distribute and modify it."
12082 srcdir=$srcdir
12083 INSTALL="$INSTALL"
12084 _ACEOF
12085
12086 cat >>$CONFIG_STATUS <<\_ACEOF
12087 # If no file are specified by the user, then we need to provide default
12088 # value.  By we need to know if files were specified by the user.
12089 ac_need_defaults=:
12090 while test $# != 0
12091 do
12092   case $1 in
12093   --*=*)
12094     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12095     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12096     ac_shift=:
12097     ;;
12098   -*)
12099     ac_option=$1
12100     ac_optarg=$2
12101     ac_shift=shift
12102     ;;
12103   *) # This is not an option, so the user has probably given explicit
12104      # arguments.
12105      ac_option=$1
12106      ac_need_defaults=false;;
12107   esac
12108
12109   case $ac_option in
12110   # Handling of the options.
12111 _ACEOF
12112 cat >>$CONFIG_STATUS <<\_ACEOF
12113   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12114     ac_cs_recheck=: ;;
12115   --version | --vers* | -V )
12116     echo "$ac_cs_version"; exit 0 ;;
12117   --he | --h)
12118     # Conflict between --help and --header
12119     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12120 Try \`$0 --help' for more information." >&5
12121 echo "$as_me: error: ambiguous option: $1
12122 Try \`$0 --help' for more information." >&2;}
12123    { (exit 1); exit 1; }; };;
12124   --help | --hel | -h )
12125     echo "$ac_cs_usage"; exit 0 ;;
12126   --debug | --d* | -d )
12127     debug=: ;;
12128   --file | --fil | --fi | --f )
12129     $ac_shift
12130     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12131     ac_need_defaults=false;;
12132   --header | --heade | --head | --hea )
12133     $ac_shift
12134     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12135     ac_need_defaults=false;;
12136   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12137   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12138     ac_cs_silent=: ;;
12139
12140   # This is an error.
12141   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12142 Try \`$0 --help' for more information." >&5
12143 echo "$as_me: error: unrecognized option: $1
12144 Try \`$0 --help' for more information." >&2;}
12145    { (exit 1); exit 1; }; } ;;
12146
12147   *) ac_config_targets="$ac_config_targets $1" ;;
12148
12149   esac
12150   shift
12151 done
12152
12153 ac_configure_extra_args=
12154
12155 if $ac_cs_silent; then
12156   exec 6>/dev/null
12157   ac_configure_extra_args="$ac_configure_extra_args --silent"
12158 fi
12159
12160 _ACEOF
12161 cat >>$CONFIG_STATUS <<_ACEOF
12162 if \$ac_cs_recheck; then
12163   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12164   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12165 fi
12166
12167 _ACEOF
12168
12169
12170
12171
12172
12173 cat >>$CONFIG_STATUS <<\_ACEOF
12174 for ac_config_target in $ac_config_targets
12175 do
12176   case "$ac_config_target" in
12177   # Handling of arguments.
12178   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12179   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12180 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12181    { (exit 1); exit 1; }; };;
12182   esac
12183 done
12184
12185 # If the user did not use the arguments to specify the items to instantiate,
12186 # then the envvar interface is used.  Set only those that are not.
12187 # We use the long form for the default assignment because of an extremely
12188 # bizarre bug on SunOS 4.1.3.
12189 if $ac_need_defaults; then
12190   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12191 fi
12192
12193 # Have a temporary directory for convenience.  Make it in the build tree
12194 # simply because there is no reason to put it here, and in addition,
12195 # creating and moving files from /tmp can sometimes cause problems.
12196 # Create a temporary directory, and hook for its removal unless debugging.
12197 $debug ||
12198 {
12199   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12200   trap '{ (exit 1); exit 1; }' 1 2 13 15
12201 }
12202
12203 # Create a (secure) tmp directory for tmp files.
12204
12205 {
12206   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12207   test -n "$tmp" && test -d "$tmp"
12208 }  ||
12209 {
12210   tmp=./confstat$$-$RANDOM
12211   (umask 077 && mkdir $tmp)
12212 } ||
12213 {
12214    echo "$me: cannot create a temporary directory in ." >&2
12215    { (exit 1); exit 1; }
12216 }
12217
12218 _ACEOF
12219
12220 cat >>$CONFIG_STATUS <<_ACEOF
12221
12222 #
12223 # CONFIG_FILES section.
12224 #
12225
12226 # No need to generate the scripts if there are no CONFIG_FILES.
12227 # This happens for instance when ./config.status config.h
12228 if test -n "\$CONFIG_FILES"; then
12229   # Protect against being on the right side of a sed subst in config.status.
12230   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12231    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12232 s,@SHELL@,$SHELL,;t t
12233 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12234 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12235 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12236 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12237 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12238 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12239 s,@exec_prefix@,$exec_prefix,;t t
12240 s,@prefix@,$prefix,;t t
12241 s,@program_transform_name@,$program_transform_name,;t t
12242 s,@bindir@,$bindir,;t t
12243 s,@sbindir@,$sbindir,;t t
12244 s,@libexecdir@,$libexecdir,;t t
12245 s,@datadir@,$datadir,;t t
12246 s,@sysconfdir@,$sysconfdir,;t t
12247 s,@sharedstatedir@,$sharedstatedir,;t t
12248 s,@localstatedir@,$localstatedir,;t t
12249 s,@libdir@,$libdir,;t t
12250 s,@includedir@,$includedir,;t t
12251 s,@oldincludedir@,$oldincludedir,;t t
12252 s,@infodir@,$infodir,;t t
12253 s,@mandir@,$mandir,;t t
12254 s,@build_alias@,$build_alias,;t t
12255 s,@host_alias@,$host_alias,;t t
12256 s,@target_alias@,$target_alias,;t t
12257 s,@DEFS@,$DEFS,;t t
12258 s,@ECHO_C@,$ECHO_C,;t t
12259 s,@ECHO_N@,$ECHO_N,;t t
12260 s,@ECHO_T@,$ECHO_T,;t t
12261 s,@LIBS@,$LIBS,;t t
12262 s,@build@,$build,;t t
12263 s,@build_cpu@,$build_cpu,;t t
12264 s,@build_vendor@,$build_vendor,;t t
12265 s,@build_os@,$build_os,;t t
12266 s,@build_noncanonical@,$build_noncanonical,;t t
12267 s,@host_noncanonical@,$host_noncanonical,;t t
12268 s,@target_noncanonical@,$target_noncanonical,;t t
12269 s,@host@,$host,;t t
12270 s,@host_cpu@,$host_cpu,;t t
12271 s,@host_vendor@,$host_vendor,;t t
12272 s,@host_os@,$host_os,;t t
12273 s,@target@,$target,;t t
12274 s,@target_cpu@,$target_cpu,;t t
12275 s,@target_vendor@,$target_vendor,;t t
12276 s,@target_os@,$target_os,;t t
12277 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12278 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12279 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12280 s,@LN@,$LN,;t t
12281 s,@LN_S@,$LN_S,;t t
12282 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12283 s,@build_libsubdir@,$build_libsubdir,;t t
12284 s,@build_subdir@,$build_subdir,;t t
12285 s,@host_subdir@,$host_subdir,;t t
12286 s,@target_subdir@,$target_subdir,;t t
12287 s,@CC@,$CC,;t t
12288 s,@CFLAGS@,$CFLAGS,;t t
12289 s,@LDFLAGS@,$LDFLAGS,;t t
12290 s,@CPPFLAGS@,$CPPFLAGS,;t t
12291 s,@ac_ct_CC@,$ac_ct_CC,;t t
12292 s,@EXEEXT@,$EXEEXT,;t t
12293 s,@OBJEXT@,$OBJEXT,;t t
12294 s,@CXX@,$CXX,;t t
12295 s,@CXXFLAGS@,$CXXFLAGS,;t t
12296 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12297 s,@GNATBIND@,$GNATBIND,;t t
12298 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12299 s,@GNATMAKE@,$GNATMAKE,;t t
12300 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12301 s,@do_compare@,$do_compare,;t t
12302 s,@gmplibs@,$gmplibs,;t t
12303 s,@gmpinc@,$gmpinc,;t t
12304 s,@stage1_languages@,$stage1_languages,;t t
12305 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12306 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12307 s,@tooldir@,$tooldir,;t t
12308 s,@build_tooldir@,$build_tooldir,;t t
12309 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12310 s,@GDB_TK@,$GDB_TK,;t t
12311 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12312 s,@build_configargs@,$build_configargs,;t t
12313 s,@build_configdirs@,$build_configdirs,;t t
12314 s,@host_configargs@,$host_configargs,;t t
12315 s,@configdirs@,$configdirs,;t t
12316 s,@target_configargs@,$target_configargs,;t t
12317 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12318 s,@config_shell@,$config_shell,;t t
12319 s,@YACC@,$YACC,;t t
12320 s,@BISON@,$BISON,;t t
12321 s,@M4@,$M4,;t t
12322 s,@LEX@,$LEX,;t t
12323 s,@FLEX@,$FLEX,;t t
12324 s,@MAKEINFO@,$MAKEINFO,;t t
12325 s,@EXPECT@,$EXPECT,;t t
12326 s,@RUNTEST@,$RUNTEST,;t t
12327 s,@AR@,$AR,;t t
12328 s,@AS@,$AS,;t t
12329 s,@DLLTOOL@,$DLLTOOL,;t t
12330 s,@LD@,$LD,;t t
12331 s,@LIPO@,$LIPO,;t t
12332 s,@NM@,$NM,;t t
12333 s,@RANLIB@,$RANLIB,;t t
12334 s,@STRIP@,$STRIP,;t t
12335 s,@WINDRES@,$WINDRES,;t t
12336 s,@OBJCOPY@,$OBJCOPY,;t t
12337 s,@OBJDUMP@,$OBJDUMP,;t t
12338 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12339 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12340 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12341 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12342 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12343 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12344 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12345 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12346 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12347 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12348 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12349 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12350 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12351 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12352 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12353 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12354 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12355 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12356 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12357 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12358 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12359 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12360 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12361 s,@MAINT@,$MAINT,;t t
12362 s,@stage1_cflags@,$stage1_cflags,;t t
12363 s,@stage1_checking@,$stage1_checking,;t t
12364 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12365 s,@datarootdir@,$datarootdir,;t t
12366 s,@docdir@,$docdir,;t t
12367 s,@pdfdir@,$pdfdir,;t t
12368 s,@htmldir@,$htmldir,;t t
12369 s,@LIBOBJS@,$LIBOBJS,;t t
12370 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12371 /@serialization_dependencies@/r $serialization_dependencies
12372 s,@serialization_dependencies@,,;t t
12373 /@host_makefile_frag@/r $host_makefile_frag
12374 s,@host_makefile_frag@,,;t t
12375 /@target_makefile_frag@/r $target_makefile_frag
12376 s,@target_makefile_frag@,,;t t
12377 /@alphaieee_frag@/r $alphaieee_frag
12378 s,@alphaieee_frag@,,;t t
12379 /@ospace_frag@/r $ospace_frag
12380 s,@ospace_frag@,,;t t
12381 CEOF
12382
12383 _ACEOF
12384
12385   cat >>$CONFIG_STATUS <<\_ACEOF
12386   # Split the substitutions into bite-sized pieces for seds with
12387   # small command number limits, like on Digital OSF/1 and HP-UX.
12388   ac_max_sed_lines=48
12389   ac_sed_frag=1 # Number of current file.
12390   ac_beg=1 # First line for current file.
12391   ac_end=$ac_max_sed_lines # Line after last line for current file.
12392   ac_more_lines=:
12393   ac_sed_cmds=
12394   while $ac_more_lines; do
12395     if test $ac_beg -gt 1; then
12396       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12397     else
12398       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12399     fi
12400     if test ! -s $tmp/subs.frag; then
12401       ac_more_lines=false
12402     else
12403       # The purpose of the label and of the branching condition is to
12404       # speed up the sed processing (if there are no `@' at all, there
12405       # is no need to browse any of the substitutions).
12406       # These are the two extra sed commands mentioned above.
12407       (echo ':t
12408   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12409       if test -z "$ac_sed_cmds"; then
12410         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12411       else
12412         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12413       fi
12414       ac_sed_frag=`expr $ac_sed_frag + 1`
12415       ac_beg=$ac_end
12416       ac_end=`expr $ac_end + $ac_max_sed_lines`
12417     fi
12418   done
12419   if test -z "$ac_sed_cmds"; then
12420     ac_sed_cmds=cat
12421   fi
12422 fi # test -n "$CONFIG_FILES"
12423
12424 _ACEOF
12425 cat >>$CONFIG_STATUS <<\_ACEOF
12426 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12427   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12428   case $ac_file in
12429   - | *:- | *:-:* ) # input from stdin
12430         cat >$tmp/stdin
12431         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12432         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12433   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12434         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12435   * )   ac_file_in=$ac_file.in ;;
12436   esac
12437
12438   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12439   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12440 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12441          X"$ac_file" : 'X\(//\)[^/]' \| \
12442          X"$ac_file" : 'X\(//\)$' \| \
12443          X"$ac_file" : 'X\(/\)' \| \
12444          .     : '\(.\)' 2>/dev/null ||
12445 echo X"$ac_file" |
12446     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12447           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12448           /^X\(\/\/\)$/{ s//\1/; q; }
12449           /^X\(\/\).*/{ s//\1/; q; }
12450           s/.*/./; q'`
12451   { if $as_mkdir_p; then
12452     mkdir -p "$ac_dir"
12453   else
12454     as_dir="$ac_dir"
12455     as_dirs=
12456     while test ! -d "$as_dir"; do
12457       as_dirs="$as_dir $as_dirs"
12458       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12459 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12460          X"$as_dir" : 'X\(//\)[^/]' \| \
12461          X"$as_dir" : 'X\(//\)$' \| \
12462          X"$as_dir" : 'X\(/\)' \| \
12463          .     : '\(.\)' 2>/dev/null ||
12464 echo X"$as_dir" |
12465     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12466           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12467           /^X\(\/\/\)$/{ s//\1/; q; }
12468           /^X\(\/\).*/{ s//\1/; q; }
12469           s/.*/./; q'`
12470     done
12471     test ! -n "$as_dirs" || mkdir $as_dirs
12472   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
12473 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
12474    { (exit 1); exit 1; }; }; }
12475
12476   ac_builddir=.
12477
12478 if test "$ac_dir" != .; then
12479   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
12480   # A "../" for each directory in $ac_dir_suffix.
12481   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
12482 else
12483   ac_dir_suffix= ac_top_builddir=
12484 fi
12485
12486 case $srcdir in
12487   .)  # No --srcdir option.  We are building in place.
12488     ac_srcdir=.
12489     if test -z "$ac_top_builddir"; then
12490        ac_top_srcdir=.
12491     else
12492        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
12493     fi ;;
12494   [\\/]* | ?:[\\/]* )  # Absolute path.
12495     ac_srcdir=$srcdir$ac_dir_suffix;
12496     ac_top_srcdir=$srcdir ;;
12497   *) # Relative path.
12498     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
12499     ac_top_srcdir=$ac_top_builddir$srcdir ;;
12500 esac
12501
12502 # Do not use `cd foo && pwd` to compute absolute paths, because
12503 # the directories may not exist.
12504 case `pwd` in
12505 .) ac_abs_builddir="$ac_dir";;
12506 *)
12507   case "$ac_dir" in
12508   .) ac_abs_builddir=`pwd`;;
12509   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
12510   *) ac_abs_builddir=`pwd`/"$ac_dir";;
12511   esac;;
12512 esac
12513 case $ac_abs_builddir in
12514 .) ac_abs_top_builddir=${ac_top_builddir}.;;
12515 *)
12516   case ${ac_top_builddir}. in
12517   .) ac_abs_top_builddir=$ac_abs_builddir;;
12518   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
12519   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
12520   esac;;
12521 esac
12522 case $ac_abs_builddir in
12523 .) ac_abs_srcdir=$ac_srcdir;;
12524 *)
12525   case $ac_srcdir in
12526   .) ac_abs_srcdir=$ac_abs_builddir;;
12527   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
12528   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
12529   esac;;
12530 esac
12531 case $ac_abs_builddir in
12532 .) ac_abs_top_srcdir=$ac_top_srcdir;;
12533 *)
12534   case $ac_top_srcdir in
12535   .) ac_abs_top_srcdir=$ac_abs_builddir;;
12536   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
12537   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
12538   esac;;
12539 esac
12540
12541
12542   case $INSTALL in
12543   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
12544   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
12545   esac
12546
12547   if test x"$ac_file" != x-; then
12548     { echo "$as_me:$LINENO: creating $ac_file" >&5
12549 echo "$as_me: creating $ac_file" >&6;}
12550     rm -f "$ac_file"
12551   fi
12552   # Let's still pretend it is `configure' which instantiates (i.e., don't
12553   # use $as_me), people would be surprised to read:
12554   #    /* config.h.  Generated by config.status.  */
12555   if test x"$ac_file" = x-; then
12556     configure_input=
12557   else
12558     configure_input="$ac_file.  "
12559   fi
12560   configure_input=$configure_input"Generated from `echo $ac_file_in |
12561                                      sed 's,.*/,,'` by configure."
12562
12563   # First look for the input files in the build tree, otherwise in the
12564   # src tree.
12565   ac_file_inputs=`IFS=:
12566     for f in $ac_file_in; do
12567       case $f in
12568       -) echo $tmp/stdin ;;
12569       [\\/$]*)
12570          # Absolute (can't be DOS-style, as IFS=:)
12571          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
12572 echo "$as_me: error: cannot find input file: $f" >&2;}
12573    { (exit 1); exit 1; }; }
12574          echo "$f";;
12575       *) # Relative
12576          if test -f "$f"; then
12577            # Build tree
12578            echo "$f"
12579          elif test -f "$srcdir/$f"; then
12580            # Source tree
12581            echo "$srcdir/$f"
12582          else
12583            # /dev/null tree
12584            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
12585 echo "$as_me: error: cannot find input file: $f" >&2;}
12586    { (exit 1); exit 1; }; }
12587          fi;;
12588       esac
12589     done` || { (exit 1); exit 1; }
12590 _ACEOF
12591 cat >>$CONFIG_STATUS <<_ACEOF
12592   sed "$ac_vpsub
12593 $extrasub
12594 _ACEOF
12595 cat >>$CONFIG_STATUS <<\_ACEOF
12596 :t
12597 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
12598 s,@configure_input@,$configure_input,;t t
12599 s,@srcdir@,$ac_srcdir,;t t
12600 s,@abs_srcdir@,$ac_abs_srcdir,;t t
12601 s,@top_srcdir@,$ac_top_srcdir,;t t
12602 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
12603 s,@builddir@,$ac_builddir,;t t
12604 s,@abs_builddir@,$ac_abs_builddir,;t t
12605 s,@top_builddir@,$ac_top_builddir,;t t
12606 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
12607 s,@INSTALL@,$ac_INSTALL,;t t
12608 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
12609   rm -f $tmp/stdin
12610   if test x"$ac_file" != x-; then
12611     mv $tmp/out $ac_file
12612   else
12613     cat $tmp/out
12614     rm -f $tmp/out
12615   fi
12616
12617 done
12618 _ACEOF
12619
12620 cat >>$CONFIG_STATUS <<\_ACEOF
12621
12622 { (exit 0); exit 0; }
12623 _ACEOF
12624 chmod +x $CONFIG_STATUS
12625 ac_clean_files=$ac_clean_files_save
12626
12627
12628 # configure is writing to config.log, and then calls config.status.
12629 # config.status does its own redirection, appending to config.log.
12630 # Unfortunately, on DOS this fails, as config.log is still kept open
12631 # by configure, so config.status won't be able to write to it; its
12632 # output is simply discarded.  So we exec the FD to /dev/null,
12633 # effectively closing config.log, so it can be properly (re)opened and
12634 # appended to by config.status.  When coming back to configure, we
12635 # need to make the FD available again.
12636 if test "$no_create" != yes; then
12637   ac_cs_success=:
12638   ac_config_status_args=
12639   test "$silent" = yes &&
12640     ac_config_status_args="$ac_config_status_args --quiet"
12641   exec 5>/dev/null
12642   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
12643   exec 5>>config.log
12644   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
12645   # would make configure fail if this is the last instruction.
12646   $ac_cs_success || { (exit 1); exit 1; }
12647 fi
12648