configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS TOPLEVEL_CONFIGURE_ARGUMENTS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277
 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_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 717
 718 ac_env_CC_set=${CC+set}
 719 ac_env_CC_value=$CC
 720 ac_cv_env_CC_set=${CC+set}
 721 ac_cv_env_CC_value=$CC
 722 ac_env_CFLAGS_set=${CFLAGS+set}
 723 ac_env_CFLAGS_value=$CFLAGS
 724 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 725 ac_cv_env_CFLAGS_value=$CFLAGS
 726 ac_env_LDFLAGS_set=${LDFLAGS+set}
 727 ac_env_LDFLAGS_value=$LDFLAGS
 728 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 729 ac_cv_env_LDFLAGS_value=$LDFLAGS
 730 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 731 ac_env_CPPFLAGS_value=$CPPFLAGS
 732 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 733 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 734 ac_env_CXX_set=${CXX+set}
 735 ac_env_CXX_value=$CXX
 736 ac_cv_env_CXX_set=${CXX+set}
 737 ac_cv_env_CXX_value=$CXX
 738 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 739 ac_env_CXXFLAGS_value=$CXXFLAGS
 740 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 741 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 742 ac_env_AR_set=${AR+set}
 743 ac_env_AR_value=$AR
 744 ac_cv_env_AR_set=${AR+set}
 745 ac_cv_env_AR_value=$AR
 746 ac_env_AS_set=${AS+set}
 747 ac_env_AS_value=$AS
 748 ac_cv_env_AS_set=${AS+set}
 749 ac_cv_env_AS_value=$AS
 750 ac_env_DLLTOOL_set=${DLLTOOL+set}
 751 ac_env_DLLTOOL_value=$DLLTOOL
 752 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 753 ac_cv_env_DLLTOOL_value=$DLLTOOL
 754 ac_env_LD_set=${LD+set}
 755 ac_env_LD_value=$LD
 756 ac_cv_env_LD_set=${LD+set}
 757 ac_cv_env_LD_value=$LD
 758 ac_env_LIPO_set=${LIPO+set}
 759 ac_env_LIPO_value=$LIPO
 760 ac_cv_env_LIPO_set=${LIPO+set}
 761 ac_cv_env_LIPO_value=$LIPO
 762 ac_env_NM_set=${NM+set}
 763 ac_env_NM_value=$NM
 764 ac_cv_env_NM_set=${NM+set}
 765 ac_cv_env_NM_value=$NM
 766 ac_env_RANLIB_set=${RANLIB+set}
 767 ac_env_RANLIB_value=$RANLIB
 768 ac_cv_env_RANLIB_set=${RANLIB+set}
 769 ac_cv_env_RANLIB_value=$RANLIB
 770 ac_env_STRIP_set=${STRIP+set}
 771 ac_env_STRIP_value=$STRIP
 772 ac_cv_env_STRIP_set=${STRIP+set}
 773 ac_cv_env_STRIP_value=$STRIP
 774 ac_env_WINDRES_set=${WINDRES+set}
 775 ac_env_WINDRES_value=$WINDRES
 776 ac_cv_env_WINDRES_set=${WINDRES+set}
 777 ac_cv_env_WINDRES_value=$WINDRES
 778 ac_env_WINDMC_set=${WINDMC+set}
 779 ac_env_WINDMC_value=$WINDMC
 780 ac_cv_env_WINDMC_set=${WINDMC+set}
 781 ac_cv_env_WINDMC_value=$WINDMC
 782 ac_env_OBJCOPY_set=${OBJCOPY+set}
 783 ac_env_OBJCOPY_value=$OBJCOPY
 784 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 785 ac_cv_env_OBJCOPY_value=$OBJCOPY
 786 ac_env_OBJDUMP_set=${OBJDUMP+set}
 787 ac_env_OBJDUMP_value=$OBJDUMP
 788 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 789 ac_cv_env_OBJDUMP_value=$OBJDUMP
 790 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 791 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 792 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 793 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 794 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 795 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 796 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 797 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 798 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 799 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 800 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 801 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 802 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 803 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 804 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 805 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 806 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 807 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 808 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 809 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 810 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 811 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 812 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 813 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 814 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 815 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 816 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 817 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 818 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 819 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 820 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 821 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 822 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 823 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 824 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 825 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 826 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 827 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 828 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 829 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 830 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 831 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 832 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 833 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 834 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 835 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 836 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 837 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 838 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 839 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 840 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 841 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 842 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 843 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 844 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 845 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 846 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 847 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 848 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 849 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 850 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 851 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 852 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 853 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 854
 855 #
 856 # Report the --help message.
 857 #
 858 if test "$ac_init_help" = "long"; then
 859   # Omit some internal or obsolete options to make the list less imposing.
 860   # This message is too long to be a string in the A/UX 3.1 sh.
 861   cat <<_ACEOF
 862 \`configure' configures this package to adapt to many kinds of systems.
 863
 864 Usage: $0 [OPTION]... [VAR=VALUE]...
 865
 866 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 867 VAR=VALUE.  See below for descriptions of some of the useful variables.
 868
 869 Defaults for the options are specified in brackets.
 870
 871 Configuration:
 872   -h, --help              display this help and exit
 873       --help=short        display options specific to this package
 874       --help=recursive    display the short help of all the included packages
 875   -V, --version           display version information and exit
 876   -q, --quiet, --silent   do not print \`checking...' messages
 877       --cache-file=FILE   cache test results in FILE [disabled]
 878   -C, --config-cache      alias for \`--cache-file=config.cache'
 879   -n, --no-create         do not create output files
 880       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 881
 882 _ACEOF
 883
 884   cat <<_ACEOF
 885 Installation directories:
 886   --prefix=PREFIX         install architecture-independent files in PREFIX
 887                           [$ac_default_prefix]
 888   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 889                           [PREFIX]
 890
 891 By default, \`make install' will install all the files in
 892 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 893 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 894 for instance \`--prefix=\$HOME'.
 895
 896 For better control, use the options below.
 897
 898 Fine tuning of the installation directories:
 899   --bindir=DIR           user executables [EPREFIX/bin]
 900   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 901   --libexecdir=DIR       program executables [EPREFIX/libexec]
 902   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 903   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 904   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 905   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 906   --libdir=DIR           object code libraries [EPREFIX/lib]
 907   --includedir=DIR       C header files [PREFIX/include]
 908   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 909   --infodir=DIR          info documentation [PREFIX/info]
 910   --mandir=DIR           man documentation [PREFIX/man]
 911 _ACEOF
 912
 913   cat <<\_ACEOF
 914
 915 Program names:
 916   --program-prefix=PREFIX            prepend PREFIX to installed program names
 917   --program-suffix=SUFFIX            append SUFFIX to installed program names
 918   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 919
 920 System types:
 921   --build=BUILD     configure for building on BUILD [guessed]
 922   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 923   --target=TARGET   configure for building compilers for TARGET [HOST]
 924 _ACEOF
 925 fi
 926
 927 if test -n "$ac_init_help"; then
 928
 929   cat <<\_ACEOF
 930
 931 Optional Features:
 932   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 933   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 934   --enable-gold           use gold instead of ld
 935   --enable-libada         build libada directory
 936   --enable-libssp         build libssp directory
 937   --enable-stage1-languages[=all]   choose additional languages to build during
 938                           stage1.  Mostly useful for compiler development.
 939   --enable-objc-gc        enable use of Boehm's garbage collector with the
 940                           GNU Objective-C runtime
 941   --enable-bootstrap      enable bootstrapping [yes if native build]
 942   --enable-serial-[{host,target,build}-]configure
 943                           force sequential configuration of
 944                           sub-packages for the host, target or build
 945                           machine, or all sub-packages
 946   --enable-maintainer-mode enable make rules and dependencies not useful
 947                           (and sometimes confusing) to the casual installer
 948   --enable-stage1-checking[=all]   choose additional checking for stage1
 949                           of the compiler
 950   --enable-werror         enable -Werror in bootstrap stage2 and later
 951
 952 Optional Packages:
 953   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 954   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 955   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 956   --with-mpfr-dir=PATH    this option has been REMOVED
 957   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 958                           Equivalent to --with-mpfr-include=PATH/include
 959                           plus --with-mpfr-lib=PATH/lib
 960   --with-mpfr-include=PATH
 961                           specify directory for installed MPFR include files
 962   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 963   --with-gmp-dir=PATH     this option has been REMOVED
 964   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 965                           Equivalent to --with-gmp-include=PATH/include
 966                           plus --with-gmp-lib=PATH/lib
 967   --with-gmp-include=PATH specify directory for installed GMP include files
 968   --with-gmp-lib=PATH     specify directory for the installed GMP library
 969   --with-build-sysroot=SYSROOT
 970                           use sysroot as the system root during the build
 971   --with-debug-prefix-map='A=B C=D ...'
 972                              map A to B, C to D ... in debug information
 973   --with-build-time-tools=PATH
 974                           use given path to find target tools during the build
 975   --with-datarootdir      use datarootdir as the data root directory.
 976   --with-docdir           install documentation in this directory.
 977   --with-pdfdir           install pdf in this directory.
 978   --with-htmldir          install html in this directory.
 979
 980 Some influential environment variables:
 981   CC          C compiler command
 982   CFLAGS      C compiler flags
 983   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 984               nonstandard directory <lib dir>
 985   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 986               headers in a nonstandard directory <include dir>
 987   CXX         C++ compiler command
 988   CXXFLAGS    C++ compiler flags
 989   AR          AR for the host
 990   AS          AS for the host
 991   DLLTOOL     DLLTOOL for the host
 992   LD          LD for the host
 993   LIPO        LIPO for the host
 994   NM          NM for the host
 995   RANLIB      RANLIB for the host
 996   STRIP       STRIP for the host
 997   WINDRES     WINDRES for the host
 998   WINDMC      WINDMC for the host
 999   OBJCOPY     OBJCOPY for the host
1000   OBJDUMP     OBJDUMP for the host
1001   CC_FOR_TARGET
1002               CC for the target
1003   CXX_FOR_TARGET
1004               CXX for the target
1005   GCC_FOR_TARGET
1006               GCC for the target
1007   GCJ_FOR_TARGET
1008               GCJ for the target
1009   GFORTRAN_FOR_TARGET
1010               GFORTRAN for the target
1011   AR_FOR_TARGET
1012               AR for the target
1013   AS_FOR_TARGET
1014               AS for the target
1015   DLLTOOL_FOR_TARGET
1016               DLLTOOL for the target
1017   LD_FOR_TARGET
1018               LD for the target
1019   LIPO_FOR_TARGET
1020               LIPO for the target
1021   NM_FOR_TARGET
1022               NM for the target
1023   OBJDUMP_FOR_TARGET
1024               OBJDUMP for the target
1025   RANLIB_FOR_TARGET
1026               RANLIB for the target
1027   STRIP_FOR_TARGET
1028               STRIP for the target
1029   WINDRES_FOR_TARGET
1030               WINDRES for the target
1031   WINDMC_FOR_TARGET
1032               WINDMC for the target
1033
1034 Use these variables to override the choices made by `configure' or to help
1035 it to find libraries and programs with nonstandard names/locations.
1036
1037 _ACEOF
1038 fi
1039
1040 if test "$ac_init_help" = "recursive"; then
1041   # If there are subdirs, report their specific --help.
1042   ac_popdir=`pwd`
1043   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1044     test -d $ac_dir || continue
1045     ac_builddir=.
1046
1047 if test "$ac_dir" != .; then
1048   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1049   # A "../" for each directory in $ac_dir_suffix.
1050   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1051 else
1052   ac_dir_suffix= ac_top_builddir=
1053 fi
1054
1055 case $srcdir in
1056   .)  # No --srcdir option.  We are building in place.
1057     ac_srcdir=.
1058     if test -z "$ac_top_builddir"; then
1059        ac_top_srcdir=.
1060     else
1061        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1062     fi ;;
1063   [\\/]* | ?:[\\/]* )  # Absolute path.
1064     ac_srcdir=$srcdir$ac_dir_suffix;
1065     ac_top_srcdir=$srcdir ;;
1066   *) # Relative path.
1067     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1068     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1069 esac
1070
1071 # Do not use `cd foo && pwd` to compute absolute paths, because
1072 # the directories may not exist.
1073 case `pwd` in
1074 .) ac_abs_builddir="$ac_dir";;
1075 *)
1076   case "$ac_dir" in
1077   .) ac_abs_builddir=`pwd`;;
1078   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1079   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1080   esac;;
1081 esac
1082 case $ac_abs_builddir in
1083 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1084 *)
1085   case ${ac_top_builddir}. in
1086   .) ac_abs_top_builddir=$ac_abs_builddir;;
1087   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1088   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1089   esac;;
1090 esac
1091 case $ac_abs_builddir in
1092 .) ac_abs_srcdir=$ac_srcdir;;
1093 *)
1094   case $ac_srcdir in
1095   .) ac_abs_srcdir=$ac_abs_builddir;;
1096   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1097   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1098   esac;;
1099 esac
1100 case $ac_abs_builddir in
1101 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1102 *)
1103   case $ac_top_srcdir in
1104   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1105   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1106   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1107   esac;;
1108 esac
1109
1110     cd $ac_dir
1111     # Check for guested configure; otherwise get Cygnus style configure.
1112     if test -f $ac_srcdir/configure.gnu; then
1113       echo
1114       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1115     elif test -f $ac_srcdir/configure; then
1116       echo
1117       $SHELL $ac_srcdir/configure  --help=recursive
1118     elif test -f $ac_srcdir/configure.ac ||
1119            test -f $ac_srcdir/configure.in; then
1120       echo
1121       $ac_configure --help
1122     else
1123       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1124     fi
1125     cd $ac_popdir
1126   done
1127 fi
1128
1129 test -n "$ac_init_help" && exit 0
1130 if $ac_init_version; then
1131   cat <<\_ACEOF
1132
1133 Copyright (C) 2003 Free Software Foundation, Inc.
1134 This configure script is free software; the Free Software Foundation
1135 gives unlimited permission to copy, distribute and modify it.
1136 _ACEOF
1137   exit 0
1138 fi
1139 exec 5>config.log
1140 cat >&5 <<_ACEOF
1141 This file contains any messages produced by compilers while
1142 running configure, to aid debugging if configure makes a mistake.
1143
1144 It was created by $as_me, which was
1145 generated by GNU Autoconf 2.59.  Invocation command line was
1146
1147   $ $0 $@
1148
1149 _ACEOF
1150 {
1151 cat <<_ASUNAME
1152 ## --------- ##
1153 ## Platform. ##
1154 ## --------- ##
1155
1156 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1157 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1158 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1159 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1160 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1161
1162 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1163 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1164
1165 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1166 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1167 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1168 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1169 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1170 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1171 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1172
1173 _ASUNAME
1174
1175 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1176 for as_dir in $PATH
1177 do
1178   IFS=$as_save_IFS
1179   test -z "$as_dir" && as_dir=.
1180   echo "PATH: $as_dir"
1181 done
1182
1183 } >&5
1184
1185 cat >&5 <<_ACEOF
1186
1187
1188 ## ----------- ##
1189 ## Core tests. ##
1190 ## ----------- ##
1191
1192 _ACEOF
1193
1194
1195 # Keep a trace of the command line.
1196 # Strip out --no-create and --no-recursion so they do not pile up.
1197 # Strip out --silent because we don't want to record it for future runs.
1198 # Also quote any args containing shell meta-characters.
1199 # Make two passes to allow for proper duplicate-argument suppression.
1200 ac_configure_args=
1201 ac_configure_args0=
1202 ac_configure_args1=
1203 ac_sep=
1204 ac_must_keep_next=false
1205 for ac_pass in 1 2
1206 do
1207   for ac_arg
1208   do
1209     case $ac_arg in
1210     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1211     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1212     | -silent | --silent | --silen | --sile | --sil)
1213       continue ;;
1214     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1215       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1216     esac
1217     case $ac_pass in
1218     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1219     2)
1220       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1221       if test $ac_must_keep_next = true; then
1222         ac_must_keep_next=false # Got value, back to normal.
1223       else
1224         case $ac_arg in
1225           *=* | --config-cache | -C | -disable-* | --disable-* \
1226           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1227           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1228           | -with-* | --with-* | -without-* | --without-* | --x)
1229             case "$ac_configure_args0 " in
1230               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1231             esac
1232             ;;
1233           -* ) ac_must_keep_next=true ;;
1234         esac
1235       fi
1236       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1237       # Get rid of the leading space.
1238       ac_sep=" "
1239       ;;
1240     esac
1241   done
1242 done
1243 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1244 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1245
1246 # When interrupted or exit'd, cleanup temporary files, and complete
1247 # config.log.  We remove comments because anyway the quotes in there
1248 # would cause problems or look ugly.
1249 # WARNING: Be sure not to use single quotes in there, as some shells,
1250 # such as our DU 5.0 friend, will then `close' the trap.
1251 trap 'exit_status=$?
1252   # Save into config.log some information that might help in debugging.
1253   {
1254     echo
1255
1256     cat <<\_ASBOX
1257 ## ---------------- ##
1258 ## Cache variables. ##
1259 ## ---------------- ##
1260 _ASBOX
1261     echo
1262     # The following way of writing the cache mishandles newlines in values,
1263 {
1264   (set) 2>&1 |
1265     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1266     *ac_space=\ *)
1267       sed -n \
1268         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1269           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1270       ;;
1271     *)
1272       sed -n \
1273         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1274       ;;
1275     esac;
1276 }
1277     echo
1278
1279     cat <<\_ASBOX
1280 ## ----------------- ##
1281 ## Output variables. ##
1282 ## ----------------- ##
1283 _ASBOX
1284     echo
1285     for ac_var in $ac_subst_vars
1286     do
1287       eval ac_val=$`echo $ac_var`
1288       echo "$ac_var='"'"'$ac_val'"'"'"
1289     done | sort
1290     echo
1291
1292     if test -n "$ac_subst_files"; then
1293       cat <<\_ASBOX
1294 ## ------------- ##
1295 ## Output files. ##
1296 ## ------------- ##
1297 _ASBOX
1298       echo
1299       for ac_var in $ac_subst_files
1300       do
1301         eval ac_val=$`echo $ac_var`
1302         echo "$ac_var='"'"'$ac_val'"'"'"
1303       done | sort
1304       echo
1305     fi
1306
1307     if test -s confdefs.h; then
1308       cat <<\_ASBOX
1309 ## ----------- ##
1310 ## confdefs.h. ##
1311 ## ----------- ##
1312 _ASBOX
1313       echo
1314       sed "/^$/d" confdefs.h | sort
1315       echo
1316     fi
1317     test "$ac_signal" != 0 &&
1318       echo "$as_me: caught signal $ac_signal"
1319     echo "$as_me: exit $exit_status"
1320   } >&5
1321   rm -f core *.core &&
1322   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1323     exit $exit_status
1324      ' 0
1325 for ac_signal in 1 2 13 15; do
1326   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1327 done
1328 ac_signal=0
1329
1330 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1331 rm -rf conftest* confdefs.h
1332 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1333 echo >confdefs.h
1334
1335 # Predefined preprocessor variables.
1336
1337 cat >>confdefs.h <<_ACEOF
1338 #define PACKAGE_NAME "$PACKAGE_NAME"
1339 _ACEOF
1340
1341
1342 cat >>confdefs.h <<_ACEOF
1343 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1344 _ACEOF
1345
1346
1347 cat >>confdefs.h <<_ACEOF
1348 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1349 _ACEOF
1350
1351
1352 cat >>confdefs.h <<_ACEOF
1353 #define PACKAGE_STRING "$PACKAGE_STRING"
1354 _ACEOF
1355
1356
1357 cat >>confdefs.h <<_ACEOF
1358 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1359 _ACEOF
1360
1361
1362 # Let the site file select an alternate cache file if it wants to.
1363 # Prefer explicitly selected file to automatically selected ones.
1364 if test -z "$CONFIG_SITE"; then
1365   if test "x$prefix" != xNONE; then
1366     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1367   else
1368     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1369   fi
1370 fi
1371 for ac_site_file in $CONFIG_SITE; do
1372   if test -r "$ac_site_file"; then
1373     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1374 echo "$as_me: loading site script $ac_site_file" >&6;}
1375     sed 's/^/| /' "$ac_site_file" >&5
1376     . "$ac_site_file"
1377   fi
1378 done
1379
1380 if test -r "$cache_file"; then
1381   # Some versions of bash will fail to source /dev/null (special
1382   # files actually), so we avoid doing that.
1383   if test -f "$cache_file"; then
1384     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1385 echo "$as_me: loading cache $cache_file" >&6;}
1386     case $cache_file in
1387       [\\/]* | ?:[\\/]* ) . $cache_file;;
1388       *)                      . ./$cache_file;;
1389     esac
1390   fi
1391 else
1392   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1393 echo "$as_me: creating cache $cache_file" >&6;}
1394   >$cache_file
1395 fi
1396
1397 # Check that the precious variables saved in the cache have kept the same
1398 # value.
1399 ac_cache_corrupted=false
1400 for ac_var in `(set) 2>&1 |
1401                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1402   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1403   eval ac_new_set=\$ac_env_${ac_var}_set
1404   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1405   eval ac_new_val="\$ac_env_${ac_var}_value"
1406   case $ac_old_set,$ac_new_set in
1407     set,)
1408       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1409 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1410       ac_cache_corrupted=: ;;
1411     ,set)
1412       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1413 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1414       ac_cache_corrupted=: ;;
1415     ,);;
1416     *)
1417       if test "x$ac_old_val" != "x$ac_new_val"; then
1418         # differences in whitespace do not lead to failure.
1419         ac_old_val_w=`echo x $ac_old_val`
1420         ac_new_val_w=`echo x $ac_new_val`
1421         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1422           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1423 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1424           ac_cache_corrupted=:
1425         else
1426           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1427 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1428           eval $ac_var=\$ac_old_val
1429         fi
1430         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1431 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1432         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1433 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1434       fi;;
1435   esac
1436   # Pass precious variables to config.status.
1437   if test "$ac_new_set" = set; then
1438     case $ac_new_val in
1439     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1440       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1441     *) ac_arg=$ac_var=$ac_new_val ;;
1442     esac
1443     case " $ac_configure_args " in
1444       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1445       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1446     esac
1447   fi
1448 done
1449 if $ac_cache_corrupted; then
1450   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1451 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1452   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1453 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1454    { (exit 1); exit 1; }; }
1455 fi
1456
1457 ac_ext=c
1458 ac_cpp='$CPP $CPPFLAGS'
1459 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1460 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1461 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483 progname=$0
1484 # if PWD already has a value, it is probably wrong.
1485 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1486
1487 # Export original configure arguments for use by sub-configures.
1488 # Quote arguments with shell meta charatcers.
1489 TOPLEVEL_CONFIGURE_ARGUMENTS=
1490 set -- "$progname" "$@"
1491 for ac_arg
1492 do
1493   case "$ac_arg" in
1494   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1495     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1496     # if the argument is of the form -foo=baz, quote the baz part only
1497     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1498   *) ;;
1499   esac
1500   # Add the quoted argument to the list.
1501   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1502 done
1503 if test "$silent" = yes; then
1504   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1505 fi
1506 # Remove the initial space we just introduced and, as these will be
1507 # expanded by make, quote '$'.
1508 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1509
1510
1511 # Find the build, host, and target systems.
1512 ac_aux_dir=
1513 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1514   if test -f $ac_dir/install-sh; then
1515     ac_aux_dir=$ac_dir
1516     ac_install_sh="$ac_aux_dir/install-sh -c"
1517     break
1518   elif test -f $ac_dir/install.sh; then
1519     ac_aux_dir=$ac_dir
1520     ac_install_sh="$ac_aux_dir/install.sh -c"
1521     break
1522   elif test -f $ac_dir/shtool; then
1523     ac_aux_dir=$ac_dir
1524     ac_install_sh="$ac_aux_dir/shtool install -c"
1525     break
1526   fi
1527 done
1528 if test -z "$ac_aux_dir"; then
1529   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1530 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1531    { (exit 1); exit 1; }; }
1532 fi
1533 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1534 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1535 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1536
1537 # Make sure we can run config.sub.
1538 $ac_config_sub sun4 >/dev/null 2>&1 ||
1539   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1540 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1541    { (exit 1); exit 1; }; }
1542
1543 echo "$as_me:$LINENO: checking build system type" >&5
1544 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1545 if test "${ac_cv_build+set}" = set; then
1546   echo $ECHO_N "(cached) $ECHO_C" >&6
1547 else
1548   ac_cv_build_alias=$build_alias
1549 test -z "$ac_cv_build_alias" &&
1550   ac_cv_build_alias=`$ac_config_guess`
1551 test -z "$ac_cv_build_alias" &&
1552   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1553 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1554    { (exit 1); exit 1; }; }
1555 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1556   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1557 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1558    { (exit 1); exit 1; }; }
1559
1560 fi
1561 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1562 echo "${ECHO_T}$ac_cv_build" >&6
1563 build=$ac_cv_build
1564 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1565 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1566 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1567
1568
1569  case ${build_alias} in
1570   "") build_noncanonical=${build} ;;
1571   *) build_noncanonical=${build_alias} ;;
1572 esac
1573
1574
1575
1576  case ${host_alias} in
1577   "") host_noncanonical=${build_noncanonical} ;;
1578   *) host_noncanonical=${host_alias} ;;
1579 esac
1580
1581
1582
1583  case ${target_alias} in
1584   "") target_noncanonical=${host_noncanonical} ;;
1585   *) target_noncanonical=${target_alias} ;;
1586 esac
1587
1588
1589
1590
1591 test "$host_noncanonical" = "$target_noncanonical" &&
1592   test "$program_prefix$program_suffix$program_transform_name" = \
1593     NONENONEs,x,x, &&
1594   program_transform_name=s,y,y,
1595
1596 echo "$as_me:$LINENO: checking host system type" >&5
1597 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1598 if test "${ac_cv_host+set}" = set; then
1599   echo $ECHO_N "(cached) $ECHO_C" >&6
1600 else
1601   ac_cv_host_alias=$host_alias
1602 test -z "$ac_cv_host_alias" &&
1603   ac_cv_host_alias=$ac_cv_build_alias
1604 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1605   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1606 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1607    { (exit 1); exit 1; }; }
1608
1609 fi
1610 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1611 echo "${ECHO_T}$ac_cv_host" >&6
1612 host=$ac_cv_host
1613 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1614 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1615 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1616
1617
1618 echo "$as_me:$LINENO: checking target system type" >&5
1619 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1620 if test "${ac_cv_target+set}" = set; then
1621   echo $ECHO_N "(cached) $ECHO_C" >&6
1622 else
1623   ac_cv_target_alias=$target_alias
1624 test "x$ac_cv_target_alias" = "x" &&
1625   ac_cv_target_alias=$ac_cv_host_alias
1626 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1627   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1628 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1629    { (exit 1); exit 1; }; }
1630
1631 fi
1632 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1633 echo "${ECHO_T}$ac_cv_target" >&6
1634 target=$ac_cv_target
1635 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1636 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1637 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1638
1639
1640 # The aliases save the names the user supplied, while $host etc.
1641 # will get canonicalized.
1642 test -n "$target_alias" &&
1643   test "$program_prefix$program_suffix$program_transform_name" = \
1644     NONENONEs,x,x, &&
1645   program_prefix=${target_alias}-
1646 test "$program_prefix" != NONE &&
1647   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1648 # Use a double $ so make ignores it.
1649 test "$program_suffix" != NONE &&
1650   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1651 # Double any \ or $.  echo might interpret backslashes.
1652 # By default was `s,x,x', remove it if useless.
1653 cat <<\_ACEOF >conftest.sed
1654 s/[\\$]/&&/g;s/;s,x,x,$//
1655 _ACEOF
1656 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1657 rm conftest.sed
1658
1659
1660
1661 # Get 'install' or 'install-sh' and its variants.
1662 # Find a good install program.  We prefer a C program (faster),
1663 # so one script is as good as another.  But avoid the broken or
1664 # incompatible versions:
1665 # SysV /etc/install, /usr/sbin/install
1666 # SunOS /usr/etc/install
1667 # IRIX /sbin/install
1668 # AIX /bin/install
1669 # AmigaOS /C/install, which installs bootblocks on floppy discs
1670 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1671 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1672 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1673 # OS/2's system install, which has a completely different semantic
1674 # ./install, which can be erroneously created by make from ./install.sh.
1675 # Reject install programs that cannot install multiple files.
1676 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1677 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1678 if test -z "$INSTALL"; then
1679 if test "${ac_cv_path_install+set}" = set; then
1680   echo $ECHO_N "(cached) $ECHO_C" >&6
1681 else
1682   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1683 for as_dir in $PATH
1684 do
1685   IFS=$as_save_IFS
1686   test -z "$as_dir" && as_dir=.
1687   # Account for people who put trailing slashes in PATH elements.
1688 case $as_dir/ in
1689   ./ | .// | /cC/* | \
1690   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1691   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1692   /usr/ucb/* ) ;;
1693   *)
1694     # OSF1 and SCO ODT 3.0 have their own names for install.
1695     # Don't use installbsd from OSF since it installs stuff as root
1696     # by default.
1697     for ac_prog in ginstall scoinst install; do
1698       for ac_exec_ext in '' $ac_executable_extensions; do
1699         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1700           if test $ac_prog = install &&
1701             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1702             # AIX install.  It has an incompatible calling convention.
1703             :
1704           elif test $ac_prog = install &&
1705             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1706             # program-specific install script used by HP pwplus--don't use.
1707             :
1708           else
1709             rm -rf conftest.one conftest.two conftest.dir
1710             echo one > conftest.one
1711             echo two > conftest.two
1712             mkdir conftest.dir
1713             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1714               test -s conftest.one && test -s conftest.two &&
1715               test -s conftest.dir/conftest.one &&
1716               test -s conftest.dir/conftest.two
1717             then
1718               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1719               break 3
1720             fi
1721           fi
1722         fi
1723       done
1724     done
1725     ;;
1726 esac
1727 done
1728
1729 rm -rf conftest.one conftest.two conftest.dir
1730
1731 fi
1732   if test "${ac_cv_path_install+set}" = set; then
1733     INSTALL=$ac_cv_path_install
1734   else
1735     # As a last resort, use the slow shell script.  Don't cache a
1736     # value for INSTALL within a source directory, because that will
1737     # break other packages using the cache if that directory is
1738     # removed, or if the value is a relative name.
1739     INSTALL=$ac_install_sh
1740   fi
1741 fi
1742 echo "$as_me:$LINENO: result: $INSTALL" >&5
1743 echo "${ECHO_T}$INSTALL" >&6
1744
1745 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1746 # It thinks the first close brace ends the variable substitution.
1747 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1748
1749 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1750
1751 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1752
1753 echo "$as_me:$LINENO: checking whether ln works" >&5
1754 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1755 if test "${acx_cv_prog_LN+set}" = set; then
1756   echo $ECHO_N "(cached) $ECHO_C" >&6
1757 else
1758   rm -f conftestdata_t
1759 echo >conftestdata_f
1760 if ln conftestdata_f conftestdata_t 2>/dev/null
1761 then
1762   acx_cv_prog_LN=ln
1763 else
1764   acx_cv_prog_LN=no
1765 fi
1766 rm -f conftestdata_f conftestdata_t
1767
1768 fi
1769 if test $acx_cv_prog_LN = no; then
1770   LN="cp"
1771   echo "$as_me:$LINENO: result: no, using $LN" >&5
1772 echo "${ECHO_T}no, using $LN" >&6
1773 else
1774   LN="$acx_cv_prog_LN"
1775   echo "$as_me:$LINENO: result: yes" >&5
1776 echo "${ECHO_T}yes" >&6
1777 fi
1778
1779 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1780 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1781 LN_S=$as_ln_s
1782 if test "$LN_S" = "ln -s"; then
1783   echo "$as_me:$LINENO: result: yes" >&5
1784 echo "${ECHO_T}yes" >&6
1785 else
1786   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1787 echo "${ECHO_T}no, using $LN_S" >&6
1788 fi
1789
1790
1791 ### we might need to use some other shell than /bin/sh for running subshells
1792 ### If we are on Windows, search for the shell.  This will permit people
1793 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1794 ### without also having to set CONFIG_SHELL.  This code will work when
1795 ### using bash, which sets OSTYPE.
1796 case "${OSTYPE}" in
1797 *win32*)
1798   if test x${CONFIG_SHELL} = x ; then
1799     if test ! -f /bin/sh ; then
1800       if test x${SHELL} != x && test -f ${SHELL} ; then
1801         CONFIG_SHELL=${SHELL}
1802         export CONFIG_SHELL
1803       else
1804         for prog in sh sh.exe bash bash.exe; do
1805           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1806           for dir in $PATH; do
1807             test -z "$dir" && dir=.
1808             if test -f $dir/$prog; then
1809               CONFIG_SHELL=$dir/$prog
1810               export CONFIG_SHELL
1811               break
1812             fi
1813           done
1814           IFS="$save_ifs"
1815           test -n "${CONFIG_SHELL}" && break
1816         done
1817       fi
1818     fi
1819   fi
1820   ;;
1821 esac
1822
1823 config_shell=${CONFIG_SHELL-/bin/sh}
1824
1825 moveifchange=${srcdir}/move-if-change
1826
1827 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1828
1829 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1830 # a relative path.
1831 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1832   INSTALL="${srcpwd}/install-sh -c"
1833 fi
1834
1835 # Set srcdir to "." if that's what it is.
1836 # This is important for multilib support.
1837 pwd=`${PWDCMD-pwd}`
1838 if test "${pwd}" = "${srcpwd}" ; then
1839   srcdir=.
1840 fi
1841
1842 topsrcdir=$srcpwd
1843
1844 extra_host_args=
1845
1846 ### To add a new directory to the tree, first choose whether it is a target
1847 ### or a host dependent tool.  Then put it into the appropriate list
1848 ### (library or tools, host or target), doing a dependency sort.
1849
1850 # Subdirs will be configured in the order listed in build_configdirs,
1851 # configdirs, or target_configdirs; see the serialization section below.
1852
1853 # Dependency sorting is only needed when *configuration* must be done in
1854 # a particular order.  In all cases a dependency should be specified in
1855 # the Makefile, whether or not it's implicitly specified here.
1856
1857 # Double entries in build_configdirs, configdirs, or target_configdirs may
1858 # cause circular dependencies and break everything horribly.
1859
1860 # these library is used by various programs built for the build
1861 # environment
1862 #
1863 build_libs="build-libiberty"
1864
1865 # these tools are built for the build environment
1866 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1867
1868 # these libraries are used by various programs built for the host environment
1869 #
1870 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1871
1872 # these tools are built for the host environment
1873 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1874 # know that we are building the simulator.
1875 # binutils, gas and ld appear in that order because it makes sense to run
1876 # "make check" in that particular order.
1877 # If --enable-gold is used, "gold" will replace "ld".
1878 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"
1879
1880 # libgcj represents the runtime libraries only used by gcj.
1881 libgcj="target-libffi \
1882         target-zlib \
1883         target-qthreads \
1884         target-libjava"
1885
1886 # these libraries are built for the target environment, and are built after
1887 # the host libraries and the host tools (which may be a cross compiler)
1888 #
1889 target_libraries="target-libgcc \
1890                 target-libiberty \
1891                 target-libgloss \
1892                 target-newlib \
1893                 target-libgomp \
1894                 target-libstdc++-v3 \
1895                 target-libmudflap \
1896                 target-libssp \
1897                 target-libgfortran \
1898                 target-boehm-gc \
1899                 ${libgcj} \
1900                 target-libobjc \
1901                 target-libada"
1902
1903 # these tools are built using the target libraries, and are intended to
1904 # run only in the target environment
1905 #
1906 # note: any program that *uses* libraries that are in the "target_libraries"
1907 # list belongs in this list.  those programs are also very likely
1908 # candidates for the "native_only" list which follows
1909 #
1910 target_tools="target-examples target-groff target-gperf target-rda"
1911
1912 ################################################################################
1913
1914 ## All tools belong in one of the four categories, and are assigned above
1915 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1916 ## is important because configure will choke if they ever get through.
1917 ## ${configdirs} is directories we build using the host tools.
1918 ## ${target_configdirs} is directories we build using the target tools.
1919 configdirs=`echo ${host_libs} ${host_tools}`
1920 target_configdirs=`echo ${target_libraries} ${target_tools}`
1921 build_configdirs=`echo ${build_libs} ${build_tools}`
1922
1923
1924
1925 ################################################################################
1926
1927 srcname="gnu development package"
1928
1929 # This gets set non-empty for some net releases of packages.
1930 appdirs=""
1931
1932 # Define is_cross_compiler to save on calls to 'test'.
1933 is_cross_compiler=
1934 if test x"${host}" = x"${target}" ; then
1935   is_cross_compiler=no
1936 else
1937   is_cross_compiler=yes
1938 fi
1939
1940 # Find the build and target subdir names.
1941
1942 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1943 # have matching libraries, they should use host libraries: Makefile.tpl
1944 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1945 # However, they still use the build modules, because the corresponding
1946 # host modules (e.g. bison) are only built for the host when bootstrap
1947 # finishes. So:
1948 # - build_subdir is where we find build modules, and never changes.
1949 # - build_libsubdir is where we find build libraries, and can be overridden.
1950
1951 # Prefix 'build-' so this never conflicts with target_subdir.
1952 build_subdir="build-${build_noncanonical}"
1953
1954 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1955 if test "${with_build_libsubdir+set}" = set; then
1956   withval="$with_build_libsubdir"
1957   build_libsubdir="$withval"
1958 else
1959   build_libsubdir="$build_subdir"
1960 fi;
1961 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1962 if ( test $srcdir = . && test -d gcc ) \
1963    || test -d $srcdir/../host-${host_noncanonical}; then
1964   host_subdir="host-${host_noncanonical}"
1965 else
1966   host_subdir=.
1967 fi
1968 # No prefix.
1969 target_subdir=${target_noncanonical}
1970
1971
1972 # Skipdirs are removed silently.
1973 skipdirs=
1974 # Noconfigdirs are removed loudly.
1975 noconfigdirs=""
1976
1977 use_gnu_ld=
1978 # Make sure we don't let GNU ld be added if we didn't want it.
1979 if test x$with_gnu_ld = xno ; then
1980   use_gnu_ld=no
1981   noconfigdirs="$noconfigdirs ld gold"
1982 fi
1983
1984 use_gnu_as=
1985 # Make sure we don't let GNU as be added if we didn't want it.
1986 if test x$with_gnu_as = xno ; then
1987   use_gnu_as=no
1988   noconfigdirs="$noconfigdirs gas"
1989 fi
1990
1991 # some tools are so dependent upon X11 that if we're not building with X,
1992 # it's not even worth trying to configure, much less build, that tool.
1993
1994 case ${with_x} in
1995   yes | "") ;; # the default value for this tree is that X11 is available
1996   no)
1997     skipdirs="${skipdirs} tk itcl libgui"
1998     # We won't be able to build gdbtk without X.
1999     enable_gdbtk=no
2000     ;;
2001   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2002 esac
2003
2004 # Some tools are only suitable for building in a "native" situation.
2005 # Remove these if host!=target.
2006 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"
2007
2008 # Similarly, some are only suitable for cross toolchains.
2009 # Remove these if host=target.
2010 cross_only="target-libgloss target-newlib target-opcodes"
2011
2012 case $is_cross_compiler in
2013   no) skipdirs="${skipdirs} ${cross_only}" ;;
2014   yes) skipdirs="${skipdirs} ${native_only}" ;;
2015 esac
2016
2017 # If both --with-headers and --with-libs are specified, default to
2018 # --without-newlib.
2019 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2020    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2021   if test x"${with_newlib}" = x ; then
2022     with_newlib=no
2023   fi
2024 fi
2025
2026 # Recognize --with-newlib/--without-newlib.
2027 case ${with_newlib} in
2028   no) skipdirs="${skipdirs} target-newlib" ;;
2029   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2030 esac
2031
2032 # Handle --enable-gold.
2033
2034 # Check whether --enable-gold or --disable-gold was given.
2035 if test "${enable_gold+set}" = set; then
2036   enableval="$enable_gold"
2037   ENABLE_GOLD=$enableval
2038 else
2039   ENABLE_GOLD=no
2040 fi;
2041 if test "${ENABLE_GOLD}" = "yes"; then
2042   # Check for ELF target.
2043   is_elf=no
2044   case "${target}" in
2045     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2046     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2047     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2048       case "${target}" in
2049         *-*-linux*aout* | *-*-linux*oldld*)
2050           ;;
2051         *)
2052           is_elf=yes
2053           ;;
2054       esac
2055   esac
2056
2057   if test "$is_elf" = "yes"; then
2058     # Check for target supported by gold.
2059     case "${target}" in
2060       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-*)
2061         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2062         ;;
2063     esac
2064   fi
2065 fi
2066
2067 # Configure extra directories which are host specific
2068
2069 case "${host}" in
2070   *-cygwin*)
2071     configdirs="$configdirs libtermcap" ;;
2072 esac
2073
2074 # A target can indicate whether a language isn't supported for some reason.
2075 # Only spaces may be used in this macro; not newlines or tabs.
2076 unsupported_languages=
2077
2078 # Remove more programs from consideration, based on the host or
2079 # target this usually means that a port of the program doesn't
2080 # exist yet.
2081
2082 case "${host}" in
2083   hppa*64*-*-*)
2084     noconfigdirs="$noconfigdirs byacc"
2085     ;;
2086   i[3456789]86-*-vsta)
2087     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2088     ;;
2089   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2090     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2091     ;;
2092   x86_64-*-mingw*)
2093     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2094     ;;
2095   i[3456789]86-*-mingw32*)
2096     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2097     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2098     ;;
2099   i[3456789]86-*-beos*)
2100     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2101     ;;
2102   *-*-cygwin*)
2103     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2104     ;;
2105   *-*-netbsd*)
2106     noconfigdirs="$noconfigdirs rcs"
2107     ;;
2108   ppc*-*-pe)
2109     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2110     ;;
2111   powerpc-*-beos*)
2112     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2113     ;;
2114 esac
2115
2116
2117 # Check whether --enable-libada or --disable-libada was given.
2118 if test "${enable_libada+set}" = set; then
2119   enableval="$enable_libada"
2120   ENABLE_LIBADA=$enableval
2121 else
2122   ENABLE_LIBADA=yes
2123 fi;
2124 if test "${ENABLE_LIBADA}" != "yes" ; then
2125   noconfigdirs="$noconfigdirs gnattools"
2126 fi
2127
2128 # Check whether --enable-libssp or --disable-libssp was given.
2129 if test "${enable_libssp+set}" = set; then
2130   enableval="$enable_libssp"
2131   ENABLE_LIBSSP=$enableval
2132 else
2133   ENABLE_LIBSSP=yes
2134 fi;
2135
2136 # Save it here so that, even in case of --enable-libgcj, if the Java
2137 # front-end isn't enabled, we still get libgcj disabled.
2138 libgcj_saved=$libgcj
2139 case $enable_libgcj in
2140 yes)
2141   # If we reset it here, it won't get added to noconfigdirs in the
2142   # target-specific build rules, so it will be forcibly enabled
2143   # (unless the Java language itself isn't enabled).
2144   libgcj=
2145   ;;
2146 no)
2147   # Make sure we get it printed in the list of not supported target libs.
2148   noconfigdirs="$noconfigdirs ${libgcj}"
2149   ;;
2150 esac
2151
2152
2153 # Disable libmudflap on some systems.
2154 if test x$enable_libmudflap = x ; then
2155     case "${target}" in
2156     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2157         # Enable libmudflap by default in GNU and friends.
2158         ;;
2159     *-*-freebsd*)
2160         # Enable libmudflap by default in FreeBSD.
2161         ;;
2162     *)
2163         # Disable it by default everywhere else.
2164         noconfigdirs="$noconfigdirs target-libmudflap"
2165         ;;
2166     esac
2167 fi
2168
2169 # Disable libgomp on non POSIX hosted systems.
2170 if test x$enable_libgomp = x ; then
2171     # Enable libgomp by default on hosted POSIX systems.
2172     case "${target}" in
2173     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2174         ;;
2175     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2176         ;;
2177     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2178         ;;
2179     *-*-darwin* | *-*-aix*)
2180         ;;
2181     *)
2182         noconfigdirs="$noconfigdirs target-libgomp"
2183         ;;
2184     esac
2185 fi
2186
2187 # Default libgloss CPU subdirectory.
2188 libgloss_dir="$target_cpu"
2189
2190 case "${target}" in
2191   *-*-chorusos)
2192     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2193     ;;
2194   powerpc-*-darwin* | i[3456789]86-*-darwin* | x86_64-*-darwin9*)
2195     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2196     noconfigdirs="$noconfigdirs sim target-rda"
2197     ;;
2198   *-*-darwin*)
2199     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2200     noconfigdirs="$noconfigdirs sim target-rda"
2201     noconfigdirs="$noconfigdirs ${libgcj}"
2202     ;;
2203   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2204     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2205     ;;
2206   *-*-freebsd*)
2207     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2208     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2209         && test -f /usr/local/include/gmp.h; then
2210       with_gmp=/usr/local
2211     fi
2212
2213     # Skip some stuff that's unsupported on some FreeBSD configurations.
2214     case "${target}" in
2215       i*86-*-*) ;;
2216       alpha*-*-*) ;;
2217       *)
2218         noconfigdirs="$noconfigdirs ${libgcj}"
2219         ;;
2220     esac
2221     ;;
2222   *-*-kaos*)
2223     # Remove unsupported stuff on all kaOS configurations.
2224     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2225     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2226     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2227     noconfigdirs="$noconfigdirs target-libgloss"
2228     ;;
2229   *-*-netbsd*)
2230     # Skip some stuff on all NetBSD configurations.
2231     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2232
2233     # Skip some stuff that's unsupported on some NetBSD configurations.
2234     case "${target}" in
2235       i*86-*-netbsdelf*) ;;
2236       arm*-*-netbsdelf*) ;;
2237       *)
2238         noconfigdirs="$noconfigdirs ${libgcj}"
2239         ;;
2240     esac
2241     ;;
2242   *-*-netware*)
2243     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2244     ;;
2245   *-*-rtems*)
2246     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2247     ;;
2248     # The tpf target doesn't support gdb yet.
2249   *-*-tpf*)
2250     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2251     ;;
2252   *-*-uclinux*)
2253     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2254     ;;
2255   *-*-vxworks*)
2256     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2257     ;;
2258   alpha*-dec-osf*)
2259     # ld works, but does not support shared libraries.
2260     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2261     # gas doesn't generate exception information.
2262     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2263     ;;
2264   alpha*-*-*vms*)
2265     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2266     ;;
2267   alpha*-*-linux*)
2268     # newlib is not 64 bit ready
2269     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2270     ;;
2271   alpha*-*-*)
2272     # newlib is not 64 bit ready
2273     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2274     ;;
2275   am33_2.0-*-linux*)
2276     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2277     ;;
2278   sh-*-linux*)
2279     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2280     ;;
2281   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2282     noconfigdirs="$noconfigdirs ${libgcj}"
2283     noconfigdirs="$noconfigdirs target-examples"
2284     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2285     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2286     noconfigdirs="$noconfigdirs expect dejagnu"
2287     # the C++ libraries don't build on top of CE's C libraries
2288     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2289     noconfigdirs="$noconfigdirs target-newlib"
2290     case "${host}" in
2291       *-*-cygwin*) ;; # keep gdb and readline
2292       *) noconfigdirs="$noconfigdirs gdb readline"
2293          ;;
2294     esac
2295     libgloss_dir=wince
2296     ;;
2297   arc-*-*)
2298     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2299     ;;
2300   arm-semi-aof )
2301     ;;
2302   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2303     noconfigdirs="$noconfigdirs ${libgcj}"
2304     libgloss_dir=arm
2305     ;;
2306   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2307     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2308     libgloss_dir=arm
2309     ;;
2310   arm*-*-linux-gnueabi)
2311     noconfigdirs="$noconfigdirs target-qthreads"
2312     case ${with_newlib} in
2313       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2314     esac
2315     libgloss_dir=arm
2316     ;;
2317   arm*-*-symbianelf*)
2318     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2319     libgloss_dir=arm
2320     ;;
2321   arm-*-pe*)
2322     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2323     ;;
2324   thumb-*-coff)
2325     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2326     ;;
2327   thumb-*-elf)
2328     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2329     ;;
2330   thumb-*-pe)
2331     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2332     ;;
2333   arm-*-riscix*)
2334     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2335     ;;
2336   avr-*-*)
2337     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2338     ;;
2339   bfin-*-*)
2340     noconfigdirs="$noconfigdirs gdb"
2341     if test x${is_cross_compiler} != xno ; then
2342       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2343     fi
2344     ;;
2345   c4x-*-* | tic4x-*-*)
2346     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2347     ;;
2348   c54x*-*-* | tic54x-*-*)
2349     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2350     ;;
2351   cr16-*-*)
2352     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2353     ;;
2354   cris-*-* | crisv32-*-*)
2355     unsupported_languages="$unsupported_languages java"
2356     case "${target}" in
2357       *-*-aout)
2358         unsupported_languages="$unsupported_languages fortran"
2359         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2360       *-*-elf)
2361         noconfigdirs="$noconfigdirs target-boehm-gc";;
2362       *-*-linux*)
2363         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2364       *)
2365         unsupported_languages="$unsupported_languages fortran"
2366         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2367     esac
2368     libgloss_dir=cris
2369     ;;
2370   crx-*-*)
2371     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2372     ;;
2373   d10v-*-*)
2374     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2375     ;;
2376   d30v-*-*)
2377     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2378     ;;
2379   ep9312-*-elf | ep9312-*-coff)
2380     libgloss_dir=arm
2381     ;;
2382   fr30-*-elf*)
2383     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2384     ;;
2385   frv-*-*)
2386     noconfigdirs="$noconfigdirs ${libgcj}"
2387     ;;
2388   h8300*-*-*)
2389     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2390     ;;
2391   h8500-*-*)
2392     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2393     ;;
2394   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2395     ;;
2396   hppa*64*-*-linux* | parisc*64*-*-linux*)
2397     # In this case, it's because the hppa64-linux target is for
2398     # the kernel only at this point and has no libc, and thus no
2399     # headers, crt*.o, etc., all of which are needed by these.
2400     noconfigdirs="$noconfigdirs target-zlib"
2401     ;;
2402   parisc*-*-linux* | hppa*-*-linux*)
2403     ;;
2404   hppa*-*-*elf* | \
2405   hppa*-*-lites* | \
2406   hppa*-*-openbsd* | \
2407   hppa*64*-*-*)
2408     noconfigdirs="$noconfigdirs ${libgcj}"
2409     ;;
2410   hppa*-hp-hpux11*)
2411     noconfigdirs="$noconfigdirs ld shellutils"
2412     ;;
2413   hppa*-*-pro*)
2414     libgloss_dir=pa
2415     ;;
2416   hppa*-*-*)
2417     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2418     # build on HP-UX 10.20.
2419     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2420     ;;
2421   i960-*-*)
2422     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2423     ;;
2424   ia64*-*-elf*)
2425     # No gdb support yet.
2426     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2427     ;;
2428   ia64*-**-hpux*)
2429     # No gdb or ld support yet.
2430     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2431     ;;
2432   i370-*-opened*)
2433     ;;
2434   i[3456789]86-*-coff | i[3456789]86-*-elf)
2435     noconfigdirs="$noconfigdirs ${libgcj}"
2436     libgloss_dir=i386
2437     ;;
2438   i[3456789]86-*-linux*)
2439     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2440     # not build java stuff by default.
2441     case "${target}" in
2442       *-*-*libc1*)
2443         noconfigdirs="$noconfigdirs ${libgcj}";;
2444     esac
2445
2446     # This section makes it possible to build newlib natively on linux.
2447     # If we are using a cross compiler then don't configure newlib.
2448     if test x${is_cross_compiler} != xno ; then
2449       noconfigdirs="$noconfigdirs target-newlib"
2450     fi
2451     noconfigdirs="$noconfigdirs target-libgloss"
2452     # If we are not using a cross compiler, do configure newlib.
2453     # Note however, that newlib will only be configured in this situation
2454     # if the --with-newlib option has been given, because otherwise
2455     # 'target-newlib' will appear in skipdirs.
2456     ;;
2457   i[3456789]86-*-mingw32*)
2458     target_configdirs="$target_configdirs target-winsup"
2459     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2460     ;;
2461   x86_64-*-mingw*)
2462     target_configdirs="$target_configdirs target-winsup"
2463     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2464     ;;
2465   *-*-cygwin*)
2466     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2467     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2468     # always build newlib if winsup directory is present.
2469     if test -d "$srcdir/winsup/cygwin"; then
2470       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2471     elif test -d "$srcdir/newlib"; then
2472       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2473     fi
2474     ;;
2475   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2476   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2477     ;;
2478   i[3456789]86-*-pe)
2479     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2480     ;;
2481   i[3456789]86-*-sco3.2v5*)
2482     # The linker does not yet know about weak symbols in COFF,
2483     # and is not configured to handle mixed ELF and COFF.
2484     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2485     ;;
2486   i[3456789]86-*-sco*)
2487     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2488     ;;
2489   i[3456789]86-*-solaris2*)
2490     noconfigdirs="$noconfigdirs target-libgloss"
2491     ;;
2492   i[3456789]86-*-sysv4*)
2493     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2494     ;;
2495   i[3456789]86-*-beos*)
2496     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2497     ;;
2498   i[3456789]86-*-rdos*)
2499     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2500     ;;
2501   m32r-*-*)
2502     noconfigdirs="$noconfigdirs ${libgcj}"
2503     ;;
2504   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2505     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2506     libgloss_dir=m68hc11
2507     ;;
2508   m68k-*-elf*)
2509     noconfigdirs="$noconfigdirs ${libgcj}"
2510     ;;
2511   m68k-*-coff*)
2512     noconfigdirs="$noconfigdirs ${libgcj}"
2513     ;;
2514   m68*-*-* | fido-*-*)
2515     libgloss_dir=m68k
2516     ;;
2517   mcore-*-pe*)
2518   # The EPOC C++ environment does not support exceptions or rtti,
2519   # and so building libstdc++-v3 tends not to always work.
2520     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2521     ;;
2522   mmix-*-*)
2523     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2524     unsupported_languages="$unsupported_languages fortran java"
2525     ;;
2526   mn10200-*-*)
2527     noconfigdirs="$noconfigdirs ${libgcj}"
2528     ;;
2529   mn10300-*-*)
2530     noconfigdirs="$noconfigdirs ${libgcj}"
2531     ;;
2532   mt-*-*)
2533     noconfigdirs="$noconfigdirs sim"
2534     ;;
2535   powerpc-*-aix*)
2536     # copied from rs6000-*-* entry
2537     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2538     ;;
2539   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2540     target_configdirs="$target_configdirs target-winsup"
2541     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2542     # always build newlib.
2543     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2544     ;;
2545     # This is temporary until we can link against shared libraries
2546   powerpcle-*-solaris*)
2547     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2548     libgloss_dir=rs6000
2549     ;;
2550   powerpc-*-beos*)
2551     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2552     ;;
2553   powerpc-*-eabi)
2554     noconfigdirs="$noconfigdirs ${libgcj}"
2555     libgloss_dir=rs6000
2556     ;;
2557   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2558     libgloss_dir=rs6000
2559     ;;
2560   rs6000-*-lynxos*)
2561     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2562     ;;
2563   rs6000-*-aix*)
2564     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2565     ;;
2566   rs6000-*-*)
2567     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2568     ;;
2569   m68k-apollo-*)
2570     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2571     ;;
2572   mips*-sde-elf*)
2573     skipdirs="$skipdirs target-libiberty"
2574     noconfigdirs="$noconfigdirs ${libgcj}"
2575     if test x$with_newlib = xyes; then
2576       noconfigdirs="$noconfigdirs gprof"
2577     fi
2578     libgloss_dir=mips
2579     ;;
2580   mips*-*-irix5*)
2581     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2582     ;;
2583   mips*-*-irix6*)
2584     # Linking libjava exceeds command-line length limits on at least
2585     # IRIX 6.2, but not on IRIX 6.5.
2586     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2587     # <oldham@codesourcery.com>
2588     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2589     ;;
2590   mips*-*-bsd*)
2591     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2592     ;;
2593   mips*-*-linux*)
2594     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2595     ;;
2596   mips*-*-*)
2597     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2598     libgloss_dir=mips
2599     ;;
2600   romp-*-*)
2601     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2602     ;;
2603   sh-*-* | sh64-*-*)
2604     case "${host}" in
2605       i[3456789]86-*-vsta) ;; # don't add gprof back in
2606       i[3456789]86-*-go32*) ;; # don't add gprof back in
2607       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2608       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2609     esac
2610     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2611     ;;
2612   sparclet-*-aout* | sparc86x-*-*)
2613     libgloss_dir=sparc
2614     ;;
2615   sparc-*-elf*)
2616     noconfigdirs="$noconfigdirs ${libgcj}"
2617     ;;
2618   sparc64-*-elf*)
2619     noconfigdirs="$noconfigdirs ${libgcj}"
2620     libgloss_dir=sparc
2621     ;;
2622   sparclite-*-*)
2623     noconfigdirs="$noconfigdirs ${libgcj}"
2624     libgloss_dir=sparc
2625     ;;
2626   sparc-*-sunos4*)
2627     noconfigdirs="$noconfigdirs ${libgcj}"
2628     if test x${is_cross_compiler} != xno ; then
2629            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2630     else
2631            use_gnu_ld=no
2632     fi
2633     ;;
2634   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2635     noconfigdirs="$noconfigdirs ${libgcj}"
2636     ;;
2637   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2638     ;;
2639   spu-*-*)
2640     skipdirs="target-libssp"
2641     ;;
2642   v810-*-*)
2643     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2644     ;;
2645   v850-*-*)
2646     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2647     ;;
2648   v850e-*-*)
2649     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2650     ;;
2651   v850ea-*-*)
2652     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2653     ;;
2654   vax-*-vms)
2655     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2656     ;;
2657   vax-*-*)
2658     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2659     ;;
2660   xtensa*-*-*)
2661     noconfigdirs="$noconfigdirs ${libgcj}"
2662     ;;
2663   ip2k-*-*)
2664     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2665     ;;
2666   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2667     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2668     ;;
2669   *-*-lynxos*)
2670     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2671     ;;
2672   *-*-*)
2673     noconfigdirs="$noconfigdirs ${libgcj}"
2674     ;;
2675 esac
2676
2677 # If we aren't building newlib, then don't build libgloss, since libgloss
2678 # depends upon some newlib header files.
2679 case "${noconfigdirs}" in
2680   *target-libgloss*) ;;
2681   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2682 esac
2683
2684 # Work in distributions that contain no compiler tools, like Autoconf.
2685 tentative_cc=""
2686 host_makefile_frag=/dev/null
2687 if test -d ${srcdir}/config ; then
2688 case "${host}" in
2689   m68k-hp-hpux*)
2690     # Avoid "too much defining" errors from HPUX compiler.
2691     tentative_cc="cc -Wp,-H256000"
2692     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2693     # If it's HP/UX ar, this should be harmless.
2694     RANLIB="ar ts"
2695     ;;
2696   m68k-apollo-sysv*)
2697     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2698     ;;
2699   m68k-apollo-bsd*)
2700     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2701     # chokes on bfd, the compiler won't let you assign integers to enums, and
2702     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2703     # the apollo compiler" (the preferred version of GCC could be called cc,
2704     # or whatever), but I'm not sure leaving CC as cc is any better...
2705     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2706     # Used to have BISON=yacc.
2707     tentative_cc=gcc
2708     ;;
2709   m88k-dg-dgux*)
2710     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2711     ;;
2712   m88k-harris-cxux*)
2713     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2714     tentative_cc="cc -Xa"
2715     host_makefile_frag="config/mh-cxux"
2716     ;;
2717   m88k-motorola-sysv*)
2718     ;;
2719   mips*-dec-ultrix*)
2720     tentative_cc="cc -Wf,-XNg1000"
2721     host_makefile_frag="config/mh-decstation"
2722     ;;
2723   mips*-nec-sysv4*)
2724     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2725     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2726     host_makefile_frag="config/mh-necv4"
2727     ;;
2728   mips*-sgi-irix4*)
2729     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2730     # environment.  Also bump switch table size so that cp-parse will
2731     # compile.  Bump string length limit so linker builds.
2732     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2733     ;;
2734   mips*-*-sysv4*)
2735     host_makefile_frag="config/mh-sysv4"
2736     ;;
2737   mips*-*-sysv*)
2738     # This is for a MIPS running RISC/os 4.52C.
2739
2740     # This is needed for GDB, but needs to be in the top-level make because
2741     # if a library is compiled with the bsd headers and gets linked with the
2742     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2743     # a different size).
2744     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2745     # known except to select the sysv environment.  Could we use /proc instead?
2746     # These "sysv environments" and "bsd environments" often end up being a pain.
2747     #
2748     # This is not part of CFLAGS because perhaps not all C compilers have this
2749     # option.
2750     tentative_cc="cc -systype sysv"
2751     ;;
2752   i370-ibm-opened*)
2753     tentative_cc="c89"
2754     ;;
2755   i[3456789]86-*-sysv5*)
2756     host_makefile_frag="config/mh-sysv5"
2757     ;;
2758   i[3456789]86-*-dgux*)
2759     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2760     host_makefile_frag="config/mh-dgux386"
2761     ;;
2762   i[3456789]86-ncr-sysv4.3*)
2763     # The MetaWare compiler will generate a copyright message unless you
2764     # turn it off by adding the -Hnocopyr flag.
2765     tentative_cc="cc -Hnocopyr"
2766     ;;
2767   i[3456789]86-ncr-sysv4*)
2768     # for an NCR 3000 (i486/SVR4) system.
2769     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2770     # This compiler not only emits obnoxious copyright messages every time
2771     # you run it, but it chokes and dies on a whole bunch of GNU source
2772     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2773     tentative_cc="/usr/ccs/ATT/cc"
2774     host_makefile_frag="config/mh-ncr3000"
2775     ;;
2776   i[3456789]86-*-sco3.2v5*)
2777     ;;
2778   i[3456789]86-*-sco*)
2779     # The native C compiler botches some simple uses of const.  Unfortunately,
2780     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2781     tentative_cc="cc -Dconst="
2782     host_makefile_frag="config/mh-sco"
2783     ;;
2784   i[3456789]86-*-udk*)
2785     host_makefile_frag="config/mh-sysv5"
2786     ;;
2787   i[3456789]86-*-solaris2*)
2788     host_makefile_frag="config/mh-sysv4"
2789     ;;
2790   i[3456789]86-*-msdosdjgpp*)
2791     host_makefile_frag="config/mh-djgpp"
2792     ;;
2793   *-cygwin*)
2794
2795 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2796 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2797 echo a >cygwin-cat-check
2798 if test `cat cygwin-cat-check` == a ; then
2799   rm cygwin-cat-check
2800   echo "$as_me:$LINENO: result: yes" >&5
2801 echo "${ECHO_T}yes" >&6
2802 else
2803   rm cygwin-cat-check
2804   echo "$as_me:$LINENO: result: no" >&5
2805 echo "${ECHO_T}no" >&6
2806   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2807   Please either mount the build directory in binary mode or run the following
2808   commands before running any configure script:
2809 set -o igncr
2810 export SHELLOPTS
2811   " >&5
2812 echo "$as_me: error: The cat command does not ignore carriage return characters.
2813   Please either mount the build directory in binary mode or run the following
2814   commands before running any configure script:
2815 set -o igncr
2816 export SHELLOPTS
2817   " >&2;}
2818    { (exit 1); exit 1; }; }
2819 fi
2820
2821     host_makefile_frag="config/mh-cygwin"
2822     ;;
2823   *-mingw*)
2824     host_makefile_frag="config/mh-mingw"
2825     ;;
2826   *-interix*)
2827     host_makefile_frag="config/mh-interix"
2828     ;;
2829   vax-*-ultrix2*)
2830     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2831     tentative_cc=gcc
2832     ;;
2833   *-*-solaris2*)
2834     host_makefile_frag="config/mh-solaris"
2835     ;;
2836   m68k-sun-sunos*)
2837     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2838     # without overflowing the jump tables (-J says to use a 32 bit table)
2839     tentative_cc="cc -J"
2840     ;;
2841   *-hp-hpux*)
2842     tentative_cc="cc -Wp,-H256000"
2843     ;;
2844   *-*-hiux*)
2845     tentative_cc="cc -Wp,-H256000"
2846     ;;
2847   rs6000-*-lynxos*)
2848     # /bin/cc is less than useful for our purposes.  Always use GCC
2849     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2850     host_makefile_frag="config/mh-lynxrs6k"
2851     ;;
2852   powerpc-*-darwin*)
2853     host_makefile_frag="config/mh-ppc-darwin"
2854     ;;
2855   powerpc-*-aix*)
2856     host_makefile_frag="config/mh-ppc-aix"
2857     ;;
2858   rs6000-*-aix*)
2859     host_makefile_frag="config/mh-ppc-aix"
2860     ;;
2861   *-*-lynxos*)
2862     # /bin/cc is less than useful for our purposes.  Always use GCC
2863     tentative_cc="/bin/gcc"
2864     ;;
2865   *-*-sysv4*)
2866     host_makefile_frag="config/mh-sysv4"
2867     ;;
2868   # This is placed last to prevent interfering with the cases above.
2869   i[3456789]86-*-*)
2870     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2871     host_makefile_frag="config/mh-x86omitfp"
2872     ;;
2873 esac
2874 fi
2875
2876 # If we aren't going to be using gcc, see if we can extract a definition
2877 # of CC from the fragment.
2878 # Actually, use the 'pre-extracted' version above.
2879 if test -z "${CC}" && test "${build}" = "${host}" ; then
2880   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2881   found=
2882   for dir in $PATH; do
2883     test -z "$dir" && dir=.
2884     if test -f $dir/gcc; then
2885       found=yes
2886       break
2887     fi
2888   done
2889   IFS="$save_ifs"
2890   if test -z "${found}" && test -n "${tentative_cc}" ; then
2891     CC=$tentative_cc
2892   fi
2893 fi
2894
2895 if test "${build}" != "${host}" ; then
2896   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2897   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2898   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2899   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2900   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2901   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2902   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2903   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2904   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2905   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2906   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2907   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2908 else
2909   AR_FOR_BUILD="\$(AR)"
2910   AS_FOR_BUILD="\$(AS)"
2911   CC_FOR_BUILD="\$(CC)"
2912   CXX_FOR_BUILD="\$(CXX)"
2913   GCJ_FOR_BUILD="\$(GCJ)"
2914   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2915   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2916   LD_FOR_BUILD="\$(LD)"
2917   NM_FOR_BUILD="\$(NM)"
2918   RANLIB_FOR_BUILD="\$(RANLIB)"
2919   WINDRES_FOR_BUILD="\$(WINDRES)"
2920   WINDMC_FOR_BUILD="\$(WINDMC)"
2921 fi
2922
2923 ac_ext=c
2924 ac_cpp='$CPP $CPPFLAGS'
2925 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2926 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2927 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2928 if test -n "$ac_tool_prefix"; then
2929   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2930 set dummy ${ac_tool_prefix}gcc; 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 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2940 for as_dir in $PATH
2941 do
2942   IFS=$as_save_IFS
2943   test -z "$as_dir" && as_dir=.
2944   for ac_exec_ext in '' $ac_executable_extensions; do
2945   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2946     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2947     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2948     break 2
2949   fi
2950 done
2951 done
2952
2953 fi
2954 fi
2955 CC=$ac_cv_prog_CC
2956 if test -n "$CC"; then
2957   echo "$as_me:$LINENO: result: $CC" >&5
2958 echo "${ECHO_T}$CC" >&6
2959 else
2960   echo "$as_me:$LINENO: result: no" >&5
2961 echo "${ECHO_T}no" >&6
2962 fi
2963
2964 fi
2965 if test -z "$ac_cv_prog_CC"; then
2966   ac_ct_CC=$CC
2967   # Extract the first word of "gcc", so it can be a program name with args.
2968 set dummy gcc; ac_word=$2
2969 echo "$as_me:$LINENO: checking for $ac_word" >&5
2970 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2971 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2972   echo $ECHO_N "(cached) $ECHO_C" >&6
2973 else
2974   if test -n "$ac_ct_CC"; then
2975   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2976 else
2977 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2978 for as_dir in $PATH
2979 do
2980   IFS=$as_save_IFS
2981   test -z "$as_dir" && as_dir=.
2982   for ac_exec_ext in '' $ac_executable_extensions; do
2983   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2984     ac_cv_prog_ac_ct_CC="gcc"
2985     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2986     break 2
2987   fi
2988 done
2989 done
2990
2991 fi
2992 fi
2993 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2994 if test -n "$ac_ct_CC"; then
2995   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2996 echo "${ECHO_T}$ac_ct_CC" >&6
2997 else
2998   echo "$as_me:$LINENO: result: no" >&5
2999 echo "${ECHO_T}no" >&6
3000 fi
3001
3002   CC=$ac_ct_CC
3003 else
3004   CC="$ac_cv_prog_CC"
3005 fi
3006
3007 if test -z "$CC"; then
3008   if test -n "$ac_tool_prefix"; then
3009   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3010 set dummy ${ac_tool_prefix}cc; ac_word=$2
3011 echo "$as_me:$LINENO: checking for $ac_word" >&5
3012 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3013 if test "${ac_cv_prog_CC+set}" = set; then
3014   echo $ECHO_N "(cached) $ECHO_C" >&6
3015 else
3016   if test -n "$CC"; then
3017   ac_cv_prog_CC="$CC" # Let the user override the test.
3018 else
3019 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3020 for as_dir in $PATH
3021 do
3022   IFS=$as_save_IFS
3023   test -z "$as_dir" && as_dir=.
3024   for ac_exec_ext in '' $ac_executable_extensions; do
3025   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3026     ac_cv_prog_CC="${ac_tool_prefix}cc"
3027     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3028     break 2
3029   fi
3030 done
3031 done
3032
3033 fi
3034 fi
3035 CC=$ac_cv_prog_CC
3036 if test -n "$CC"; then
3037   echo "$as_me:$LINENO: result: $CC" >&5
3038 echo "${ECHO_T}$CC" >&6
3039 else
3040   echo "$as_me:$LINENO: result: no" >&5
3041 echo "${ECHO_T}no" >&6
3042 fi
3043
3044 fi
3045 if test -z "$ac_cv_prog_CC"; then
3046   ac_ct_CC=$CC
3047   # Extract the first word of "cc", so it can be a program name with args.
3048 set dummy cc; ac_word=$2
3049 echo "$as_me:$LINENO: checking for $ac_word" >&5
3050 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3051 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3052   echo $ECHO_N "(cached) $ECHO_C" >&6
3053 else
3054   if test -n "$ac_ct_CC"; then
3055   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3056 else
3057 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3058 for as_dir in $PATH
3059 do
3060   IFS=$as_save_IFS
3061   test -z "$as_dir" && as_dir=.
3062   for ac_exec_ext in '' $ac_executable_extensions; do
3063   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3064     ac_cv_prog_ac_ct_CC="cc"
3065     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3066     break 2
3067   fi
3068 done
3069 done
3070
3071 fi
3072 fi
3073 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3074 if test -n "$ac_ct_CC"; then
3075   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3076 echo "${ECHO_T}$ac_ct_CC" >&6
3077 else
3078   echo "$as_me:$LINENO: result: no" >&5
3079 echo "${ECHO_T}no" >&6
3080 fi
3081
3082   CC=$ac_ct_CC
3083 else
3084   CC="$ac_cv_prog_CC"
3085 fi
3086
3087 fi
3088 if test -z "$CC"; then
3089   # Extract the first word of "cc", so it can be a program name with args.
3090 set dummy cc; ac_word=$2
3091 echo "$as_me:$LINENO: checking for $ac_word" >&5
3092 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3093 if test "${ac_cv_prog_CC+set}" = set; then
3094   echo $ECHO_N "(cached) $ECHO_C" >&6
3095 else
3096   if test -n "$CC"; then
3097   ac_cv_prog_CC="$CC" # Let the user override the test.
3098 else
3099   ac_prog_rejected=no
3100 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3101 for as_dir in $PATH
3102 do
3103   IFS=$as_save_IFS
3104   test -z "$as_dir" && as_dir=.
3105   for ac_exec_ext in '' $ac_executable_extensions; do
3106   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3107     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3108        ac_prog_rejected=yes
3109        continue
3110      fi
3111     ac_cv_prog_CC="cc"
3112     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3113     break 2
3114   fi
3115 done
3116 done
3117
3118 if test $ac_prog_rejected = yes; then
3119   # We found a bogon in the path, so make sure we never use it.
3120   set dummy $ac_cv_prog_CC
3121   shift
3122   if test $# != 0; then
3123     # We chose a different compiler from the bogus one.
3124     # However, it has the same basename, so the bogon will be chosen
3125     # first if we set CC to just the basename; use the full file name.
3126     shift
3127     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3128   fi
3129 fi
3130 fi
3131 fi
3132 CC=$ac_cv_prog_CC
3133 if test -n "$CC"; then
3134   echo "$as_me:$LINENO: result: $CC" >&5
3135 echo "${ECHO_T}$CC" >&6
3136 else
3137   echo "$as_me:$LINENO: result: no" >&5
3138 echo "${ECHO_T}no" >&6
3139 fi
3140
3141 fi
3142 if test -z "$CC"; then
3143   if test -n "$ac_tool_prefix"; then
3144   for ac_prog in cl
3145   do
3146     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3147 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3148 echo "$as_me:$LINENO: checking for $ac_word" >&5
3149 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3150 if test "${ac_cv_prog_CC+set}" = set; then
3151   echo $ECHO_N "(cached) $ECHO_C" >&6
3152 else
3153   if test -n "$CC"; then
3154   ac_cv_prog_CC="$CC" # Let the user override the test.
3155 else
3156 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3157 for as_dir in $PATH
3158 do
3159   IFS=$as_save_IFS
3160   test -z "$as_dir" && as_dir=.
3161   for ac_exec_ext in '' $ac_executable_extensions; do
3162   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3163     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3164     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3165     break 2
3166   fi
3167 done
3168 done
3169
3170 fi
3171 fi
3172 CC=$ac_cv_prog_CC
3173 if test -n "$CC"; then
3174   echo "$as_me:$LINENO: result: $CC" >&5
3175 echo "${ECHO_T}$CC" >&6
3176 else
3177   echo "$as_me:$LINENO: result: no" >&5
3178 echo "${ECHO_T}no" >&6
3179 fi
3180
3181     test -n "$CC" && break
3182   done
3183 fi
3184 if test -z "$CC"; then
3185   ac_ct_CC=$CC
3186   for ac_prog in cl
3187 do
3188   # Extract the first word of "$ac_prog", so it can be a program name with args.
3189 set dummy $ac_prog; ac_word=$2
3190 echo "$as_me:$LINENO: checking for $ac_word" >&5
3191 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3192 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3193   echo $ECHO_N "(cached) $ECHO_C" >&6
3194 else
3195   if test -n "$ac_ct_CC"; then
3196   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3197 else
3198 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3199 for as_dir in $PATH
3200 do
3201   IFS=$as_save_IFS
3202   test -z "$as_dir" && as_dir=.
3203   for ac_exec_ext in '' $ac_executable_extensions; do
3204   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3205     ac_cv_prog_ac_ct_CC="$ac_prog"
3206     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3207     break 2
3208   fi
3209 done
3210 done
3211
3212 fi
3213 fi
3214 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3215 if test -n "$ac_ct_CC"; then
3216   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3217 echo "${ECHO_T}$ac_ct_CC" >&6
3218 else
3219   echo "$as_me:$LINENO: result: no" >&5
3220 echo "${ECHO_T}no" >&6
3221 fi
3222
3223   test -n "$ac_ct_CC" && break
3224 done
3225
3226   CC=$ac_ct_CC
3227 fi
3228
3229 fi
3230
3231
3232 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3233 See \`config.log' for more details." >&5
3234 echo "$as_me: error: no acceptable C compiler found in \$PATH
3235 See \`config.log' for more details." >&2;}
3236    { (exit 1); exit 1; }; }
3237
3238 # Provide some information about the compiler.
3239 echo "$as_me:$LINENO:" \
3240      "checking for C compiler version" >&5
3241 ac_compiler=`set X $ac_compile; echo $2`
3242 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3243   (eval $ac_compiler --version </dev/null >&5) 2>&5
3244   ac_status=$?
3245   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3246   (exit $ac_status); }
3247 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3248   (eval $ac_compiler -v </dev/null >&5) 2>&5
3249   ac_status=$?
3250   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3251   (exit $ac_status); }
3252 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3253   (eval $ac_compiler -V </dev/null >&5) 2>&5
3254   ac_status=$?
3255   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3256   (exit $ac_status); }
3257
3258 cat >conftest.$ac_ext <<_ACEOF
3259 /* confdefs.h.  */
3260 _ACEOF
3261 cat confdefs.h >>conftest.$ac_ext
3262 cat >>conftest.$ac_ext <<_ACEOF
3263 /* end confdefs.h.  */
3264
3265 int
3266 main ()
3267 {
3268
3269   ;
3270   return 0;
3271 }
3272 _ACEOF
3273 ac_clean_files_save=$ac_clean_files
3274 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3275 # Try to create an executable without -o first, disregard a.out.
3276 # It will help us diagnose broken compilers, and finding out an intuition
3277 # of exeext.
3278 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3279 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3280 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3281 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3282   (eval $ac_link_default) 2>&5
3283   ac_status=$?
3284   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3285   (exit $ac_status); }; then
3286   # Find the output, starting from the most likely.  This scheme is
3287 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3288 # resort.
3289
3290 # Be careful to initialize this variable, since it used to be cached.
3291 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3292 ac_cv_exeext=
3293 # b.out is created by i960 compilers.
3294 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3295 do
3296   test -f "$ac_file" || continue
3297   case $ac_file in
3298     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3299         ;;
3300     conftest.$ac_ext )
3301         # This is the source file.
3302         ;;
3303     [ab].out )
3304         # We found the default executable, but exeext='' is most
3305         # certainly right.
3306         break;;
3307     *.* )
3308         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3309         # FIXME: I believe we export ac_cv_exeext for Libtool,
3310         # but it would be cool to find out if it's true.  Does anybody
3311         # maintain Libtool? --akim.
3312         export ac_cv_exeext
3313         break;;
3314     * )
3315         break;;
3316   esac
3317 done
3318 else
3319   echo "$as_me: failed program was:" >&5
3320 sed 's/^/| /' conftest.$ac_ext >&5
3321
3322 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3323 See \`config.log' for more details." >&5
3324 echo "$as_me: error: C compiler cannot create executables
3325 See \`config.log' for more details." >&2;}
3326    { (exit 77); exit 77; }; }
3327 fi
3328
3329 ac_exeext=$ac_cv_exeext
3330 echo "$as_me:$LINENO: result: $ac_file" >&5
3331 echo "${ECHO_T}$ac_file" >&6
3332
3333 # Check the compiler produces executables we can run.  If not, either
3334 # the compiler is broken, or we cross compile.
3335 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3336 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3337 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3338 # If not cross compiling, check that we can run a simple program.
3339 if test "$cross_compiling" != yes; then
3340   if { ac_try='./$ac_file'
3341   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3342   (eval $ac_try) 2>&5
3343   ac_status=$?
3344   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3345   (exit $ac_status); }; }; then
3346     cross_compiling=no
3347   else
3348     if test "$cross_compiling" = maybe; then
3349         cross_compiling=yes
3350     else
3351         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3352 If you meant to cross compile, use \`--host'.
3353 See \`config.log' for more details." >&5
3354 echo "$as_me: error: cannot run C compiled programs.
3355 If you meant to cross compile, use \`--host'.
3356 See \`config.log' for more details." >&2;}
3357    { (exit 1); exit 1; }; }
3358     fi
3359   fi
3360 fi
3361 echo "$as_me:$LINENO: result: yes" >&5
3362 echo "${ECHO_T}yes" >&6
3363
3364 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3365 ac_clean_files=$ac_clean_files_save
3366 # Check the compiler produces executables we can run.  If not, either
3367 # the compiler is broken, or we cross compile.
3368 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3369 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3370 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3371 echo "${ECHO_T}$cross_compiling" >&6
3372
3373 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3374 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3375 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3376   (eval $ac_link) 2>&5
3377   ac_status=$?
3378   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3379   (exit $ac_status); }; then
3380   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3381 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3382 # work properly (i.e., refer to `conftest.exe'), while it won't with
3383 # `rm'.
3384 for ac_file in conftest.exe conftest conftest.*; do
3385   test -f "$ac_file" || continue
3386   case $ac_file in
3387     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3388     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3389           export ac_cv_exeext
3390           break;;
3391     * ) break;;
3392   esac
3393 done
3394 else
3395   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3396 See \`config.log' for more details." >&5
3397 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3398 See \`config.log' for more details." >&2;}
3399    { (exit 1); exit 1; }; }
3400 fi
3401
3402 rm -f conftest$ac_cv_exeext
3403 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3404 echo "${ECHO_T}$ac_cv_exeext" >&6
3405
3406 rm -f conftest.$ac_ext
3407 EXEEXT=$ac_cv_exeext
3408 ac_exeext=$EXEEXT
3409 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3410 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3411 if test "${ac_cv_objext+set}" = set; then
3412   echo $ECHO_N "(cached) $ECHO_C" >&6
3413 else
3414   cat >conftest.$ac_ext <<_ACEOF
3415 /* confdefs.h.  */
3416 _ACEOF
3417 cat confdefs.h >>conftest.$ac_ext
3418 cat >>conftest.$ac_ext <<_ACEOF
3419 /* end confdefs.h.  */
3420
3421 int
3422 main ()
3423 {
3424
3425   ;
3426   return 0;
3427 }
3428 _ACEOF
3429 rm -f conftest.o conftest.obj
3430 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3431   (eval $ac_compile) 2>&5
3432   ac_status=$?
3433   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3434   (exit $ac_status); }; then
3435   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3436   case $ac_file in
3437     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3438     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3439        break;;
3440   esac
3441 done
3442 else
3443   echo "$as_me: failed program was:" >&5
3444 sed 's/^/| /' conftest.$ac_ext >&5
3445
3446 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3447 See \`config.log' for more details." >&5
3448 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3449 See \`config.log' for more details." >&2;}
3450    { (exit 1); exit 1; }; }
3451 fi
3452
3453 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3454 fi
3455 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3456 echo "${ECHO_T}$ac_cv_objext" >&6
3457 OBJEXT=$ac_cv_objext
3458 ac_objext=$OBJEXT
3459 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3460 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3461 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3462   echo $ECHO_N "(cached) $ECHO_C" >&6
3463 else
3464   cat >conftest.$ac_ext <<_ACEOF
3465 /* confdefs.h.  */
3466 _ACEOF
3467 cat confdefs.h >>conftest.$ac_ext
3468 cat >>conftest.$ac_ext <<_ACEOF
3469 /* end confdefs.h.  */
3470
3471 int
3472 main ()
3473 {
3474 #ifndef __GNUC__
3475        choke me
3476 #endif
3477
3478   ;
3479   return 0;
3480 }
3481 _ACEOF
3482 rm -f conftest.$ac_objext
3483 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3484   (eval $ac_compile) 2>conftest.er1
3485   ac_status=$?
3486   grep -v '^ *+' conftest.er1 >conftest.err
3487   rm -f conftest.er1
3488   cat conftest.err >&5
3489   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3490   (exit $ac_status); } &&
3491          { ac_try='test -z "$ac_c_werror_flag"
3492                          || test ! -s conftest.err'
3493   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3494   (eval $ac_try) 2>&5
3495   ac_status=$?
3496   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3497   (exit $ac_status); }; } &&
3498          { ac_try='test -s conftest.$ac_objext'
3499   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3500   (eval $ac_try) 2>&5
3501   ac_status=$?
3502   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3503   (exit $ac_status); }; }; then
3504   ac_compiler_gnu=yes
3505 else
3506   echo "$as_me: failed program was:" >&5
3507 sed 's/^/| /' conftest.$ac_ext >&5
3508
3509 ac_compiler_gnu=no
3510 fi
3511 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3512 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3513
3514 fi
3515 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3516 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3517 GCC=`test $ac_compiler_gnu = yes && echo yes`
3518 ac_test_CFLAGS=${CFLAGS+set}
3519 ac_save_CFLAGS=$CFLAGS
3520 CFLAGS="-g"
3521 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3522 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3523 if test "${ac_cv_prog_cc_g+set}" = set; then
3524   echo $ECHO_N "(cached) $ECHO_C" >&6
3525 else
3526   cat >conftest.$ac_ext <<_ACEOF
3527 /* confdefs.h.  */
3528 _ACEOF
3529 cat confdefs.h >>conftest.$ac_ext
3530 cat >>conftest.$ac_ext <<_ACEOF
3531 /* end confdefs.h.  */
3532
3533 int
3534 main ()
3535 {
3536
3537   ;
3538   return 0;
3539 }
3540 _ACEOF
3541 rm -f conftest.$ac_objext
3542 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3543   (eval $ac_compile) 2>conftest.er1
3544   ac_status=$?
3545   grep -v '^ *+' conftest.er1 >conftest.err
3546   rm -f conftest.er1
3547   cat conftest.err >&5
3548   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3549   (exit $ac_status); } &&
3550          { ac_try='test -z "$ac_c_werror_flag"
3551                          || test ! -s conftest.err'
3552   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3553   (eval $ac_try) 2>&5
3554   ac_status=$?
3555   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3556   (exit $ac_status); }; } &&
3557          { ac_try='test -s conftest.$ac_objext'
3558   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3559   (eval $ac_try) 2>&5
3560   ac_status=$?
3561   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3562   (exit $ac_status); }; }; then
3563   ac_cv_prog_cc_g=yes
3564 else
3565   echo "$as_me: failed program was:" >&5
3566 sed 's/^/| /' conftest.$ac_ext >&5
3567
3568 ac_cv_prog_cc_g=no
3569 fi
3570 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3571 fi
3572 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3573 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3574 if test "$ac_test_CFLAGS" = set; then
3575   CFLAGS=$ac_save_CFLAGS
3576 elif test $ac_cv_prog_cc_g = yes; then
3577   if test "$GCC" = yes; then
3578     CFLAGS="-g -O2"
3579   else
3580     CFLAGS="-g"
3581   fi
3582 else
3583   if test "$GCC" = yes; then
3584     CFLAGS="-O2"
3585   else
3586     CFLAGS=
3587   fi
3588 fi
3589 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3590 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3591 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3592   echo $ECHO_N "(cached) $ECHO_C" >&6
3593 else
3594   ac_cv_prog_cc_stdc=no
3595 ac_save_CC=$CC
3596 cat >conftest.$ac_ext <<_ACEOF
3597 /* confdefs.h.  */
3598 _ACEOF
3599 cat confdefs.h >>conftest.$ac_ext
3600 cat >>conftest.$ac_ext <<_ACEOF
3601 /* end confdefs.h.  */
3602 #include <stdarg.h>
3603 #include <stdio.h>
3604 #include <sys/types.h>
3605 #include <sys/stat.h>
3606 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3607 struct buf { int x; };
3608 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3609 static char *e (p, i)
3610      char **p;
3611      int i;
3612 {
3613   return p[i];
3614 }
3615 static char *f (char * (*g) (char **, int), char **p, ...)
3616 {
3617   char *s;
3618   va_list v;
3619   va_start (v,p);
3620   s = g (p, va_arg (v,int));
3621   va_end (v);
3622   return s;
3623 }
3624
3625 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3626    function prototypes and stuff, but not '\xHH' hex character constants.
3627    These don't provoke an error unfortunately, instead are silently treated
3628    as 'x'.  The following induces an error, until -std1 is added to get
3629    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3630    array size at least.  It's necessary to write '\x00'==0 to get something
3631    that's true only with -std1.  */
3632 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3633
3634 int test (int i, double x);
3635 struct s1 {int (*f) (int a);};
3636 struct s2 {int (*f) (double a);};
3637 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3638 int argc;
3639 char **argv;
3640 int
3641 main ()
3642 {
3643 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3644   ;
3645   return 0;
3646 }
3647 _ACEOF
3648 # Don't try gcc -ansi; that turns off useful extensions and
3649 # breaks some systems' header files.
3650 # AIX                   -qlanglvl=ansi
3651 # Ultrix and OSF/1      -std1
3652 # HP-UX 10.20 and later -Ae
3653 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3654 # SVR4                  -Xc -D__EXTENSIONS__
3655 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3656 do
3657   CC="$ac_save_CC $ac_arg"
3658   rm -f conftest.$ac_objext
3659 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3660   (eval $ac_compile) 2>conftest.er1
3661   ac_status=$?
3662   grep -v '^ *+' conftest.er1 >conftest.err
3663   rm -f conftest.er1
3664   cat conftest.err >&5
3665   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3666   (exit $ac_status); } &&
3667          { ac_try='test -z "$ac_c_werror_flag"
3668                          || test ! -s conftest.err'
3669   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3670   (eval $ac_try) 2>&5
3671   ac_status=$?
3672   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3673   (exit $ac_status); }; } &&
3674          { ac_try='test -s conftest.$ac_objext'
3675   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3676   (eval $ac_try) 2>&5
3677   ac_status=$?
3678   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3679   (exit $ac_status); }; }; then
3680   ac_cv_prog_cc_stdc=$ac_arg
3681 break
3682 else
3683   echo "$as_me: failed program was:" >&5
3684 sed 's/^/| /' conftest.$ac_ext >&5
3685
3686 fi
3687 rm -f conftest.err conftest.$ac_objext
3688 done
3689 rm -f conftest.$ac_ext conftest.$ac_objext
3690 CC=$ac_save_CC
3691
3692 fi
3693
3694 case "x$ac_cv_prog_cc_stdc" in
3695   x|xno)
3696     echo "$as_me:$LINENO: result: none needed" >&5
3697 echo "${ECHO_T}none needed" >&6 ;;
3698   *)
3699     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3700 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3701     CC="$CC $ac_cv_prog_cc_stdc" ;;
3702 esac
3703
3704 # Some people use a C++ compiler to compile C.  Since we use `exit',
3705 # in C++ we need to declare it.  In case someone uses the same compiler
3706 # for both compiling C and C++ we need to have the C++ compiler decide
3707 # the declaration of exit, since it's the most demanding environment.
3708 cat >conftest.$ac_ext <<_ACEOF
3709 #ifndef __cplusplus
3710   choke me
3711 #endif
3712 _ACEOF
3713 rm -f conftest.$ac_objext
3714 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3715   (eval $ac_compile) 2>conftest.er1
3716   ac_status=$?
3717   grep -v '^ *+' conftest.er1 >conftest.err
3718   rm -f conftest.er1
3719   cat conftest.err >&5
3720   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3721   (exit $ac_status); } &&
3722          { ac_try='test -z "$ac_c_werror_flag"
3723                          || test ! -s conftest.err'
3724   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3725   (eval $ac_try) 2>&5
3726   ac_status=$?
3727   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3728   (exit $ac_status); }; } &&
3729          { ac_try='test -s conftest.$ac_objext'
3730   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3731   (eval $ac_try) 2>&5
3732   ac_status=$?
3733   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3734   (exit $ac_status); }; }; then
3735   for ac_declaration in \
3736    '' \
3737    'extern "C" void std::exit (int) throw (); using std::exit;' \
3738    'extern "C" void std::exit (int); using std::exit;' \
3739    'extern "C" void exit (int) throw ();' \
3740    'extern "C" void exit (int);' \
3741    'void exit (int);'
3742 do
3743   cat >conftest.$ac_ext <<_ACEOF
3744 /* confdefs.h.  */
3745 _ACEOF
3746 cat confdefs.h >>conftest.$ac_ext
3747 cat >>conftest.$ac_ext <<_ACEOF
3748 /* end confdefs.h.  */
3749 $ac_declaration
3750 #include <stdlib.h>
3751 int
3752 main ()
3753 {
3754 exit (42);
3755   ;
3756   return 0;
3757 }
3758 _ACEOF
3759 rm -f conftest.$ac_objext
3760 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3761   (eval $ac_compile) 2>conftest.er1
3762   ac_status=$?
3763   grep -v '^ *+' conftest.er1 >conftest.err
3764   rm -f conftest.er1
3765   cat conftest.err >&5
3766   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3767   (exit $ac_status); } &&
3768          { ac_try='test -z "$ac_c_werror_flag"
3769                          || test ! -s conftest.err'
3770   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3771   (eval $ac_try) 2>&5
3772   ac_status=$?
3773   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3774   (exit $ac_status); }; } &&
3775          { ac_try='test -s conftest.$ac_objext'
3776   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3777   (eval $ac_try) 2>&5
3778   ac_status=$?
3779   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3780   (exit $ac_status); }; }; then
3781   :
3782 else
3783   echo "$as_me: failed program was:" >&5
3784 sed 's/^/| /' conftest.$ac_ext >&5
3785
3786 continue
3787 fi
3788 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3789   cat >conftest.$ac_ext <<_ACEOF
3790 /* confdefs.h.  */
3791 _ACEOF
3792 cat confdefs.h >>conftest.$ac_ext
3793 cat >>conftest.$ac_ext <<_ACEOF
3794 /* end confdefs.h.  */
3795 $ac_declaration
3796 int
3797 main ()
3798 {
3799 exit (42);
3800   ;
3801   return 0;
3802 }
3803 _ACEOF
3804 rm -f conftest.$ac_objext
3805 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3806   (eval $ac_compile) 2>conftest.er1
3807   ac_status=$?
3808   grep -v '^ *+' conftest.er1 >conftest.err
3809   rm -f conftest.er1
3810   cat conftest.err >&5
3811   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3812   (exit $ac_status); } &&
3813          { ac_try='test -z "$ac_c_werror_flag"
3814                          || test ! -s conftest.err'
3815   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3816   (eval $ac_try) 2>&5
3817   ac_status=$?
3818   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3819   (exit $ac_status); }; } &&
3820          { ac_try='test -s conftest.$ac_objext'
3821   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3822   (eval $ac_try) 2>&5
3823   ac_status=$?
3824   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3825   (exit $ac_status); }; }; then
3826   break
3827 else
3828   echo "$as_me: failed program was:" >&5
3829 sed 's/^/| /' conftest.$ac_ext >&5
3830
3831 fi
3832 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3833 done
3834 rm -f conftest*
3835 if test -n "$ac_declaration"; then
3836   echo '#ifdef __cplusplus' >>confdefs.h
3837   echo $ac_declaration      >>confdefs.h
3838   echo '#endif'             >>confdefs.h
3839 fi
3840
3841 else
3842   echo "$as_me: failed program was:" >&5
3843 sed 's/^/| /' conftest.$ac_ext >&5
3844
3845 fi
3846 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3847 ac_ext=c
3848 ac_cpp='$CPP $CPPFLAGS'
3849 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3850 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3851 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3852
3853 ac_ext=cc
3854 ac_cpp='$CXXCPP $CPPFLAGS'
3855 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3856 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3857 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3858 if test -n "$ac_tool_prefix"; then
3859   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3860   do
3861     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3862 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3863 echo "$as_me:$LINENO: checking for $ac_word" >&5
3864 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3865 if test "${ac_cv_prog_CXX+set}" = set; then
3866   echo $ECHO_N "(cached) $ECHO_C" >&6
3867 else
3868   if test -n "$CXX"; then
3869   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3870 else
3871 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3872 for as_dir in $PATH
3873 do
3874   IFS=$as_save_IFS
3875   test -z "$as_dir" && as_dir=.
3876   for ac_exec_ext in '' $ac_executable_extensions; do
3877   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3878     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3879     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3880     break 2
3881   fi
3882 done
3883 done
3884
3885 fi
3886 fi
3887 CXX=$ac_cv_prog_CXX
3888 if test -n "$CXX"; then
3889   echo "$as_me:$LINENO: result: $CXX" >&5
3890 echo "${ECHO_T}$CXX" >&6
3891 else
3892   echo "$as_me:$LINENO: result: no" >&5
3893 echo "${ECHO_T}no" >&6
3894 fi
3895
3896     test -n "$CXX" && break
3897   done
3898 fi
3899 if test -z "$CXX"; then
3900   ac_ct_CXX=$CXX
3901   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3902 do
3903   # Extract the first word of "$ac_prog", so it can be a program name with args.
3904 set dummy $ac_prog; ac_word=$2
3905 echo "$as_me:$LINENO: checking for $ac_word" >&5
3906 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3907 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3908   echo $ECHO_N "(cached) $ECHO_C" >&6
3909 else
3910   if test -n "$ac_ct_CXX"; then
3911   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3912 else
3913 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3914 for as_dir in $PATH
3915 do
3916   IFS=$as_save_IFS
3917   test -z "$as_dir" && as_dir=.
3918   for ac_exec_ext in '' $ac_executable_extensions; do
3919   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3920     ac_cv_prog_ac_ct_CXX="$ac_prog"
3921     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3922     break 2
3923   fi
3924 done
3925 done
3926
3927 fi
3928 fi
3929 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3930 if test -n "$ac_ct_CXX"; then
3931   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3932 echo "${ECHO_T}$ac_ct_CXX" >&6
3933 else
3934   echo "$as_me:$LINENO: result: no" >&5
3935 echo "${ECHO_T}no" >&6
3936 fi
3937
3938   test -n "$ac_ct_CXX" && break
3939 done
3940 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3941
3942   CXX=$ac_ct_CXX
3943 fi
3944
3945
3946 # Provide some information about the compiler.
3947 echo "$as_me:$LINENO:" \
3948      "checking for C++ compiler version" >&5
3949 ac_compiler=`set X $ac_compile; echo $2`
3950 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3951   (eval $ac_compiler --version </dev/null >&5) 2>&5
3952   ac_status=$?
3953   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3954   (exit $ac_status); }
3955 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3956   (eval $ac_compiler -v </dev/null >&5) 2>&5
3957   ac_status=$?
3958   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3959   (exit $ac_status); }
3960 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3961   (eval $ac_compiler -V </dev/null >&5) 2>&5
3962   ac_status=$?
3963   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3964   (exit $ac_status); }
3965
3966 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3967 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3968 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3969   echo $ECHO_N "(cached) $ECHO_C" >&6
3970 else
3971   cat >conftest.$ac_ext <<_ACEOF
3972 /* confdefs.h.  */
3973 _ACEOF
3974 cat confdefs.h >>conftest.$ac_ext
3975 cat >>conftest.$ac_ext <<_ACEOF
3976 /* end confdefs.h.  */
3977
3978 int
3979 main ()
3980 {
3981 #ifndef __GNUC__
3982        choke me
3983 #endif
3984
3985   ;
3986   return 0;
3987 }
3988 _ACEOF
3989 rm -f conftest.$ac_objext
3990 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3991   (eval $ac_compile) 2>conftest.er1
3992   ac_status=$?
3993   grep -v '^ *+' conftest.er1 >conftest.err
3994   rm -f conftest.er1
3995   cat conftest.err >&5
3996   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3997   (exit $ac_status); } &&
3998          { ac_try='test -z "$ac_cxx_werror_flag"
3999                          || test ! -s conftest.err'
4000   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4001   (eval $ac_try) 2>&5
4002   ac_status=$?
4003   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4004   (exit $ac_status); }; } &&
4005          { ac_try='test -s conftest.$ac_objext'
4006   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4007   (eval $ac_try) 2>&5
4008   ac_status=$?
4009   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4010   (exit $ac_status); }; }; then
4011   ac_compiler_gnu=yes
4012 else
4013   echo "$as_me: failed program was:" >&5
4014 sed 's/^/| /' conftest.$ac_ext >&5
4015
4016 ac_compiler_gnu=no
4017 fi
4018 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4019 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4020
4021 fi
4022 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4023 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4024 GXX=`test $ac_compiler_gnu = yes && echo yes`
4025 ac_test_CXXFLAGS=${CXXFLAGS+set}
4026 ac_save_CXXFLAGS=$CXXFLAGS
4027 CXXFLAGS="-g"
4028 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4029 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4030 if test "${ac_cv_prog_cxx_g+set}" = set; then
4031   echo $ECHO_N "(cached) $ECHO_C" >&6
4032 else
4033   cat >conftest.$ac_ext <<_ACEOF
4034 /* confdefs.h.  */
4035 _ACEOF
4036 cat confdefs.h >>conftest.$ac_ext
4037 cat >>conftest.$ac_ext <<_ACEOF
4038 /* end confdefs.h.  */
4039
4040 int
4041 main ()
4042 {
4043
4044   ;
4045   return 0;
4046 }
4047 _ACEOF
4048 rm -f conftest.$ac_objext
4049 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4050   (eval $ac_compile) 2>conftest.er1
4051   ac_status=$?
4052   grep -v '^ *+' conftest.er1 >conftest.err
4053   rm -f conftest.er1
4054   cat conftest.err >&5
4055   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4056   (exit $ac_status); } &&
4057          { ac_try='test -z "$ac_cxx_werror_flag"
4058                          || test ! -s conftest.err'
4059   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4060   (eval $ac_try) 2>&5
4061   ac_status=$?
4062   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4063   (exit $ac_status); }; } &&
4064          { ac_try='test -s conftest.$ac_objext'
4065   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4066   (eval $ac_try) 2>&5
4067   ac_status=$?
4068   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4069   (exit $ac_status); }; }; then
4070   ac_cv_prog_cxx_g=yes
4071 else
4072   echo "$as_me: failed program was:" >&5
4073 sed 's/^/| /' conftest.$ac_ext >&5
4074
4075 ac_cv_prog_cxx_g=no
4076 fi
4077 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4078 fi
4079 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4080 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4081 if test "$ac_test_CXXFLAGS" = set; then
4082   CXXFLAGS=$ac_save_CXXFLAGS
4083 elif test $ac_cv_prog_cxx_g = yes; then
4084   if test "$GXX" = yes; then
4085     CXXFLAGS="-g -O2"
4086   else
4087     CXXFLAGS="-g"
4088   fi
4089 else
4090   if test "$GXX" = yes; then
4091     CXXFLAGS="-O2"
4092   else
4093     CXXFLAGS=
4094   fi
4095 fi
4096 for ac_declaration in \
4097    '' \
4098    'extern "C" void std::exit (int) throw (); using std::exit;' \
4099    'extern "C" void std::exit (int); using std::exit;' \
4100    'extern "C" void exit (int) throw ();' \
4101    'extern "C" void exit (int);' \
4102    'void exit (int);'
4103 do
4104   cat >conftest.$ac_ext <<_ACEOF
4105 /* confdefs.h.  */
4106 _ACEOF
4107 cat confdefs.h >>conftest.$ac_ext
4108 cat >>conftest.$ac_ext <<_ACEOF
4109 /* end confdefs.h.  */
4110 $ac_declaration
4111 #include <stdlib.h>
4112 int
4113 main ()
4114 {
4115 exit (42);
4116   ;
4117   return 0;
4118 }
4119 _ACEOF
4120 rm -f conftest.$ac_objext
4121 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4122   (eval $ac_compile) 2>conftest.er1
4123   ac_status=$?
4124   grep -v '^ *+' conftest.er1 >conftest.err
4125   rm -f conftest.er1
4126   cat conftest.err >&5
4127   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4128   (exit $ac_status); } &&
4129          { ac_try='test -z "$ac_cxx_werror_flag"
4130                          || test ! -s conftest.err'
4131   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4132   (eval $ac_try) 2>&5
4133   ac_status=$?
4134   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4135   (exit $ac_status); }; } &&
4136          { ac_try='test -s conftest.$ac_objext'
4137   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4138   (eval $ac_try) 2>&5
4139   ac_status=$?
4140   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4141   (exit $ac_status); }; }; then
4142   :
4143 else
4144   echo "$as_me: failed program was:" >&5
4145 sed 's/^/| /' conftest.$ac_ext >&5
4146
4147 continue
4148 fi
4149 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4150   cat >conftest.$ac_ext <<_ACEOF
4151 /* confdefs.h.  */
4152 _ACEOF
4153 cat confdefs.h >>conftest.$ac_ext
4154 cat >>conftest.$ac_ext <<_ACEOF
4155 /* end confdefs.h.  */
4156 $ac_declaration
4157 int
4158 main ()
4159 {
4160 exit (42);
4161   ;
4162   return 0;
4163 }
4164 _ACEOF
4165 rm -f conftest.$ac_objext
4166 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4167   (eval $ac_compile) 2>conftest.er1
4168   ac_status=$?
4169   grep -v '^ *+' conftest.er1 >conftest.err
4170   rm -f conftest.er1
4171   cat conftest.err >&5
4172   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4173   (exit $ac_status); } &&
4174          { ac_try='test -z "$ac_cxx_werror_flag"
4175                          || test ! -s conftest.err'
4176   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4177   (eval $ac_try) 2>&5
4178   ac_status=$?
4179   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4180   (exit $ac_status); }; } &&
4181          { ac_try='test -s conftest.$ac_objext'
4182   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4183   (eval $ac_try) 2>&5
4184   ac_status=$?
4185   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4186   (exit $ac_status); }; }; then
4187   break
4188 else
4189   echo "$as_me: failed program was:" >&5
4190 sed 's/^/| /' conftest.$ac_ext >&5
4191
4192 fi
4193 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4194 done
4195 rm -f conftest*
4196 if test -n "$ac_declaration"; then
4197   echo '#ifdef __cplusplus' >>confdefs.h
4198   echo $ac_declaration      >>confdefs.h
4199   echo '#endif'             >>confdefs.h
4200 fi
4201
4202 ac_ext=c
4203 ac_cpp='$CPP $CPPFLAGS'
4204 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4205 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4206 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4207
4208
4209 # We must set the default linker to the linker used by gcc for the correct
4210 # operation of libtool.  If LD is not defined and we are using gcc, try to
4211 # set the LD default to the ld used by gcc.
4212 if test -z "$LD"; then
4213   if test "$GCC" = yes; then
4214     case $build in
4215     *-*-mingw*)
4216       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4217     *)
4218       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4219     esac
4220     case $gcc_prog_ld in
4221     # Accept absolute paths.
4222     [\\/]* | [A-Za-z]:[\\/]*)
4223       LD="$gcc_prog_ld" ;;
4224     esac
4225   fi
4226 fi
4227
4228
4229
4230
4231 if test -n "$ac_tool_prefix"; then
4232   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4233 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4234 echo "$as_me:$LINENO: checking for $ac_word" >&5
4235 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4236 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4237   echo $ECHO_N "(cached) $ECHO_C" >&6
4238 else
4239   if test -n "$GNATBIND"; then
4240   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4241 else
4242 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4243 for as_dir in $PATH
4244 do
4245   IFS=$as_save_IFS
4246   test -z "$as_dir" && as_dir=.
4247   for ac_exec_ext in '' $ac_executable_extensions; do
4248   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4249     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4250     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4251     break 2
4252   fi
4253 done
4254 done
4255
4256 fi
4257 fi
4258 GNATBIND=$ac_cv_prog_GNATBIND
4259 if test -n "$GNATBIND"; then
4260   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4261 echo "${ECHO_T}$GNATBIND" >&6
4262 else
4263   echo "$as_me:$LINENO: result: no" >&5
4264 echo "${ECHO_T}no" >&6
4265 fi
4266
4267 fi
4268 if test -z "$ac_cv_prog_GNATBIND"; then
4269   ac_ct_GNATBIND=$GNATBIND
4270   # Extract the first word of "gnatbind", so it can be a program name with args.
4271 set dummy gnatbind; ac_word=$2
4272 echo "$as_me:$LINENO: checking for $ac_word" >&5
4273 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4274 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4275   echo $ECHO_N "(cached) $ECHO_C" >&6
4276 else
4277   if test -n "$ac_ct_GNATBIND"; then
4278   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4279 else
4280 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4281 for as_dir in $PATH
4282 do
4283   IFS=$as_save_IFS
4284   test -z "$as_dir" && as_dir=.
4285   for ac_exec_ext in '' $ac_executable_extensions; do
4286   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4287     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4288     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4289     break 2
4290   fi
4291 done
4292 done
4293
4294   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4295 fi
4296 fi
4297 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4298 if test -n "$ac_ct_GNATBIND"; then
4299   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4300 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4301 else
4302   echo "$as_me:$LINENO: result: no" >&5
4303 echo "${ECHO_T}no" >&6
4304 fi
4305
4306   GNATBIND=$ac_ct_GNATBIND
4307 else
4308   GNATBIND="$ac_cv_prog_GNATBIND"
4309 fi
4310
4311 if test -n "$ac_tool_prefix"; then
4312   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4313 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4314 echo "$as_me:$LINENO: checking for $ac_word" >&5
4315 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4316 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4317   echo $ECHO_N "(cached) $ECHO_C" >&6
4318 else
4319   if test -n "$GNATMAKE"; then
4320   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4321 else
4322 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4323 for as_dir in $PATH
4324 do
4325   IFS=$as_save_IFS
4326   test -z "$as_dir" && as_dir=.
4327   for ac_exec_ext in '' $ac_executable_extensions; do
4328   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4329     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4330     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4331     break 2
4332   fi
4333 done
4334 done
4335
4336 fi
4337 fi
4338 GNATMAKE=$ac_cv_prog_GNATMAKE
4339 if test -n "$GNATMAKE"; then
4340   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4341 echo "${ECHO_T}$GNATMAKE" >&6
4342 else
4343   echo "$as_me:$LINENO: result: no" >&5
4344 echo "${ECHO_T}no" >&6
4345 fi
4346
4347 fi
4348 if test -z "$ac_cv_prog_GNATMAKE"; then
4349   ac_ct_GNATMAKE=$GNATMAKE
4350   # Extract the first word of "gnatmake", so it can be a program name with args.
4351 set dummy gnatmake; ac_word=$2
4352 echo "$as_me:$LINENO: checking for $ac_word" >&5
4353 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4354 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4355   echo $ECHO_N "(cached) $ECHO_C" >&6
4356 else
4357   if test -n "$ac_ct_GNATMAKE"; then
4358   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4359 else
4360 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4361 for as_dir in $PATH
4362 do
4363   IFS=$as_save_IFS
4364   test -z "$as_dir" && as_dir=.
4365   for ac_exec_ext in '' $ac_executable_extensions; do
4366   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4367     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4368     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4369     break 2
4370   fi
4371 done
4372 done
4373
4374   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4375 fi
4376 fi
4377 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4378 if test -n "$ac_ct_GNATMAKE"; then
4379   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4380 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4381 else
4382   echo "$as_me:$LINENO: result: no" >&5
4383 echo "${ECHO_T}no" >&6
4384 fi
4385
4386   GNATMAKE=$ac_ct_GNATMAKE
4387 else
4388   GNATMAKE="$ac_cv_prog_GNATMAKE"
4389 fi
4390
4391 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4392 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4393 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4394   echo $ECHO_N "(cached) $ECHO_C" >&6
4395 else
4396   cat >conftest.adb <<EOF
4397 procedure conftest is begin null; end conftest;
4398 EOF
4399 acx_cv_cc_gcc_supports_ada=no
4400 # There is a bug in old released versions of GCC which causes the
4401 # driver to exit successfully when the appropriate language module
4402 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4403 # Therefore we must check for the error message as well as an
4404 # unsuccessful exit.
4405 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4406 # given a .adb file, but produce no object file.  So we must check
4407 # if an object file was really produced to guard against this.
4408 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4409 if test x"$errors" = x && test -f conftest.$ac_objext; then
4410   acx_cv_cc_gcc_supports_ada=yes
4411 fi
4412 rm -f conftest.*
4413 fi
4414 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4415 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4416
4417 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4418   have_gnat=yes
4419 else
4420   have_gnat=no
4421 fi
4422
4423 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4424 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4425 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4426   echo $ECHO_N "(cached) $ECHO_C" >&6
4427 else
4428    echo abfoo >t1
4429   echo cdfoo >t2
4430   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4431   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4432     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4433       :
4434     else
4435       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4436     fi
4437   fi
4438   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4439     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4440       :
4441     else
4442       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4443     fi
4444   fi
4445   rm t1 t2
4446
4447 fi
4448 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4449 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4450 do_compare="$gcc_cv_prog_cmp_skip"
4451
4452
4453
4454 # Check for GMP and MPFR
4455 gmplibs="-lmpfr -lgmp"
4456 gmpinc=
4457 have_gmp=no
4458
4459 # Specify a location for mpfr
4460 # check for this first so it ends up on the link line before gmp.
4461
4462 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4463 if test "${with_mpfr_dir+set}" = set; then
4464   withval="$with_mpfr_dir"
4465   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4466 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4467 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4468 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4469    { (exit 1); exit 1; }; }
4470 fi;
4471
4472
4473 # Check whether --with-mpfr or --without-mpfr was given.
4474 if test "${with_mpfr+set}" = set; then
4475   withval="$with_mpfr"
4476
4477 fi;
4478
4479 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4480 if test "${with_mpfr_include+set}" = set; then
4481   withval="$with_mpfr_include"
4482
4483 fi;
4484
4485 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4486 if test "${with_mpfr_lib+set}" = set; then
4487   withval="$with_mpfr_lib"
4488
4489 fi;
4490
4491 if test "x$with_mpfr" != x; then
4492   gmplibs="-L$with_mpfr/lib $gmplibs"
4493   gmpinc="-I$with_mpfr/include"
4494 fi
4495 if test "x$with_mpfr_include" != x; then
4496   gmpinc="-I$with_mpfr_include"
4497 fi
4498 if test "x$with_mpfr_lib" != x; then
4499   gmplibs="-L$with_mpfr_lib $gmplibs"
4500 fi
4501 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4502   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4503   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4504   # Do not test the mpfr version.  Assume that it is sufficient, since
4505   # it is in the source tree, and the library has not been built yet
4506   # but it would be included on the link line in the version check below
4507   # hence making the test fail.
4508   have_gmp=yes
4509 fi
4510
4511 # Specify a location for gmp
4512
4513 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4514 if test "${with_gmp_dir+set}" = set; then
4515   withval="$with_gmp_dir"
4516   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4517 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4518 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4519 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4520    { (exit 1); exit 1; }; }
4521 fi;
4522
4523
4524 # Check whether --with-gmp or --without-gmp was given.
4525 if test "${with_gmp+set}" = set; then
4526   withval="$with_gmp"
4527
4528 fi;
4529
4530 # Check whether --with-gmp_include or --without-gmp_include was given.
4531 if test "${with_gmp_include+set}" = set; then
4532   withval="$with_gmp_include"
4533
4534 fi;
4535
4536 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4537 if test "${with_gmp_lib+set}" = set; then
4538   withval="$with_gmp_lib"
4539
4540 fi;
4541
4542
4543 if test "x$with_gmp" != x; then
4544   gmplibs="-L$with_gmp/lib $gmplibs"
4545   gmpinc="-I$with_gmp/include $gmpinc"
4546 fi
4547 if test "x$with_gmp_include" != x; then
4548   gmpinc="-I$with_gmp_include $gmpinc"
4549 fi
4550 if test "x$with_gmp_lib" != x; then
4551   gmplibs="-L$with_gmp_lib $gmplibs"
4552 fi
4553 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4554   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4555   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4556   # Do not test the gmp version.  Assume that it is sufficient, since
4557   # it is in the source tree, and the library has not been built yet
4558   # but it would be included on the link line in the version check below
4559   # hence making the test fail.
4560   have_gmp=yes
4561 fi
4562
4563 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4564   have_gmp=yes
4565   saved_CFLAGS="$CFLAGS"
4566   CFLAGS="$CFLAGS $gmpinc"
4567   # Check GMP actually works
4568   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4569 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4570
4571 cat >conftest.$ac_ext <<_ACEOF
4572 /* confdefs.h.  */
4573 _ACEOF
4574 cat confdefs.h >>conftest.$ac_ext
4575 cat >>conftest.$ac_ext <<_ACEOF
4576 /* end confdefs.h.  */
4577 #include "gmp.h"
4578 int
4579 main ()
4580 {
4581
4582   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4583   choke me
4584   #endif
4585
4586   ;
4587   return 0;
4588 }
4589 _ACEOF
4590 rm -f conftest.$ac_objext
4591 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4592   (eval $ac_compile) 2>conftest.er1
4593   ac_status=$?
4594   grep -v '^ *+' conftest.er1 >conftest.err
4595   rm -f conftest.er1
4596   cat conftest.err >&5
4597   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4598   (exit $ac_status); } &&
4599          { ac_try='test -z "$ac_c_werror_flag"
4600                          || test ! -s conftest.err'
4601   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4602   (eval $ac_try) 2>&5
4603   ac_status=$?
4604   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4605   (exit $ac_status); }; } &&
4606          { ac_try='test -s conftest.$ac_objext'
4607   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4608   (eval $ac_try) 2>&5
4609   ac_status=$?
4610   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4611   (exit $ac_status); }; }; then
4612   echo "$as_me:$LINENO: result: yes" >&5
4613 echo "${ECHO_T}yes" >&6
4614 else
4615   echo "$as_me: failed program was:" >&5
4616 sed 's/^/| /' conftest.$ac_ext >&5
4617
4618 echo "$as_me:$LINENO: result: no" >&5
4619 echo "${ECHO_T}no" >&6; have_gmp=no
4620 fi
4621 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4622
4623   if test x"$have_gmp" = xyes; then
4624     saved_LIBS="$LIBS"
4625     LIBS="$LIBS $gmplibs"
4626         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4627 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4628     cat >conftest.$ac_ext <<_ACEOF
4629 /* confdefs.h.  */
4630 _ACEOF
4631 cat confdefs.h >>conftest.$ac_ext
4632 cat >>conftest.$ac_ext <<_ACEOF
4633 /* end confdefs.h.  */
4634 #include <gmp.h>
4635     #include <mpfr.h>
4636 int
4637 main ()
4638 {
4639
4640     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4641     choke me
4642     #endif
4643     mpfr_t n;
4644     mpfr_t x;
4645     int t;
4646     mpfr_init (n);
4647     mpfr_init (x);
4648     mpfr_atan2 (n, n, x, GMP_RNDN);
4649     mpfr_erfc (n, x, GMP_RNDN);
4650     mpfr_subnormalize (x, t, GMP_RNDN);
4651
4652   ;
4653   return 0;
4654 }
4655 _ACEOF
4656 rm -f conftest.$ac_objext conftest$ac_exeext
4657 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4658   (eval $ac_link) 2>conftest.er1
4659   ac_status=$?
4660   grep -v '^ *+' conftest.er1 >conftest.err
4661   rm -f conftest.er1
4662   cat conftest.err >&5
4663   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4664   (exit $ac_status); } &&
4665          { ac_try='test -z "$ac_c_werror_flag"
4666                          || test ! -s conftest.err'
4667   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4668   (eval $ac_try) 2>&5
4669   ac_status=$?
4670   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4671   (exit $ac_status); }; } &&
4672          { ac_try='test -s conftest$ac_exeext'
4673   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4674   (eval $ac_try) 2>&5
4675   ac_status=$?
4676   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4677   (exit $ac_status); }; }; then
4678   cat >conftest.$ac_ext <<_ACEOF
4679 /* confdefs.h.  */
4680 _ACEOF
4681 cat confdefs.h >>conftest.$ac_ext
4682 cat >>conftest.$ac_ext <<_ACEOF
4683 /* end confdefs.h.  */
4684 #include <gmp.h>
4685     #include <mpfr.h>
4686 int
4687 main ()
4688 {
4689
4690     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4691     choke me
4692     #endif
4693     mpfr_t n; mpfr_init(n);
4694
4695   ;
4696   return 0;
4697 }
4698 _ACEOF
4699 rm -f conftest.$ac_objext conftest$ac_exeext
4700 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4701   (eval $ac_link) 2>conftest.er1
4702   ac_status=$?
4703   grep -v '^ *+' conftest.er1 >conftest.err
4704   rm -f conftest.er1
4705   cat conftest.err >&5
4706   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4707   (exit $ac_status); } &&
4708          { ac_try='test -z "$ac_c_werror_flag"
4709                          || test ! -s conftest.err'
4710   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4711   (eval $ac_try) 2>&5
4712   ac_status=$?
4713   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4714   (exit $ac_status); }; } &&
4715          { ac_try='test -s conftest$ac_exeext'
4716   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4717   (eval $ac_try) 2>&5
4718   ac_status=$?
4719   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4720   (exit $ac_status); }; }; then
4721   echo "$as_me:$LINENO: result: yes" >&5
4722 echo "${ECHO_T}yes" >&6
4723 else
4724   echo "$as_me: failed program was:" >&5
4725 sed 's/^/| /' conftest.$ac_ext >&5
4726
4727 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4728 echo "${ECHO_T}buggy but acceptable" >&6
4729 fi
4730 rm -f conftest.err conftest.$ac_objext \
4731       conftest$ac_exeext conftest.$ac_ext
4732 else
4733   echo "$as_me: failed program was:" >&5
4734 sed 's/^/| /' conftest.$ac_ext >&5
4735
4736 echo "$as_me:$LINENO: result: no" >&5
4737 echo "${ECHO_T}no" >&6; have_gmp=no
4738 fi
4739 rm -f conftest.err conftest.$ac_objext \
4740       conftest$ac_exeext conftest.$ac_ext
4741       LIBS="$saved_LIBS"
4742   fi
4743   CFLAGS="$saved_CFLAGS"
4744
4745   if test x$have_gmp != xyes; then
4746     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4747 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4748 Copies of these libraries' source code can be found at their respective
4749 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4750 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4751 If you obtained GMP and/or MPFR from a vendor distribution package, make
4752 sure that you have installed both the libraries and the header files.
4753 They may be located in separate packages." >&5
4754 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4755 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4756 Copies of these libraries' source code can be found at their respective
4757 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4758 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4759 If you obtained GMP and/or MPFR from a vendor distribution package, make
4760 sure that you have installed both the libraries and the header files.
4761 They may be located in separate packages." >&2;}
4762    { (exit 1); exit 1; }; }
4763   fi
4764 fi
4765
4766 # Flags needed for both GMP and/or MPFR
4767
4768
4769
4770 # By default, C is the only stage 1 language.
4771 stage1_languages=,c,
4772
4773 # Figure out what language subdirectories are present.
4774 # Look if the user specified --enable-languages="..."; if not, use
4775 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4776 # go away some day.
4777 # NB:  embedded tabs in this IF block -- do not untabify
4778 if test -d ${srcdir}/gcc; then
4779   if test x"${enable_languages+set}" != xset; then
4780     if test x"${LANGUAGES+set}" = xset; then
4781       enable_languages="${LANGUAGES}"
4782         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4783     else
4784       enable_languages=all
4785     fi
4786   else
4787     if test x"${enable_languages}" = x ||
4788        test x"${enable_languages}" = xyes;
4789        then
4790       echo configure.in: --enable-languages needs at least one language argument 1>&2
4791       exit 1
4792     fi
4793   fi
4794   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4795
4796   # 'f95' is the old name for the 'fortran' language. We issue a warning
4797   # and make the substitution.
4798   case ,${enable_languages}, in
4799     *,f95,*)
4800       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4801       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4802       ;;
4803   esac
4804
4805   # First scan to see if an enabled language requires some other language.
4806   # We assume that a given config-lang.in will list all the language
4807   # front ends it requires, even if some are required indirectly.
4808   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4809     case ${lang_frag} in
4810       ..) ;;
4811       # The odd quoting in the next line works around
4812       # an apparent bug in bash 1.12 on linux.
4813       ${srcdir}/gcc/[*]/config-lang.in) ;;
4814       *)
4815         # From the config-lang.in, get $language, $lang_requires
4816         language=
4817         lang_requires=
4818         . ${lang_frag}
4819         for other in ${lang_requires} ; do
4820           case ,${enable_languages}, in
4821             *,$other,*) ;;
4822             *,all,*) ;;
4823             *,$language,*)
4824               echo " \`$other' language required by \`$language'; enabling" 1>&2
4825               enable_languages="${enable_languages},${other}"
4826               ;;
4827           esac
4828         done
4829         ;;
4830     esac
4831   done
4832
4833   new_enable_languages=,c,
4834   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4835   potential_languages=,c,
4836
4837   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4838     case ${lang_frag} in
4839       ..) ;;
4840       # The odd quoting in the next line works around
4841       # an apparent bug in bash 1.12 on linux.
4842       ${srcdir}/gcc/[*]/config-lang.in) ;;
4843       *)
4844         # From the config-lang.in, get $language, $target_libs,
4845         # $lang_dirs, $boot_language, and $build_by_default
4846         language=
4847         target_libs=
4848         lang_dirs=
4849         subdir_requires=
4850         boot_language=no
4851         build_by_default=yes
4852         . ${lang_frag}
4853         if test x${language} = x; then
4854           echo "${lang_frag} doesn't set \$language." 1>&2
4855           exit 1
4856         fi
4857
4858         case ,${enable_languages}, in
4859           *,${language},*)
4860             # Language was explicitly selected; include it.
4861             add_this_lang=yes
4862             ;;
4863           *,all,*)
4864             # 'all' was selected, select it if it is a default language
4865             add_this_lang=${build_by_default}
4866             ;;
4867           *)
4868             add_this_lang=no
4869             ;;
4870         esac
4871
4872         # Disable languages that need other directories if these aren't available.
4873         for i in $subdir_requires; do
4874           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4875           case ,${enable_languages}, in
4876             *,${language},*)
4877               # Specifically requested language; tell them.
4878               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4879 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4880    { (exit 1); exit 1; }; }
4881               ;;
4882             *)
4883               # Silently disable.
4884               add_this_lang=unsupported
4885               ;;
4886           esac
4887         done
4888
4889         # Disable Ada if no preexisting GNAT is available.
4890         case ,${enable_languages},:${language}:${have_gnat} in
4891           *,${language},*:ada:no)
4892             # Specifically requested language; tell them.
4893             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4894 echo "$as_me: error: GNAT is required to build $language" >&2;}
4895    { (exit 1); exit 1; }; }
4896             ;;
4897           *:ada:no)
4898             # Silently disable.
4899             add_this_lang=unsupported
4900             ;;
4901         esac
4902
4903         # Disable a language that is unsupported by the target.
4904         case " $unsupported_languages " in
4905           *" $language "*)
4906             add_this_lang=unsupported
4907             ;;
4908         esac
4909
4910         case $add_this_lang in
4911           unsupported)
4912             # Remove language-dependent dirs.
4913             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4914             ;;
4915           no)
4916             # Remove language-dependent dirs; still show language as supported.
4917             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4918             potential_languages="${potential_languages}${language},"
4919             ;;
4920           yes)
4921             new_enable_languages="${new_enable_languages}${language},"
4922             potential_languages="${potential_languages}${language},"
4923             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4924             case ${boot_language} in
4925               yes)
4926                 # Add to (comma-separated) list of stage 1 languages.
4927                 stage1_languages="${stage1_languages}${language},"
4928                 ;;
4929             esac
4930             ;;
4931         esac
4932         ;;
4933     esac
4934   done
4935
4936   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4937 if test "${enable_stage1_languages+set}" = set; then
4938   enableval="$enable_stage1_languages"
4939   case ,${enable_stage1_languages}, in
4940     ,no,|,,)
4941       # Set it to something that will have no effect in the loop below
4942       enable_stage1_languages=c ;;
4943     ,yes,)
4944       enable_stage1_languages=`echo $new_enable_languages | \
4945         sed -e "s/^,//" -e "s/,$//" ` ;;
4946     *,all,*)
4947       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4948         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4949   esac
4950
4951   # Add "good" languages from enable_stage1_languages to stage1_languages,
4952   # while "bad" languages go in missing_languages.  Leave no duplicates.
4953   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4954     case $potential_languages in
4955       *,$i,*)
4956         case $stage1_languages in
4957           *,$i,*) ;;
4958           *) stage1_languages="$stage1_languages$i," ;;
4959         esac ;;
4960       *)
4961         case $missing_languages in
4962           *,$i,*) ;;
4963           *) missing_languages="$missing_languages$i," ;;
4964         esac ;;
4965      esac
4966   done
4967 fi;
4968
4969   # Remove leading/trailing commas that were added for simplicity
4970   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4971   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4972   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4973   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4974
4975   if test "x$missing_languages" != x; then
4976     { { echo "$as_me:$LINENO: error:
4977 The following requested languages could not be built: ${missing_languages}
4978 Supported languages are: ${potential_languages}" >&5
4979 echo "$as_me: error:
4980 The following requested languages could not be built: ${missing_languages}
4981 Supported languages are: ${potential_languages}" >&2;}
4982    { (exit 1); exit 1; }; }
4983   fi
4984   if test "x$new_enable_languages" != "x$enable_languages"; then
4985     echo The following languages will be built: ${new_enable_languages}
4986     enable_languages="$new_enable_languages"
4987   fi
4988
4989
4990   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4991 fi
4992
4993 # Handle --disable-<component> generically.
4994 for dir in $configdirs $build_configdirs $target_configdirs ; do
4995   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4996   varname=`echo $dirname | sed -e s/+/_/g`
4997   if eval test x\${enable_${varname}} "=" xno ; then
4998     noconfigdirs="$noconfigdirs $dir"
4999   fi
5000 done
5001
5002 # Check for Boehm's garbage collector
5003 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5004 if test "${enable_objc_gc+set}" = set; then
5005   enableval="$enable_objc_gc"
5006   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5007   *,objc,*:*:yes:*target-boehm-gc*)
5008     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5009 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5010    { (exit 1); exit 1; }; }
5011     ;;
5012 esac
5013 fi;
5014
5015 # Make sure we only build Boehm's garbage collector if required.
5016 case ,${enable_languages},:${enable_objc_gc} in
5017   *,objc,*:yes)
5018     # Keep target-boehm-gc if requested for Objective-C.
5019     ;;
5020   *)
5021     # Otherwise remove target-boehm-gc depending on target-libjava.
5022     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5023       noconfigdirs="$noconfigdirs target-boehm-gc"
5024     fi
5025     ;;
5026 esac
5027
5028 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5029 # $build_configdirs and $target_configdirs.
5030 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5031
5032 notsupp=""
5033 for dir in . $skipdirs $noconfigdirs ; do
5034   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5035   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5036     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5037     if test -r $srcdir/$dirname/configure ; then
5038       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5039         true
5040       else
5041         notsupp="$notsupp $dir"
5042       fi
5043     fi
5044   fi
5045   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5046     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5047     if test -r $srcdir/$dirname/configure ; then
5048       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5049         true
5050       else
5051         notsupp="$notsupp $dir"
5052       fi
5053     fi
5054   fi
5055   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5056     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5057     if test -r $srcdir/$dirname/configure ; then
5058       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5059         true
5060       else
5061         notsupp="$notsupp $dir"
5062       fi
5063     fi
5064   fi
5065 done
5066
5067 # Sometimes the tools are distributed with libiberty but with no other
5068 # libraries.  In that case, we don't want to build target-libiberty.
5069 # Don't let libgcc imply libiberty either.
5070 if test -n "${target_configdirs}" ; then
5071   libgcc=
5072   others=
5073   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5074     if test "$i" = "libgcc"; then
5075       libgcc=target-libgcc
5076     elif test "$i" != "libiberty" ; then
5077       if test -r $srcdir/$i/configure ; then
5078         others=yes;
5079         break;
5080       fi
5081     fi
5082   done
5083   if test -z "${others}" ; then
5084     target_configdirs=$libgcc
5085   fi
5086 fi
5087
5088 # Quietly strip out all directories which aren't configurable in this tree.
5089 # This relies on all configurable subdirectories being autoconfiscated, which
5090 # is now the case.
5091 build_configdirs_all="$build_configdirs"
5092 build_configdirs=
5093 for i in ${build_configdirs_all} ; do
5094   j=`echo $i | sed -e s/build-//g`
5095   if test -f ${srcdir}/$j/configure ; then
5096     build_configdirs="${build_configdirs} $i"
5097   fi
5098 done
5099
5100 configdirs_all="$configdirs"
5101 configdirs=
5102 for i in ${configdirs_all} ; do
5103   if test -f ${srcdir}/$i/configure ; then
5104     configdirs="${configdirs} $i"
5105   fi
5106 done
5107
5108 target_configdirs_all="$target_configdirs"
5109 target_configdirs=
5110 for i in ${target_configdirs_all} ; do
5111   j=`echo $i | sed -e s/target-//g`
5112   if test -f ${srcdir}/$j/configure ; then
5113     target_configdirs="${target_configdirs} $i"
5114   fi
5115 done
5116
5117 # Produce a warning message for the subdirs we can't configure.
5118 # This isn't especially interesting in the Cygnus tree, but in the individual
5119 # FSF releases, it's important to let people know when their machine isn't
5120 # supported by the one or two programs in a package.
5121
5122 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5123   # If $appdirs is non-empty, at least one of those directories must still
5124   # be configured, or we error out.  (E.g., if the gas release supports a
5125   # specified target in some subdirs but not the gas subdir, we shouldn't
5126   # pretend that all is well.)
5127   if test -n "$appdirs" ; then
5128     for dir in $appdirs ; do
5129       if test -r $dir/Makefile.in ; then
5130         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5131           appdirs=""
5132           break
5133         fi
5134         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5135           appdirs=""
5136           break
5137         fi
5138       fi
5139     done
5140     if test -n "$appdirs" ; then
5141       echo "*** This configuration is not supported by this package." 1>&2
5142       exit 1
5143     fi
5144   fi
5145   # Okay, some application will build, or we don't care to check.  Still
5146   # notify of subdirs not getting built.
5147   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5148   echo "    ${notsupp}" 1>&2
5149   echo "    (Any other directories should still work fine.)" 1>&2
5150 fi
5151
5152 case "$host" in
5153   *msdosdjgpp*)
5154     enable_gdbtk=no ;;
5155 esac
5156
5157 # To find our prefix, in gcc_cv_tool_prefix.
5158
5159 # The user is always right.
5160 if test "${PATH_SEPARATOR+set}" != set; then
5161   echo "#! /bin/sh" >conf$$.sh
5162   echo  "exit 0"   >>conf$$.sh
5163   chmod +x conf$$.sh
5164   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5165     PATH_SEPARATOR=';'
5166   else
5167     PATH_SEPARATOR=:
5168   fi
5169   rm -f conf$$.sh
5170 fi
5171
5172
5173
5174 if test "x$exec_prefix" = xNONE; then
5175         if test "x$prefix" = xNONE; then
5176                 gcc_cv_tool_prefix=$ac_default_prefix
5177         else
5178                 gcc_cv_tool_prefix=$prefix
5179         fi
5180 else
5181         gcc_cv_tool_prefix=$exec_prefix
5182 fi
5183
5184 # If there is no compiler in the tree, use the PATH only.  In any
5185 # case, if there is no compiler in the tree nobody should use
5186 # AS_FOR_TARGET and LD_FOR_TARGET.
5187 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5188     gcc_version=`cat $srcdir/gcc/BASE-VER`
5189     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5190     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5191     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5192     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5193     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5194     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5195 else
5196     gcc_cv_tool_dirs=
5197 fi
5198
5199 if test x$build = x$target && test -n "$md_exec_prefix"; then
5200         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5201 fi
5202
5203
5204
5205 copy_dirs=
5206
5207
5208 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5209 if test "${with_build_sysroot+set}" = set; then
5210   withval="$with_build_sysroot"
5211   if test x"$withval" != x ; then
5212      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5213    fi
5214 else
5215   SYSROOT_CFLAGS_FOR_TARGET=
5216 fi;
5217
5218
5219
5220 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5221 if test "${with_debug_prefix_map+set}" = set; then
5222   withval="$with_debug_prefix_map"
5223   if test x"$withval" != x; then
5224      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5225      for debug_map in $withval; do
5226        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5227      done
5228    fi
5229 else
5230   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5231 fi;
5232
5233
5234 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5235 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5236 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5237 # We want to ensure that TARGET libraries (which we know are built with
5238 # gcc) are built with "-O2 -g", so include those options when setting
5239 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5240 if test "x$CFLAGS_FOR_TARGET" = x; then
5241   CFLAGS_FOR_TARGET=$CFLAGS
5242   case " $CFLAGS " in
5243     *" -O2 "*) ;;
5244     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5245   esac
5246   case " $CFLAGS " in
5247     *" -g "* | *" -g3 "*) ;;
5248     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5249   esac
5250 fi
5251
5252
5253 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5254   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5255   case " $CXXFLAGS " in
5256     *" -O2 "*) ;;
5257     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5258   esac
5259   case " $CXXFLAGS " in
5260     *" -g "* | *" -g3 "*) ;;
5261     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5262   esac
5263 fi
5264
5265
5266 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5267 # the named directory are copied to $(tooldir)/sys-include.
5268 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5269   if test x${is_cross_compiler} = xno ; then
5270     echo 1>&2 '***' --with-headers is only supported when cross compiling
5271     exit 1
5272   fi
5273   if test x"${with_headers}" != xyes ; then
5274     x=${gcc_cv_tool_prefix}
5275     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5276   fi
5277 fi
5278
5279 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5280 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5281 # are permitted.
5282 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5283   if test x${is_cross_compiler} = xno ; then
5284     echo 1>&2 '***' --with-libs is only supported when cross compiling
5285     exit 1
5286   fi
5287   if test x"${with_libs}" != xyes ; then
5288     # Copy the libraries in reverse order, so that files in the first named
5289     # library override files in subsequent libraries.
5290     x=${gcc_cv_tool_prefix}
5291     for l in ${with_libs}; do
5292       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5293     done
5294   fi
5295 fi
5296
5297 # Set with_gnu_as and with_gnu_ld as appropriate.
5298 #
5299 # This is done by determining whether or not the appropriate directory
5300 # is available, and by checking whether or not specific configurations
5301 # have requested that this magic not happen.
5302 #
5303 # The command line options always override the explicit settings in
5304 # configure.in, and the settings in configure.in override this magic.
5305 #
5306 # If the default for a toolchain is to use GNU as and ld, and you don't
5307 # want to do that, then you should use the --without-gnu-as and
5308 # --without-gnu-ld options for the configure script.
5309
5310 if test x${use_gnu_as} = x &&
5311    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5312   with_gnu_as=yes
5313   extra_host_args="$extra_host_args --with-gnu-as"
5314 fi
5315
5316 if test x${use_gnu_ld} = x &&
5317    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5318   with_gnu_ld=yes
5319   extra_host_args="$extra_host_args --with-gnu-ld"
5320 fi
5321
5322 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5323 # can detect this case.
5324
5325 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5326   with_newlib=yes
5327   extra_host_args="$extra_host_args --with-newlib"
5328 fi
5329
5330 # Handle ${copy_dirs}
5331 set fnord ${copy_dirs}
5332 shift
5333 while test $# != 0 ; do
5334   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5335     :
5336   else
5337     echo Copying $1 to $2
5338
5339     # Use the install script to create the directory and all required
5340     # parent directories.
5341     if test -d $2 ; then
5342       :
5343     else
5344       echo >config.temp
5345       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5346     fi
5347
5348     # Copy the directory, assuming we have tar.
5349     # FIXME: Should we use B in the second tar?  Not all systems support it.
5350     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5351
5352     # It is the responsibility of the user to correctly adjust all
5353     # symlinks.  If somebody can figure out how to handle them correctly
5354     # here, feel free to add the code.
5355
5356     echo $1 > $2/COPIED
5357   fi
5358   shift; shift
5359 done
5360
5361 # Determine a target-dependent exec_prefix that the installed
5362 # gcc will search in.  Keep this list sorted by triplet, with
5363 # the *-*-osname triplets last.
5364 md_exec_prefix=
5365 case "${target}" in
5366   alpha*-*-*vms*)
5367     md_exec_prefix=/gnu/lib/gcc-lib
5368     ;;
5369   i[34567]86-pc-msdosdjgpp*)
5370     md_exec_prefix=/dev/env/DJDIR/bin
5371     ;;
5372   i[34567]86-*-sco3.2v5*)
5373     if test $with_gnu_as = yes; then
5374       md_exec_prefix=/usr/gnu/bin
5375     else
5376       md_exec_prefix=/usr/ccs/bin/elf
5377     fi
5378     ;;
5379
5380   mn10300-*-* | \
5381   powerpc-*-chorusos* | \
5382   powerpc*-*-eabi* | \
5383   powerpc*-*-sysv* | \
5384   powerpc*-*-kaos* | \
5385   s390x-ibm-tpf*)
5386     md_exec_prefix=/usr/ccs/bin
5387     ;;
5388   sparc64-*-elf*)
5389     ;;
5390   v850*-*-*)
5391     md_exec_prefix=/usr/ccs/bin
5392     ;;
5393   xtensa*-*-elf*)
5394     ;;
5395
5396   *-*-beos* | \
5397   *-*-elf* | \
5398   *-*-hpux* | \
5399   *-*-netware* | \
5400   *-*-nto-qnx* | \
5401   *-*-rtems* | \
5402   *-*-solaris2* | \
5403   *-*-sysv[45]* | \
5404   *-*-vxworks* | \
5405   *-wrs-windiss)
5406     md_exec_prefix=/usr/ccs/bin
5407     ;;
5408 esac
5409
5410 extra_arflags_for_target=
5411 extra_nmflags_for_target=
5412 extra_ranlibflags_for_target=
5413 target_makefile_frag=/dev/null
5414 case "${target}" in
5415   mep*-*-*)
5416     target_makefile_frag="config/mt-mep"
5417     ;;
5418   spu-*-*)
5419     target_makefile_frag="config/mt-spu"
5420     ;;
5421   mips*-sde-elf*)
5422     target_makefile_frag="config/mt-sde"
5423     ;;
5424   mipsisa*-*-elfoabi*)
5425     target_makefile_frag="config/mt-mips-elfoabi"
5426     ;;
5427   *-*-netware*)
5428     target_makefile_frag="config/mt-netware"
5429     ;;
5430   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5431     target_makefile_frag="config/mt-gnu"
5432     ;;
5433   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5434     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5435     # commands to handle both 32-bit and 64-bit objects.  These flags are
5436     # harmless if we're using GNU nm or ar.
5437     extra_arflags_for_target=" -X32_64"
5438     extra_nmflags_for_target=" -B -X32_64"
5439     ;;
5440   *-*-darwin*)
5441     # ranlib from Darwin requires the -c flag to look at common symbols.
5442     extra_ranlibflags_for_target=" -c"
5443     ;;
5444   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5445     target_makefile_frag="config/mt-wince"
5446     ;;
5447 esac
5448
5449 alphaieee_frag=/dev/null
5450 case $target in
5451   alpha*-*-*)
5452     # This just makes sure to use the -mieee option to build target libs.
5453     # This should probably be set individually by each library.
5454     alphaieee_frag="config/mt-alphaieee"
5455     ;;
5456 esac
5457
5458 # If --enable-target-optspace always use -Os instead of -O2 to build
5459 # the target libraries, similarly if it is not specified, use -Os
5460 # on selected platforms.
5461 ospace_frag=/dev/null
5462 case "${enable_target_optspace}:${target}" in
5463   yes:*)
5464     ospace_frag="config/mt-ospace"
5465     ;;
5466   :d30v-*)
5467     ospace_frag="config/mt-d30v"
5468     ;;
5469   :m32r-* | :d10v-* | :fr30-*)
5470     ospace_frag="config/mt-ospace"
5471     ;;
5472   no:* | :*)
5473     ;;
5474   *)
5475     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5476     ;;
5477 esac
5478
5479 # Default to using --with-stabs for certain targets.
5480 if test x${with_stabs} = x ; then
5481   case "${target}" in
5482   mips*-*-irix[56]*)
5483     ;;
5484   mips*-*-* | alpha*-*-osf*)
5485     with_stabs=yes;
5486     extra_host_args="${extra_host_args} --with-stabs"
5487     ;;
5488   esac
5489 fi
5490
5491 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5492 # them automatically.
5493 case "${host}" in
5494   hppa*64*-*-hpux11*)
5495     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5496     ;;
5497 esac
5498
5499 # Some systems (e.g., one of the i386-aix systems the gas testers are
5500 # using) don't handle "\$" correctly, so don't use it here.
5501 tooldir='${exec_prefix}'/${target_noncanonical}
5502 build_tooldir=${tooldir}
5503
5504 # Create a .gdbinit file which runs the one in srcdir
5505 # and tells GDB to look there for source files.
5506
5507 if test -r ${srcdir}/.gdbinit ; then
5508   case ${srcdir} in
5509     .) ;;
5510     *) cat > ./.gdbinit <<EOF
5511 # ${NO_EDIT}
5512 dir ${srcdir}
5513 dir .
5514 source ${srcdir}/.gdbinit
5515 EOF
5516     ;;
5517   esac
5518 fi
5519
5520 # Make sure that the compiler is able to generate an executable.  If it
5521 # can't, we are probably in trouble.  We don't care whether we can run the
5522 # executable--we might be using a cross compiler--we only care whether it
5523 # can be created.  At this point the main configure script has set CC.
5524 we_are_ok=no
5525 echo "int main () { return 0; }" > conftest.c
5526 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5527 if test $? = 0 ; then
5528   if test -s conftest || test -s conftest.exe ; then
5529     we_are_ok=yes
5530   fi
5531 fi
5532 case $we_are_ok in
5533   no)
5534     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5535     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5536     rm -f conftest*
5537     exit 1
5538     ;;
5539 esac
5540 rm -f conftest*
5541
5542 # The Solaris /usr/ucb/cc compiler does not appear to work.
5543 case "${host}" in
5544   sparc-sun-solaris2*)
5545       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5546       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5547           could_use=
5548           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5549           if test -d /opt/cygnus/bin ; then
5550               if test "$could_use" = "" ; then
5551                   could_use="/opt/cygnus/bin"
5552               else
5553                   could_use="$could_use or /opt/cygnus/bin"
5554               fi
5555           fi
5556         if test "$could_use" = "" ; then
5557             echo "Warning: compilation may fail because you're using"
5558             echo "/usr/ucb/cc.  You should change your PATH or CC "
5559             echo "variable and rerun configure."
5560         else
5561             echo "Warning: compilation may fail because you're using"
5562             echo "/usr/ucb/cc, when you should use the C compiler from"
5563             echo "$could_use.  You should change your"
5564             echo "PATH or CC variable and rerun configure."
5565         fi
5566       fi
5567   ;;
5568 esac
5569
5570 case "${host}" in
5571   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5572   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5573   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5574 esac
5575
5576 # Record target_configdirs and the configure arguments for target and
5577 # build configuration in Makefile.
5578 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5579 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5580
5581 # Determine whether gdb needs tk/tcl or not.
5582 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5583 # and in that case we want gdb to be built without tk.  Ugh!
5584 # In fact I believe gdb is the *only* package directly dependent on tk,
5585 # so we should be able to put the 'maybe's in unconditionally and
5586 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5587 # 100% sure that that's safe though.
5588
5589 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5590 case "$enable_gdbtk" in
5591   no)
5592     GDB_TK="" ;;
5593   yes)
5594     GDB_TK="${gdb_tk}" ;;
5595   *)
5596     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5597     # distro.  Eventually someone will fix this and move Insight, nee
5598     # gdbtk to a separate directory.
5599     if test -d ${srcdir}/gdb/gdbtk ; then
5600       GDB_TK="${gdb_tk}"
5601     else
5602       GDB_TK=""
5603     fi
5604     ;;
5605 esac
5606 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5607 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5608
5609 # Strip out unwanted targets.
5610
5611 # While at that, we remove Makefiles if we were started for recursive
5612 # configuration, so that the top-level Makefile reconfigures them,
5613 # like we used to do when configure itself was recursive.
5614
5615 # Loop over modules.  $extrasub must be used with care, limiting as
5616 # much as possible the usage of range addresses.  That's because autoconf
5617 # splits the sed script to overcome limits in the number of commands,
5618 # and relying on carefully-timed sed passes may turn out to be very hard
5619 # to maintain later.  In this particular case, you just have to be careful
5620 # not to nest @if/@endif pairs, because configure will not warn you at all.
5621
5622 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5623 if test "${enable_bootstrap+set}" = set; then
5624   enableval="$enable_bootstrap"
5625
5626 else
5627   enable_bootstrap=default
5628 fi;
5629
5630 # Issue errors and warnings for invalid/strange bootstrap combinations.
5631 case "$configdirs" in
5632   *gcc*) have_compiler=yes ;;
5633   *) have_compiler=no ;;
5634 esac
5635
5636 case "$have_compiler:$host:$target:$enable_bootstrap" in
5637   *:*:*:no) ;;
5638
5639   # Default behavior.  Enable bootstrap if we have a compiler
5640   # and we are in a native configuration.
5641   yes:$build:$build:default)
5642     enable_bootstrap=yes ;;
5643
5644   *:*:*:default)
5645     enable_bootstrap=no ;;
5646
5647   # We have a compiler and we are in a native configuration, bootstrap is ok
5648   yes:$build:$build:yes)
5649     ;;
5650
5651   # Other configurations, but we have a compiler.  Assume the user knows
5652   # what he's doing.
5653   yes:*:*:yes)
5654     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5655 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5656     ;;
5657
5658   # No compiler: if they passed --enable-bootstrap explicitly, fail
5659   no:*:*:yes)
5660     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5661 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5662    { (exit 1); exit 1; }; } ;;
5663
5664   # Fail if wrong command line
5665   *)
5666     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5667 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5668    { (exit 1); exit 1; }; }
5669     ;;
5670 esac
5671
5672 # Adjust the toplevel makefile according to whether bootstrap was selected.
5673 case "$enable_bootstrap" in
5674   yes)
5675     bootstrap_suffix=bootstrap ;;
5676   no)
5677     bootstrap_suffix=no-bootstrap ;;
5678 esac
5679
5680 for module in ${build_configdirs} ; do
5681   if test -z "${no_recursion}" \
5682      && test -f ${build_subdir}/${module}/Makefile; then
5683     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5684     rm -f ${build_subdir}/${module}/Makefile
5685   fi
5686   extrasub="$extrasub
5687 /^@if build-$module\$/d
5688 /^@endif build-$module\$/d
5689 /^@if build-$module-$bootstrap_suffix\$/d
5690 /^@endif build-$module-$bootstrap_suffix\$/d"
5691 done
5692 for module in ${configdirs} ; do
5693   if test -z "${no_recursion}"; then
5694     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5695       if test -f ${file}; then
5696         echo 1>&2 "*** removing ${file} to force reconfigure"
5697         rm -f ${file}
5698       fi
5699     done
5700   fi
5701   extrasub="$extrasub
5702 /^@if $module\$/d
5703 /^@endif $module\$/d
5704 /^@if $module-$bootstrap_suffix\$/d
5705 /^@endif $module-$bootstrap_suffix\$/d"
5706 done
5707 for module in ${target_configdirs} ; do
5708   if test -z "${no_recursion}" \
5709      && test -f ${target_subdir}/${module}/Makefile; then
5710     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5711     rm -f ${target_subdir}/${module}/Makefile
5712   fi
5713   extrasub="$extrasub
5714 /^@if target-$module\$/d
5715 /^@endif target-$module\$/d
5716 /^@if target-$module-$bootstrap_suffix\$/d
5717 /^@endif target-$module-$bootstrap_suffix\$/d"
5718 done
5719
5720 extrasub="$extrasub
5721 /^@if /,/^@endif /d"
5722
5723 # Create the serialization dependencies.  This uses a temporary file.
5724
5725 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5726 if test "${enable_serial_configure+set}" = set; then
5727   enableval="$enable_serial_configure"
5728
5729 fi;
5730
5731 case ${enable_serial_configure} in
5732   yes)
5733     enable_serial_build_configure=yes
5734     enable_serial_host_configure=yes
5735     enable_serial_target_configure=yes
5736     ;;
5737 esac
5738
5739 # These force 'configure's to be done one at a time, to avoid problems
5740 # with contention over a shared config.cache.
5741 rm -f serdep.tmp
5742 echo '# serdep.tmp' > serdep.tmp
5743 olditem=
5744 test "x${enable_serial_build_configure}" = xyes &&
5745 for item in ${build_configdirs} ; do
5746   case ${olditem} in
5747     "") ;;
5748     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5749   esac
5750   olditem=${item}
5751 done
5752 olditem=
5753 test "x${enable_serial_host_configure}" = xyes &&
5754 for item in ${configdirs} ; do
5755   case ${olditem} in
5756     "") ;;
5757     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5758   esac
5759   olditem=${item}
5760 done
5761 olditem=
5762 test "x${enable_serial_target_configure}" = xyes &&
5763 for item in ${target_configdirs} ; do
5764   case ${olditem} in
5765     "") ;;
5766     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5767   esac
5768   olditem=${item}
5769 done
5770 serialization_dependencies=serdep.tmp
5771
5772
5773 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5774 # target, nonopt, and variable assignments.  These are the ones we
5775 # might not want to pass down to subconfigures.  Also strip
5776 # program-prefix, program-suffix, and program-transform-name, so that
5777 # we can pass down a consistent program-transform-name.
5778 baseargs=
5779 keep_next=no
5780 skip_next=no
5781 eval "set -- $ac_configure_args"
5782 for ac_arg
5783 do
5784   if test X"$skip_next" = X"yes"; then
5785     skip_next=no
5786     continue
5787   fi
5788   if test X"$keep_next" = X"yes"; then
5789     case $ac_arg in
5790       *\'*)
5791         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5792     esac
5793     baseargs="$baseargs '$ac_arg'"
5794     keep_next=no
5795     continue
5796   fi
5797
5798   # Handle separated arguments.  Based on the logic generated by
5799   # autoconf 2.59.
5800   case $ac_arg in
5801     *=* | --config-cache | -C | -disable-* | --disable-* \
5802       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5803       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5804       | -with-* | --with-* | -without-* | --without-* | --x)
5805       separate_arg=no
5806       ;;
5807     -*)
5808       separate_arg=yes
5809       ;;
5810     *)
5811       separate_arg=no
5812       ;;
5813   esac
5814
5815   case "$ac_arg" in
5816     --no*)
5817       continue
5818       ;;
5819     --c* | \
5820     --sr* | \
5821     --ho* | \
5822     --bu* | \
5823     --t* | \
5824     --program-* | \
5825     -cache_file* | \
5826     -srcdir* | \
5827     -host* | \
5828     -build* | \
5829     -target* | \
5830     -program-prefix* | \
5831     -program-suffix* | \
5832     -program-transform-name* )
5833       skip_next=$separate_arg
5834       continue
5835       ;;
5836     -*)
5837       # An option.  Add it.
5838       case $ac_arg in
5839         *\'*)
5840           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5841       esac
5842       baseargs="$baseargs '$ac_arg'"
5843       keep_next=$separate_arg
5844       ;;
5845     *)
5846       # Either a variable assignment, or a nonopt (triplet).  Don't
5847       # pass it down; let the Makefile handle this.
5848       continue
5849       ;;
5850   esac
5851 done
5852 # Remove the initial space we just introduced and, as these will be
5853 # expanded by make, quote '$'.
5854 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5855
5856 # Add in --program-transform-name, after --program-prefix and
5857 # --program-suffix have been applied to it.  Autoconf has already
5858 # doubled dollar signs and backslashes in program_transform_name; we want
5859 # the backslashes un-doubled, and then the entire thing wrapped in single
5860 # quotes, because this will be expanded first by make and then by the shell.
5861 # Also, because we want to override the logic in subdir configure scripts to
5862 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5863 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5864 ${program_transform_name}
5865 EOF_SED
5866 gcc_transform_name=`cat conftestsed.out`
5867 rm -f conftestsed.out
5868 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5869 if test "$silent" = yes; then
5870   baseargs="$baseargs --silent"
5871 fi
5872
5873 # For the build-side libraries, we just need to pretend we're native,
5874 # and not use the same cache file.  Multilibs are neither needed nor
5875 # desired.
5876 build_configargs="--cache-file=../config.cache ${baseargs}"
5877
5878 # For host modules, accept cache file option, or specification as blank.
5879 case "${cache_file}" in
5880 "") # empty
5881   cache_file_option="" ;;
5882 /* | [A-Za-z]:[\\/]* ) # absolute path
5883   cache_file_option="--cache-file=${cache_file}" ;;
5884 *) # relative path
5885   cache_file_option="--cache-file=../${cache_file}" ;;
5886 esac
5887
5888 # Host dirs don't like to share a cache file either, horribly enough.
5889 # This seems to be due to autoconf 2.5x stupidity.
5890 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5891
5892 target_configargs=${baseargs}
5893
5894 # Passing a --with-cross-host argument lets the target libraries know
5895 # whether they are being built with a cross-compiler or being built
5896 # native.  However, it would be better to use other mechanisms to make the
5897 # sorts of decisions they want to make on this basis.  Please consider
5898 # this option to be deprecated.  FIXME.
5899 if test x${is_cross_compiler} = xyes ; then
5900   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5901 fi
5902
5903 # Default to --enable-multilib.
5904 if test x${enable_multilib} = x ; then
5905   target_configargs="--enable-multilib ${target_configargs}"
5906 fi
5907
5908 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5909 # changed from the earlier setting of with_newlib.
5910 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5911   target_configargs="--with-newlib ${target_configargs}"
5912 fi
5913
5914 # Different target subdirs use different values of certain variables
5915 # (notably CXX).  Worse, multilibs use *lots* of different values.
5916 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5917 # it doesn't automatically accept command-line overrides of them.
5918 # This means it's not safe for target subdirs to share a cache file,
5919 # which is disgusting, but there you have it.  Hopefully this can be
5920 # fixed in future.  It's still worthwhile to use a cache file for each
5921 # directory.  I think.
5922
5923 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5924 # We need to pass --target, as newer autoconf's requires consistency
5925 # for target_alias and gcc doesn't manage it consistently.
5926 target_configargs="--cache-file=./config.cache ${target_configargs}"
5927
5928 FLAGS_FOR_TARGET=
5929 case " $target_configdirs " in
5930  *" newlib "*)
5931   case " $target_configargs " in
5932   *" --with-newlib "*)
5933    case "$target" in
5934    *-cygwin*)
5935      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' ;;
5936    esac
5937
5938    # If we're not building GCC, don't discard standard headers.
5939    if test -d ${srcdir}/gcc; then
5940      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5941
5942      if test "${build}" != "${host}"; then
5943        # On Canadian crosses, CC_FOR_TARGET will have already been set
5944        # by `configure', so we won't have an opportunity to add -Bgcc/
5945        # to it.  This is right: we don't want to search that directory
5946        # for binaries, but we want the header files in there, so add
5947        # them explicitly.
5948        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5949
5950        # Someone might think of using the pre-installed headers on
5951        # Canadian crosses, in case the installed compiler is not fully
5952        # compatible with the compiler being built.  In this case, it
5953        # would be better to flag an error than risking having
5954        # incompatible object files being constructed.  We can't
5955        # guarantee that an error will be flagged, but let's hope the
5956        # compiler will do it, when presented with incompatible header
5957        # files.
5958      fi
5959    fi
5960
5961    case "${target}-${is_cross_compiler}" in
5962    i[3456789]86-*-linux*-no)
5963       # Here host == target, so we don't need to build gcc,
5964       # so we don't want to discard standard headers.
5965       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5966       ;;
5967    *)
5968       # If we're building newlib, use its generic headers last, but search
5969       # for any libc-related directories first (so make it the last -B
5970       # switch).
5971       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5972
5973       # If we're building libgloss, find the startup file, simulator library
5974       # and linker script.
5975       case " $target_configdirs " in
5976         *" libgloss "*)
5977         # Look for startup file, simulator library and maybe linker script.
5978         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
5979         # Look for libnosys.a in case the target needs it.
5980         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5981         # Most targets have the linker script in the source directory.
5982         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
5983         ;;
5984       esac
5985       ;;
5986    esac
5987    ;;
5988   esac
5989   ;;
5990 esac
5991 case "$target" in
5992 *-mingw*)
5993   # Can't be handled as Cygwin above since Mingw does not use newlib.
5994   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' ;;
5995 esac
5996
5997 # Allow the user to override the flags for
5998 # our build compiler if desired.
5999 if test x"${build}" = x"${host}" ; then
6000   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6001   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6002   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6003 fi
6004
6005 # On Canadian crosses, we'll be searching the right directories for
6006 # the previously-installed cross compiler, so don't bother to add
6007 # flags for directories within the install tree of the compiler
6008 # being built; programs in there won't even run.
6009 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6010   # Search for pre-installed headers if nothing else fits.
6011   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6012 fi
6013
6014 if test "x${use_gnu_ld}" = x &&
6015    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6016   # Arrange for us to find uninstalled linker scripts.
6017   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6018 fi
6019
6020 # Search for other target-specific linker scripts and such.
6021 case "${target}" in
6022   mep*)
6023     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6024     ;;
6025 esac
6026
6027 # Makefile fragments.
6028 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6029 do
6030   eval fragval=\$$frag
6031   if test $fragval != /dev/null; then
6032     eval $frag=${srcdir}/$fragval
6033   fi
6034 done
6035
6036
6037
6038
6039
6040 # Miscellanea: directories, flags, etc.
6041
6042
6043
6044
6045
6046
6047
6048 # Build module lists & subconfigure args.
6049
6050
6051
6052 # Host module lists & subconfigure args.
6053
6054
6055
6056 # Target module lists & subconfigure args.
6057
6058
6059
6060 # Build tools.
6061
6062
6063
6064
6065
6066
6067
6068
6069
6070
6071
6072
6073
6074
6075
6076
6077
6078 # Generate default definitions for YACC, M4, LEX and other programs that run
6079 # on the build machine.  These are used if the Makefile can't locate these
6080 # programs in objdir.
6081 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6082
6083 for ac_prog in 'bison -y' byacc yacc
6084 do
6085   # Extract the first word of "$ac_prog", so it can be a program name with args.
6086 set dummy $ac_prog; ac_word=$2
6087 echo "$as_me:$LINENO: checking for $ac_word" >&5
6088 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6089 if test "${ac_cv_prog_YACC+set}" = set; then
6090   echo $ECHO_N "(cached) $ECHO_C" >&6
6091 else
6092   if test -n "$YACC"; then
6093   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6094 else
6095 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6096 for as_dir in $PATH
6097 do
6098   IFS=$as_save_IFS
6099   test -z "$as_dir" && as_dir=.
6100   for ac_exec_ext in '' $ac_executable_extensions; do
6101   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6102     ac_cv_prog_YACC="$ac_prog"
6103     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6104     break 2
6105   fi
6106 done
6107 done
6108
6109 fi
6110 fi
6111 YACC=$ac_cv_prog_YACC
6112 if test -n "$YACC"; then
6113   echo "$as_me:$LINENO: result: $YACC" >&5
6114 echo "${ECHO_T}$YACC" >&6
6115 else
6116   echo "$as_me:$LINENO: result: no" >&5
6117 echo "${ECHO_T}no" >&6
6118 fi
6119
6120   test -n "$YACC" && break
6121 done
6122 test -n "$YACC" || YACC="$MISSING bison -y"
6123
6124 case " $build_configdirs " in
6125   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6126   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6127 esac
6128
6129 for ac_prog in bison
6130 do
6131   # Extract the first word of "$ac_prog", so it can be a program name with args.
6132 set dummy $ac_prog; ac_word=$2
6133 echo "$as_me:$LINENO: checking for $ac_word" >&5
6134 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6135 if test "${ac_cv_prog_BISON+set}" = set; then
6136   echo $ECHO_N "(cached) $ECHO_C" >&6
6137 else
6138   if test -n "$BISON"; then
6139   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6140 else
6141 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6142 for as_dir in $PATH
6143 do
6144   IFS=$as_save_IFS
6145   test -z "$as_dir" && as_dir=.
6146   for ac_exec_ext in '' $ac_executable_extensions; do
6147   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6148     ac_cv_prog_BISON="$ac_prog"
6149     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6150     break 2
6151   fi
6152 done
6153 done
6154
6155 fi
6156 fi
6157 BISON=$ac_cv_prog_BISON
6158 if test -n "$BISON"; then
6159   echo "$as_me:$LINENO: result: $BISON" >&5
6160 echo "${ECHO_T}$BISON" >&6
6161 else
6162   echo "$as_me:$LINENO: result: no" >&5
6163 echo "${ECHO_T}no" >&6
6164 fi
6165
6166   test -n "$BISON" && break
6167 done
6168 test -n "$BISON" || BISON="$MISSING bison"
6169
6170 case " $build_configdirs " in
6171   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6172 esac
6173
6174 for ac_prog in gm4 gnum4 m4
6175 do
6176   # Extract the first word of "$ac_prog", so it can be a program name with args.
6177 set dummy $ac_prog; ac_word=$2
6178 echo "$as_me:$LINENO: checking for $ac_word" >&5
6179 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6180 if test "${ac_cv_prog_M4+set}" = set; then
6181   echo $ECHO_N "(cached) $ECHO_C" >&6
6182 else
6183   if test -n "$M4"; then
6184   ac_cv_prog_M4="$M4" # Let the user override the test.
6185 else
6186 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6187 for as_dir in $PATH
6188 do
6189   IFS=$as_save_IFS
6190   test -z "$as_dir" && as_dir=.
6191   for ac_exec_ext in '' $ac_executable_extensions; do
6192   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6193     ac_cv_prog_M4="$ac_prog"
6194     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6195     break 2
6196   fi
6197 done
6198 done
6199
6200 fi
6201 fi
6202 M4=$ac_cv_prog_M4
6203 if test -n "$M4"; then
6204   echo "$as_me:$LINENO: result: $M4" >&5
6205 echo "${ECHO_T}$M4" >&6
6206 else
6207   echo "$as_me:$LINENO: result: no" >&5
6208 echo "${ECHO_T}no" >&6
6209 fi
6210
6211   test -n "$M4" && break
6212 done
6213 test -n "$M4" || M4="$MISSING m4"
6214
6215 case " $build_configdirs " in
6216   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6217 esac
6218
6219 for ac_prog in flex lex
6220 do
6221   # Extract the first word of "$ac_prog", so it can be a program name with args.
6222 set dummy $ac_prog; ac_word=$2
6223 echo "$as_me:$LINENO: checking for $ac_word" >&5
6224 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6225 if test "${ac_cv_prog_LEX+set}" = set; then
6226   echo $ECHO_N "(cached) $ECHO_C" >&6
6227 else
6228   if test -n "$LEX"; then
6229   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6230 else
6231 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6232 for as_dir in $PATH
6233 do
6234   IFS=$as_save_IFS
6235   test -z "$as_dir" && as_dir=.
6236   for ac_exec_ext in '' $ac_executable_extensions; do
6237   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6238     ac_cv_prog_LEX="$ac_prog"
6239     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6240     break 2
6241   fi
6242 done
6243 done
6244
6245 fi
6246 fi
6247 LEX=$ac_cv_prog_LEX
6248 if test -n "$LEX"; then
6249   echo "$as_me:$LINENO: result: $LEX" >&5
6250 echo "${ECHO_T}$LEX" >&6
6251 else
6252   echo "$as_me:$LINENO: result: no" >&5
6253 echo "${ECHO_T}no" >&6
6254 fi
6255
6256   test -n "$LEX" && break
6257 done
6258 test -n "$LEX" || LEX="$MISSING flex"
6259
6260 case " $build_configdirs " in
6261   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6262   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6263 esac
6264
6265 for ac_prog in flex
6266 do
6267   # Extract the first word of "$ac_prog", so it can be a program name with args.
6268 set dummy $ac_prog; ac_word=$2
6269 echo "$as_me:$LINENO: checking for $ac_word" >&5
6270 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6271 if test "${ac_cv_prog_FLEX+set}" = set; then
6272   echo $ECHO_N "(cached) $ECHO_C" >&6
6273 else
6274   if test -n "$FLEX"; then
6275   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6276 else
6277 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6278 for as_dir in $PATH
6279 do
6280   IFS=$as_save_IFS
6281   test -z "$as_dir" && as_dir=.
6282   for ac_exec_ext in '' $ac_executable_extensions; do
6283   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6284     ac_cv_prog_FLEX="$ac_prog"
6285     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6286     break 2
6287   fi
6288 done
6289 done
6290
6291 fi
6292 fi
6293 FLEX=$ac_cv_prog_FLEX
6294 if test -n "$FLEX"; then
6295   echo "$as_me:$LINENO: result: $FLEX" >&5
6296 echo "${ECHO_T}$FLEX" >&6
6297 else
6298   echo "$as_me:$LINENO: result: no" >&5
6299 echo "${ECHO_T}no" >&6
6300 fi
6301
6302   test -n "$FLEX" && break
6303 done
6304 test -n "$FLEX" || FLEX="$MISSING flex"
6305
6306 case " $build_configdirs " in
6307   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6308 esac
6309
6310 for ac_prog in makeinfo
6311 do
6312   # Extract the first word of "$ac_prog", so it can be a program name with args.
6313 set dummy $ac_prog; ac_word=$2
6314 echo "$as_me:$LINENO: checking for $ac_word" >&5
6315 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6316 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6317   echo $ECHO_N "(cached) $ECHO_C" >&6
6318 else
6319   if test -n "$MAKEINFO"; then
6320   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6321 else
6322 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6323 for as_dir in $PATH
6324 do
6325   IFS=$as_save_IFS
6326   test -z "$as_dir" && as_dir=.
6327   for ac_exec_ext in '' $ac_executable_extensions; do
6328   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6329     ac_cv_prog_MAKEINFO="$ac_prog"
6330     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6331     break 2
6332   fi
6333 done
6334 done
6335
6336 fi
6337 fi
6338 MAKEINFO=$ac_cv_prog_MAKEINFO
6339 if test -n "$MAKEINFO"; then
6340   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6341 echo "${ECHO_T}$MAKEINFO" >&6
6342 else
6343   echo "$as_me:$LINENO: result: no" >&5
6344 echo "${ECHO_T}no" >&6
6345 fi
6346
6347   test -n "$MAKEINFO" && break
6348 done
6349 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6350
6351 case " $build_configdirs " in
6352   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6353   *)
6354
6355     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6356     # higher, else we use the "missing" dummy.
6357     if ${MAKEINFO} --version \
6358        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6359       :
6360     else
6361       MAKEINFO="$MISSING makeinfo"
6362     fi
6363     ;;
6364
6365 esac
6366
6367 # FIXME: expect and dejagnu may become build tools?
6368
6369 for ac_prog in expect
6370 do
6371   # Extract the first word of "$ac_prog", so it can be a program name with args.
6372 set dummy $ac_prog; ac_word=$2
6373 echo "$as_me:$LINENO: checking for $ac_word" >&5
6374 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6375 if test "${ac_cv_prog_EXPECT+set}" = set; then
6376   echo $ECHO_N "(cached) $ECHO_C" >&6
6377 else
6378   if test -n "$EXPECT"; then
6379   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6380 else
6381 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6382 for as_dir in $PATH
6383 do
6384   IFS=$as_save_IFS
6385   test -z "$as_dir" && as_dir=.
6386   for ac_exec_ext in '' $ac_executable_extensions; do
6387   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6388     ac_cv_prog_EXPECT="$ac_prog"
6389     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6390     break 2
6391   fi
6392 done
6393 done
6394
6395 fi
6396 fi
6397 EXPECT=$ac_cv_prog_EXPECT
6398 if test -n "$EXPECT"; then
6399   echo "$as_me:$LINENO: result: $EXPECT" >&5
6400 echo "${ECHO_T}$EXPECT" >&6
6401 else
6402   echo "$as_me:$LINENO: result: no" >&5
6403 echo "${ECHO_T}no" >&6
6404 fi
6405
6406   test -n "$EXPECT" && break
6407 done
6408 test -n "$EXPECT" || EXPECT="expect"
6409
6410 case " $configdirs " in
6411   *" expect "*)
6412     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6413     ;;
6414 esac
6415
6416 for ac_prog in runtest
6417 do
6418   # Extract the first word of "$ac_prog", so it can be a program name with args.
6419 set dummy $ac_prog; ac_word=$2
6420 echo "$as_me:$LINENO: checking for $ac_word" >&5
6421 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6422 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6423   echo $ECHO_N "(cached) $ECHO_C" >&6
6424 else
6425   if test -n "$RUNTEST"; then
6426   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6427 else
6428 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6429 for as_dir in $PATH
6430 do
6431   IFS=$as_save_IFS
6432   test -z "$as_dir" && as_dir=.
6433   for ac_exec_ext in '' $ac_executable_extensions; do
6434   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6435     ac_cv_prog_RUNTEST="$ac_prog"
6436     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6437     break 2
6438   fi
6439 done
6440 done
6441
6442 fi
6443 fi
6444 RUNTEST=$ac_cv_prog_RUNTEST
6445 if test -n "$RUNTEST"; then
6446   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6447 echo "${ECHO_T}$RUNTEST" >&6
6448 else
6449   echo "$as_me:$LINENO: result: no" >&5
6450 echo "${ECHO_T}no" >&6
6451 fi
6452
6453   test -n "$RUNTEST" && break
6454 done
6455 test -n "$RUNTEST" || RUNTEST="runtest"
6456
6457 case " $configdirs " in
6458   *" dejagnu "*)
6459     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6460     ;;
6461 esac
6462
6463
6464 # Host tools.
6465 ncn_tool_prefix=
6466 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6467 ncn_target_tool_prefix=
6468 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6469
6470
6471
6472 if test -n "$AR"; then
6473   ac_cv_prog_AR=$AR
6474 elif test -n "$ac_cv_prog_AR"; then
6475   AR=$ac_cv_prog_AR
6476 fi
6477
6478 if test -n "$ac_cv_prog_AR"; then
6479   for ncn_progname in ar; do
6480     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6481 set dummy ${ncn_progname}; ac_word=$2
6482 echo "$as_me:$LINENO: checking for $ac_word" >&5
6483 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6484 if test "${ac_cv_prog_AR+set}" = set; then
6485   echo $ECHO_N "(cached) $ECHO_C" >&6
6486 else
6487   if test -n "$AR"; then
6488   ac_cv_prog_AR="$AR" # Let the user override the test.
6489 else
6490 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6491 for as_dir in $PATH
6492 do
6493   IFS=$as_save_IFS
6494   test -z "$as_dir" && as_dir=.
6495   for ac_exec_ext in '' $ac_executable_extensions; do
6496   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6497     ac_cv_prog_AR="${ncn_progname}"
6498     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6499     break 2
6500   fi
6501 done
6502 done
6503
6504 fi
6505 fi
6506 AR=$ac_cv_prog_AR
6507 if test -n "$AR"; then
6508   echo "$as_me:$LINENO: result: $AR" >&5
6509 echo "${ECHO_T}$AR" >&6
6510 else
6511   echo "$as_me:$LINENO: result: no" >&5
6512 echo "${ECHO_T}no" >&6
6513 fi
6514
6515   done
6516 fi
6517
6518 for ncn_progname in ar; do
6519   if test -n "$ncn_tool_prefix"; then
6520     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6521 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6522 echo "$as_me:$LINENO: checking for $ac_word" >&5
6523 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6524 if test "${ac_cv_prog_AR+set}" = set; then
6525   echo $ECHO_N "(cached) $ECHO_C" >&6
6526 else
6527   if test -n "$AR"; then
6528   ac_cv_prog_AR="$AR" # Let the user override the test.
6529 else
6530 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6531 for as_dir in $PATH
6532 do
6533   IFS=$as_save_IFS
6534   test -z "$as_dir" && as_dir=.
6535   for ac_exec_ext in '' $ac_executable_extensions; do
6536   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6537     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6538     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6539     break 2
6540   fi
6541 done
6542 done
6543
6544 fi
6545 fi
6546 AR=$ac_cv_prog_AR
6547 if test -n "$AR"; then
6548   echo "$as_me:$LINENO: result: $AR" >&5
6549 echo "${ECHO_T}$AR" >&6
6550 else
6551   echo "$as_me:$LINENO: result: no" >&5
6552 echo "${ECHO_T}no" >&6
6553 fi
6554
6555   fi
6556   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6557     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6558 set dummy ${ncn_progname}; ac_word=$2
6559 echo "$as_me:$LINENO: checking for $ac_word" >&5
6560 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6561 if test "${ac_cv_prog_AR+set}" = set; then
6562   echo $ECHO_N "(cached) $ECHO_C" >&6
6563 else
6564   if test -n "$AR"; then
6565   ac_cv_prog_AR="$AR" # Let the user override the test.
6566 else
6567 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6568 for as_dir in $PATH
6569 do
6570   IFS=$as_save_IFS
6571   test -z "$as_dir" && as_dir=.
6572   for ac_exec_ext in '' $ac_executable_extensions; do
6573   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6574     ac_cv_prog_AR="${ncn_progname}"
6575     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6576     break 2
6577   fi
6578 done
6579 done
6580
6581 fi
6582 fi
6583 AR=$ac_cv_prog_AR
6584 if test -n "$AR"; then
6585   echo "$as_me:$LINENO: result: $AR" >&5
6586 echo "${ECHO_T}$AR" >&6
6587 else
6588   echo "$as_me:$LINENO: result: no" >&5
6589 echo "${ECHO_T}no" >&6
6590 fi
6591
6592   fi
6593   test -n "$ac_cv_prog_AR" && break
6594 done
6595
6596 if test -z "$ac_cv_prog_AR" ; then
6597   set dummy ar
6598   if test $build = $host ; then
6599     AR="$2"
6600   else
6601     AR="${ncn_tool_prefix}$2"
6602   fi
6603 fi
6604
6605
6606
6607 if test -n "$AS"; then
6608   ac_cv_prog_AS=$AS
6609 elif test -n "$ac_cv_prog_AS"; then
6610   AS=$ac_cv_prog_AS
6611 fi
6612
6613 if test -n "$ac_cv_prog_AS"; then
6614   for ncn_progname in as; do
6615     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6616 set dummy ${ncn_progname}; ac_word=$2
6617 echo "$as_me:$LINENO: checking for $ac_word" >&5
6618 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6619 if test "${ac_cv_prog_AS+set}" = set; then
6620   echo $ECHO_N "(cached) $ECHO_C" >&6
6621 else
6622   if test -n "$AS"; then
6623   ac_cv_prog_AS="$AS" # Let the user override the test.
6624 else
6625 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6626 for as_dir in $PATH
6627 do
6628   IFS=$as_save_IFS
6629   test -z "$as_dir" && as_dir=.
6630   for ac_exec_ext in '' $ac_executable_extensions; do
6631   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6632     ac_cv_prog_AS="${ncn_progname}"
6633     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6634     break 2
6635   fi
6636 done
6637 done
6638
6639 fi
6640 fi
6641 AS=$ac_cv_prog_AS
6642 if test -n "$AS"; then
6643   echo "$as_me:$LINENO: result: $AS" >&5
6644 echo "${ECHO_T}$AS" >&6
6645 else
6646   echo "$as_me:$LINENO: result: no" >&5
6647 echo "${ECHO_T}no" >&6
6648 fi
6649
6650   done
6651 fi
6652
6653 for ncn_progname in as; do
6654   if test -n "$ncn_tool_prefix"; then
6655     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6656 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6657 echo "$as_me:$LINENO: checking for $ac_word" >&5
6658 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6659 if test "${ac_cv_prog_AS+set}" = set; then
6660   echo $ECHO_N "(cached) $ECHO_C" >&6
6661 else
6662   if test -n "$AS"; then
6663   ac_cv_prog_AS="$AS" # Let the user override the test.
6664 else
6665 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6666 for as_dir in $PATH
6667 do
6668   IFS=$as_save_IFS
6669   test -z "$as_dir" && as_dir=.
6670   for ac_exec_ext in '' $ac_executable_extensions; do
6671   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6672     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6673     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6674     break 2
6675   fi
6676 done
6677 done
6678
6679 fi
6680 fi
6681 AS=$ac_cv_prog_AS
6682 if test -n "$AS"; then
6683   echo "$as_me:$LINENO: result: $AS" >&5
6684 echo "${ECHO_T}$AS" >&6
6685 else
6686   echo "$as_me:$LINENO: result: no" >&5
6687 echo "${ECHO_T}no" >&6
6688 fi
6689
6690   fi
6691   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6692     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6693 set dummy ${ncn_progname}; ac_word=$2
6694 echo "$as_me:$LINENO: checking for $ac_word" >&5
6695 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6696 if test "${ac_cv_prog_AS+set}" = set; then
6697   echo $ECHO_N "(cached) $ECHO_C" >&6
6698 else
6699   if test -n "$AS"; then
6700   ac_cv_prog_AS="$AS" # Let the user override the test.
6701 else
6702 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6703 for as_dir in $PATH
6704 do
6705   IFS=$as_save_IFS
6706   test -z "$as_dir" && as_dir=.
6707   for ac_exec_ext in '' $ac_executable_extensions; do
6708   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6709     ac_cv_prog_AS="${ncn_progname}"
6710     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6711     break 2
6712   fi
6713 done
6714 done
6715
6716 fi
6717 fi
6718 AS=$ac_cv_prog_AS
6719 if test -n "$AS"; then
6720   echo "$as_me:$LINENO: result: $AS" >&5
6721 echo "${ECHO_T}$AS" >&6
6722 else
6723   echo "$as_me:$LINENO: result: no" >&5
6724 echo "${ECHO_T}no" >&6
6725 fi
6726
6727   fi
6728   test -n "$ac_cv_prog_AS" && break
6729 done
6730
6731 if test -z "$ac_cv_prog_AS" ; then
6732   set dummy as
6733   if test $build = $host ; then
6734     AS="$2"
6735   else
6736     AS="${ncn_tool_prefix}$2"
6737   fi
6738 fi
6739
6740
6741
6742 if test -n "$DLLTOOL"; then
6743   ac_cv_prog_DLLTOOL=$DLLTOOL
6744 elif test -n "$ac_cv_prog_DLLTOOL"; then
6745   DLLTOOL=$ac_cv_prog_DLLTOOL
6746 fi
6747
6748 if test -n "$ac_cv_prog_DLLTOOL"; then
6749   for ncn_progname in dlltool; do
6750     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6751 set dummy ${ncn_progname}; ac_word=$2
6752 echo "$as_me:$LINENO: checking for $ac_word" >&5
6753 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6754 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6755   echo $ECHO_N "(cached) $ECHO_C" >&6
6756 else
6757   if test -n "$DLLTOOL"; then
6758   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6759 else
6760 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6761 for as_dir in $PATH
6762 do
6763   IFS=$as_save_IFS
6764   test -z "$as_dir" && as_dir=.
6765   for ac_exec_ext in '' $ac_executable_extensions; do
6766   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6767     ac_cv_prog_DLLTOOL="${ncn_progname}"
6768     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6769     break 2
6770   fi
6771 done
6772 done
6773
6774 fi
6775 fi
6776 DLLTOOL=$ac_cv_prog_DLLTOOL
6777 if test -n "$DLLTOOL"; then
6778   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6779 echo "${ECHO_T}$DLLTOOL" >&6
6780 else
6781   echo "$as_me:$LINENO: result: no" >&5
6782 echo "${ECHO_T}no" >&6
6783 fi
6784
6785   done
6786 fi
6787
6788 for ncn_progname in dlltool; do
6789   if test -n "$ncn_tool_prefix"; then
6790     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6791 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6792 echo "$as_me:$LINENO: checking for $ac_word" >&5
6793 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6794 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6795   echo $ECHO_N "(cached) $ECHO_C" >&6
6796 else
6797   if test -n "$DLLTOOL"; then
6798   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6799 else
6800 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6801 for as_dir in $PATH
6802 do
6803   IFS=$as_save_IFS
6804   test -z "$as_dir" && as_dir=.
6805   for ac_exec_ext in '' $ac_executable_extensions; do
6806   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6807     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6808     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6809     break 2
6810   fi
6811 done
6812 done
6813
6814 fi
6815 fi
6816 DLLTOOL=$ac_cv_prog_DLLTOOL
6817 if test -n "$DLLTOOL"; then
6818   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6819 echo "${ECHO_T}$DLLTOOL" >&6
6820 else
6821   echo "$as_me:$LINENO: result: no" >&5
6822 echo "${ECHO_T}no" >&6
6823 fi
6824
6825   fi
6826   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6827     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6828 set dummy ${ncn_progname}; ac_word=$2
6829 echo "$as_me:$LINENO: checking for $ac_word" >&5
6830 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6831 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6832   echo $ECHO_N "(cached) $ECHO_C" >&6
6833 else
6834   if test -n "$DLLTOOL"; then
6835   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6836 else
6837 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6838 for as_dir in $PATH
6839 do
6840   IFS=$as_save_IFS
6841   test -z "$as_dir" && as_dir=.
6842   for ac_exec_ext in '' $ac_executable_extensions; do
6843   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6844     ac_cv_prog_DLLTOOL="${ncn_progname}"
6845     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6846     break 2
6847   fi
6848 done
6849 done
6850
6851 fi
6852 fi
6853 DLLTOOL=$ac_cv_prog_DLLTOOL
6854 if test -n "$DLLTOOL"; then
6855   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6856 echo "${ECHO_T}$DLLTOOL" >&6
6857 else
6858   echo "$as_me:$LINENO: result: no" >&5
6859 echo "${ECHO_T}no" >&6
6860 fi
6861
6862   fi
6863   test -n "$ac_cv_prog_DLLTOOL" && break
6864 done
6865
6866 if test -z "$ac_cv_prog_DLLTOOL" ; then
6867   set dummy dlltool
6868   if test $build = $host ; then
6869     DLLTOOL="$2"
6870   else
6871     DLLTOOL="${ncn_tool_prefix}$2"
6872   fi
6873 fi
6874
6875
6876
6877 if test -n "$LD"; then
6878   ac_cv_prog_LD=$LD
6879 elif test -n "$ac_cv_prog_LD"; then
6880   LD=$ac_cv_prog_LD
6881 fi
6882
6883 if test -n "$ac_cv_prog_LD"; then
6884   for ncn_progname in ld; do
6885     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6886 set dummy ${ncn_progname}; ac_word=$2
6887 echo "$as_me:$LINENO: checking for $ac_word" >&5
6888 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6889 if test "${ac_cv_prog_LD+set}" = set; then
6890   echo $ECHO_N "(cached) $ECHO_C" >&6
6891 else
6892   if test -n "$LD"; then
6893   ac_cv_prog_LD="$LD" # Let the user override the test.
6894 else
6895 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6896 for as_dir in $PATH
6897 do
6898   IFS=$as_save_IFS
6899   test -z "$as_dir" && as_dir=.
6900   for ac_exec_ext in '' $ac_executable_extensions; do
6901   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6902     ac_cv_prog_LD="${ncn_progname}"
6903     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6904     break 2
6905   fi
6906 done
6907 done
6908
6909 fi
6910 fi
6911 LD=$ac_cv_prog_LD
6912 if test -n "$LD"; then
6913   echo "$as_me:$LINENO: result: $LD" >&5
6914 echo "${ECHO_T}$LD" >&6
6915 else
6916   echo "$as_me:$LINENO: result: no" >&5
6917 echo "${ECHO_T}no" >&6
6918 fi
6919
6920   done
6921 fi
6922
6923 for ncn_progname in ld; do
6924   if test -n "$ncn_tool_prefix"; then
6925     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6926 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6927 echo "$as_me:$LINENO: checking for $ac_word" >&5
6928 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6929 if test "${ac_cv_prog_LD+set}" = set; then
6930   echo $ECHO_N "(cached) $ECHO_C" >&6
6931 else
6932   if test -n "$LD"; then
6933   ac_cv_prog_LD="$LD" # Let the user override the test.
6934 else
6935 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6936 for as_dir in $PATH
6937 do
6938   IFS=$as_save_IFS
6939   test -z "$as_dir" && as_dir=.
6940   for ac_exec_ext in '' $ac_executable_extensions; do
6941   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6942     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6943     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6944     break 2
6945   fi
6946 done
6947 done
6948
6949 fi
6950 fi
6951 LD=$ac_cv_prog_LD
6952 if test -n "$LD"; then
6953   echo "$as_me:$LINENO: result: $LD" >&5
6954 echo "${ECHO_T}$LD" >&6
6955 else
6956   echo "$as_me:$LINENO: result: no" >&5
6957 echo "${ECHO_T}no" >&6
6958 fi
6959
6960   fi
6961   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6962     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6963 set dummy ${ncn_progname}; ac_word=$2
6964 echo "$as_me:$LINENO: checking for $ac_word" >&5
6965 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6966 if test "${ac_cv_prog_LD+set}" = set; then
6967   echo $ECHO_N "(cached) $ECHO_C" >&6
6968 else
6969   if test -n "$LD"; then
6970   ac_cv_prog_LD="$LD" # Let the user override the test.
6971 else
6972 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6973 for as_dir in $PATH
6974 do
6975   IFS=$as_save_IFS
6976   test -z "$as_dir" && as_dir=.
6977   for ac_exec_ext in '' $ac_executable_extensions; do
6978   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6979     ac_cv_prog_LD="${ncn_progname}"
6980     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6981     break 2
6982   fi
6983 done
6984 done
6985
6986 fi
6987 fi
6988 LD=$ac_cv_prog_LD
6989 if test -n "$LD"; then
6990   echo "$as_me:$LINENO: result: $LD" >&5
6991 echo "${ECHO_T}$LD" >&6
6992 else
6993   echo "$as_me:$LINENO: result: no" >&5
6994 echo "${ECHO_T}no" >&6
6995 fi
6996
6997   fi
6998   test -n "$ac_cv_prog_LD" && break
6999 done
7000
7001 if test -z "$ac_cv_prog_LD" ; then
7002   set dummy ld
7003   if test $build = $host ; then
7004     LD="$2"
7005   else
7006     LD="${ncn_tool_prefix}$2"
7007   fi
7008 fi
7009
7010
7011
7012 if test -n "$LIPO"; then
7013   ac_cv_prog_LIPO=$LIPO
7014 elif test -n "$ac_cv_prog_LIPO"; then
7015   LIPO=$ac_cv_prog_LIPO
7016 fi
7017
7018 if test -n "$ac_cv_prog_LIPO"; then
7019   for ncn_progname in lipo; do
7020     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7021 set dummy ${ncn_progname}; ac_word=$2
7022 echo "$as_me:$LINENO: checking for $ac_word" >&5
7023 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7024 if test "${ac_cv_prog_LIPO+set}" = set; then
7025   echo $ECHO_N "(cached) $ECHO_C" >&6
7026 else
7027   if test -n "$LIPO"; then
7028   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7029 else
7030 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7031 for as_dir in $PATH
7032 do
7033   IFS=$as_save_IFS
7034   test -z "$as_dir" && as_dir=.
7035   for ac_exec_ext in '' $ac_executable_extensions; do
7036   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7037     ac_cv_prog_LIPO="${ncn_progname}"
7038     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7039     break 2
7040   fi
7041 done
7042 done
7043
7044 fi
7045 fi
7046 LIPO=$ac_cv_prog_LIPO
7047 if test -n "$LIPO"; then
7048   echo "$as_me:$LINENO: result: $LIPO" >&5
7049 echo "${ECHO_T}$LIPO" >&6
7050 else
7051   echo "$as_me:$LINENO: result: no" >&5
7052 echo "${ECHO_T}no" >&6
7053 fi
7054
7055   done
7056 fi
7057
7058 for ncn_progname in lipo; do
7059   if test -n "$ncn_tool_prefix"; then
7060     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7061 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7062 echo "$as_me:$LINENO: checking for $ac_word" >&5
7063 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7064 if test "${ac_cv_prog_LIPO+set}" = set; then
7065   echo $ECHO_N "(cached) $ECHO_C" >&6
7066 else
7067   if test -n "$LIPO"; then
7068   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7069 else
7070 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7071 for as_dir in $PATH
7072 do
7073   IFS=$as_save_IFS
7074   test -z "$as_dir" && as_dir=.
7075   for ac_exec_ext in '' $ac_executable_extensions; do
7076   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7077     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7078     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7079     break 2
7080   fi
7081 done
7082 done
7083
7084 fi
7085 fi
7086 LIPO=$ac_cv_prog_LIPO
7087 if test -n "$LIPO"; then
7088   echo "$as_me:$LINENO: result: $LIPO" >&5
7089 echo "${ECHO_T}$LIPO" >&6
7090 else
7091   echo "$as_me:$LINENO: result: no" >&5
7092 echo "${ECHO_T}no" >&6
7093 fi
7094
7095   fi
7096   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7097     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7098 set dummy ${ncn_progname}; ac_word=$2
7099 echo "$as_me:$LINENO: checking for $ac_word" >&5
7100 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7101 if test "${ac_cv_prog_LIPO+set}" = set; then
7102   echo $ECHO_N "(cached) $ECHO_C" >&6
7103 else
7104   if test -n "$LIPO"; then
7105   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7106 else
7107 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7108 for as_dir in $PATH
7109 do
7110   IFS=$as_save_IFS
7111   test -z "$as_dir" && as_dir=.
7112   for ac_exec_ext in '' $ac_executable_extensions; do
7113   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7114     ac_cv_prog_LIPO="${ncn_progname}"
7115     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7116     break 2
7117   fi
7118 done
7119 done
7120
7121 fi
7122 fi
7123 LIPO=$ac_cv_prog_LIPO
7124 if test -n "$LIPO"; then
7125   echo "$as_me:$LINENO: result: $LIPO" >&5
7126 echo "${ECHO_T}$LIPO" >&6
7127 else
7128   echo "$as_me:$LINENO: result: no" >&5
7129 echo "${ECHO_T}no" >&6
7130 fi
7131
7132   fi
7133   test -n "$ac_cv_prog_LIPO" && break
7134 done
7135
7136 if test -z "$ac_cv_prog_LIPO" ; then
7137   set dummy lipo
7138   if test $build = $host ; then
7139     LIPO="$2"
7140   else
7141     LIPO="${ncn_tool_prefix}$2"
7142   fi
7143 fi
7144
7145
7146
7147 if test -n "$NM"; then
7148   ac_cv_prog_NM=$NM
7149 elif test -n "$ac_cv_prog_NM"; then
7150   NM=$ac_cv_prog_NM
7151 fi
7152
7153 if test -n "$ac_cv_prog_NM"; then
7154   for ncn_progname in nm; do
7155     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7156 set dummy ${ncn_progname}; ac_word=$2
7157 echo "$as_me:$LINENO: checking for $ac_word" >&5
7158 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7159 if test "${ac_cv_prog_NM+set}" = set; then
7160   echo $ECHO_N "(cached) $ECHO_C" >&6
7161 else
7162   if test -n "$NM"; then
7163   ac_cv_prog_NM="$NM" # Let the user override the test.
7164 else
7165 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7166 for as_dir in $PATH
7167 do
7168   IFS=$as_save_IFS
7169   test -z "$as_dir" && as_dir=.
7170   for ac_exec_ext in '' $ac_executable_extensions; do
7171   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7172     ac_cv_prog_NM="${ncn_progname}"
7173     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7174     break 2
7175   fi
7176 done
7177 done
7178
7179 fi
7180 fi
7181 NM=$ac_cv_prog_NM
7182 if test -n "$NM"; then
7183   echo "$as_me:$LINENO: result: $NM" >&5
7184 echo "${ECHO_T}$NM" >&6
7185 else
7186   echo "$as_me:$LINENO: result: no" >&5
7187 echo "${ECHO_T}no" >&6
7188 fi
7189
7190   done
7191 fi
7192
7193 for ncn_progname in nm; do
7194   if test -n "$ncn_tool_prefix"; then
7195     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7196 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7197 echo "$as_me:$LINENO: checking for $ac_word" >&5
7198 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7199 if test "${ac_cv_prog_NM+set}" = set; then
7200   echo $ECHO_N "(cached) $ECHO_C" >&6
7201 else
7202   if test -n "$NM"; then
7203   ac_cv_prog_NM="$NM" # Let the user override the test.
7204 else
7205 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7206 for as_dir in $PATH
7207 do
7208   IFS=$as_save_IFS
7209   test -z "$as_dir" && as_dir=.
7210   for ac_exec_ext in '' $ac_executable_extensions; do
7211   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7212     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7213     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7214     break 2
7215   fi
7216 done
7217 done
7218
7219 fi
7220 fi
7221 NM=$ac_cv_prog_NM
7222 if test -n "$NM"; then
7223   echo "$as_me:$LINENO: result: $NM" >&5
7224 echo "${ECHO_T}$NM" >&6
7225 else
7226   echo "$as_me:$LINENO: result: no" >&5
7227 echo "${ECHO_T}no" >&6
7228 fi
7229
7230   fi
7231   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7232     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7233 set dummy ${ncn_progname}; ac_word=$2
7234 echo "$as_me:$LINENO: checking for $ac_word" >&5
7235 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7236 if test "${ac_cv_prog_NM+set}" = set; then
7237   echo $ECHO_N "(cached) $ECHO_C" >&6
7238 else
7239   if test -n "$NM"; then
7240   ac_cv_prog_NM="$NM" # Let the user override the test.
7241 else
7242 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7243 for as_dir in $PATH
7244 do
7245   IFS=$as_save_IFS
7246   test -z "$as_dir" && as_dir=.
7247   for ac_exec_ext in '' $ac_executable_extensions; do
7248   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7249     ac_cv_prog_NM="${ncn_progname}"
7250     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7251     break 2
7252   fi
7253 done
7254 done
7255
7256 fi
7257 fi
7258 NM=$ac_cv_prog_NM
7259 if test -n "$NM"; then
7260   echo "$as_me:$LINENO: result: $NM" >&5
7261 echo "${ECHO_T}$NM" >&6
7262 else
7263   echo "$as_me:$LINENO: result: no" >&5
7264 echo "${ECHO_T}no" >&6
7265 fi
7266
7267   fi
7268   test -n "$ac_cv_prog_NM" && break
7269 done
7270
7271 if test -z "$ac_cv_prog_NM" ; then
7272   set dummy nm
7273   if test $build = $host ; then
7274     NM="$2"
7275   else
7276     NM="${ncn_tool_prefix}$2"
7277   fi
7278 fi
7279
7280
7281
7282 if test -n "$RANLIB"; then
7283   ac_cv_prog_RANLIB=$RANLIB
7284 elif test -n "$ac_cv_prog_RANLIB"; then
7285   RANLIB=$ac_cv_prog_RANLIB
7286 fi
7287
7288 if test -n "$ac_cv_prog_RANLIB"; then
7289   for ncn_progname in ranlib; do
7290     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7291 set dummy ${ncn_progname}; ac_word=$2
7292 echo "$as_me:$LINENO: checking for $ac_word" >&5
7293 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7294 if test "${ac_cv_prog_RANLIB+set}" = set; then
7295   echo $ECHO_N "(cached) $ECHO_C" >&6
7296 else
7297   if test -n "$RANLIB"; then
7298   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7299 else
7300 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7301 for as_dir in $PATH
7302 do
7303   IFS=$as_save_IFS
7304   test -z "$as_dir" && as_dir=.
7305   for ac_exec_ext in '' $ac_executable_extensions; do
7306   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7307     ac_cv_prog_RANLIB="${ncn_progname}"
7308     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7309     break 2
7310   fi
7311 done
7312 done
7313
7314 fi
7315 fi
7316 RANLIB=$ac_cv_prog_RANLIB
7317 if test -n "$RANLIB"; then
7318   echo "$as_me:$LINENO: result: $RANLIB" >&5
7319 echo "${ECHO_T}$RANLIB" >&6
7320 else
7321   echo "$as_me:$LINENO: result: no" >&5
7322 echo "${ECHO_T}no" >&6
7323 fi
7324
7325   done
7326 fi
7327
7328 for ncn_progname in ranlib; do
7329   if test -n "$ncn_tool_prefix"; then
7330     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7331 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7332 echo "$as_me:$LINENO: checking for $ac_word" >&5
7333 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7334 if test "${ac_cv_prog_RANLIB+set}" = set; then
7335   echo $ECHO_N "(cached) $ECHO_C" >&6
7336 else
7337   if test -n "$RANLIB"; then
7338   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7339 else
7340 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7341 for as_dir in $PATH
7342 do
7343   IFS=$as_save_IFS
7344   test -z "$as_dir" && as_dir=.
7345   for ac_exec_ext in '' $ac_executable_extensions; do
7346   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7347     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7348     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7349     break 2
7350   fi
7351 done
7352 done
7353
7354 fi
7355 fi
7356 RANLIB=$ac_cv_prog_RANLIB
7357 if test -n "$RANLIB"; then
7358   echo "$as_me:$LINENO: result: $RANLIB" >&5
7359 echo "${ECHO_T}$RANLIB" >&6
7360 else
7361   echo "$as_me:$LINENO: result: no" >&5
7362 echo "${ECHO_T}no" >&6
7363 fi
7364
7365   fi
7366   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7367     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7368 set dummy ${ncn_progname}; ac_word=$2
7369 echo "$as_me:$LINENO: checking for $ac_word" >&5
7370 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7371 if test "${ac_cv_prog_RANLIB+set}" = set; then
7372   echo $ECHO_N "(cached) $ECHO_C" >&6
7373 else
7374   if test -n "$RANLIB"; then
7375   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7376 else
7377 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7378 for as_dir in $PATH
7379 do
7380   IFS=$as_save_IFS
7381   test -z "$as_dir" && as_dir=.
7382   for ac_exec_ext in '' $ac_executable_extensions; do
7383   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7384     ac_cv_prog_RANLIB="${ncn_progname}"
7385     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7386     break 2
7387   fi
7388 done
7389 done
7390
7391 fi
7392 fi
7393 RANLIB=$ac_cv_prog_RANLIB
7394 if test -n "$RANLIB"; then
7395   echo "$as_me:$LINENO: result: $RANLIB" >&5
7396 echo "${ECHO_T}$RANLIB" >&6
7397 else
7398   echo "$as_me:$LINENO: result: no" >&5
7399 echo "${ECHO_T}no" >&6
7400 fi
7401
7402   fi
7403   test -n "$ac_cv_prog_RANLIB" && break
7404 done
7405
7406 if test -z "$ac_cv_prog_RANLIB" ; then
7407   RANLIB=":"
7408 fi
7409
7410
7411
7412 if test -n "$STRIP"; then
7413   ac_cv_prog_STRIP=$STRIP
7414 elif test -n "$ac_cv_prog_STRIP"; then
7415   STRIP=$ac_cv_prog_STRIP
7416 fi
7417
7418 if test -n "$ac_cv_prog_STRIP"; then
7419   for ncn_progname in strip; do
7420     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7421 set dummy ${ncn_progname}; ac_word=$2
7422 echo "$as_me:$LINENO: checking for $ac_word" >&5
7423 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7424 if test "${ac_cv_prog_STRIP+set}" = set; then
7425   echo $ECHO_N "(cached) $ECHO_C" >&6
7426 else
7427   if test -n "$STRIP"; then
7428   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7429 else
7430 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7431 for as_dir in $PATH
7432 do
7433   IFS=$as_save_IFS
7434   test -z "$as_dir" && as_dir=.
7435   for ac_exec_ext in '' $ac_executable_extensions; do
7436   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7437     ac_cv_prog_STRIP="${ncn_progname}"
7438     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7439     break 2
7440   fi
7441 done
7442 done
7443
7444 fi
7445 fi
7446 STRIP=$ac_cv_prog_STRIP
7447 if test -n "$STRIP"; then
7448   echo "$as_me:$LINENO: result: $STRIP" >&5
7449 echo "${ECHO_T}$STRIP" >&6
7450 else
7451   echo "$as_me:$LINENO: result: no" >&5
7452 echo "${ECHO_T}no" >&6
7453 fi
7454
7455   done
7456 fi
7457
7458 for ncn_progname in strip; do
7459   if test -n "$ncn_tool_prefix"; then
7460     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7461 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7462 echo "$as_me:$LINENO: checking for $ac_word" >&5
7463 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7464 if test "${ac_cv_prog_STRIP+set}" = set; then
7465   echo $ECHO_N "(cached) $ECHO_C" >&6
7466 else
7467   if test -n "$STRIP"; then
7468   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7469 else
7470 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7471 for as_dir in $PATH
7472 do
7473   IFS=$as_save_IFS
7474   test -z "$as_dir" && as_dir=.
7475   for ac_exec_ext in '' $ac_executable_extensions; do
7476   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7477     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7478     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7479     break 2
7480   fi
7481 done
7482 done
7483
7484 fi
7485 fi
7486 STRIP=$ac_cv_prog_STRIP
7487 if test -n "$STRIP"; then
7488   echo "$as_me:$LINENO: result: $STRIP" >&5
7489 echo "${ECHO_T}$STRIP" >&6
7490 else
7491   echo "$as_me:$LINENO: result: no" >&5
7492 echo "${ECHO_T}no" >&6
7493 fi
7494
7495   fi
7496   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7497     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7498 set dummy ${ncn_progname}; ac_word=$2
7499 echo "$as_me:$LINENO: checking for $ac_word" >&5
7500 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7501 if test "${ac_cv_prog_STRIP+set}" = set; then
7502   echo $ECHO_N "(cached) $ECHO_C" >&6
7503 else
7504   if test -n "$STRIP"; then
7505   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7506 else
7507 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7508 for as_dir in $PATH
7509 do
7510   IFS=$as_save_IFS
7511   test -z "$as_dir" && as_dir=.
7512   for ac_exec_ext in '' $ac_executable_extensions; do
7513   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7514     ac_cv_prog_STRIP="${ncn_progname}"
7515     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7516     break 2
7517   fi
7518 done
7519 done
7520
7521 fi
7522 fi
7523 STRIP=$ac_cv_prog_STRIP
7524 if test -n "$STRIP"; then
7525   echo "$as_me:$LINENO: result: $STRIP" >&5
7526 echo "${ECHO_T}$STRIP" >&6
7527 else
7528   echo "$as_me:$LINENO: result: no" >&5
7529 echo "${ECHO_T}no" >&6
7530 fi
7531
7532   fi
7533   test -n "$ac_cv_prog_STRIP" && break
7534 done
7535
7536 if test -z "$ac_cv_prog_STRIP" ; then
7537   STRIP=":"
7538 fi
7539
7540
7541
7542 if test -n "$WINDRES"; then
7543   ac_cv_prog_WINDRES=$WINDRES
7544 elif test -n "$ac_cv_prog_WINDRES"; then
7545   WINDRES=$ac_cv_prog_WINDRES
7546 fi
7547
7548 if test -n "$ac_cv_prog_WINDRES"; then
7549   for ncn_progname in windres; do
7550     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7551 set dummy ${ncn_progname}; ac_word=$2
7552 echo "$as_me:$LINENO: checking for $ac_word" >&5
7553 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7554 if test "${ac_cv_prog_WINDRES+set}" = set; then
7555   echo $ECHO_N "(cached) $ECHO_C" >&6
7556 else
7557   if test -n "$WINDRES"; then
7558   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7559 else
7560 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7561 for as_dir in $PATH
7562 do
7563   IFS=$as_save_IFS
7564   test -z "$as_dir" && as_dir=.
7565   for ac_exec_ext in '' $ac_executable_extensions; do
7566   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7567     ac_cv_prog_WINDRES="${ncn_progname}"
7568     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7569     break 2
7570   fi
7571 done
7572 done
7573
7574 fi
7575 fi
7576 WINDRES=$ac_cv_prog_WINDRES
7577 if test -n "$WINDRES"; then
7578   echo "$as_me:$LINENO: result: $WINDRES" >&5
7579 echo "${ECHO_T}$WINDRES" >&6
7580 else
7581   echo "$as_me:$LINENO: result: no" >&5
7582 echo "${ECHO_T}no" >&6
7583 fi
7584
7585   done
7586 fi
7587
7588 for ncn_progname in windres; do
7589   if test -n "$ncn_tool_prefix"; then
7590     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7591 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7592 echo "$as_me:$LINENO: checking for $ac_word" >&5
7593 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7594 if test "${ac_cv_prog_WINDRES+set}" = set; then
7595   echo $ECHO_N "(cached) $ECHO_C" >&6
7596 else
7597   if test -n "$WINDRES"; then
7598   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7599 else
7600 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7601 for as_dir in $PATH
7602 do
7603   IFS=$as_save_IFS
7604   test -z "$as_dir" && as_dir=.
7605   for ac_exec_ext in '' $ac_executable_extensions; do
7606   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7607     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7608     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7609     break 2
7610   fi
7611 done
7612 done
7613
7614 fi
7615 fi
7616 WINDRES=$ac_cv_prog_WINDRES
7617 if test -n "$WINDRES"; then
7618   echo "$as_me:$LINENO: result: $WINDRES" >&5
7619 echo "${ECHO_T}$WINDRES" >&6
7620 else
7621   echo "$as_me:$LINENO: result: no" >&5
7622 echo "${ECHO_T}no" >&6
7623 fi
7624
7625   fi
7626   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7627     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7628 set dummy ${ncn_progname}; ac_word=$2
7629 echo "$as_me:$LINENO: checking for $ac_word" >&5
7630 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7631 if test "${ac_cv_prog_WINDRES+set}" = set; then
7632   echo $ECHO_N "(cached) $ECHO_C" >&6
7633 else
7634   if test -n "$WINDRES"; then
7635   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7636 else
7637 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7638 for as_dir in $PATH
7639 do
7640   IFS=$as_save_IFS
7641   test -z "$as_dir" && as_dir=.
7642   for ac_exec_ext in '' $ac_executable_extensions; do
7643   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7644     ac_cv_prog_WINDRES="${ncn_progname}"
7645     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7646     break 2
7647   fi
7648 done
7649 done
7650
7651 fi
7652 fi
7653 WINDRES=$ac_cv_prog_WINDRES
7654 if test -n "$WINDRES"; then
7655   echo "$as_me:$LINENO: result: $WINDRES" >&5
7656 echo "${ECHO_T}$WINDRES" >&6
7657 else
7658   echo "$as_me:$LINENO: result: no" >&5
7659 echo "${ECHO_T}no" >&6
7660 fi
7661
7662   fi
7663   test -n "$ac_cv_prog_WINDRES" && break
7664 done
7665
7666 if test -z "$ac_cv_prog_WINDRES" ; then
7667   set dummy windres
7668   if test $build = $host ; then
7669     WINDRES="$2"
7670   else
7671     WINDRES="${ncn_tool_prefix}$2"
7672   fi
7673 fi
7674
7675
7676
7677 if test -n "$WINDMC"; then
7678   ac_cv_prog_WINDMC=$WINDMC
7679 elif test -n "$ac_cv_prog_WINDMC"; then
7680   WINDMC=$ac_cv_prog_WINDMC
7681 fi
7682
7683 if test -n "$ac_cv_prog_WINDMC"; then
7684   for ncn_progname in windmc; do
7685     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7686 set dummy ${ncn_progname}; ac_word=$2
7687 echo "$as_me:$LINENO: checking for $ac_word" >&5
7688 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7689 if test "${ac_cv_prog_WINDMC+set}" = set; then
7690   echo $ECHO_N "(cached) $ECHO_C" >&6
7691 else
7692   if test -n "$WINDMC"; then
7693   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7694 else
7695 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7696 for as_dir in $PATH
7697 do
7698   IFS=$as_save_IFS
7699   test -z "$as_dir" && as_dir=.
7700   for ac_exec_ext in '' $ac_executable_extensions; do
7701   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7702     ac_cv_prog_WINDMC="${ncn_progname}"
7703     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7704     break 2
7705   fi
7706 done
7707 done
7708
7709 fi
7710 fi
7711 WINDMC=$ac_cv_prog_WINDMC
7712 if test -n "$WINDMC"; then
7713   echo "$as_me:$LINENO: result: $WINDMC" >&5
7714 echo "${ECHO_T}$WINDMC" >&6
7715 else
7716   echo "$as_me:$LINENO: result: no" >&5
7717 echo "${ECHO_T}no" >&6
7718 fi
7719
7720   done
7721 fi
7722
7723 for ncn_progname in windmc; do
7724   if test -n "$ncn_tool_prefix"; then
7725     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7726 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7727 echo "$as_me:$LINENO: checking for $ac_word" >&5
7728 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7729 if test "${ac_cv_prog_WINDMC+set}" = set; then
7730   echo $ECHO_N "(cached) $ECHO_C" >&6
7731 else
7732   if test -n "$WINDMC"; then
7733   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7734 else
7735 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7736 for as_dir in $PATH
7737 do
7738   IFS=$as_save_IFS
7739   test -z "$as_dir" && as_dir=.
7740   for ac_exec_ext in '' $ac_executable_extensions; do
7741   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7742     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7743     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7744     break 2
7745   fi
7746 done
7747 done
7748
7749 fi
7750 fi
7751 WINDMC=$ac_cv_prog_WINDMC
7752 if test -n "$WINDMC"; then
7753   echo "$as_me:$LINENO: result: $WINDMC" >&5
7754 echo "${ECHO_T}$WINDMC" >&6
7755 else
7756   echo "$as_me:$LINENO: result: no" >&5
7757 echo "${ECHO_T}no" >&6
7758 fi
7759
7760   fi
7761   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7762     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7763 set dummy ${ncn_progname}; ac_word=$2
7764 echo "$as_me:$LINENO: checking for $ac_word" >&5
7765 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7766 if test "${ac_cv_prog_WINDMC+set}" = set; then
7767   echo $ECHO_N "(cached) $ECHO_C" >&6
7768 else
7769   if test -n "$WINDMC"; then
7770   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7771 else
7772 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7773 for as_dir in $PATH
7774 do
7775   IFS=$as_save_IFS
7776   test -z "$as_dir" && as_dir=.
7777   for ac_exec_ext in '' $ac_executable_extensions; do
7778   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7779     ac_cv_prog_WINDMC="${ncn_progname}"
7780     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7781     break 2
7782   fi
7783 done
7784 done
7785
7786 fi
7787 fi
7788 WINDMC=$ac_cv_prog_WINDMC
7789 if test -n "$WINDMC"; then
7790   echo "$as_me:$LINENO: result: $WINDMC" >&5
7791 echo "${ECHO_T}$WINDMC" >&6
7792 else
7793   echo "$as_me:$LINENO: result: no" >&5
7794 echo "${ECHO_T}no" >&6
7795 fi
7796
7797   fi
7798   test -n "$ac_cv_prog_WINDMC" && break
7799 done
7800
7801 if test -z "$ac_cv_prog_WINDMC" ; then
7802   set dummy windmc
7803   if test $build = $host ; then
7804     WINDMC="$2"
7805   else
7806     WINDMC="${ncn_tool_prefix}$2"
7807   fi
7808 fi
7809
7810
7811
7812 if test -n "$OBJCOPY"; then
7813   ac_cv_prog_OBJCOPY=$OBJCOPY
7814 elif test -n "$ac_cv_prog_OBJCOPY"; then
7815   OBJCOPY=$ac_cv_prog_OBJCOPY
7816 fi
7817
7818 if test -n "$ac_cv_prog_OBJCOPY"; then
7819   for ncn_progname in objcopy; do
7820     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7821 set dummy ${ncn_progname}; ac_word=$2
7822 echo "$as_me:$LINENO: checking for $ac_word" >&5
7823 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7824 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7825   echo $ECHO_N "(cached) $ECHO_C" >&6
7826 else
7827   if test -n "$OBJCOPY"; then
7828   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7829 else
7830 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7831 for as_dir in $PATH
7832 do
7833   IFS=$as_save_IFS
7834   test -z "$as_dir" && as_dir=.
7835   for ac_exec_ext in '' $ac_executable_extensions; do
7836   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7837     ac_cv_prog_OBJCOPY="${ncn_progname}"
7838     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7839     break 2
7840   fi
7841 done
7842 done
7843
7844 fi
7845 fi
7846 OBJCOPY=$ac_cv_prog_OBJCOPY
7847 if test -n "$OBJCOPY"; then
7848   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7849 echo "${ECHO_T}$OBJCOPY" >&6
7850 else
7851   echo "$as_me:$LINENO: result: no" >&5
7852 echo "${ECHO_T}no" >&6
7853 fi
7854
7855   done
7856 fi
7857
7858 for ncn_progname in objcopy; do
7859   if test -n "$ncn_tool_prefix"; then
7860     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7861 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7862 echo "$as_me:$LINENO: checking for $ac_word" >&5
7863 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7864 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7865   echo $ECHO_N "(cached) $ECHO_C" >&6
7866 else
7867   if test -n "$OBJCOPY"; then
7868   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7869 else
7870 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7871 for as_dir in $PATH
7872 do
7873   IFS=$as_save_IFS
7874   test -z "$as_dir" && as_dir=.
7875   for ac_exec_ext in '' $ac_executable_extensions; do
7876   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7877     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7878     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7879     break 2
7880   fi
7881 done
7882 done
7883
7884 fi
7885 fi
7886 OBJCOPY=$ac_cv_prog_OBJCOPY
7887 if test -n "$OBJCOPY"; then
7888   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7889 echo "${ECHO_T}$OBJCOPY" >&6
7890 else
7891   echo "$as_me:$LINENO: result: no" >&5
7892 echo "${ECHO_T}no" >&6
7893 fi
7894
7895   fi
7896   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7897     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7898 set dummy ${ncn_progname}; ac_word=$2
7899 echo "$as_me:$LINENO: checking for $ac_word" >&5
7900 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7901 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7902   echo $ECHO_N "(cached) $ECHO_C" >&6
7903 else
7904   if test -n "$OBJCOPY"; then
7905   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7906 else
7907 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7908 for as_dir in $PATH
7909 do
7910   IFS=$as_save_IFS
7911   test -z "$as_dir" && as_dir=.
7912   for ac_exec_ext in '' $ac_executable_extensions; do
7913   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7914     ac_cv_prog_OBJCOPY="${ncn_progname}"
7915     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7916     break 2
7917   fi
7918 done
7919 done
7920
7921 fi
7922 fi
7923 OBJCOPY=$ac_cv_prog_OBJCOPY
7924 if test -n "$OBJCOPY"; then
7925   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7926 echo "${ECHO_T}$OBJCOPY" >&6
7927 else
7928   echo "$as_me:$LINENO: result: no" >&5
7929 echo "${ECHO_T}no" >&6
7930 fi
7931
7932   fi
7933   test -n "$ac_cv_prog_OBJCOPY" && break
7934 done
7935
7936 if test -z "$ac_cv_prog_OBJCOPY" ; then
7937   set dummy objcopy
7938   if test $build = $host ; then
7939     OBJCOPY="$2"
7940   else
7941     OBJCOPY="${ncn_tool_prefix}$2"
7942   fi
7943 fi
7944
7945
7946
7947 if test -n "$OBJDUMP"; then
7948   ac_cv_prog_OBJDUMP=$OBJDUMP
7949 elif test -n "$ac_cv_prog_OBJDUMP"; then
7950   OBJDUMP=$ac_cv_prog_OBJDUMP
7951 fi
7952
7953 if test -n "$ac_cv_prog_OBJDUMP"; then
7954   for ncn_progname in objdump; do
7955     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7956 set dummy ${ncn_progname}; ac_word=$2
7957 echo "$as_me:$LINENO: checking for $ac_word" >&5
7958 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7959 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7960   echo $ECHO_N "(cached) $ECHO_C" >&6
7961 else
7962   if test -n "$OBJDUMP"; then
7963   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7964 else
7965 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7966 for as_dir in $PATH
7967 do
7968   IFS=$as_save_IFS
7969   test -z "$as_dir" && as_dir=.
7970   for ac_exec_ext in '' $ac_executable_extensions; do
7971   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7972     ac_cv_prog_OBJDUMP="${ncn_progname}"
7973     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7974     break 2
7975   fi
7976 done
7977 done
7978
7979 fi
7980 fi
7981 OBJDUMP=$ac_cv_prog_OBJDUMP
7982 if test -n "$OBJDUMP"; then
7983   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7984 echo "${ECHO_T}$OBJDUMP" >&6
7985 else
7986   echo "$as_me:$LINENO: result: no" >&5
7987 echo "${ECHO_T}no" >&6
7988 fi
7989
7990   done
7991 fi
7992
7993 for ncn_progname in objdump; do
7994   if test -n "$ncn_tool_prefix"; then
7995     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7996 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7997 echo "$as_me:$LINENO: checking for $ac_word" >&5
7998 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7999 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8000   echo $ECHO_N "(cached) $ECHO_C" >&6
8001 else
8002   if test -n "$OBJDUMP"; then
8003   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8004 else
8005 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8006 for as_dir in $PATH
8007 do
8008   IFS=$as_save_IFS
8009   test -z "$as_dir" && as_dir=.
8010   for ac_exec_ext in '' $ac_executable_extensions; do
8011   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8012     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8013     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8014     break 2
8015   fi
8016 done
8017 done
8018
8019 fi
8020 fi
8021 OBJDUMP=$ac_cv_prog_OBJDUMP
8022 if test -n "$OBJDUMP"; then
8023   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8024 echo "${ECHO_T}$OBJDUMP" >&6
8025 else
8026   echo "$as_me:$LINENO: result: no" >&5
8027 echo "${ECHO_T}no" >&6
8028 fi
8029
8030   fi
8031   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8032     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8033 set dummy ${ncn_progname}; ac_word=$2
8034 echo "$as_me:$LINENO: checking for $ac_word" >&5
8035 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8036 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8037   echo $ECHO_N "(cached) $ECHO_C" >&6
8038 else
8039   if test -n "$OBJDUMP"; then
8040   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8041 else
8042 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8043 for as_dir in $PATH
8044 do
8045   IFS=$as_save_IFS
8046   test -z "$as_dir" && as_dir=.
8047   for ac_exec_ext in '' $ac_executable_extensions; do
8048   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8049     ac_cv_prog_OBJDUMP="${ncn_progname}"
8050     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8051     break 2
8052   fi
8053 done
8054 done
8055
8056 fi
8057 fi
8058 OBJDUMP=$ac_cv_prog_OBJDUMP
8059 if test -n "$OBJDUMP"; then
8060   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8061 echo "${ECHO_T}$OBJDUMP" >&6
8062 else
8063   echo "$as_me:$LINENO: result: no" >&5
8064 echo "${ECHO_T}no" >&6
8065 fi
8066
8067   fi
8068   test -n "$ac_cv_prog_OBJDUMP" && break
8069 done
8070
8071 if test -z "$ac_cv_prog_OBJDUMP" ; then
8072   set dummy objdump
8073   if test $build = $host ; then
8074     OBJDUMP="$2"
8075   else
8076     OBJDUMP="${ncn_tool_prefix}$2"
8077   fi
8078 fi
8079
8080
8081
8082
8083
8084
8085 # Target tools.
8086
8087 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8088 if test "${with_build_time_tools+set}" = set; then
8089   withval="$with_build_time_tools"
8090   case x"$withval" in
8091      x/*) ;;
8092      *)
8093        with_build_time_tools=
8094        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8095 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8096        ;;
8097    esac
8098 else
8099   with_build_time_tools=
8100 fi;
8101
8102
8103
8104 if test -n "$CC_FOR_TARGET"; then
8105   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8106 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8107   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8108 fi
8109
8110 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8111   for ncn_progname in cc gcc; do
8112     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8113 set dummy ${ncn_progname}; ac_word=$2
8114 echo "$as_me:$LINENO: checking for $ac_word" >&5
8115 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8116 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8117   echo $ECHO_N "(cached) $ECHO_C" >&6
8118 else
8119   if test -n "$CC_FOR_TARGET"; then
8120   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8121 else
8122 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8123 for as_dir in $PATH
8124 do
8125   IFS=$as_save_IFS
8126   test -z "$as_dir" && as_dir=.
8127   for ac_exec_ext in '' $ac_executable_extensions; do
8128   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8129     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8130     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8131     break 2
8132   fi
8133 done
8134 done
8135
8136 fi
8137 fi
8138 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8139 if test -n "$CC_FOR_TARGET"; then
8140   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8141 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8142 else
8143   echo "$as_me:$LINENO: result: no" >&5
8144 echo "${ECHO_T}no" >&6
8145 fi
8146
8147   done
8148 fi
8149
8150 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8151   for ncn_progname in cc gcc; do
8152     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8153 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8154     if test -x $with_build_time_tools/${ncn_progname}; then
8155       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8156       echo "$as_me:$LINENO: result: yes" >&5
8157 echo "${ECHO_T}yes" >&6
8158       break
8159     else
8160       echo "$as_me:$LINENO: result: no" >&5
8161 echo "${ECHO_T}no" >&6
8162     fi
8163   done
8164 fi
8165
8166 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8167   for ncn_progname in cc gcc; do
8168     if test -n "$ncn_target_tool_prefix"; then
8169       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8170 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8171 echo "$as_me:$LINENO: checking for $ac_word" >&5
8172 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8173 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8174   echo $ECHO_N "(cached) $ECHO_C" >&6
8175 else
8176   if test -n "$CC_FOR_TARGET"; then
8177   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8178 else
8179 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8180 for as_dir in $PATH
8181 do
8182   IFS=$as_save_IFS
8183   test -z "$as_dir" && as_dir=.
8184   for ac_exec_ext in '' $ac_executable_extensions; do
8185   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8186     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8187     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8188     break 2
8189   fi
8190 done
8191 done
8192
8193 fi
8194 fi
8195 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8196 if test -n "$CC_FOR_TARGET"; then
8197   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8198 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8199 else
8200   echo "$as_me:$LINENO: result: no" >&5
8201 echo "${ECHO_T}no" >&6
8202 fi
8203
8204     fi
8205     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8206       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8207 set dummy ${ncn_progname}; ac_word=$2
8208 echo "$as_me:$LINENO: checking for $ac_word" >&5
8209 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8210 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8211   echo $ECHO_N "(cached) $ECHO_C" >&6
8212 else
8213   if test -n "$CC_FOR_TARGET"; then
8214   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8215 else
8216 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8217 for as_dir in $PATH
8218 do
8219   IFS=$as_save_IFS
8220   test -z "$as_dir" && as_dir=.
8221   for ac_exec_ext in '' $ac_executable_extensions; do
8222   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8223     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8224     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8225     break 2
8226   fi
8227 done
8228 done
8229
8230 fi
8231 fi
8232 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8233 if test -n "$CC_FOR_TARGET"; then
8234   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8235 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8236 else
8237   echo "$as_me:$LINENO: result: no" >&5
8238 echo "${ECHO_T}no" >&6
8239 fi
8240
8241     fi
8242     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8243   done
8244 fi
8245
8246 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8247   set dummy cc gcc
8248   if test $build = $target ; then
8249     CC_FOR_TARGET="$2"
8250   else
8251     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8252   fi
8253 else
8254   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8255 fi
8256
8257
8258
8259 if test -n "$CXX_FOR_TARGET"; then
8260   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8261 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8262   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8263 fi
8264
8265 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8266   for ncn_progname in c++ g++ cxx gxx; do
8267     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8268 set dummy ${ncn_progname}; ac_word=$2
8269 echo "$as_me:$LINENO: checking for $ac_word" >&5
8270 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8271 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8272   echo $ECHO_N "(cached) $ECHO_C" >&6
8273 else
8274   if test -n "$CXX_FOR_TARGET"; then
8275   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8276 else
8277 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8278 for as_dir in $PATH
8279 do
8280   IFS=$as_save_IFS
8281   test -z "$as_dir" && as_dir=.
8282   for ac_exec_ext in '' $ac_executable_extensions; do
8283   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8284     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8285     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8286     break 2
8287   fi
8288 done
8289 done
8290
8291 fi
8292 fi
8293 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8294 if test -n "$CXX_FOR_TARGET"; then
8295   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8296 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8297 else
8298   echo "$as_me:$LINENO: result: no" >&5
8299 echo "${ECHO_T}no" >&6
8300 fi
8301
8302   done
8303 fi
8304
8305 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8306   for ncn_progname in c++ g++ cxx gxx; do
8307     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8308 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8309     if test -x $with_build_time_tools/${ncn_progname}; then
8310       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8311       echo "$as_me:$LINENO: result: yes" >&5
8312 echo "${ECHO_T}yes" >&6
8313       break
8314     else
8315       echo "$as_me:$LINENO: result: no" >&5
8316 echo "${ECHO_T}no" >&6
8317     fi
8318   done
8319 fi
8320
8321 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8322   for ncn_progname in c++ g++ cxx gxx; do
8323     if test -n "$ncn_target_tool_prefix"; then
8324       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8325 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8326 echo "$as_me:$LINENO: checking for $ac_word" >&5
8327 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8328 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8329   echo $ECHO_N "(cached) $ECHO_C" >&6
8330 else
8331   if test -n "$CXX_FOR_TARGET"; then
8332   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8333 else
8334 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8335 for as_dir in $PATH
8336 do
8337   IFS=$as_save_IFS
8338   test -z "$as_dir" && as_dir=.
8339   for ac_exec_ext in '' $ac_executable_extensions; do
8340   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8341     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8342     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8343     break 2
8344   fi
8345 done
8346 done
8347
8348 fi
8349 fi
8350 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8351 if test -n "$CXX_FOR_TARGET"; then
8352   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8353 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8354 else
8355   echo "$as_me:$LINENO: result: no" >&5
8356 echo "${ECHO_T}no" >&6
8357 fi
8358
8359     fi
8360     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8361       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8362 set dummy ${ncn_progname}; ac_word=$2
8363 echo "$as_me:$LINENO: checking for $ac_word" >&5
8364 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8365 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8366   echo $ECHO_N "(cached) $ECHO_C" >&6
8367 else
8368   if test -n "$CXX_FOR_TARGET"; then
8369   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8370 else
8371 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8372 for as_dir in $PATH
8373 do
8374   IFS=$as_save_IFS
8375   test -z "$as_dir" && as_dir=.
8376   for ac_exec_ext in '' $ac_executable_extensions; do
8377   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8378     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8379     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8380     break 2
8381   fi
8382 done
8383 done
8384
8385 fi
8386 fi
8387 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8388 if test -n "$CXX_FOR_TARGET"; then
8389   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8390 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8391 else
8392   echo "$as_me:$LINENO: result: no" >&5
8393 echo "${ECHO_T}no" >&6
8394 fi
8395
8396     fi
8397     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8398   done
8399 fi
8400
8401 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8402   set dummy c++ g++ cxx gxx
8403   if test $build = $target ; then
8404     CXX_FOR_TARGET="$2"
8405   else
8406     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8407   fi
8408 else
8409   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8410 fi
8411
8412
8413
8414 if test -n "$GCC_FOR_TARGET"; then
8415   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8416 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8417   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8418 fi
8419
8420 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8421   for ncn_progname in gcc; do
8422     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8423 set dummy ${ncn_progname}; ac_word=$2
8424 echo "$as_me:$LINENO: checking for $ac_word" >&5
8425 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8426 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8427   echo $ECHO_N "(cached) $ECHO_C" >&6
8428 else
8429   if test -n "$GCC_FOR_TARGET"; then
8430   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8431 else
8432 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8433 for as_dir in $PATH
8434 do
8435   IFS=$as_save_IFS
8436   test -z "$as_dir" && as_dir=.
8437   for ac_exec_ext in '' $ac_executable_extensions; do
8438   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8439     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8440     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8441     break 2
8442   fi
8443 done
8444 done
8445
8446 fi
8447 fi
8448 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8449 if test -n "$GCC_FOR_TARGET"; then
8450   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8451 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8452 else
8453   echo "$as_me:$LINENO: result: no" >&5
8454 echo "${ECHO_T}no" >&6
8455 fi
8456
8457   done
8458 fi
8459
8460 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8461   for ncn_progname in gcc; do
8462     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8463 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8464     if test -x $with_build_time_tools/${ncn_progname}; then
8465       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8466       echo "$as_me:$LINENO: result: yes" >&5
8467 echo "${ECHO_T}yes" >&6
8468       break
8469     else
8470       echo "$as_me:$LINENO: result: no" >&5
8471 echo "${ECHO_T}no" >&6
8472     fi
8473   done
8474 fi
8475
8476 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8477   for ncn_progname in gcc; do
8478     if test -n "$ncn_target_tool_prefix"; then
8479       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8480 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8481 echo "$as_me:$LINENO: checking for $ac_word" >&5
8482 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8483 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8484   echo $ECHO_N "(cached) $ECHO_C" >&6
8485 else
8486   if test -n "$GCC_FOR_TARGET"; then
8487   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8488 else
8489 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8490 for as_dir in $PATH
8491 do
8492   IFS=$as_save_IFS
8493   test -z "$as_dir" && as_dir=.
8494   for ac_exec_ext in '' $ac_executable_extensions; do
8495   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8496     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8497     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8498     break 2
8499   fi
8500 done
8501 done
8502
8503 fi
8504 fi
8505 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8506 if test -n "$GCC_FOR_TARGET"; then
8507   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8508 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8509 else
8510   echo "$as_me:$LINENO: result: no" >&5
8511 echo "${ECHO_T}no" >&6
8512 fi
8513
8514     fi
8515     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8516       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8517 set dummy ${ncn_progname}; ac_word=$2
8518 echo "$as_me:$LINENO: checking for $ac_word" >&5
8519 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8520 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8521   echo $ECHO_N "(cached) $ECHO_C" >&6
8522 else
8523   if test -n "$GCC_FOR_TARGET"; then
8524   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8525 else
8526 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8527 for as_dir in $PATH
8528 do
8529   IFS=$as_save_IFS
8530   test -z "$as_dir" && as_dir=.
8531   for ac_exec_ext in '' $ac_executable_extensions; do
8532   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8533     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8534     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8535     break 2
8536   fi
8537 done
8538 done
8539
8540 fi
8541 fi
8542 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8543 if test -n "$GCC_FOR_TARGET"; then
8544   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8545 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8546 else
8547   echo "$as_me:$LINENO: result: no" >&5
8548 echo "${ECHO_T}no" >&6
8549 fi
8550
8551     fi
8552     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8553   done
8554 fi
8555
8556 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8557   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8558 else
8559   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8560 fi
8561
8562
8563
8564 if test -n "$GCJ_FOR_TARGET"; then
8565   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8566 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8567   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8568 fi
8569
8570 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8571   for ncn_progname in gcj; do
8572     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8573 set dummy ${ncn_progname}; ac_word=$2
8574 echo "$as_me:$LINENO: checking for $ac_word" >&5
8575 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8576 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8577   echo $ECHO_N "(cached) $ECHO_C" >&6
8578 else
8579   if test -n "$GCJ_FOR_TARGET"; then
8580   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8581 else
8582 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8583 for as_dir in $PATH
8584 do
8585   IFS=$as_save_IFS
8586   test -z "$as_dir" && as_dir=.
8587   for ac_exec_ext in '' $ac_executable_extensions; do
8588   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8589     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8590     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8591     break 2
8592   fi
8593 done
8594 done
8595
8596 fi
8597 fi
8598 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8599 if test -n "$GCJ_FOR_TARGET"; then
8600   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8601 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8602 else
8603   echo "$as_me:$LINENO: result: no" >&5
8604 echo "${ECHO_T}no" >&6
8605 fi
8606
8607   done
8608 fi
8609
8610 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8611   for ncn_progname in gcj; do
8612     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8613 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8614     if test -x $with_build_time_tools/${ncn_progname}; then
8615       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8616       echo "$as_me:$LINENO: result: yes" >&5
8617 echo "${ECHO_T}yes" >&6
8618       break
8619     else
8620       echo "$as_me:$LINENO: result: no" >&5
8621 echo "${ECHO_T}no" >&6
8622     fi
8623   done
8624 fi
8625
8626 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8627   for ncn_progname in gcj; do
8628     if test -n "$ncn_target_tool_prefix"; then
8629       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8630 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8631 echo "$as_me:$LINENO: checking for $ac_word" >&5
8632 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8633 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8634   echo $ECHO_N "(cached) $ECHO_C" >&6
8635 else
8636   if test -n "$GCJ_FOR_TARGET"; then
8637   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8638 else
8639 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8640 for as_dir in $PATH
8641 do
8642   IFS=$as_save_IFS
8643   test -z "$as_dir" && as_dir=.
8644   for ac_exec_ext in '' $ac_executable_extensions; do
8645   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8646     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8647     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8648     break 2
8649   fi
8650 done
8651 done
8652
8653 fi
8654 fi
8655 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8656 if test -n "$GCJ_FOR_TARGET"; then
8657   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8658 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8659 else
8660   echo "$as_me:$LINENO: result: no" >&5
8661 echo "${ECHO_T}no" >&6
8662 fi
8663
8664     fi
8665     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8666       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8667 set dummy ${ncn_progname}; ac_word=$2
8668 echo "$as_me:$LINENO: checking for $ac_word" >&5
8669 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8670 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8671   echo $ECHO_N "(cached) $ECHO_C" >&6
8672 else
8673   if test -n "$GCJ_FOR_TARGET"; then
8674   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8675 else
8676 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8677 for as_dir in $PATH
8678 do
8679   IFS=$as_save_IFS
8680   test -z "$as_dir" && as_dir=.
8681   for ac_exec_ext in '' $ac_executable_extensions; do
8682   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8683     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8684     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8685     break 2
8686   fi
8687 done
8688 done
8689
8690 fi
8691 fi
8692 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8693 if test -n "$GCJ_FOR_TARGET"; then
8694   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8695 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8696 else
8697   echo "$as_me:$LINENO: result: no" >&5
8698 echo "${ECHO_T}no" >&6
8699 fi
8700
8701     fi
8702     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8703   done
8704 fi
8705
8706 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8707   set dummy gcj
8708   if test $build = $target ; then
8709     GCJ_FOR_TARGET="$2"
8710   else
8711     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8712   fi
8713 else
8714   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8715 fi
8716
8717
8718
8719 if test -n "$GFORTRAN_FOR_TARGET"; then
8720   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8721 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8722   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8723 fi
8724
8725 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8726   for ncn_progname in gfortran; do
8727     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8728 set dummy ${ncn_progname}; ac_word=$2
8729 echo "$as_me:$LINENO: checking for $ac_word" >&5
8730 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8731 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8732   echo $ECHO_N "(cached) $ECHO_C" >&6
8733 else
8734   if test -n "$GFORTRAN_FOR_TARGET"; then
8735   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8736 else
8737 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8738 for as_dir in $PATH
8739 do
8740   IFS=$as_save_IFS
8741   test -z "$as_dir" && as_dir=.
8742   for ac_exec_ext in '' $ac_executable_extensions; do
8743   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8744     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8745     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8746     break 2
8747   fi
8748 done
8749 done
8750
8751 fi
8752 fi
8753 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8754 if test -n "$GFORTRAN_FOR_TARGET"; then
8755   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8756 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8757 else
8758   echo "$as_me:$LINENO: result: no" >&5
8759 echo "${ECHO_T}no" >&6
8760 fi
8761
8762   done
8763 fi
8764
8765 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8766   for ncn_progname in gfortran; do
8767     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8768 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8769     if test -x $with_build_time_tools/${ncn_progname}; then
8770       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8771       echo "$as_me:$LINENO: result: yes" >&5
8772 echo "${ECHO_T}yes" >&6
8773       break
8774     else
8775       echo "$as_me:$LINENO: result: no" >&5
8776 echo "${ECHO_T}no" >&6
8777     fi
8778   done
8779 fi
8780
8781 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8782   for ncn_progname in gfortran; do
8783     if test -n "$ncn_target_tool_prefix"; then
8784       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8785 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8786 echo "$as_me:$LINENO: checking for $ac_word" >&5
8787 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8788 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8789   echo $ECHO_N "(cached) $ECHO_C" >&6
8790 else
8791   if test -n "$GFORTRAN_FOR_TARGET"; then
8792   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8793 else
8794 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8795 for as_dir in $PATH
8796 do
8797   IFS=$as_save_IFS
8798   test -z "$as_dir" && as_dir=.
8799   for ac_exec_ext in '' $ac_executable_extensions; do
8800   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8801     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8802     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8803     break 2
8804   fi
8805 done
8806 done
8807
8808 fi
8809 fi
8810 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8811 if test -n "$GFORTRAN_FOR_TARGET"; then
8812   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8813 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8814 else
8815   echo "$as_me:$LINENO: result: no" >&5
8816 echo "${ECHO_T}no" >&6
8817 fi
8818
8819     fi
8820     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8821       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8822 set dummy ${ncn_progname}; ac_word=$2
8823 echo "$as_me:$LINENO: checking for $ac_word" >&5
8824 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8825 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8826   echo $ECHO_N "(cached) $ECHO_C" >&6
8827 else
8828   if test -n "$GFORTRAN_FOR_TARGET"; then
8829   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8830 else
8831 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8832 for as_dir in $PATH
8833 do
8834   IFS=$as_save_IFS
8835   test -z "$as_dir" && as_dir=.
8836   for ac_exec_ext in '' $ac_executable_extensions; do
8837   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8838     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8839     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8840     break 2
8841   fi
8842 done
8843 done
8844
8845 fi
8846 fi
8847 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8848 if test -n "$GFORTRAN_FOR_TARGET"; then
8849   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8850 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8851 else
8852   echo "$as_me:$LINENO: result: no" >&5
8853 echo "${ECHO_T}no" >&6
8854 fi
8855
8856     fi
8857     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8858   done
8859 fi
8860
8861 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8862   set dummy gfortran
8863   if test $build = $target ; then
8864     GFORTRAN_FOR_TARGET="$2"
8865   else
8866     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8867   fi
8868 else
8869   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8870 fi
8871
8872
8873
8874 cat > conftest.c << \EOF
8875 #ifdef __GNUC__
8876   gcc_yay;
8877 #endif
8878 EOF
8879 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8880   have_gcc_for_target=yes
8881 else
8882   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8883   have_gcc_for_target=no
8884 fi
8885 rm conftest.c
8886
8887
8888
8889
8890 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8891   if test -n "$with_build_time_tools"; then
8892     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8893 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8894     if test -x $with_build_time_tools/ar; then
8895       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8896       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8897       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8898 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8899     else
8900       echo "$as_me:$LINENO: result: no" >&5
8901 echo "${ECHO_T}no" >&6
8902     fi
8903   elif test $build != $host && test $have_gcc_for_target = yes; then
8904     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8905     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8906     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8907   fi
8908 fi
8909 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8910   # Extract the first word of "ar", so it can be a program name with args.
8911 set dummy ar; ac_word=$2
8912 echo "$as_me:$LINENO: checking for $ac_word" >&5
8913 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8914 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8915   echo $ECHO_N "(cached) $ECHO_C" >&6
8916 else
8917   case $AR_FOR_TARGET in
8918   [\\/]* | ?:[\\/]*)
8919   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8920   ;;
8921   *)
8922   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8923 for as_dir in $gcc_cv_tool_dirs
8924 do
8925   IFS=$as_save_IFS
8926   test -z "$as_dir" && as_dir=.
8927   for ac_exec_ext in '' $ac_executable_extensions; do
8928   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8929     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8930     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8931     break 2
8932   fi
8933 done
8934 done
8935
8936   ;;
8937 esac
8938 fi
8939 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8940
8941 if test -n "$AR_FOR_TARGET"; then
8942   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8943 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8944 else
8945   echo "$as_me:$LINENO: result: no" >&5
8946 echo "${ECHO_T}no" >&6
8947 fi
8948
8949 fi
8950 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8951
8952
8953 if test -n "$AR_FOR_TARGET"; then
8954   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8955 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8956   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8957 fi
8958
8959 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8960   for ncn_progname in ar; do
8961     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8962 set dummy ${ncn_progname}; ac_word=$2
8963 echo "$as_me:$LINENO: checking for $ac_word" >&5
8964 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8965 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8966   echo $ECHO_N "(cached) $ECHO_C" >&6
8967 else
8968   if test -n "$AR_FOR_TARGET"; then
8969   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8970 else
8971 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8972 for as_dir in $PATH
8973 do
8974   IFS=$as_save_IFS
8975   test -z "$as_dir" && as_dir=.
8976   for ac_exec_ext in '' $ac_executable_extensions; do
8977   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8978     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8979     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8980     break 2
8981   fi
8982 done
8983 done
8984
8985 fi
8986 fi
8987 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8988 if test -n "$AR_FOR_TARGET"; then
8989   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8990 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8991 else
8992   echo "$as_me:$LINENO: result: no" >&5
8993 echo "${ECHO_T}no" >&6
8994 fi
8995
8996   done
8997 fi
8998
8999 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9000   for ncn_progname in ar; do
9001     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9002 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9003     if test -x $with_build_time_tools/${ncn_progname}; then
9004       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9005       echo "$as_me:$LINENO: result: yes" >&5
9006 echo "${ECHO_T}yes" >&6
9007       break
9008     else
9009       echo "$as_me:$LINENO: result: no" >&5
9010 echo "${ECHO_T}no" >&6
9011     fi
9012   done
9013 fi
9014
9015 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9016   for ncn_progname in ar; do
9017     if test -n "$ncn_target_tool_prefix"; then
9018       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9019 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9020 echo "$as_me:$LINENO: checking for $ac_word" >&5
9021 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9022 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9023   echo $ECHO_N "(cached) $ECHO_C" >&6
9024 else
9025   if test -n "$AR_FOR_TARGET"; then
9026   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9027 else
9028 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9029 for as_dir in $PATH
9030 do
9031   IFS=$as_save_IFS
9032   test -z "$as_dir" && as_dir=.
9033   for ac_exec_ext in '' $ac_executable_extensions; do
9034   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9035     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9036     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9037     break 2
9038   fi
9039 done
9040 done
9041
9042 fi
9043 fi
9044 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9045 if test -n "$AR_FOR_TARGET"; then
9046   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9047 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9048 else
9049   echo "$as_me:$LINENO: result: no" >&5
9050 echo "${ECHO_T}no" >&6
9051 fi
9052
9053     fi
9054     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9055       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9056 set dummy ${ncn_progname}; ac_word=$2
9057 echo "$as_me:$LINENO: checking for $ac_word" >&5
9058 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9059 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9060   echo $ECHO_N "(cached) $ECHO_C" >&6
9061 else
9062   if test -n "$AR_FOR_TARGET"; then
9063   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9064 else
9065 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9066 for as_dir in $PATH
9067 do
9068   IFS=$as_save_IFS
9069   test -z "$as_dir" && as_dir=.
9070   for ac_exec_ext in '' $ac_executable_extensions; do
9071   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9072     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9073     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9074     break 2
9075   fi
9076 done
9077 done
9078
9079 fi
9080 fi
9081 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9082 if test -n "$AR_FOR_TARGET"; then
9083   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9084 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9085 else
9086   echo "$as_me:$LINENO: result: no" >&5
9087 echo "${ECHO_T}no" >&6
9088 fi
9089
9090     fi
9091     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9092   done
9093 fi
9094
9095 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9096   set dummy ar
9097   if test $build = $target ; then
9098     AR_FOR_TARGET="$2"
9099   else
9100     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9101   fi
9102 else
9103   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9104 fi
9105
9106 else
9107   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9108 fi
9109
9110
9111
9112
9113 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9114   if test -n "$with_build_time_tools"; then
9115     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9116 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9117     if test -x $with_build_time_tools/as; then
9118       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9119       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9120       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9121 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9122     else
9123       echo "$as_me:$LINENO: result: no" >&5
9124 echo "${ECHO_T}no" >&6
9125     fi
9126   elif test $build != $host && test $have_gcc_for_target = yes; then
9127     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9128     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9129     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9130   fi
9131 fi
9132 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9133   # Extract the first word of "as", so it can be a program name with args.
9134 set dummy as; ac_word=$2
9135 echo "$as_me:$LINENO: checking for $ac_word" >&5
9136 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9137 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9138   echo $ECHO_N "(cached) $ECHO_C" >&6
9139 else
9140   case $AS_FOR_TARGET in
9141   [\\/]* | ?:[\\/]*)
9142   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9143   ;;
9144   *)
9145   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9146 for as_dir in $gcc_cv_tool_dirs
9147 do
9148   IFS=$as_save_IFS
9149   test -z "$as_dir" && as_dir=.
9150   for ac_exec_ext in '' $ac_executable_extensions; do
9151   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9152     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9153     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9154     break 2
9155   fi
9156 done
9157 done
9158
9159   ;;
9160 esac
9161 fi
9162 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9163
9164 if test -n "$AS_FOR_TARGET"; then
9165   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9166 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9167 else
9168   echo "$as_me:$LINENO: result: no" >&5
9169 echo "${ECHO_T}no" >&6
9170 fi
9171
9172 fi
9173 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9174
9175
9176 if test -n "$AS_FOR_TARGET"; then
9177   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9178 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9179   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9180 fi
9181
9182 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9183   for ncn_progname in as; do
9184     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9185 set dummy ${ncn_progname}; ac_word=$2
9186 echo "$as_me:$LINENO: checking for $ac_word" >&5
9187 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9188 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9189   echo $ECHO_N "(cached) $ECHO_C" >&6
9190 else
9191   if test -n "$AS_FOR_TARGET"; then
9192   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9193 else
9194 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9195 for as_dir in $PATH
9196 do
9197   IFS=$as_save_IFS
9198   test -z "$as_dir" && as_dir=.
9199   for ac_exec_ext in '' $ac_executable_extensions; do
9200   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9201     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9202     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9203     break 2
9204   fi
9205 done
9206 done
9207
9208 fi
9209 fi
9210 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9211 if test -n "$AS_FOR_TARGET"; then
9212   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9213 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9214 else
9215   echo "$as_me:$LINENO: result: no" >&5
9216 echo "${ECHO_T}no" >&6
9217 fi
9218
9219   done
9220 fi
9221
9222 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9223   for ncn_progname in as; do
9224     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9225 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9226     if test -x $with_build_time_tools/${ncn_progname}; then
9227       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9228       echo "$as_me:$LINENO: result: yes" >&5
9229 echo "${ECHO_T}yes" >&6
9230       break
9231     else
9232       echo "$as_me:$LINENO: result: no" >&5
9233 echo "${ECHO_T}no" >&6
9234     fi
9235   done
9236 fi
9237
9238 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9239   for ncn_progname in as; do
9240     if test -n "$ncn_target_tool_prefix"; then
9241       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9242 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9243 echo "$as_me:$LINENO: checking for $ac_word" >&5
9244 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9245 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9246   echo $ECHO_N "(cached) $ECHO_C" >&6
9247 else
9248   if test -n "$AS_FOR_TARGET"; then
9249   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9250 else
9251 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9252 for as_dir in $PATH
9253 do
9254   IFS=$as_save_IFS
9255   test -z "$as_dir" && as_dir=.
9256   for ac_exec_ext in '' $ac_executable_extensions; do
9257   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9258     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9259     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9260     break 2
9261   fi
9262 done
9263 done
9264
9265 fi
9266 fi
9267 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9268 if test -n "$AS_FOR_TARGET"; then
9269   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9270 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9271 else
9272   echo "$as_me:$LINENO: result: no" >&5
9273 echo "${ECHO_T}no" >&6
9274 fi
9275
9276     fi
9277     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9278       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9279 set dummy ${ncn_progname}; ac_word=$2
9280 echo "$as_me:$LINENO: checking for $ac_word" >&5
9281 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9282 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9283   echo $ECHO_N "(cached) $ECHO_C" >&6
9284 else
9285   if test -n "$AS_FOR_TARGET"; then
9286   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9287 else
9288 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9289 for as_dir in $PATH
9290 do
9291   IFS=$as_save_IFS
9292   test -z "$as_dir" && as_dir=.
9293   for ac_exec_ext in '' $ac_executable_extensions; do
9294   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9295     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9296     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9297     break 2
9298   fi
9299 done
9300 done
9301
9302 fi
9303 fi
9304 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9305 if test -n "$AS_FOR_TARGET"; then
9306   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9307 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9308 else
9309   echo "$as_me:$LINENO: result: no" >&5
9310 echo "${ECHO_T}no" >&6
9311 fi
9312
9313     fi
9314     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9315   done
9316 fi
9317
9318 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9319   set dummy as
9320   if test $build = $target ; then
9321     AS_FOR_TARGET="$2"
9322   else
9323     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9324   fi
9325 else
9326   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9327 fi
9328
9329 else
9330   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9331 fi
9332
9333
9334
9335
9336 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9337   if test -n "$with_build_time_tools"; then
9338     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9339 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9340     if test -x $with_build_time_tools/dlltool; then
9341       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9342       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9343       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9344 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9345     else
9346       echo "$as_me:$LINENO: result: no" >&5
9347 echo "${ECHO_T}no" >&6
9348     fi
9349   elif test $build != $host && test $have_gcc_for_target = yes; then
9350     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9351     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9352     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9353   fi
9354 fi
9355 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9356   # Extract the first word of "dlltool", so it can be a program name with args.
9357 set dummy dlltool; ac_word=$2
9358 echo "$as_me:$LINENO: checking for $ac_word" >&5
9359 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9360 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9361   echo $ECHO_N "(cached) $ECHO_C" >&6
9362 else
9363   case $DLLTOOL_FOR_TARGET in
9364   [\\/]* | ?:[\\/]*)
9365   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9366   ;;
9367   *)
9368   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9369 for as_dir in $gcc_cv_tool_dirs
9370 do
9371   IFS=$as_save_IFS
9372   test -z "$as_dir" && as_dir=.
9373   for ac_exec_ext in '' $ac_executable_extensions; do
9374   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9375     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9376     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9377     break 2
9378   fi
9379 done
9380 done
9381
9382   ;;
9383 esac
9384 fi
9385 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9386
9387 if test -n "$DLLTOOL_FOR_TARGET"; then
9388   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9389 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9390 else
9391   echo "$as_me:$LINENO: result: no" >&5
9392 echo "${ECHO_T}no" >&6
9393 fi
9394
9395 fi
9396 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9397
9398
9399 if test -n "$DLLTOOL_FOR_TARGET"; then
9400   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9401 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9402   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9403 fi
9404
9405 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9406   for ncn_progname in dlltool; do
9407     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9408 set dummy ${ncn_progname}; ac_word=$2
9409 echo "$as_me:$LINENO: checking for $ac_word" >&5
9410 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9411 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9412   echo $ECHO_N "(cached) $ECHO_C" >&6
9413 else
9414   if test -n "$DLLTOOL_FOR_TARGET"; then
9415   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9416 else
9417 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9418 for as_dir in $PATH
9419 do
9420   IFS=$as_save_IFS
9421   test -z "$as_dir" && as_dir=.
9422   for ac_exec_ext in '' $ac_executable_extensions; do
9423   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9424     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9425     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9426     break 2
9427   fi
9428 done
9429 done
9430
9431 fi
9432 fi
9433 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9434 if test -n "$DLLTOOL_FOR_TARGET"; then
9435   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9436 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9437 else
9438   echo "$as_me:$LINENO: result: no" >&5
9439 echo "${ECHO_T}no" >&6
9440 fi
9441
9442   done
9443 fi
9444
9445 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9446   for ncn_progname in dlltool; do
9447     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9448 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9449     if test -x $with_build_time_tools/${ncn_progname}; then
9450       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9451       echo "$as_me:$LINENO: result: yes" >&5
9452 echo "${ECHO_T}yes" >&6
9453       break
9454     else
9455       echo "$as_me:$LINENO: result: no" >&5
9456 echo "${ECHO_T}no" >&6
9457     fi
9458   done
9459 fi
9460
9461 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9462   for ncn_progname in dlltool; do
9463     if test -n "$ncn_target_tool_prefix"; then
9464       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9465 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9466 echo "$as_me:$LINENO: checking for $ac_word" >&5
9467 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9468 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9469   echo $ECHO_N "(cached) $ECHO_C" >&6
9470 else
9471   if test -n "$DLLTOOL_FOR_TARGET"; then
9472   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9473 else
9474 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9475 for as_dir in $PATH
9476 do
9477   IFS=$as_save_IFS
9478   test -z "$as_dir" && as_dir=.
9479   for ac_exec_ext in '' $ac_executable_extensions; do
9480   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9481     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9482     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9483     break 2
9484   fi
9485 done
9486 done
9487
9488 fi
9489 fi
9490 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9491 if test -n "$DLLTOOL_FOR_TARGET"; then
9492   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9493 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9494 else
9495   echo "$as_me:$LINENO: result: no" >&5
9496 echo "${ECHO_T}no" >&6
9497 fi
9498
9499     fi
9500     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9501       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9502 set dummy ${ncn_progname}; ac_word=$2
9503 echo "$as_me:$LINENO: checking for $ac_word" >&5
9504 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9505 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9506   echo $ECHO_N "(cached) $ECHO_C" >&6
9507 else
9508   if test -n "$DLLTOOL_FOR_TARGET"; then
9509   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9510 else
9511 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9512 for as_dir in $PATH
9513 do
9514   IFS=$as_save_IFS
9515   test -z "$as_dir" && as_dir=.
9516   for ac_exec_ext in '' $ac_executable_extensions; do
9517   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9518     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9519     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9520     break 2
9521   fi
9522 done
9523 done
9524
9525 fi
9526 fi
9527 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9528 if test -n "$DLLTOOL_FOR_TARGET"; then
9529   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9530 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9531 else
9532   echo "$as_me:$LINENO: result: no" >&5
9533 echo "${ECHO_T}no" >&6
9534 fi
9535
9536     fi
9537     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9538   done
9539 fi
9540
9541 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9542   set dummy dlltool
9543   if test $build = $target ; then
9544     DLLTOOL_FOR_TARGET="$2"
9545   else
9546     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9547   fi
9548 else
9549   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9550 fi
9551
9552 else
9553   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9554 fi
9555
9556
9557
9558
9559 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9560   if test -n "$with_build_time_tools"; then
9561     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9562 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9563     if test -x $with_build_time_tools/ld; then
9564       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9565       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9566       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9567 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9568     else
9569       echo "$as_me:$LINENO: result: no" >&5
9570 echo "${ECHO_T}no" >&6
9571     fi
9572   elif test $build != $host && test $have_gcc_for_target = yes; then
9573     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9574     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9575     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9576   fi
9577 fi
9578 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9579   # Extract the first word of "ld", so it can be a program name with args.
9580 set dummy ld; ac_word=$2
9581 echo "$as_me:$LINENO: checking for $ac_word" >&5
9582 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9583 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9584   echo $ECHO_N "(cached) $ECHO_C" >&6
9585 else
9586   case $LD_FOR_TARGET in
9587   [\\/]* | ?:[\\/]*)
9588   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9589   ;;
9590   *)
9591   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9592 for as_dir in $gcc_cv_tool_dirs
9593 do
9594   IFS=$as_save_IFS
9595   test -z "$as_dir" && as_dir=.
9596   for ac_exec_ext in '' $ac_executable_extensions; do
9597   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9598     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9599     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9600     break 2
9601   fi
9602 done
9603 done
9604
9605   ;;
9606 esac
9607 fi
9608 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9609
9610 if test -n "$LD_FOR_TARGET"; then
9611   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9612 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9613 else
9614   echo "$as_me:$LINENO: result: no" >&5
9615 echo "${ECHO_T}no" >&6
9616 fi
9617
9618 fi
9619 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9620
9621
9622 if test -n "$LD_FOR_TARGET"; then
9623   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9624 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9625   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9626 fi
9627
9628 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9629   for ncn_progname in ld; do
9630     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9631 set dummy ${ncn_progname}; ac_word=$2
9632 echo "$as_me:$LINENO: checking for $ac_word" >&5
9633 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9634 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9635   echo $ECHO_N "(cached) $ECHO_C" >&6
9636 else
9637   if test -n "$LD_FOR_TARGET"; then
9638   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9639 else
9640 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9641 for as_dir in $PATH
9642 do
9643   IFS=$as_save_IFS
9644   test -z "$as_dir" && as_dir=.
9645   for ac_exec_ext in '' $ac_executable_extensions; do
9646   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9647     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9648     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9649     break 2
9650   fi
9651 done
9652 done
9653
9654 fi
9655 fi
9656 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9657 if test -n "$LD_FOR_TARGET"; then
9658   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9659 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9660 else
9661   echo "$as_me:$LINENO: result: no" >&5
9662 echo "${ECHO_T}no" >&6
9663 fi
9664
9665   done
9666 fi
9667
9668 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9669   for ncn_progname in ld; do
9670     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9671 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9672     if test -x $with_build_time_tools/${ncn_progname}; then
9673       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9674       echo "$as_me:$LINENO: result: yes" >&5
9675 echo "${ECHO_T}yes" >&6
9676       break
9677     else
9678       echo "$as_me:$LINENO: result: no" >&5
9679 echo "${ECHO_T}no" >&6
9680     fi
9681   done
9682 fi
9683
9684 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9685   for ncn_progname in ld; do
9686     if test -n "$ncn_target_tool_prefix"; then
9687       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9688 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9689 echo "$as_me:$LINENO: checking for $ac_word" >&5
9690 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9691 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9692   echo $ECHO_N "(cached) $ECHO_C" >&6
9693 else
9694   if test -n "$LD_FOR_TARGET"; then
9695   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9696 else
9697 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9698 for as_dir in $PATH
9699 do
9700   IFS=$as_save_IFS
9701   test -z "$as_dir" && as_dir=.
9702   for ac_exec_ext in '' $ac_executable_extensions; do
9703   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9704     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9705     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9706     break 2
9707   fi
9708 done
9709 done
9710
9711 fi
9712 fi
9713 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9714 if test -n "$LD_FOR_TARGET"; then
9715   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9716 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9717 else
9718   echo "$as_me:$LINENO: result: no" >&5
9719 echo "${ECHO_T}no" >&6
9720 fi
9721
9722     fi
9723     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9724       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9725 set dummy ${ncn_progname}; ac_word=$2
9726 echo "$as_me:$LINENO: checking for $ac_word" >&5
9727 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9728 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9729   echo $ECHO_N "(cached) $ECHO_C" >&6
9730 else
9731   if test -n "$LD_FOR_TARGET"; then
9732   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9733 else
9734 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9735 for as_dir in $PATH
9736 do
9737   IFS=$as_save_IFS
9738   test -z "$as_dir" && as_dir=.
9739   for ac_exec_ext in '' $ac_executable_extensions; do
9740   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9741     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9742     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9743     break 2
9744   fi
9745 done
9746 done
9747
9748 fi
9749 fi
9750 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9751 if test -n "$LD_FOR_TARGET"; then
9752   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9753 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9754 else
9755   echo "$as_me:$LINENO: result: no" >&5
9756 echo "${ECHO_T}no" >&6
9757 fi
9758
9759     fi
9760     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9761   done
9762 fi
9763
9764 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9765   set dummy ld
9766   if test $build = $target ; then
9767     LD_FOR_TARGET="$2"
9768   else
9769     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9770   fi
9771 else
9772   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9773 fi
9774
9775 else
9776   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9777 fi
9778
9779
9780
9781
9782 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9783   if test -n "$with_build_time_tools"; then
9784     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9785 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9786     if test -x $with_build_time_tools/lipo; then
9787       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9788       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9789       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9790 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9791     else
9792       echo "$as_me:$LINENO: result: no" >&5
9793 echo "${ECHO_T}no" >&6
9794     fi
9795   elif test $build != $host && test $have_gcc_for_target = yes; then
9796     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9797     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9798     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9799   fi
9800 fi
9801 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9802   # Extract the first word of "lipo", so it can be a program name with args.
9803 set dummy lipo; ac_word=$2
9804 echo "$as_me:$LINENO: checking for $ac_word" >&5
9805 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9806 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9807   echo $ECHO_N "(cached) $ECHO_C" >&6
9808 else
9809   case $LIPO_FOR_TARGET in
9810   [\\/]* | ?:[\\/]*)
9811   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9812   ;;
9813   *)
9814   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9815 for as_dir in $gcc_cv_tool_dirs
9816 do
9817   IFS=$as_save_IFS
9818   test -z "$as_dir" && as_dir=.
9819   for ac_exec_ext in '' $ac_executable_extensions; do
9820   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9821     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9822     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9823     break 2
9824   fi
9825 done
9826 done
9827
9828   ;;
9829 esac
9830 fi
9831 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9832
9833 if test -n "$LIPO_FOR_TARGET"; then
9834   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9835 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9836 else
9837   echo "$as_me:$LINENO: result: no" >&5
9838 echo "${ECHO_T}no" >&6
9839 fi
9840
9841 fi
9842 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9843
9844
9845 if test -n "$LIPO_FOR_TARGET"; then
9846   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9847 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9848   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9849 fi
9850
9851 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9852   for ncn_progname in lipo; do
9853     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9854 set dummy ${ncn_progname}; ac_word=$2
9855 echo "$as_me:$LINENO: checking for $ac_word" >&5
9856 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9857 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9858   echo $ECHO_N "(cached) $ECHO_C" >&6
9859 else
9860   if test -n "$LIPO_FOR_TARGET"; then
9861   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9862 else
9863 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9864 for as_dir in $PATH
9865 do
9866   IFS=$as_save_IFS
9867   test -z "$as_dir" && as_dir=.
9868   for ac_exec_ext in '' $ac_executable_extensions; do
9869   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9870     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9871     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9872     break 2
9873   fi
9874 done
9875 done
9876
9877 fi
9878 fi
9879 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9880 if test -n "$LIPO_FOR_TARGET"; then
9881   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9882 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9883 else
9884   echo "$as_me:$LINENO: result: no" >&5
9885 echo "${ECHO_T}no" >&6
9886 fi
9887
9888   done
9889 fi
9890
9891 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9892   for ncn_progname in lipo; do
9893     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9894 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9895     if test -x $with_build_time_tools/${ncn_progname}; then
9896       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9897       echo "$as_me:$LINENO: result: yes" >&5
9898 echo "${ECHO_T}yes" >&6
9899       break
9900     else
9901       echo "$as_me:$LINENO: result: no" >&5
9902 echo "${ECHO_T}no" >&6
9903     fi
9904   done
9905 fi
9906
9907 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9908   for ncn_progname in lipo; do
9909     if test -n "$ncn_target_tool_prefix"; then
9910       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9911 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9912 echo "$as_me:$LINENO: checking for $ac_word" >&5
9913 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9914 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9915   echo $ECHO_N "(cached) $ECHO_C" >&6
9916 else
9917   if test -n "$LIPO_FOR_TARGET"; then
9918   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9919 else
9920 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9921 for as_dir in $PATH
9922 do
9923   IFS=$as_save_IFS
9924   test -z "$as_dir" && as_dir=.
9925   for ac_exec_ext in '' $ac_executable_extensions; do
9926   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9927     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9928     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9929     break 2
9930   fi
9931 done
9932 done
9933
9934 fi
9935 fi
9936 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9937 if test -n "$LIPO_FOR_TARGET"; then
9938   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9939 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9940 else
9941   echo "$as_me:$LINENO: result: no" >&5
9942 echo "${ECHO_T}no" >&6
9943 fi
9944
9945     fi
9946     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9947       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9948 set dummy ${ncn_progname}; ac_word=$2
9949 echo "$as_me:$LINENO: checking for $ac_word" >&5
9950 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9951 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9952   echo $ECHO_N "(cached) $ECHO_C" >&6
9953 else
9954   if test -n "$LIPO_FOR_TARGET"; then
9955   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9956 else
9957 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9958 for as_dir in $PATH
9959 do
9960   IFS=$as_save_IFS
9961   test -z "$as_dir" && as_dir=.
9962   for ac_exec_ext in '' $ac_executable_extensions; do
9963   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9964     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9965     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9966     break 2
9967   fi
9968 done
9969 done
9970
9971 fi
9972 fi
9973 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9974 if test -n "$LIPO_FOR_TARGET"; then
9975   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9976 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9977 else
9978   echo "$as_me:$LINENO: result: no" >&5
9979 echo "${ECHO_T}no" >&6
9980 fi
9981
9982     fi
9983     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9984   done
9985 fi
9986
9987 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9988   set dummy lipo
9989   if test $build = $target ; then
9990     LIPO_FOR_TARGET="$2"
9991   else
9992     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9993   fi
9994 else
9995   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9996 fi
9997
9998 else
9999   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10000 fi
10001
10002
10003
10004
10005 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10006   if test -n "$with_build_time_tools"; then
10007     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10008 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10009     if test -x $with_build_time_tools/nm; then
10010       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10011       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10012       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10013 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10014     else
10015       echo "$as_me:$LINENO: result: no" >&5
10016 echo "${ECHO_T}no" >&6
10017     fi
10018   elif test $build != $host && test $have_gcc_for_target = yes; then
10019     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10020     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10021     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10022   fi
10023 fi
10024 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10025   # Extract the first word of "nm", so it can be a program name with args.
10026 set dummy nm; ac_word=$2
10027 echo "$as_me:$LINENO: checking for $ac_word" >&5
10028 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10029 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10030   echo $ECHO_N "(cached) $ECHO_C" >&6
10031 else
10032   case $NM_FOR_TARGET in
10033   [\\/]* | ?:[\\/]*)
10034   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10035   ;;
10036   *)
10037   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10038 for as_dir in $gcc_cv_tool_dirs
10039 do
10040   IFS=$as_save_IFS
10041   test -z "$as_dir" && as_dir=.
10042   for ac_exec_ext in '' $ac_executable_extensions; do
10043   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10044     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10045     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10046     break 2
10047   fi
10048 done
10049 done
10050
10051   ;;
10052 esac
10053 fi
10054 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10055
10056 if test -n "$NM_FOR_TARGET"; then
10057   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10058 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10059 else
10060   echo "$as_me:$LINENO: result: no" >&5
10061 echo "${ECHO_T}no" >&6
10062 fi
10063
10064 fi
10065 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10066
10067
10068 if test -n "$NM_FOR_TARGET"; then
10069   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10070 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10071   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10072 fi
10073
10074 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10075   for ncn_progname in nm; do
10076     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10077 set dummy ${ncn_progname}; ac_word=$2
10078 echo "$as_me:$LINENO: checking for $ac_word" >&5
10079 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10080 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10081   echo $ECHO_N "(cached) $ECHO_C" >&6
10082 else
10083   if test -n "$NM_FOR_TARGET"; then
10084   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10085 else
10086 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10087 for as_dir in $PATH
10088 do
10089   IFS=$as_save_IFS
10090   test -z "$as_dir" && as_dir=.
10091   for ac_exec_ext in '' $ac_executable_extensions; do
10092   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10093     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10094     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10095     break 2
10096   fi
10097 done
10098 done
10099
10100 fi
10101 fi
10102 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10103 if test -n "$NM_FOR_TARGET"; then
10104   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10105 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10106 else
10107   echo "$as_me:$LINENO: result: no" >&5
10108 echo "${ECHO_T}no" >&6
10109 fi
10110
10111   done
10112 fi
10113
10114 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10115   for ncn_progname in nm; do
10116     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10117 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10118     if test -x $with_build_time_tools/${ncn_progname}; then
10119       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10120       echo "$as_me:$LINENO: result: yes" >&5
10121 echo "${ECHO_T}yes" >&6
10122       break
10123     else
10124       echo "$as_me:$LINENO: result: no" >&5
10125 echo "${ECHO_T}no" >&6
10126     fi
10127   done
10128 fi
10129
10130 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10131   for ncn_progname in nm; do
10132     if test -n "$ncn_target_tool_prefix"; then
10133       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10134 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10135 echo "$as_me:$LINENO: checking for $ac_word" >&5
10136 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10137 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10138   echo $ECHO_N "(cached) $ECHO_C" >&6
10139 else
10140   if test -n "$NM_FOR_TARGET"; then
10141   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10142 else
10143 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10144 for as_dir in $PATH
10145 do
10146   IFS=$as_save_IFS
10147   test -z "$as_dir" && as_dir=.
10148   for ac_exec_ext in '' $ac_executable_extensions; do
10149   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10150     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10151     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10152     break 2
10153   fi
10154 done
10155 done
10156
10157 fi
10158 fi
10159 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10160 if test -n "$NM_FOR_TARGET"; then
10161   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10162 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10163 else
10164   echo "$as_me:$LINENO: result: no" >&5
10165 echo "${ECHO_T}no" >&6
10166 fi
10167
10168     fi
10169     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10170       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10171 set dummy ${ncn_progname}; ac_word=$2
10172 echo "$as_me:$LINENO: checking for $ac_word" >&5
10173 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10174 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10175   echo $ECHO_N "(cached) $ECHO_C" >&6
10176 else
10177   if test -n "$NM_FOR_TARGET"; then
10178   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10179 else
10180 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10181 for as_dir in $PATH
10182 do
10183   IFS=$as_save_IFS
10184   test -z "$as_dir" && as_dir=.
10185   for ac_exec_ext in '' $ac_executable_extensions; do
10186   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10187     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10188     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10189     break 2
10190   fi
10191 done
10192 done
10193
10194 fi
10195 fi
10196 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10197 if test -n "$NM_FOR_TARGET"; then
10198   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10199 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10200 else
10201   echo "$as_me:$LINENO: result: no" >&5
10202 echo "${ECHO_T}no" >&6
10203 fi
10204
10205     fi
10206     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10207   done
10208 fi
10209
10210 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10211   set dummy nm
10212   if test $build = $target ; then
10213     NM_FOR_TARGET="$2"
10214   else
10215     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10216   fi
10217 else
10218   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10219 fi
10220
10221 else
10222   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10223 fi
10224
10225
10226
10227
10228 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10229   if test -n "$with_build_time_tools"; then
10230     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10231 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10232     if test -x $with_build_time_tools/objdump; then
10233       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10234       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10235       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10236 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10237     else
10238       echo "$as_me:$LINENO: result: no" >&5
10239 echo "${ECHO_T}no" >&6
10240     fi
10241   elif test $build != $host && test $have_gcc_for_target = yes; then
10242     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10243     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10244     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10245   fi
10246 fi
10247 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10248   # Extract the first word of "objdump", so it can be a program name with args.
10249 set dummy objdump; ac_word=$2
10250 echo "$as_me:$LINENO: checking for $ac_word" >&5
10251 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10252 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10253   echo $ECHO_N "(cached) $ECHO_C" >&6
10254 else
10255   case $OBJDUMP_FOR_TARGET in
10256   [\\/]* | ?:[\\/]*)
10257   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10258   ;;
10259   *)
10260   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10261 for as_dir in $gcc_cv_tool_dirs
10262 do
10263   IFS=$as_save_IFS
10264   test -z "$as_dir" && as_dir=.
10265   for ac_exec_ext in '' $ac_executable_extensions; do
10266   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10267     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10268     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10269     break 2
10270   fi
10271 done
10272 done
10273
10274   ;;
10275 esac
10276 fi
10277 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10278
10279 if test -n "$OBJDUMP_FOR_TARGET"; then
10280   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10281 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10282 else
10283   echo "$as_me:$LINENO: result: no" >&5
10284 echo "${ECHO_T}no" >&6
10285 fi
10286
10287 fi
10288 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10289
10290
10291 if test -n "$OBJDUMP_FOR_TARGET"; then
10292   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10293 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10294   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10295 fi
10296
10297 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10298   for ncn_progname in objdump; do
10299     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10300 set dummy ${ncn_progname}; ac_word=$2
10301 echo "$as_me:$LINENO: checking for $ac_word" >&5
10302 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10303 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10304   echo $ECHO_N "(cached) $ECHO_C" >&6
10305 else
10306   if test -n "$OBJDUMP_FOR_TARGET"; then
10307   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10308 else
10309 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10310 for as_dir in $PATH
10311 do
10312   IFS=$as_save_IFS
10313   test -z "$as_dir" && as_dir=.
10314   for ac_exec_ext in '' $ac_executable_extensions; do
10315   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10316     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10317     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10318     break 2
10319   fi
10320 done
10321 done
10322
10323 fi
10324 fi
10325 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10326 if test -n "$OBJDUMP_FOR_TARGET"; then
10327   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10328 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10329 else
10330   echo "$as_me:$LINENO: result: no" >&5
10331 echo "${ECHO_T}no" >&6
10332 fi
10333
10334   done
10335 fi
10336
10337 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10338   for ncn_progname in objdump; do
10339     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10340 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10341     if test -x $with_build_time_tools/${ncn_progname}; then
10342       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10343       echo "$as_me:$LINENO: result: yes" >&5
10344 echo "${ECHO_T}yes" >&6
10345       break
10346     else
10347       echo "$as_me:$LINENO: result: no" >&5
10348 echo "${ECHO_T}no" >&6
10349     fi
10350   done
10351 fi
10352
10353 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10354   for ncn_progname in objdump; do
10355     if test -n "$ncn_target_tool_prefix"; then
10356       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10357 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10358 echo "$as_me:$LINENO: checking for $ac_word" >&5
10359 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10360 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10361   echo $ECHO_N "(cached) $ECHO_C" >&6
10362 else
10363   if test -n "$OBJDUMP_FOR_TARGET"; then
10364   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10365 else
10366 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10367 for as_dir in $PATH
10368 do
10369   IFS=$as_save_IFS
10370   test -z "$as_dir" && as_dir=.
10371   for ac_exec_ext in '' $ac_executable_extensions; do
10372   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10373     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10374     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10375     break 2
10376   fi
10377 done
10378 done
10379
10380 fi
10381 fi
10382 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10383 if test -n "$OBJDUMP_FOR_TARGET"; then
10384   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10385 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10386 else
10387   echo "$as_me:$LINENO: result: no" >&5
10388 echo "${ECHO_T}no" >&6
10389 fi
10390
10391     fi
10392     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10393       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10394 set dummy ${ncn_progname}; ac_word=$2
10395 echo "$as_me:$LINENO: checking for $ac_word" >&5
10396 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10397 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10398   echo $ECHO_N "(cached) $ECHO_C" >&6
10399 else
10400   if test -n "$OBJDUMP_FOR_TARGET"; then
10401   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10402 else
10403 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10404 for as_dir in $PATH
10405 do
10406   IFS=$as_save_IFS
10407   test -z "$as_dir" && as_dir=.
10408   for ac_exec_ext in '' $ac_executable_extensions; do
10409   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10410     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10411     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10412     break 2
10413   fi
10414 done
10415 done
10416
10417 fi
10418 fi
10419 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10420 if test -n "$OBJDUMP_FOR_TARGET"; then
10421   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10422 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10423 else
10424   echo "$as_me:$LINENO: result: no" >&5
10425 echo "${ECHO_T}no" >&6
10426 fi
10427
10428     fi
10429     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10430   done
10431 fi
10432
10433 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10434   set dummy objdump
10435   if test $build = $target ; then
10436     OBJDUMP_FOR_TARGET="$2"
10437   else
10438     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10439   fi
10440 else
10441   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10442 fi
10443
10444 else
10445   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10446 fi
10447
10448
10449
10450
10451 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10452   if test -n "$with_build_time_tools"; then
10453     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10454 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10455     if test -x $with_build_time_tools/ranlib; then
10456       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10457       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10458       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10459 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10460     else
10461       echo "$as_me:$LINENO: result: no" >&5
10462 echo "${ECHO_T}no" >&6
10463     fi
10464   elif test $build != $host && test $have_gcc_for_target = yes; then
10465     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10466     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10467     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10468   fi
10469 fi
10470 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10471   # Extract the first word of "ranlib", so it can be a program name with args.
10472 set dummy ranlib; ac_word=$2
10473 echo "$as_me:$LINENO: checking for $ac_word" >&5
10474 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10475 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10476   echo $ECHO_N "(cached) $ECHO_C" >&6
10477 else
10478   case $RANLIB_FOR_TARGET in
10479   [\\/]* | ?:[\\/]*)
10480   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10481   ;;
10482   *)
10483   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10484 for as_dir in $gcc_cv_tool_dirs
10485 do
10486   IFS=$as_save_IFS
10487   test -z "$as_dir" && as_dir=.
10488   for ac_exec_ext in '' $ac_executable_extensions; do
10489   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10490     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10491     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10492     break 2
10493   fi
10494 done
10495 done
10496
10497   ;;
10498 esac
10499 fi
10500 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10501
10502 if test -n "$RANLIB_FOR_TARGET"; then
10503   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10504 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10505 else
10506   echo "$as_me:$LINENO: result: no" >&5
10507 echo "${ECHO_T}no" >&6
10508 fi
10509
10510 fi
10511 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10512
10513
10514 if test -n "$RANLIB_FOR_TARGET"; then
10515   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10516 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10517   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10518 fi
10519
10520 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10521   for ncn_progname in ranlib; do
10522     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10523 set dummy ${ncn_progname}; ac_word=$2
10524 echo "$as_me:$LINENO: checking for $ac_word" >&5
10525 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10526 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10527   echo $ECHO_N "(cached) $ECHO_C" >&6
10528 else
10529   if test -n "$RANLIB_FOR_TARGET"; then
10530   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10531 else
10532 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10533 for as_dir in $PATH
10534 do
10535   IFS=$as_save_IFS
10536   test -z "$as_dir" && as_dir=.
10537   for ac_exec_ext in '' $ac_executable_extensions; do
10538   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10539     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10540     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10541     break 2
10542   fi
10543 done
10544 done
10545
10546 fi
10547 fi
10548 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10549 if test -n "$RANLIB_FOR_TARGET"; then
10550   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10551 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10552 else
10553   echo "$as_me:$LINENO: result: no" >&5
10554 echo "${ECHO_T}no" >&6
10555 fi
10556
10557   done
10558 fi
10559
10560 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10561   for ncn_progname in ranlib; do
10562     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10563 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10564     if test -x $with_build_time_tools/${ncn_progname}; then
10565       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10566       echo "$as_me:$LINENO: result: yes" >&5
10567 echo "${ECHO_T}yes" >&6
10568       break
10569     else
10570       echo "$as_me:$LINENO: result: no" >&5
10571 echo "${ECHO_T}no" >&6
10572     fi
10573   done
10574 fi
10575
10576 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10577   for ncn_progname in ranlib; do
10578     if test -n "$ncn_target_tool_prefix"; then
10579       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10580 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10581 echo "$as_me:$LINENO: checking for $ac_word" >&5
10582 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10583 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10584   echo $ECHO_N "(cached) $ECHO_C" >&6
10585 else
10586   if test -n "$RANLIB_FOR_TARGET"; then
10587   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10588 else
10589 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10590 for as_dir in $PATH
10591 do
10592   IFS=$as_save_IFS
10593   test -z "$as_dir" && as_dir=.
10594   for ac_exec_ext in '' $ac_executable_extensions; do
10595   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10596     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10597     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10598     break 2
10599   fi
10600 done
10601 done
10602
10603 fi
10604 fi
10605 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10606 if test -n "$RANLIB_FOR_TARGET"; then
10607   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10608 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10609 else
10610   echo "$as_me:$LINENO: result: no" >&5
10611 echo "${ECHO_T}no" >&6
10612 fi
10613
10614     fi
10615     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10616       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10617 set dummy ${ncn_progname}; ac_word=$2
10618 echo "$as_me:$LINENO: checking for $ac_word" >&5
10619 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10620 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10621   echo $ECHO_N "(cached) $ECHO_C" >&6
10622 else
10623   if test -n "$RANLIB_FOR_TARGET"; then
10624   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10625 else
10626 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10627 for as_dir in $PATH
10628 do
10629   IFS=$as_save_IFS
10630   test -z "$as_dir" && as_dir=.
10631   for ac_exec_ext in '' $ac_executable_extensions; do
10632   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10633     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10634     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10635     break 2
10636   fi
10637 done
10638 done
10639
10640 fi
10641 fi
10642 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10643 if test -n "$RANLIB_FOR_TARGET"; then
10644   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10645 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10646 else
10647   echo "$as_me:$LINENO: result: no" >&5
10648 echo "${ECHO_T}no" >&6
10649 fi
10650
10651     fi
10652     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10653   done
10654 fi
10655
10656 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10657   set dummy ranlib
10658   if test $build = $target ; then
10659     RANLIB_FOR_TARGET="$2"
10660   else
10661     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10662   fi
10663 else
10664   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10665 fi
10666
10667 else
10668   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10669 fi
10670
10671
10672
10673
10674 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10675   if test -n "$with_build_time_tools"; then
10676     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10677 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10678     if test -x $with_build_time_tools/strip; then
10679       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10680       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10681       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10682 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10683     else
10684       echo "$as_me:$LINENO: result: no" >&5
10685 echo "${ECHO_T}no" >&6
10686     fi
10687   elif test $build != $host && test $have_gcc_for_target = yes; then
10688     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10689     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10690     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10691   fi
10692 fi
10693 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10694   # Extract the first word of "strip", so it can be a program name with args.
10695 set dummy strip; ac_word=$2
10696 echo "$as_me:$LINENO: checking for $ac_word" >&5
10697 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10698 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10699   echo $ECHO_N "(cached) $ECHO_C" >&6
10700 else
10701   case $STRIP_FOR_TARGET in
10702   [\\/]* | ?:[\\/]*)
10703   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10704   ;;
10705   *)
10706   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10707 for as_dir in $gcc_cv_tool_dirs
10708 do
10709   IFS=$as_save_IFS
10710   test -z "$as_dir" && as_dir=.
10711   for ac_exec_ext in '' $ac_executable_extensions; do
10712   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10713     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10714     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10715     break 2
10716   fi
10717 done
10718 done
10719
10720   ;;
10721 esac
10722 fi
10723 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10724
10725 if test -n "$STRIP_FOR_TARGET"; then
10726   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10727 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10728 else
10729   echo "$as_me:$LINENO: result: no" >&5
10730 echo "${ECHO_T}no" >&6
10731 fi
10732
10733 fi
10734 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10735
10736
10737 if test -n "$STRIP_FOR_TARGET"; then
10738   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10739 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10740   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10741 fi
10742
10743 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10744   for ncn_progname in strip; do
10745     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10746 set dummy ${ncn_progname}; ac_word=$2
10747 echo "$as_me:$LINENO: checking for $ac_word" >&5
10748 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10749 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10750   echo $ECHO_N "(cached) $ECHO_C" >&6
10751 else
10752   if test -n "$STRIP_FOR_TARGET"; then
10753   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10754 else
10755 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10756 for as_dir in $PATH
10757 do
10758   IFS=$as_save_IFS
10759   test -z "$as_dir" && as_dir=.
10760   for ac_exec_ext in '' $ac_executable_extensions; do
10761   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10762     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10763     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10764     break 2
10765   fi
10766 done
10767 done
10768
10769 fi
10770 fi
10771 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10772 if test -n "$STRIP_FOR_TARGET"; then
10773   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10774 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10775 else
10776   echo "$as_me:$LINENO: result: no" >&5
10777 echo "${ECHO_T}no" >&6
10778 fi
10779
10780   done
10781 fi
10782
10783 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10784   for ncn_progname in strip; do
10785     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10786 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10787     if test -x $with_build_time_tools/${ncn_progname}; then
10788       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10789       echo "$as_me:$LINENO: result: yes" >&5
10790 echo "${ECHO_T}yes" >&6
10791       break
10792     else
10793       echo "$as_me:$LINENO: result: no" >&5
10794 echo "${ECHO_T}no" >&6
10795     fi
10796   done
10797 fi
10798
10799 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10800   for ncn_progname in strip; do
10801     if test -n "$ncn_target_tool_prefix"; then
10802       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10803 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10804 echo "$as_me:$LINENO: checking for $ac_word" >&5
10805 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10806 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10807   echo $ECHO_N "(cached) $ECHO_C" >&6
10808 else
10809   if test -n "$STRIP_FOR_TARGET"; then
10810   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10811 else
10812 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10813 for as_dir in $PATH
10814 do
10815   IFS=$as_save_IFS
10816   test -z "$as_dir" && as_dir=.
10817   for ac_exec_ext in '' $ac_executable_extensions; do
10818   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10819     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10820     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10821     break 2
10822   fi
10823 done
10824 done
10825
10826 fi
10827 fi
10828 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10829 if test -n "$STRIP_FOR_TARGET"; then
10830   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10831 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10832 else
10833   echo "$as_me:$LINENO: result: no" >&5
10834 echo "${ECHO_T}no" >&6
10835 fi
10836
10837     fi
10838     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10839       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10840 set dummy ${ncn_progname}; ac_word=$2
10841 echo "$as_me:$LINENO: checking for $ac_word" >&5
10842 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10843 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10844   echo $ECHO_N "(cached) $ECHO_C" >&6
10845 else
10846   if test -n "$STRIP_FOR_TARGET"; then
10847   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10848 else
10849 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10850 for as_dir in $PATH
10851 do
10852   IFS=$as_save_IFS
10853   test -z "$as_dir" && as_dir=.
10854   for ac_exec_ext in '' $ac_executable_extensions; do
10855   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10856     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10857     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10858     break 2
10859   fi
10860 done
10861 done
10862
10863 fi
10864 fi
10865 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10866 if test -n "$STRIP_FOR_TARGET"; then
10867   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10868 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10869 else
10870   echo "$as_me:$LINENO: result: no" >&5
10871 echo "${ECHO_T}no" >&6
10872 fi
10873
10874     fi
10875     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10876   done
10877 fi
10878
10879 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10880   set dummy strip
10881   if test $build = $target ; then
10882     STRIP_FOR_TARGET="$2"
10883   else
10884     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10885   fi
10886 else
10887   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10888 fi
10889
10890 else
10891   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10892 fi
10893
10894
10895
10896
10897 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10898   if test -n "$with_build_time_tools"; then
10899     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10900 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10901     if test -x $with_build_time_tools/windres; then
10902       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10903       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10904       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10905 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10906     else
10907       echo "$as_me:$LINENO: result: no" >&5
10908 echo "${ECHO_T}no" >&6
10909     fi
10910   elif test $build != $host && test $have_gcc_for_target = yes; then
10911     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10912     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10913     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10914   fi
10915 fi
10916 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10917   # Extract the first word of "windres", so it can be a program name with args.
10918 set dummy windres; ac_word=$2
10919 echo "$as_me:$LINENO: checking for $ac_word" >&5
10920 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10921 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10922   echo $ECHO_N "(cached) $ECHO_C" >&6
10923 else
10924   case $WINDRES_FOR_TARGET in
10925   [\\/]* | ?:[\\/]*)
10926   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10927   ;;
10928   *)
10929   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10930 for as_dir in $gcc_cv_tool_dirs
10931 do
10932   IFS=$as_save_IFS
10933   test -z "$as_dir" && as_dir=.
10934   for ac_exec_ext in '' $ac_executable_extensions; do
10935   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10936     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10937     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10938     break 2
10939   fi
10940 done
10941 done
10942
10943   ;;
10944 esac
10945 fi
10946 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10947
10948 if test -n "$WINDRES_FOR_TARGET"; then
10949   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10950 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10951 else
10952   echo "$as_me:$LINENO: result: no" >&5
10953 echo "${ECHO_T}no" >&6
10954 fi
10955
10956 fi
10957 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10958
10959
10960 if test -n "$WINDRES_FOR_TARGET"; then
10961   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10962 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10963   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10964 fi
10965
10966 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10967   for ncn_progname in windres; do
10968     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10969 set dummy ${ncn_progname}; ac_word=$2
10970 echo "$as_me:$LINENO: checking for $ac_word" >&5
10971 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10972 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10973   echo $ECHO_N "(cached) $ECHO_C" >&6
10974 else
10975   if test -n "$WINDRES_FOR_TARGET"; then
10976   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10977 else
10978 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10979 for as_dir in $PATH
10980 do
10981   IFS=$as_save_IFS
10982   test -z "$as_dir" && as_dir=.
10983   for ac_exec_ext in '' $ac_executable_extensions; do
10984   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10985     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10986     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10987     break 2
10988   fi
10989 done
10990 done
10991
10992 fi
10993 fi
10994 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10995 if test -n "$WINDRES_FOR_TARGET"; then
10996   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10997 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10998 else
10999   echo "$as_me:$LINENO: result: no" >&5
11000 echo "${ECHO_T}no" >&6
11001 fi
11002
11003   done
11004 fi
11005
11006 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11007   for ncn_progname in windres; do
11008     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11009 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11010     if test -x $with_build_time_tools/${ncn_progname}; then
11011       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11012       echo "$as_me:$LINENO: result: yes" >&5
11013 echo "${ECHO_T}yes" >&6
11014       break
11015     else
11016       echo "$as_me:$LINENO: result: no" >&5
11017 echo "${ECHO_T}no" >&6
11018     fi
11019   done
11020 fi
11021
11022 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11023   for ncn_progname in windres; do
11024     if test -n "$ncn_target_tool_prefix"; then
11025       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11026 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11027 echo "$as_me:$LINENO: checking for $ac_word" >&5
11028 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11029 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11030   echo $ECHO_N "(cached) $ECHO_C" >&6
11031 else
11032   if test -n "$WINDRES_FOR_TARGET"; then
11033   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11034 else
11035 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11036 for as_dir in $PATH
11037 do
11038   IFS=$as_save_IFS
11039   test -z "$as_dir" && as_dir=.
11040   for ac_exec_ext in '' $ac_executable_extensions; do
11041   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11042     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11043     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11044     break 2
11045   fi
11046 done
11047 done
11048
11049 fi
11050 fi
11051 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11052 if test -n "$WINDRES_FOR_TARGET"; then
11053   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11054 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11055 else
11056   echo "$as_me:$LINENO: result: no" >&5
11057 echo "${ECHO_T}no" >&6
11058 fi
11059
11060     fi
11061     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11062       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11063 set dummy ${ncn_progname}; ac_word=$2
11064 echo "$as_me:$LINENO: checking for $ac_word" >&5
11065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11066 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11067   echo $ECHO_N "(cached) $ECHO_C" >&6
11068 else
11069   if test -n "$WINDRES_FOR_TARGET"; then
11070   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11071 else
11072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11073 for as_dir in $PATH
11074 do
11075   IFS=$as_save_IFS
11076   test -z "$as_dir" && as_dir=.
11077   for ac_exec_ext in '' $ac_executable_extensions; do
11078   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11079     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11080     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11081     break 2
11082   fi
11083 done
11084 done
11085
11086 fi
11087 fi
11088 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11089 if test -n "$WINDRES_FOR_TARGET"; then
11090   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11091 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11092 else
11093   echo "$as_me:$LINENO: result: no" >&5
11094 echo "${ECHO_T}no" >&6
11095 fi
11096
11097     fi
11098     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11099   done
11100 fi
11101
11102 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11103   set dummy windres
11104   if test $build = $target ; then
11105     WINDRES_FOR_TARGET="$2"
11106   else
11107     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11108   fi
11109 else
11110   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11111 fi
11112
11113 else
11114   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11115 fi
11116
11117
11118
11119
11120 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11121   if test -n "$with_build_time_tools"; then
11122     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11123 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11124     if test -x $with_build_time_tools/windmc; then
11125       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11126       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11127       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11128 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11129     else
11130       echo "$as_me:$LINENO: result: no" >&5
11131 echo "${ECHO_T}no" >&6
11132     fi
11133   elif test $build != $host && test $have_gcc_for_target = yes; then
11134     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11135     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11136     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11137   fi
11138 fi
11139 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11140   # Extract the first word of "windmc", so it can be a program name with args.
11141 set dummy windmc; ac_word=$2
11142 echo "$as_me:$LINENO: checking for $ac_word" >&5
11143 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11144 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11145   echo $ECHO_N "(cached) $ECHO_C" >&6
11146 else
11147   case $WINDMC_FOR_TARGET in
11148   [\\/]* | ?:[\\/]*)
11149   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11150   ;;
11151   *)
11152   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11153 for as_dir in $gcc_cv_tool_dirs
11154 do
11155   IFS=$as_save_IFS
11156   test -z "$as_dir" && as_dir=.
11157   for ac_exec_ext in '' $ac_executable_extensions; do
11158   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11159     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11160     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11161     break 2
11162   fi
11163 done
11164 done
11165
11166   ;;
11167 esac
11168 fi
11169 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11170
11171 if test -n "$WINDMC_FOR_TARGET"; then
11172   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11173 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11174 else
11175   echo "$as_me:$LINENO: result: no" >&5
11176 echo "${ECHO_T}no" >&6
11177 fi
11178
11179 fi
11180 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11181
11182
11183 if test -n "$WINDMC_FOR_TARGET"; then
11184   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11185 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11186   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11187 fi
11188
11189 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11190   for ncn_progname in windmc; do
11191     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11192 set dummy ${ncn_progname}; ac_word=$2
11193 echo "$as_me:$LINENO: checking for $ac_word" >&5
11194 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11195 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11196   echo $ECHO_N "(cached) $ECHO_C" >&6
11197 else
11198   if test -n "$WINDMC_FOR_TARGET"; then
11199   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11200 else
11201 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11202 for as_dir in $PATH
11203 do
11204   IFS=$as_save_IFS
11205   test -z "$as_dir" && as_dir=.
11206   for ac_exec_ext in '' $ac_executable_extensions; do
11207   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11208     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11209     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11210     break 2
11211   fi
11212 done
11213 done
11214
11215 fi
11216 fi
11217 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11218 if test -n "$WINDMC_FOR_TARGET"; then
11219   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11220 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11221 else
11222   echo "$as_me:$LINENO: result: no" >&5
11223 echo "${ECHO_T}no" >&6
11224 fi
11225
11226   done
11227 fi
11228
11229 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11230   for ncn_progname in windmc; do
11231     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11232 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11233     if test -x $with_build_time_tools/${ncn_progname}; then
11234       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11235       echo "$as_me:$LINENO: result: yes" >&5
11236 echo "${ECHO_T}yes" >&6
11237       break
11238     else
11239       echo "$as_me:$LINENO: result: no" >&5
11240 echo "${ECHO_T}no" >&6
11241     fi
11242   done
11243 fi
11244
11245 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11246   for ncn_progname in windmc; do
11247     if test -n "$ncn_target_tool_prefix"; then
11248       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11249 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11250 echo "$as_me:$LINENO: checking for $ac_word" >&5
11251 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11252 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11253   echo $ECHO_N "(cached) $ECHO_C" >&6
11254 else
11255   if test -n "$WINDMC_FOR_TARGET"; then
11256   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11257 else
11258 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11259 for as_dir in $PATH
11260 do
11261   IFS=$as_save_IFS
11262   test -z "$as_dir" && as_dir=.
11263   for ac_exec_ext in '' $ac_executable_extensions; do
11264   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11265     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11266     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11267     break 2
11268   fi
11269 done
11270 done
11271
11272 fi
11273 fi
11274 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11275 if test -n "$WINDMC_FOR_TARGET"; then
11276   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11277 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11278 else
11279   echo "$as_me:$LINENO: result: no" >&5
11280 echo "${ECHO_T}no" >&6
11281 fi
11282
11283     fi
11284     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11285       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11286 set dummy ${ncn_progname}; ac_word=$2
11287 echo "$as_me:$LINENO: checking for $ac_word" >&5
11288 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11289 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11290   echo $ECHO_N "(cached) $ECHO_C" >&6
11291 else
11292   if test -n "$WINDMC_FOR_TARGET"; then
11293   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11294 else
11295 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11296 for as_dir in $PATH
11297 do
11298   IFS=$as_save_IFS
11299   test -z "$as_dir" && as_dir=.
11300   for ac_exec_ext in '' $ac_executable_extensions; do
11301   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11302     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11303     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11304     break 2
11305   fi
11306 done
11307 done
11308
11309 fi
11310 fi
11311 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11312 if test -n "$WINDMC_FOR_TARGET"; then
11313   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11314 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11315 else
11316   echo "$as_me:$LINENO: result: no" >&5
11317 echo "${ECHO_T}no" >&6
11318 fi
11319
11320     fi
11321     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11322   done
11323 fi
11324
11325 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11326   set dummy windmc
11327   if test $build = $target ; then
11328     WINDMC_FOR_TARGET="$2"
11329   else
11330     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11331   fi
11332 else
11333   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11334 fi
11335
11336 else
11337   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11338 fi
11339
11340
11341 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11342
11343 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11344 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11345 if test "x${build}" != "x${host}" ; then
11346   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11347     # We already found the complete path
11348     ac_dir=`dirname $AR_FOR_TARGET`
11349     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11350 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11351   else
11352     # Canadian cross, just use what we found
11353     echo "$as_me:$LINENO: result: pre-installed" >&5
11354 echo "${ECHO_T}pre-installed" >&6
11355   fi
11356 else
11357   ok=yes
11358   case " ${configdirs} " in
11359     *" binutils "*) ;;
11360     *) ok=no ;;
11361   esac
11362
11363   if test $ok = yes; then
11364     # An in-tree tool is available and we can use it
11365     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11366     echo "$as_me:$LINENO: result: just compiled" >&5
11367 echo "${ECHO_T}just compiled" >&6
11368   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11369     # We already found the complete path
11370     ac_dir=`dirname $AR_FOR_TARGET`
11371     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11372 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11373   elif test "x$target" = "x$host"; then
11374     # We can use an host tool
11375     AR_FOR_TARGET='$(AR)'
11376     echo "$as_me:$LINENO: result: host tool" >&5
11377 echo "${ECHO_T}host tool" >&6
11378   else
11379     # We need a cross tool
11380     echo "$as_me:$LINENO: result: pre-installed" >&5
11381 echo "${ECHO_T}pre-installed" >&6
11382   fi
11383 fi
11384
11385 echo "$as_me:$LINENO: checking where to find the target as" >&5
11386 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11387 if test "x${build}" != "x${host}" ; then
11388   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11389     # We already found the complete path
11390     ac_dir=`dirname $AS_FOR_TARGET`
11391     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11392 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11393   else
11394     # Canadian cross, just use what we found
11395     echo "$as_me:$LINENO: result: pre-installed" >&5
11396 echo "${ECHO_T}pre-installed" >&6
11397   fi
11398 else
11399   ok=yes
11400   case " ${configdirs} " in
11401     *" gas "*) ;;
11402     *) ok=no ;;
11403   esac
11404
11405   if test $ok = yes; then
11406     # An in-tree tool is available and we can use it
11407     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11408     echo "$as_me:$LINENO: result: just compiled" >&5
11409 echo "${ECHO_T}just compiled" >&6
11410   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11411     # We already found the complete path
11412     ac_dir=`dirname $AS_FOR_TARGET`
11413     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11414 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11415   elif test "x$target" = "x$host"; then
11416     # We can use an host tool
11417     AS_FOR_TARGET='$(AS)'
11418     echo "$as_me:$LINENO: result: host tool" >&5
11419 echo "${ECHO_T}host tool" >&6
11420   else
11421     # We need a cross tool
11422     echo "$as_me:$LINENO: result: pre-installed" >&5
11423 echo "${ECHO_T}pre-installed" >&6
11424   fi
11425 fi
11426
11427 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11428 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11429 if test "x${build}" != "x${host}" ; then
11430   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11431     # We already found the complete path
11432     ac_dir=`dirname $CC_FOR_TARGET`
11433     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11434 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11435   else
11436     # Canadian cross, just use what we found
11437     echo "$as_me:$LINENO: result: pre-installed" >&5
11438 echo "${ECHO_T}pre-installed" >&6
11439   fi
11440 else
11441   ok=yes
11442   case " ${configdirs} " in
11443     *" gcc "*) ;;
11444     *) ok=no ;;
11445   esac
11446
11447   if test $ok = yes; then
11448     # An in-tree tool is available and we can use it
11449     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11450     echo "$as_me:$LINENO: result: just compiled" >&5
11451 echo "${ECHO_T}just compiled" >&6
11452   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11453     # We already found the complete path
11454     ac_dir=`dirname $CC_FOR_TARGET`
11455     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11456 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11457   elif test "x$target" = "x$host"; then
11458     # We can use an host tool
11459     CC_FOR_TARGET='$(CC)'
11460     echo "$as_me:$LINENO: result: host tool" >&5
11461 echo "${ECHO_T}host tool" >&6
11462   else
11463     # We need a cross tool
11464     echo "$as_me:$LINENO: result: pre-installed" >&5
11465 echo "${ECHO_T}pre-installed" >&6
11466   fi
11467 fi
11468
11469 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11470 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11471 if test "x${build}" != "x${host}" ; then
11472   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11473     # We already found the complete path
11474     ac_dir=`dirname $CXX_FOR_TARGET`
11475     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11476 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11477   else
11478     # Canadian cross, just use what we found
11479     echo "$as_me:$LINENO: result: pre-installed" >&5
11480 echo "${ECHO_T}pre-installed" >&6
11481   fi
11482 else
11483   ok=yes
11484   case " ${configdirs} " in
11485     *" gcc "*) ;;
11486     *) ok=no ;;
11487   esac
11488   case ,${enable_languages}, in
11489     *,c++,*) ;;
11490     *) ok=no ;;
11491   esac
11492   if test $ok = yes; then
11493     # An in-tree tool is available and we can use it
11494     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'
11495     echo "$as_me:$LINENO: result: just compiled" >&5
11496 echo "${ECHO_T}just compiled" >&6
11497   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11498     # We already found the complete path
11499     ac_dir=`dirname $CXX_FOR_TARGET`
11500     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11501 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11502   elif test "x$target" = "x$host"; then
11503     # We can use an host tool
11504     CXX_FOR_TARGET='$(CXX)'
11505     echo "$as_me:$LINENO: result: host tool" >&5
11506 echo "${ECHO_T}host tool" >&6
11507   else
11508     # We need a cross tool
11509     echo "$as_me:$LINENO: result: pre-installed" >&5
11510 echo "${ECHO_T}pre-installed" >&6
11511   fi
11512 fi
11513
11514 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11515 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11516 if test "x${build}" != "x${host}" ; then
11517   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11518     # We already found the complete path
11519     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11520     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11521 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11522   else
11523     # Canadian cross, just use what we found
11524     echo "$as_me:$LINENO: result: pre-installed" >&5
11525 echo "${ECHO_T}pre-installed" >&6
11526   fi
11527 else
11528   ok=yes
11529   case " ${configdirs} " in
11530     *" gcc "*) ;;
11531     *) ok=no ;;
11532   esac
11533   case ,${enable_languages}, in
11534     *,c++,*) ;;
11535     *) ok=no ;;
11536   esac
11537   if test $ok = yes; then
11538     # An in-tree tool is available and we can use it
11539     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'
11540     echo "$as_me:$LINENO: result: just compiled" >&5
11541 echo "${ECHO_T}just compiled" >&6
11542   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11543     # We already found the complete path
11544     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11545     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11546 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11547   elif test "x$target" = "x$host"; then
11548     # We can use an host tool
11549     RAW_CXX_FOR_TARGET='$(CXX)'
11550     echo "$as_me:$LINENO: result: host tool" >&5
11551 echo "${ECHO_T}host tool" >&6
11552   else
11553     # We need a cross tool
11554     echo "$as_me:$LINENO: result: pre-installed" >&5
11555 echo "${ECHO_T}pre-installed" >&6
11556   fi
11557 fi
11558
11559 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11560 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11561 if test "x${build}" != "x${host}" ; then
11562   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11563     # We already found the complete path
11564     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11565     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11566 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11567   else
11568     # Canadian cross, just use what we found
11569     echo "$as_me:$LINENO: result: pre-installed" >&5
11570 echo "${ECHO_T}pre-installed" >&6
11571   fi
11572 else
11573   ok=yes
11574   case " ${configdirs} " in
11575     *" binutils "*) ;;
11576     *) ok=no ;;
11577   esac
11578
11579   if test $ok = yes; then
11580     # An in-tree tool is available and we can use it
11581     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11582     echo "$as_me:$LINENO: result: just compiled" >&5
11583 echo "${ECHO_T}just compiled" >&6
11584   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11585     # We already found the complete path
11586     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11587     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11588 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11589   elif test "x$target" = "x$host"; then
11590     # We can use an host tool
11591     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11592     echo "$as_me:$LINENO: result: host tool" >&5
11593 echo "${ECHO_T}host tool" >&6
11594   else
11595     # We need a cross tool
11596     echo "$as_me:$LINENO: result: pre-installed" >&5
11597 echo "${ECHO_T}pre-installed" >&6
11598   fi
11599 fi
11600
11601 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11602 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11603 if test "x${build}" != "x${host}" ; then
11604   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11605     # We already found the complete path
11606     ac_dir=`dirname $GCC_FOR_TARGET`
11607     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11608 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11609   else
11610     # Canadian cross, just use what we found
11611     echo "$as_me:$LINENO: result: pre-installed" >&5
11612 echo "${ECHO_T}pre-installed" >&6
11613   fi
11614 else
11615   ok=yes
11616   case " ${configdirs} " in
11617     *" gcc "*) ;;
11618     *) ok=no ;;
11619   esac
11620
11621   if test $ok = yes; then
11622     # An in-tree tool is available and we can use it
11623     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11624     echo "$as_me:$LINENO: result: just compiled" >&5
11625 echo "${ECHO_T}just compiled" >&6
11626   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11627     # We already found the complete path
11628     ac_dir=`dirname $GCC_FOR_TARGET`
11629     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11630 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11631   elif test "x$target" = "x$host"; then
11632     # We can use an host tool
11633     GCC_FOR_TARGET='$()'
11634     echo "$as_me:$LINENO: result: host tool" >&5
11635 echo "${ECHO_T}host tool" >&6
11636   else
11637     # We need a cross tool
11638     echo "$as_me:$LINENO: result: pre-installed" >&5
11639 echo "${ECHO_T}pre-installed" >&6
11640   fi
11641 fi
11642
11643 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11644 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11645 if test "x${build}" != "x${host}" ; then
11646   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11647     # We already found the complete path
11648     ac_dir=`dirname $GCJ_FOR_TARGET`
11649     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11650 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11651   else
11652     # Canadian cross, just use what we found
11653     echo "$as_me:$LINENO: result: pre-installed" >&5
11654 echo "${ECHO_T}pre-installed" >&6
11655   fi
11656 else
11657   ok=yes
11658   case " ${configdirs} " in
11659     *" gcc "*) ;;
11660     *) ok=no ;;
11661   esac
11662   case ,${enable_languages}, in
11663     *,java,*) ;;
11664     *) ok=no ;;
11665   esac
11666   if test $ok = yes; then
11667     # An in-tree tool is available and we can use it
11668     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11669     echo "$as_me:$LINENO: result: just compiled" >&5
11670 echo "${ECHO_T}just compiled" >&6
11671   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11672     # We already found the complete path
11673     ac_dir=`dirname $GCJ_FOR_TARGET`
11674     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11675 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11676   elif test "x$target" = "x$host"; then
11677     # We can use an host tool
11678     GCJ_FOR_TARGET='$(GCJ)'
11679     echo "$as_me:$LINENO: result: host tool" >&5
11680 echo "${ECHO_T}host tool" >&6
11681   else
11682     # We need a cross tool
11683     echo "$as_me:$LINENO: result: pre-installed" >&5
11684 echo "${ECHO_T}pre-installed" >&6
11685   fi
11686 fi
11687
11688 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11689 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11690 if test "x${build}" != "x${host}" ; then
11691   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11692     # We already found the complete path
11693     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11694     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11695 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11696   else
11697     # Canadian cross, just use what we found
11698     echo "$as_me:$LINENO: result: pre-installed" >&5
11699 echo "${ECHO_T}pre-installed" >&6
11700   fi
11701 else
11702   ok=yes
11703   case " ${configdirs} " in
11704     *" gcc "*) ;;
11705     *) ok=no ;;
11706   esac
11707   case ,${enable_languages}, in
11708     *,fortran,*) ;;
11709     *) ok=no ;;
11710   esac
11711   if test $ok = yes; then
11712     # An in-tree tool is available and we can use it
11713     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11714     echo "$as_me:$LINENO: result: just compiled" >&5
11715 echo "${ECHO_T}just compiled" >&6
11716   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11717     # We already found the complete path
11718     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11719     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11720 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11721   elif test "x$target" = "x$host"; then
11722     # We can use an host tool
11723     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11724     echo "$as_me:$LINENO: result: host tool" >&5
11725 echo "${ECHO_T}host tool" >&6
11726   else
11727     # We need a cross tool
11728     echo "$as_me:$LINENO: result: pre-installed" >&5
11729 echo "${ECHO_T}pre-installed" >&6
11730   fi
11731 fi
11732
11733 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11734 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11735 if test "x${build}" != "x${host}" ; then
11736   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11737     # We already found the complete path
11738     ac_dir=`dirname $LD_FOR_TARGET`
11739     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11740 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11741   else
11742     # Canadian cross, just use what we found
11743     echo "$as_me:$LINENO: result: pre-installed" >&5
11744 echo "${ECHO_T}pre-installed" >&6
11745   fi
11746 else
11747   ok=yes
11748   case " ${configdirs} " in
11749     *" ld "*) ;;
11750     *) ok=no ;;
11751   esac
11752
11753   if test $ok = yes; then
11754     # An in-tree tool is available and we can use it
11755     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11756     echo "$as_me:$LINENO: result: just compiled" >&5
11757 echo "${ECHO_T}just compiled" >&6
11758   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11759     # We already found the complete path
11760     ac_dir=`dirname $LD_FOR_TARGET`
11761     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11762 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11763   elif test "x$target" = "x$host"; then
11764     # We can use an host tool
11765     LD_FOR_TARGET='$(LD)'
11766     echo "$as_me:$LINENO: result: host tool" >&5
11767 echo "${ECHO_T}host tool" >&6
11768   else
11769     # We need a cross tool
11770     echo "$as_me:$LINENO: result: pre-installed" >&5
11771 echo "${ECHO_T}pre-installed" >&6
11772   fi
11773 fi
11774
11775 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11776 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11777 if test "x${build}" != "x${host}" ; then
11778   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11779     # We already found the complete path
11780     ac_dir=`dirname $LIPO_FOR_TARGET`
11781     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11782 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11783   else
11784     # Canadian cross, just use what we found
11785     echo "$as_me:$LINENO: result: pre-installed" >&5
11786 echo "${ECHO_T}pre-installed" >&6
11787   fi
11788 else
11789   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11790     # We already found the complete path
11791     ac_dir=`dirname $LIPO_FOR_TARGET`
11792     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11793 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11794   elif test "x$target" = "x$host"; then
11795     # We can use an host tool
11796     LIPO_FOR_TARGET='$(LIPO)'
11797     echo "$as_me:$LINENO: result: host tool" >&5
11798 echo "${ECHO_T}host tool" >&6
11799   else
11800     # We need a cross tool
11801     echo "$as_me:$LINENO: result: pre-installed" >&5
11802 echo "${ECHO_T}pre-installed" >&6
11803   fi
11804 fi
11805
11806 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11807 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11808 if test "x${build}" != "x${host}" ; then
11809   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11810     # We already found the complete path
11811     ac_dir=`dirname $NM_FOR_TARGET`
11812     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11813 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11814   else
11815     # Canadian cross, just use what we found
11816     echo "$as_me:$LINENO: result: pre-installed" >&5
11817 echo "${ECHO_T}pre-installed" >&6
11818   fi
11819 else
11820   ok=yes
11821   case " ${configdirs} " in
11822     *" binutils "*) ;;
11823     *) ok=no ;;
11824   esac
11825
11826   if test $ok = yes; then
11827     # An in-tree tool is available and we can use it
11828     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11829     echo "$as_me:$LINENO: result: just compiled" >&5
11830 echo "${ECHO_T}just compiled" >&6
11831   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11832     # We already found the complete path
11833     ac_dir=`dirname $NM_FOR_TARGET`
11834     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11835 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11836   elif test "x$target" = "x$host"; then
11837     # We can use an host tool
11838     NM_FOR_TARGET='$(NM)'
11839     echo "$as_me:$LINENO: result: host tool" >&5
11840 echo "${ECHO_T}host tool" >&6
11841   else
11842     # We need a cross tool
11843     echo "$as_me:$LINENO: result: pre-installed" >&5
11844 echo "${ECHO_T}pre-installed" >&6
11845   fi
11846 fi
11847
11848 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11849 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11850 if test "x${build}" != "x${host}" ; then
11851   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11852     # We already found the complete path
11853     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11854     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11855 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11856   else
11857     # Canadian cross, just use what we found
11858     echo "$as_me:$LINENO: result: pre-installed" >&5
11859 echo "${ECHO_T}pre-installed" >&6
11860   fi
11861 else
11862   ok=yes
11863   case " ${configdirs} " in
11864     *" binutils "*) ;;
11865     *) ok=no ;;
11866   esac
11867
11868   if test $ok = yes; then
11869     # An in-tree tool is available and we can use it
11870     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11871     echo "$as_me:$LINENO: result: just compiled" >&5
11872 echo "${ECHO_T}just compiled" >&6
11873   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11874     # We already found the complete path
11875     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11876     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11877 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11878   elif test "x$target" = "x$host"; then
11879     # We can use an host tool
11880     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11881     echo "$as_me:$LINENO: result: host tool" >&5
11882 echo "${ECHO_T}host tool" >&6
11883   else
11884     # We need a cross tool
11885     echo "$as_me:$LINENO: result: pre-installed" >&5
11886 echo "${ECHO_T}pre-installed" >&6
11887   fi
11888 fi
11889
11890 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11891 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11892 if test "x${build}" != "x${host}" ; then
11893   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11894     # We already found the complete path
11895     ac_dir=`dirname $RANLIB_FOR_TARGET`
11896     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11897 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11898   else
11899     # Canadian cross, just use what we found
11900     echo "$as_me:$LINENO: result: pre-installed" >&5
11901 echo "${ECHO_T}pre-installed" >&6
11902   fi
11903 else
11904   ok=yes
11905   case " ${configdirs} " in
11906     *" binutils "*) ;;
11907     *) ok=no ;;
11908   esac
11909
11910   if test $ok = yes; then
11911     # An in-tree tool is available and we can use it
11912     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11913     echo "$as_me:$LINENO: result: just compiled" >&5
11914 echo "${ECHO_T}just compiled" >&6
11915   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11916     # We already found the complete path
11917     ac_dir=`dirname $RANLIB_FOR_TARGET`
11918     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11919 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11920   elif test "x$target" = "x$host"; then
11921     # We can use an host tool
11922     RANLIB_FOR_TARGET='$(RANLIB)'
11923     echo "$as_me:$LINENO: result: host tool" >&5
11924 echo "${ECHO_T}host tool" >&6
11925   else
11926     # We need a cross tool
11927     echo "$as_me:$LINENO: result: pre-installed" >&5
11928 echo "${ECHO_T}pre-installed" >&6
11929   fi
11930 fi
11931
11932 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11933 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11934 if test "x${build}" != "x${host}" ; then
11935   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11936     # We already found the complete path
11937     ac_dir=`dirname $STRIP_FOR_TARGET`
11938     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11939 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11940   else
11941     # Canadian cross, just use what we found
11942     echo "$as_me:$LINENO: result: pre-installed" >&5
11943 echo "${ECHO_T}pre-installed" >&6
11944   fi
11945 else
11946   ok=yes
11947   case " ${configdirs} " in
11948     *" binutils "*) ;;
11949     *) ok=no ;;
11950   esac
11951
11952   if test $ok = yes; then
11953     # An in-tree tool is available and we can use it
11954     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11955     echo "$as_me:$LINENO: result: just compiled" >&5
11956 echo "${ECHO_T}just compiled" >&6
11957   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11958     # We already found the complete path
11959     ac_dir=`dirname $STRIP_FOR_TARGET`
11960     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11961 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11962   elif test "x$target" = "x$host"; then
11963     # We can use an host tool
11964     STRIP_FOR_TARGET='$(STRIP)'
11965     echo "$as_me:$LINENO: result: host tool" >&5
11966 echo "${ECHO_T}host tool" >&6
11967   else
11968     # We need a cross tool
11969     echo "$as_me:$LINENO: result: pre-installed" >&5
11970 echo "${ECHO_T}pre-installed" >&6
11971   fi
11972 fi
11973
11974 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11975 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11976 if test "x${build}" != "x${host}" ; then
11977   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11978     # We already found the complete path
11979     ac_dir=`dirname $WINDRES_FOR_TARGET`
11980     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11981 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11982   else
11983     # Canadian cross, just use what we found
11984     echo "$as_me:$LINENO: result: pre-installed" >&5
11985 echo "${ECHO_T}pre-installed" >&6
11986   fi
11987 else
11988   ok=yes
11989   case " ${configdirs} " in
11990     *" binutils "*) ;;
11991     *) ok=no ;;
11992   esac
11993
11994   if test $ok = yes; then
11995     # An in-tree tool is available and we can use it
11996     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11997     echo "$as_me:$LINENO: result: just compiled" >&5
11998 echo "${ECHO_T}just compiled" >&6
11999   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12000     # We already found the complete path
12001     ac_dir=`dirname $WINDRES_FOR_TARGET`
12002     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12003 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12004   elif test "x$target" = "x$host"; then
12005     # We can use an host tool
12006     WINDRES_FOR_TARGET='$(WINDRES)'
12007     echo "$as_me:$LINENO: result: host tool" >&5
12008 echo "${ECHO_T}host tool" >&6
12009   else
12010     # We need a cross tool
12011     echo "$as_me:$LINENO: result: pre-installed" >&5
12012 echo "${ECHO_T}pre-installed" >&6
12013   fi
12014 fi
12015
12016 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12017 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12018 if test "x${build}" != "x${host}" ; then
12019   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12020     # We already found the complete path
12021     ac_dir=`dirname $WINDMC_FOR_TARGET`
12022     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12023 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12024   else
12025     # Canadian cross, just use what we found
12026     echo "$as_me:$LINENO: result: pre-installed" >&5
12027 echo "${ECHO_T}pre-installed" >&6
12028   fi
12029 else
12030   ok=yes
12031   case " ${configdirs} " in
12032     *" binutils "*) ;;
12033     *) ok=no ;;
12034   esac
12035
12036   if test $ok = yes; then
12037     # An in-tree tool is available and we can use it
12038     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12039     echo "$as_me:$LINENO: result: just compiled" >&5
12040 echo "${ECHO_T}just compiled" >&6
12041   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12042     # We already found the complete path
12043     ac_dir=`dirname $WINDMC_FOR_TARGET`
12044     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12045 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12046   elif test "x$target" = "x$host"; then
12047     # We can use an host tool
12048     WINDMC_FOR_TARGET='$(WINDMC)'
12049     echo "$as_me:$LINENO: result: host tool" >&5
12050 echo "${ECHO_T}host tool" >&6
12051   else
12052     # We need a cross tool
12053     echo "$as_me:$LINENO: result: pre-installed" >&5
12054 echo "${ECHO_T}pre-installed" >&6
12055   fi
12056 fi
12057
12058
12059
12060
12061
12062 # Certain tools may need extra flags.
12063 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12064 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12065 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12066
12067 # When building target libraries, except in a Canadian cross, we use
12068 # the same toolchain as the compiler we just built.
12069 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12070 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12071 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12072 if test $host = $build; then
12073   case " $configdirs " in
12074     *" gcc "*)
12075       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12076       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12077       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12078       ;;
12079   esac
12080 fi
12081
12082
12083
12084
12085
12086 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12087 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12088 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12089 if test "${enable_maintainer_mode+set}" = set; then
12090   enableval="$enable_maintainer_mode"
12091   USE_MAINTAINER_MODE=$enableval
12092 else
12093   USE_MAINTAINER_MODE=no
12094 fi;
12095 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12096 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12097
12098
12099 if test "$USE_MAINTAINER_MODE" = yes; then
12100   MAINTAINER_MODE_TRUE=
12101   MAINTAINER_MODE_FALSE='#'
12102 else
12103   MAINTAINER_MODE_TRUE='#'
12104   MAINTAINER_MODE_FALSE=
12105 fi
12106 MAINT=$MAINTAINER_MODE_TRUE
12107
12108 # ---------------------
12109 # GCC bootstrap support
12110 # ---------------------
12111
12112 # Stage specific cflags for build.
12113 stage1_cflags="-g"
12114 case $build in
12115   vax-*-*)
12116     case ${GCC} in
12117       yes) stage1_cflags="-g -Wa,-J" ;;
12118       *) stage1_cflags="-g -J" ;;
12119     esac ;;
12120 esac
12121
12122 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12123 if test "$GCC" = yes; then
12124   saved_CFLAGS="$CFLAGS"
12125
12126   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12127   CFLAGS="$CFLAGS -fkeep-inline-functions"
12128   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12129 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12130   cat >conftest.$ac_ext <<_ACEOF
12131 /* confdefs.h.  */
12132 _ACEOF
12133 cat confdefs.h >>conftest.$ac_ext
12134 cat >>conftest.$ac_ext <<_ACEOF
12135 /* end confdefs.h.  */
12136
12137 #if (__GNUC__ < 3) \
12138     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12139                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12140 #error http://gcc.gnu.org/PR29382
12141 #endif
12142
12143 int
12144 main ()
12145 {
12146
12147   ;
12148   return 0;
12149 }
12150 _ACEOF
12151 rm -f conftest.$ac_objext
12152 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12153   (eval $ac_compile) 2>conftest.er1
12154   ac_status=$?
12155   grep -v '^ *+' conftest.er1 >conftest.err
12156   rm -f conftest.er1
12157   cat conftest.err >&5
12158   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12159   (exit $ac_status); } &&
12160          { ac_try='test -z "$ac_c_werror_flag"
12161                          || test ! -s conftest.err'
12162   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12163   (eval $ac_try) 2>&5
12164   ac_status=$?
12165   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12166   (exit $ac_status); }; } &&
12167          { ac_try='test -s conftest.$ac_objext'
12168   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12169   (eval $ac_try) 2>&5
12170   ac_status=$?
12171   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12172   (exit $ac_status); }; }; then
12173   echo "$as_me:$LINENO: result: yes" >&5
12174 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12175 else
12176   echo "$as_me: failed program was:" >&5
12177 sed 's/^/| /' conftest.$ac_ext >&5
12178
12179 echo "$as_me:$LINENO: result: no" >&5
12180 echo "${ECHO_T}no" >&6
12181 fi
12182 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12183
12184   CFLAGS="$saved_CFLAGS"
12185 fi
12186
12187
12188
12189 # Enable --enable-checking in stage1 of the compiler.
12190 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12191 if test "${enable_stage1_checking+set}" = set; then
12192   enableval="$enable_stage1_checking"
12193   stage1_checking=--enable-checking=${enable_stage1_checking}
12194 else
12195   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12196   stage1_checking=--enable-checking=yes,types
12197 else
12198   stage1_checking=--enable-checking=$enable_checking,types
12199 fi
12200 fi;
12201
12202
12203 # Enable -Werror in bootstrap stage2 and later.
12204 # Check whether --enable-werror or --disable-werror was given.
12205 if test "${enable_werror+set}" = set; then
12206   enableval="$enable_werror"
12207
12208 else
12209   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12210   enable_werror=yes
12211 else
12212   enable_werror=no
12213 fi
12214 fi;
12215 case ${enable_werror} in
12216   yes) stage2_werror_flag="--enable-werror-always" ;;
12217   *) stage2_werror_flag="" ;;
12218 esac
12219
12220
12221 # Flags needed to enable html installing and building
12222
12223 # Check whether --with-datarootdir or --without-datarootdir was given.
12224 if test "${with_datarootdir+set}" = set; then
12225   withval="$with_datarootdir"
12226   datarootdir="\${prefix}/${withval}"
12227 else
12228   datarootdir="\${prefix}/share"
12229 fi;
12230
12231
12232 # Check whether --with-docdir or --without-docdir was given.
12233 if test "${with_docdir+set}" = set; then
12234   withval="$with_docdir"
12235   docdir="\${prefix}/${withval}"
12236 else
12237   docdir="\${datarootdir}/doc"
12238 fi;
12239
12240
12241 # Check whether --with-pdfdir or --without-pdfdir was given.
12242 if test "${with_pdfdir+set}" = set; then
12243   withval="$with_pdfdir"
12244   pdfdir="\${prefix}/${withval}"
12245 else
12246   pdfdir="\${docdir}"
12247 fi;
12248
12249
12250 # Check whether --with-htmldir or --without-htmldir was given.
12251 if test "${with_htmldir+set}" = set; then
12252   withval="$with_htmldir"
12253   htmldir="\${prefix}/${withval}"
12254 else
12255   htmldir="\${docdir}"
12256 fi;
12257
12258
12259
12260
12261
12262
12263           ac_config_files="$ac_config_files Makefile"
12264 cat >confcache <<\_ACEOF
12265 # This file is a shell script that caches the results of configure
12266 # tests run on this system so they can be shared between configure
12267 # scripts and configure runs, see configure's option --config-cache.
12268 # It is not useful on other systems.  If it contains results you don't
12269 # want to keep, you may remove or edit it.
12270 #
12271 # config.status only pays attention to the cache file if you give it
12272 # the --recheck option to rerun configure.
12273 #
12274 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12275 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12276 # following values.
12277
12278 _ACEOF
12279
12280 # The following way of writing the cache mishandles newlines in values,
12281 # but we know of no workaround that is simple, portable, and efficient.
12282 # So, don't put newlines in cache variables' values.
12283 # Ultrix sh set writes to stderr and can't be redirected directly,
12284 # and sets the high bit in the cache file unless we assign to the vars.
12285 {
12286   (set) 2>&1 |
12287     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12288     *ac_space=\ *)
12289       # `set' does not quote correctly, so add quotes (double-quote
12290       # substitution turns \\\\ into \\, and sed turns \\ into \).
12291       sed -n \
12292         "s/'/'\\\\''/g;
12293           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12294       ;;
12295     *)
12296       # `set' quotes correctly as required by POSIX, so do not add quotes.
12297       sed -n \
12298         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12299       ;;
12300     esac;
12301 } |
12302   sed '
12303      t clear
12304      : clear
12305      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12306      t end
12307      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12308      : end' >>confcache
12309 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12310   if test -w $cache_file; then
12311     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12312     cat confcache >$cache_file
12313   else
12314     echo "not updating unwritable cache $cache_file"
12315   fi
12316 fi
12317 rm -f confcache
12318
12319 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12320 # Let make expand exec_prefix.
12321 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12322
12323 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12324 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12325 # trailing colons and then remove the whole line if VPATH becomes empty
12326 # (actually we leave an empty line to preserve line numbers).
12327 if test "x$srcdir" = x.; then
12328   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12329 s/:*\$(srcdir):*/:/;
12330 s/:*\${srcdir}:*/:/;
12331 s/:*@srcdir@:*/:/;
12332 s/^\([^=]*=[     ]*\):*/\1/;
12333 s/:*$//;
12334 s/^[^=]*=[       ]*$//;
12335 }'
12336 fi
12337
12338 # Transform confdefs.h into DEFS.
12339 # Protect against shell expansion while executing Makefile rules.
12340 # Protect against Makefile macro expansion.
12341 #
12342 # If the first sed substitution is executed (which looks for macros that
12343 # take arguments), then we branch to the quote section.  Otherwise,
12344 # look for a macro that doesn't take arguments.
12345 cat >confdef2opt.sed <<\_ACEOF
12346 t clear
12347 : clear
12348 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12349 t quote
12350 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12351 t quote
12352 d
12353 : quote
12354 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12355 s,\[,\\&,g
12356 s,\],\\&,g
12357 s,\$,$$,g
12358 p
12359 _ACEOF
12360 # We use echo to avoid assuming a particular line-breaking character.
12361 # The extra dot is to prevent the shell from consuming trailing
12362 # line-breaks from the sub-command output.  A line-break within
12363 # single-quotes doesn't work because, if this script is created in a
12364 # platform that uses two characters for line-breaks (e.g., DOS), tr
12365 # would break.
12366 ac_LF_and_DOT=`echo; echo .`
12367 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12368 rm -f confdef2opt.sed
12369
12370
12371 ac_libobjs=
12372 ac_ltlibobjs=
12373 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12374   # 1. Remove the extension, and $U if already installed.
12375   ac_i=`echo "$ac_i" |
12376          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12377   # 2. Add them.
12378   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12379   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12380 done
12381 LIBOBJS=$ac_libobjs
12382
12383 LTLIBOBJS=$ac_ltlibobjs
12384
12385
12386
12387 : ${CONFIG_STATUS=./config.status}
12388 ac_clean_files_save=$ac_clean_files
12389 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12390 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12391 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12392 cat >$CONFIG_STATUS <<_ACEOF
12393 #! $SHELL
12394 # Generated by $as_me.
12395 # Run this file to recreate the current configuration.
12396 # Compiler output produced by configure, useful for debugging
12397 # configure, is in config.log if it exists.
12398
12399 debug=false
12400 ac_cs_recheck=false
12401 ac_cs_silent=false
12402 SHELL=\${CONFIG_SHELL-$SHELL}
12403 _ACEOF
12404
12405 cat >>$CONFIG_STATUS <<\_ACEOF
12406 ## --------------------- ##
12407 ## M4sh Initialization.  ##
12408 ## --------------------- ##
12409
12410 # Be Bourne compatible
12411 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12412   emulate sh
12413   NULLCMD=:
12414   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12415   # is contrary to our usage.  Disable this feature.
12416   alias -g '${1+"$@"}'='"$@"'
12417 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12418   set -o posix
12419 fi
12420 DUALCASE=1; export DUALCASE # for MKS sh
12421
12422 # Support unset when possible.
12423 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12424   as_unset=unset
12425 else
12426   as_unset=false
12427 fi
12428
12429
12430 # Work around bugs in pre-3.0 UWIN ksh.
12431 $as_unset ENV MAIL MAILPATH
12432 PS1='$ '
12433 PS2='> '
12434 PS4='+ '
12435
12436 # NLS nuisances.
12437 for as_var in \
12438   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12439   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12440   LC_TELEPHONE LC_TIME
12441 do
12442   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12443     eval $as_var=C; export $as_var
12444   else
12445     $as_unset $as_var
12446   fi
12447 done
12448
12449 # Required to use basename.
12450 if expr a : '\(a\)' >/dev/null 2>&1; then
12451   as_expr=expr
12452 else
12453   as_expr=false
12454 fi
12455
12456 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12457   as_basename=basename
12458 else
12459   as_basename=false
12460 fi
12461
12462
12463 # Name of the executable.
12464 as_me=`$as_basename "$0" ||
12465 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12466          X"$0" : 'X\(//\)$' \| \
12467          X"$0" : 'X\(/\)$' \| \
12468          .     : '\(.\)' 2>/dev/null ||
12469 echo X/"$0" |
12470     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12471           /^X\/\(\/\/\)$/{ s//\1/; q; }
12472           /^X\/\(\/\).*/{ s//\1/; q; }
12473           s/.*/./; q'`
12474
12475
12476 # PATH needs CR, and LINENO needs CR and PATH.
12477 # Avoid depending upon Character Ranges.
12478 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12479 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12480 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12481 as_cr_digits='0123456789'
12482 as_cr_alnum=$as_cr_Letters$as_cr_digits
12483
12484 # The user is always right.
12485 if test "${PATH_SEPARATOR+set}" != set; then
12486   echo "#! /bin/sh" >conf$$.sh
12487   echo  "exit 0"   >>conf$$.sh
12488   chmod +x conf$$.sh
12489   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12490     PATH_SEPARATOR=';'
12491   else
12492     PATH_SEPARATOR=:
12493   fi
12494   rm -f conf$$.sh
12495 fi
12496
12497
12498   as_lineno_1=$LINENO
12499   as_lineno_2=$LINENO
12500   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12501   test "x$as_lineno_1" != "x$as_lineno_2" &&
12502   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12503   # Find who we are.  Look in the path if we contain no path at all
12504   # relative or not.
12505   case $0 in
12506     *[\\/]* ) as_myself=$0 ;;
12507     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12508 for as_dir in $PATH
12509 do
12510   IFS=$as_save_IFS
12511   test -z "$as_dir" && as_dir=.
12512   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12513 done
12514
12515        ;;
12516   esac
12517   # We did not find ourselves, most probably we were run as `sh COMMAND'
12518   # in which case we are not to be found in the path.
12519   if test "x$as_myself" = x; then
12520     as_myself=$0
12521   fi
12522   if test ! -f "$as_myself"; then
12523     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12524 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12525    { (exit 1); exit 1; }; }
12526   fi
12527   case $CONFIG_SHELL in
12528   '')
12529     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12530 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12531 do
12532   IFS=$as_save_IFS
12533   test -z "$as_dir" && as_dir=.
12534   for as_base in sh bash ksh sh5; do
12535          case $as_dir in
12536          /*)
12537            if ("$as_dir/$as_base" -c '
12538   as_lineno_1=$LINENO
12539   as_lineno_2=$LINENO
12540   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12541   test "x$as_lineno_1" != "x$as_lineno_2" &&
12542   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12543              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12544              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12545              CONFIG_SHELL=$as_dir/$as_base
12546              export CONFIG_SHELL
12547              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12548            fi;;
12549          esac
12550        done
12551 done
12552 ;;
12553   esac
12554
12555   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12556   # uniformly replaced by the line number.  The first 'sed' inserts a
12557   # line-number line before each line; the second 'sed' does the real
12558   # work.  The second script uses 'N' to pair each line-number line
12559   # with the numbered line, and appends trailing '-' during
12560   # substitution so that $LINENO is not a special case at line end.
12561   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12562   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12563   sed '=' <$as_myself |
12564     sed '
12565       N
12566       s,$,-,
12567       : loop
12568       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12569       t loop
12570       s,-$,,
12571       s,^['$as_cr_digits']*\n,,
12572     ' >$as_me.lineno &&
12573   chmod +x $as_me.lineno ||
12574     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12575 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12576    { (exit 1); exit 1; }; }
12577
12578   # Don't try to exec as it changes $[0], causing all sort of problems
12579   # (the dirname of $[0] is not the place where we might find the
12580   # original and so on.  Autoconf is especially sensible to this).
12581   . ./$as_me.lineno
12582   # Exit status is that of the last command.
12583   exit
12584 }
12585
12586
12587 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12588   *c*,-n*) ECHO_N= ECHO_C='
12589 ' ECHO_T='      ' ;;
12590   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12591   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12592 esac
12593
12594 if expr a : '\(a\)' >/dev/null 2>&1; then
12595   as_expr=expr
12596 else
12597   as_expr=false
12598 fi
12599
12600 rm -f conf$$ conf$$.exe conf$$.file
12601 echo >conf$$.file
12602 if ln -s conf$$.file conf$$ 2>/dev/null; then
12603   # We could just check for DJGPP; but this test a) works b) is more generic
12604   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12605   if test -f conf$$.exe; then
12606     # Don't use ln at all; we don't have any links
12607     as_ln_s='cp -p'
12608   else
12609     as_ln_s='ln -s'
12610   fi
12611 elif ln conf$$.file conf$$ 2>/dev/null; then
12612   as_ln_s=ln
12613 else
12614   as_ln_s='cp -p'
12615 fi
12616 rm -f conf$$ conf$$.exe conf$$.file
12617
12618 if mkdir -p . 2>/dev/null; then
12619   as_mkdir_p=:
12620 else
12621   test -d ./-p && rmdir ./-p
12622   as_mkdir_p=false
12623 fi
12624
12625 as_executable_p="test -f"
12626
12627 # Sed expression to map a string onto a valid CPP name.
12628 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12629
12630 # Sed expression to map a string onto a valid variable name.
12631 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12632
12633
12634 # IFS
12635 # We need space, tab and new line, in precisely that order.
12636 as_nl='
12637 '
12638 IFS="   $as_nl"
12639
12640 # CDPATH.
12641 $as_unset CDPATH
12642
12643 exec 6>&1
12644
12645 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12646 # report actual input values of CONFIG_FILES etc. instead of their
12647 # values after options handling.  Logging --version etc. is OK.
12648 exec 5>>config.log
12649 {
12650   echo
12651   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12652 ## Running $as_me. ##
12653 _ASBOX
12654 } >&5
12655 cat >&5 <<_CSEOF
12656
12657 This file was extended by $as_me, which was
12658 generated by GNU Autoconf 2.59.  Invocation command line was
12659
12660   CONFIG_FILES    = $CONFIG_FILES
12661   CONFIG_HEADERS  = $CONFIG_HEADERS
12662   CONFIG_LINKS    = $CONFIG_LINKS
12663   CONFIG_COMMANDS = $CONFIG_COMMANDS
12664   $ $0 $@
12665
12666 _CSEOF
12667 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12668 echo >&5
12669 _ACEOF
12670
12671 # Files that config.status was made for.
12672 if test -n "$ac_config_files"; then
12673   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12674 fi
12675
12676 if test -n "$ac_config_headers"; then
12677   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12678 fi
12679
12680 if test -n "$ac_config_links"; then
12681   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12682 fi
12683
12684 if test -n "$ac_config_commands"; then
12685   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12686 fi
12687
12688 cat >>$CONFIG_STATUS <<\_ACEOF
12689
12690 ac_cs_usage="\
12691 \`$as_me' instantiates files from templates according to the
12692 current configuration.
12693
12694 Usage: $0 [OPTIONS] [FILE]...
12695
12696   -h, --help       print this help, then exit
12697   -V, --version    print version number, then exit
12698   -q, --quiet      do not print progress messages
12699   -d, --debug      don't remove temporary files
12700       --recheck    update $as_me by reconfiguring in the same conditions
12701   --file=FILE[:TEMPLATE]
12702                    instantiate the configuration file FILE
12703
12704 Configuration files:
12705 $config_files
12706
12707 Report bugs to <bug-autoconf@gnu.org>."
12708 _ACEOF
12709
12710 cat >>$CONFIG_STATUS <<_ACEOF
12711 ac_cs_version="\\
12712 config.status
12713 configured by $0, generated by GNU Autoconf 2.59,
12714   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12715
12716 Copyright (C) 2003 Free Software Foundation, Inc.
12717 This config.status script is free software; the Free Software Foundation
12718 gives unlimited permission to copy, distribute and modify it."
12719 srcdir=$srcdir
12720 INSTALL="$INSTALL"
12721 _ACEOF
12722
12723 cat >>$CONFIG_STATUS <<\_ACEOF
12724 # If no file are specified by the user, then we need to provide default
12725 # value.  By we need to know if files were specified by the user.
12726 ac_need_defaults=:
12727 while test $# != 0
12728 do
12729   case $1 in
12730   --*=*)
12731     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12732     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12733     ac_shift=:
12734     ;;
12735   -*)
12736     ac_option=$1
12737     ac_optarg=$2
12738     ac_shift=shift
12739     ;;
12740   *) # This is not an option, so the user has probably given explicit
12741      # arguments.
12742      ac_option=$1
12743      ac_need_defaults=false;;
12744   esac
12745
12746   case $ac_option in
12747   # Handling of the options.
12748 _ACEOF
12749 cat >>$CONFIG_STATUS <<\_ACEOF
12750   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12751     ac_cs_recheck=: ;;
12752   --version | --vers* | -V )
12753     echo "$ac_cs_version"; exit 0 ;;
12754   --he | --h)
12755     # Conflict between --help and --header
12756     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12757 Try \`$0 --help' for more information." >&5
12758 echo "$as_me: error: ambiguous option: $1
12759 Try \`$0 --help' for more information." >&2;}
12760    { (exit 1); exit 1; }; };;
12761   --help | --hel | -h )
12762     echo "$ac_cs_usage"; exit 0 ;;
12763   --debug | --d* | -d )
12764     debug=: ;;
12765   --file | --fil | --fi | --f )
12766     $ac_shift
12767     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12768     ac_need_defaults=false;;
12769   --header | --heade | --head | --hea )
12770     $ac_shift
12771     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12772     ac_need_defaults=false;;
12773   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12774   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12775     ac_cs_silent=: ;;
12776
12777   # This is an error.
12778   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12779 Try \`$0 --help' for more information." >&5
12780 echo "$as_me: error: unrecognized option: $1
12781 Try \`$0 --help' for more information." >&2;}
12782    { (exit 1); exit 1; }; } ;;
12783
12784   *) ac_config_targets="$ac_config_targets $1" ;;
12785
12786   esac
12787   shift
12788 done
12789
12790 ac_configure_extra_args=
12791
12792 if $ac_cs_silent; then
12793   exec 6>/dev/null
12794   ac_configure_extra_args="$ac_configure_extra_args --silent"
12795 fi
12796
12797 _ACEOF
12798 cat >>$CONFIG_STATUS <<_ACEOF
12799 if \$ac_cs_recheck; then
12800   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12801   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12802 fi
12803
12804 _ACEOF
12805
12806
12807
12808
12809
12810 cat >>$CONFIG_STATUS <<\_ACEOF
12811 for ac_config_target in $ac_config_targets
12812 do
12813   case "$ac_config_target" in
12814   # Handling of arguments.
12815   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12816   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12817 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12818    { (exit 1); exit 1; }; };;
12819   esac
12820 done
12821
12822 # If the user did not use the arguments to specify the items to instantiate,
12823 # then the envvar interface is used.  Set only those that are not.
12824 # We use the long form for the default assignment because of an extremely
12825 # bizarre bug on SunOS 4.1.3.
12826 if $ac_need_defaults; then
12827   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12828 fi
12829
12830 # Have a temporary directory for convenience.  Make it in the build tree
12831 # simply because there is no reason to put it here, and in addition,
12832 # creating and moving files from /tmp can sometimes cause problems.
12833 # Create a temporary directory, and hook for its removal unless debugging.
12834 $debug ||
12835 {
12836   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12837   trap '{ (exit 1); exit 1; }' 1 2 13 15
12838 }
12839
12840 # Create a (secure) tmp directory for tmp files.
12841
12842 {
12843   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12844   test -n "$tmp" && test -d "$tmp"
12845 }  ||
12846 {
12847   tmp=./confstat$$-$RANDOM
12848   (umask 077 && mkdir $tmp)
12849 } ||
12850 {
12851    echo "$me: cannot create a temporary directory in ." >&2
12852    { (exit 1); exit 1; }
12853 }
12854
12855 _ACEOF
12856
12857 cat >>$CONFIG_STATUS <<_ACEOF
12858
12859 #
12860 # CONFIG_FILES section.
12861 #
12862
12863 # No need to generate the scripts if there are no CONFIG_FILES.
12864 # This happens for instance when ./config.status config.h
12865 if test -n "\$CONFIG_FILES"; then
12866   # Protect against being on the right side of a sed subst in config.status.
12867   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12868    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12869 s,@SHELL@,$SHELL,;t t
12870 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12871 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12872 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12873 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12874 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12875 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12876 s,@exec_prefix@,$exec_prefix,;t t
12877 s,@prefix@,$prefix,;t t
12878 s,@program_transform_name@,$program_transform_name,;t t
12879 s,@bindir@,$bindir,;t t
12880 s,@sbindir@,$sbindir,;t t
12881 s,@libexecdir@,$libexecdir,;t t
12882 s,@datadir@,$datadir,;t t
12883 s,@sysconfdir@,$sysconfdir,;t t
12884 s,@sharedstatedir@,$sharedstatedir,;t t
12885 s,@localstatedir@,$localstatedir,;t t
12886 s,@libdir@,$libdir,;t t
12887 s,@includedir@,$includedir,;t t
12888 s,@oldincludedir@,$oldincludedir,;t t
12889 s,@infodir@,$infodir,;t t
12890 s,@mandir@,$mandir,;t t
12891 s,@build_alias@,$build_alias,;t t
12892 s,@host_alias@,$host_alias,;t t
12893 s,@target_alias@,$target_alias,;t t
12894 s,@DEFS@,$DEFS,;t t
12895 s,@ECHO_C@,$ECHO_C,;t t
12896 s,@ECHO_N@,$ECHO_N,;t t
12897 s,@ECHO_T@,$ECHO_T,;t t
12898 s,@LIBS@,$LIBS,;t t
12899 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12900 s,@build@,$build,;t t
12901 s,@build_cpu@,$build_cpu,;t t
12902 s,@build_vendor@,$build_vendor,;t t
12903 s,@build_os@,$build_os,;t t
12904 s,@build_noncanonical@,$build_noncanonical,;t t
12905 s,@host_noncanonical@,$host_noncanonical,;t t
12906 s,@target_noncanonical@,$target_noncanonical,;t t
12907 s,@host@,$host,;t t
12908 s,@host_cpu@,$host_cpu,;t t
12909 s,@host_vendor@,$host_vendor,;t t
12910 s,@host_os@,$host_os,;t t
12911 s,@target@,$target,;t t
12912 s,@target_cpu@,$target_cpu,;t t
12913 s,@target_vendor@,$target_vendor,;t t
12914 s,@target_os@,$target_os,;t t
12915 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12916 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12917 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12918 s,@LN@,$LN,;t t
12919 s,@LN_S@,$LN_S,;t t
12920 s,@build_libsubdir@,$build_libsubdir,;t t
12921 s,@build_subdir@,$build_subdir,;t t
12922 s,@host_subdir@,$host_subdir,;t t
12923 s,@target_subdir@,$target_subdir,;t t
12924 s,@CC@,$CC,;t t
12925 s,@CFLAGS@,$CFLAGS,;t t
12926 s,@LDFLAGS@,$LDFLAGS,;t t
12927 s,@CPPFLAGS@,$CPPFLAGS,;t t
12928 s,@ac_ct_CC@,$ac_ct_CC,;t t
12929 s,@EXEEXT@,$EXEEXT,;t t
12930 s,@OBJEXT@,$OBJEXT,;t t
12931 s,@CXX@,$CXX,;t t
12932 s,@CXXFLAGS@,$CXXFLAGS,;t t
12933 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12934 s,@GNATBIND@,$GNATBIND,;t t
12935 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12936 s,@GNATMAKE@,$GNATMAKE,;t t
12937 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12938 s,@do_compare@,$do_compare,;t t
12939 s,@gmplibs@,$gmplibs,;t t
12940 s,@gmpinc@,$gmpinc,;t t
12941 s,@stage1_languages@,$stage1_languages,;t t
12942 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12943 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12944 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
12945 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
12946 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12947 s,@tooldir@,$tooldir,;t t
12948 s,@build_tooldir@,$build_tooldir,;t t
12949 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12950 s,@GDB_TK@,$GDB_TK,;t t
12951 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12952 s,@build_configargs@,$build_configargs,;t t
12953 s,@build_configdirs@,$build_configdirs,;t t
12954 s,@host_configargs@,$host_configargs,;t t
12955 s,@configdirs@,$configdirs,;t t
12956 s,@target_configargs@,$target_configargs,;t t
12957 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12958 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12959 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12960 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12961 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
12962 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
12963 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
12964 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
12965 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
12966 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
12967 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
12968 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
12969 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
12970 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
12971 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
12972 s,@config_shell@,$config_shell,;t t
12973 s,@YACC@,$YACC,;t t
12974 s,@BISON@,$BISON,;t t
12975 s,@M4@,$M4,;t t
12976 s,@LEX@,$LEX,;t t
12977 s,@FLEX@,$FLEX,;t t
12978 s,@MAKEINFO@,$MAKEINFO,;t t
12979 s,@EXPECT@,$EXPECT,;t t
12980 s,@RUNTEST@,$RUNTEST,;t t
12981 s,@AR@,$AR,;t t
12982 s,@AS@,$AS,;t t
12983 s,@DLLTOOL@,$DLLTOOL,;t t
12984 s,@LD@,$LD,;t t
12985 s,@LIPO@,$LIPO,;t t
12986 s,@NM@,$NM,;t t
12987 s,@RANLIB@,$RANLIB,;t t
12988 s,@STRIP@,$STRIP,;t t
12989 s,@WINDRES@,$WINDRES,;t t
12990 s,@WINDMC@,$WINDMC,;t t
12991 s,@OBJCOPY@,$OBJCOPY,;t t
12992 s,@OBJDUMP@,$OBJDUMP,;t t
12993 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12994 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12995 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12996 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12997 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12998 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12999 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13000 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13001 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13002 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13003 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13004 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13005 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13006 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13007 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13008 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13009 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13010 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13011 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13012 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13013 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13014 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13015 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13016 s,@MAINT@,$MAINT,;t t
13017 s,@stage1_cflags@,$stage1_cflags,;t t
13018 s,@stage1_checking@,$stage1_checking,;t t
13019 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13020 s,@datarootdir@,$datarootdir,;t t
13021 s,@docdir@,$docdir,;t t
13022 s,@pdfdir@,$pdfdir,;t t
13023 s,@htmldir@,$htmldir,;t t
13024 s,@LIBOBJS@,$LIBOBJS,;t t
13025 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13026 /@serialization_dependencies@/r $serialization_dependencies
13027 s,@serialization_dependencies@,,;t t
13028 /@host_makefile_frag@/r $host_makefile_frag
13029 s,@host_makefile_frag@,,;t t
13030 /@target_makefile_frag@/r $target_makefile_frag
13031 s,@target_makefile_frag@,,;t t
13032 /@alphaieee_frag@/r $alphaieee_frag
13033 s,@alphaieee_frag@,,;t t
13034 /@ospace_frag@/r $ospace_frag
13035 s,@ospace_frag@,,;t t
13036 CEOF
13037
13038 _ACEOF
13039
13040   cat >>$CONFIG_STATUS <<\_ACEOF
13041   # Split the substitutions into bite-sized pieces for seds with
13042   # small command number limits, like on Digital OSF/1 and HP-UX.
13043   ac_max_sed_lines=48
13044   ac_sed_frag=1 # Number of current file.
13045   ac_beg=1 # First line for current file.
13046   ac_end=$ac_max_sed_lines # Line after last line for current file.
13047   ac_more_lines=:
13048   ac_sed_cmds=
13049   while $ac_more_lines; do
13050     if test $ac_beg -gt 1; then
13051       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13052     else
13053       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13054     fi
13055     if test ! -s $tmp/subs.frag; then
13056       ac_more_lines=false
13057     else
13058       # The purpose of the label and of the branching condition is to
13059       # speed up the sed processing (if there are no `@' at all, there
13060       # is no need to browse any of the substitutions).
13061       # These are the two extra sed commands mentioned above.
13062       (echo ':t
13063   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13064       if test -z "$ac_sed_cmds"; then
13065         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13066       else
13067         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13068       fi
13069       ac_sed_frag=`expr $ac_sed_frag + 1`
13070       ac_beg=$ac_end
13071       ac_end=`expr $ac_end + $ac_max_sed_lines`
13072     fi
13073   done
13074   if test -z "$ac_sed_cmds"; then
13075     ac_sed_cmds=cat
13076   fi
13077 fi # test -n "$CONFIG_FILES"
13078
13079 _ACEOF
13080 cat >>$CONFIG_STATUS <<\_ACEOF
13081 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13082   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13083   case $ac_file in
13084   - | *:- | *:-:* ) # input from stdin
13085         cat >$tmp/stdin
13086         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13087         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13088   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13089         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13090   * )   ac_file_in=$ac_file.in ;;
13091   esac
13092
13093   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13094   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13095 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13096          X"$ac_file" : 'X\(//\)[^/]' \| \
13097          X"$ac_file" : 'X\(//\)$' \| \
13098          X"$ac_file" : 'X\(/\)' \| \
13099          .     : '\(.\)' 2>/dev/null ||
13100 echo X"$ac_file" |
13101     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13102           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13103           /^X\(\/\/\)$/{ s//\1/; q; }
13104           /^X\(\/\).*/{ s//\1/; q; }
13105           s/.*/./; q'`
13106   { if $as_mkdir_p; then
13107     mkdir -p "$ac_dir"
13108   else
13109     as_dir="$ac_dir"
13110     as_dirs=
13111     while test ! -d "$as_dir"; do
13112       as_dirs="$as_dir $as_dirs"
13113       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13114 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13115          X"$as_dir" : 'X\(//\)[^/]' \| \
13116          X"$as_dir" : 'X\(//\)$' \| \
13117          X"$as_dir" : 'X\(/\)' \| \
13118          .     : '\(.\)' 2>/dev/null ||
13119 echo X"$as_dir" |
13120     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13121           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13122           /^X\(\/\/\)$/{ s//\1/; q; }
13123           /^X\(\/\).*/{ s//\1/; q; }
13124           s/.*/./; q'`
13125     done
13126     test ! -n "$as_dirs" || mkdir $as_dirs
13127   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13128 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13129    { (exit 1); exit 1; }; }; }
13130
13131   ac_builddir=.
13132
13133 if test "$ac_dir" != .; then
13134   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13135   # A "../" for each directory in $ac_dir_suffix.
13136   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13137 else
13138   ac_dir_suffix= ac_top_builddir=
13139 fi
13140
13141 case $srcdir in
13142   .)  # No --srcdir option.  We are building in place.
13143     ac_srcdir=.
13144     if test -z "$ac_top_builddir"; then
13145        ac_top_srcdir=.
13146     else
13147        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13148     fi ;;
13149   [\\/]* | ?:[\\/]* )  # Absolute path.
13150     ac_srcdir=$srcdir$ac_dir_suffix;
13151     ac_top_srcdir=$srcdir ;;
13152   *) # Relative path.
13153     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13154     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13155 esac
13156
13157 # Do not use `cd foo && pwd` to compute absolute paths, because
13158 # the directories may not exist.
13159 case `pwd` in
13160 .) ac_abs_builddir="$ac_dir";;
13161 *)
13162   case "$ac_dir" in
13163   .) ac_abs_builddir=`pwd`;;
13164   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13165   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13166   esac;;
13167 esac
13168 case $ac_abs_builddir in
13169 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13170 *)
13171   case ${ac_top_builddir}. in
13172   .) ac_abs_top_builddir=$ac_abs_builddir;;
13173   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13174   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13175   esac;;
13176 esac
13177 case $ac_abs_builddir in
13178 .) ac_abs_srcdir=$ac_srcdir;;
13179 *)
13180   case $ac_srcdir in
13181   .) ac_abs_srcdir=$ac_abs_builddir;;
13182   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13183   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13184   esac;;
13185 esac
13186 case $ac_abs_builddir in
13187 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13188 *)
13189   case $ac_top_srcdir in
13190   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13191   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13192   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13193   esac;;
13194 esac
13195
13196
13197   case $INSTALL in
13198   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13199   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13200   esac
13201
13202   if test x"$ac_file" != x-; then
13203     { echo "$as_me:$LINENO: creating $ac_file" >&5
13204 echo "$as_me: creating $ac_file" >&6;}
13205     rm -f "$ac_file"
13206   fi
13207   # Let's still pretend it is `configure' which instantiates (i.e., don't
13208   # use $as_me), people would be surprised to read:
13209   #    /* config.h.  Generated by config.status.  */
13210   if test x"$ac_file" = x-; then
13211     configure_input=
13212   else
13213     configure_input="$ac_file.  "
13214   fi
13215   configure_input=$configure_input"Generated from `echo $ac_file_in |
13216                                      sed 's,.*/,,'` by configure."
13217
13218   # First look for the input files in the build tree, otherwise in the
13219   # src tree.
13220   ac_file_inputs=`IFS=:
13221     for f in $ac_file_in; do
13222       case $f in
13223       -) echo $tmp/stdin ;;
13224       [\\/$]*)
13225          # Absolute (can't be DOS-style, as IFS=:)
13226          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13227 echo "$as_me: error: cannot find input file: $f" >&2;}
13228    { (exit 1); exit 1; }; }
13229          echo "$f";;
13230       *) # Relative
13231          if test -f "$f"; then
13232            # Build tree
13233            echo "$f"
13234          elif test -f "$srcdir/$f"; then
13235            # Source tree
13236            echo "$srcdir/$f"
13237          else
13238            # /dev/null tree
13239            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13240 echo "$as_me: error: cannot find input file: $f" >&2;}
13241    { (exit 1); exit 1; }; }
13242          fi;;
13243       esac
13244     done` || { (exit 1); exit 1; }
13245 _ACEOF
13246 cat >>$CONFIG_STATUS <<_ACEOF
13247   sed "$ac_vpsub
13248 $extrasub
13249 _ACEOF
13250 cat >>$CONFIG_STATUS <<\_ACEOF
13251 :t
13252 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13253 s,@configure_input@,$configure_input,;t t
13254 s,@srcdir@,$ac_srcdir,;t t
13255 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13256 s,@top_srcdir@,$ac_top_srcdir,;t t
13257 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13258 s,@builddir@,$ac_builddir,;t t
13259 s,@abs_builddir@,$ac_abs_builddir,;t t
13260 s,@top_builddir@,$ac_top_builddir,;t t
13261 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13262 s,@INSTALL@,$ac_INSTALL,;t t
13263 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13264   rm -f $tmp/stdin
13265   if test x"$ac_file" != x-; then
13266     mv $tmp/out $ac_file
13267   else
13268     cat $tmp/out
13269     rm -f $tmp/out
13270   fi
13271
13272 done
13273 _ACEOF
13274
13275 cat >>$CONFIG_STATUS <<\_ACEOF
13276
13277 { (exit 0); exit 0; }
13278 _ACEOF
13279 chmod +x $CONFIG_STATUS
13280 ac_clean_files=$ac_clean_files_save
13281
13282
13283 # configure is writing to config.log, and then calls config.status.
13284 # config.status does its own redirection, appending to config.log.
13285 # Unfortunately, on DOS this fails, as config.log is still kept open
13286 # by configure, so config.status won't be able to write to it; its
13287 # output is simply discarded.  So we exec the FD to /dev/null,
13288 # effectively closing config.log, so it can be properly (re)opened and
13289 # appended to by config.status.  When coming back to configure, we
13290 # need to make the FD available again.
13291 if test "$no_create" != yes; then
13292   ac_cs_success=:
13293   ac_config_status_args=
13294   test "$silent" = yes &&
13295     ac_config_status_args="$ac_config_status_args --quiet"
13296   exec 5>/dev/null
13297   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13298   exec 5>>config.log
13299   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13300   # would make configure fail if this is the last instruction.
13301   $ac_cs_success || { (exit 1); exit 1; }
13302 fi
13303