configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS TOPLEVEL_CONFIGURE_ARGUMENTS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc ppllibs pplinc clooglibs clooginc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR GCC_SHLIB_SUBDIR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277 ac_pwd=`pwd`
 278
 279 # Initialize some variables set by options.
 280 ac_init_help=
 281 ac_init_version=false
 282 # The variables have the same names as the options, with
 283 # dashes changed to underlines.
 284 cache_file=/dev/null
 285 exec_prefix=NONE
 286 no_create=
 287 no_recursion=
 288 prefix=NONE
 289 program_prefix=NONE
 290 program_suffix=NONE
 291 program_transform_name=s,x,x,
 292 silent=
 293 site=
 294 srcdir=
 295 verbose=
 296 x_includes=NONE
 297 x_libraries=NONE
 298
 299 # Installation directory options.
 300 # These are left unexpanded so users can "make install exec_prefix=/foo"
 301 # and all the variables that are supposed to be based on exec_prefix
 302 # by default will actually change.
 303 # Use braces instead of parens because sh, perl, etc. also accept them.
 304 bindir='${exec_prefix}/bin'
 305 sbindir='${exec_prefix}/sbin'
 306 libexecdir='${exec_prefix}/libexec'
 307 datadir='${prefix}/share'
 308 sysconfdir='${prefix}/etc'
 309 sharedstatedir='${prefix}/com'
 310 localstatedir='${prefix}/var'
 311 libdir='${exec_prefix}/lib'
 312 includedir='${prefix}/include'
 313 oldincludedir='/usr/include'
 314 infodir='${prefix}/info'
 315 mandir='${prefix}/man'
 316
 317 ac_prev=
 318 for ac_option
 319 do
 320   # If the previous option needs an argument, assign it.
 321   if test -n "$ac_prev"; then
 322     eval "$ac_prev=\$ac_option"
 323     ac_prev=
 324     continue
 325   fi
 326
 327   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 328
 329   # Accept the important Cygnus configure options, so we can diagnose typos.
 330
 331   case $ac_option in
 332
 333   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 334     ac_prev=bindir ;;
 335   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 336     bindir=$ac_optarg ;;
 337
 338   -build | --build | --buil | --bui | --bu)
 339     ac_prev=build_alias ;;
 340   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 341     build_alias=$ac_optarg ;;
 342
 343   -cache-file | --cache-file | --cache-fil | --cache-fi \
 344   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 345     ac_prev=cache_file ;;
 346   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 347   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 348     cache_file=$ac_optarg ;;
 349
 350   --config-cache | -C)
 351     cache_file=config.cache ;;
 352
 353   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 354     ac_prev=datadir ;;
 355   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 356   | --da=*)
 357     datadir=$ac_optarg ;;
 358
 359   -disable-* | --disable-*)
 360     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 361     # Reject names that are not valid shell variable names.
 362     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 363       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 364    { (exit 1); exit 1; }; }
 365     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 366     eval "enable_$ac_feature=no" ;;
 367
 368   -enable-* | --enable-*)
 369     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 370     # Reject names that are not valid shell variable names.
 371     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 372       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 373    { (exit 1); exit 1; }; }
 374     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 375     case $ac_option in
 376       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 377       *) ac_optarg=yes ;;
 378     esac
 379     eval "enable_$ac_feature='$ac_optarg'" ;;
 380
 381   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 382   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 383   | --exec | --exe | --ex)
 384     ac_prev=exec_prefix ;;
 385   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 386   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 387   | --exec=* | --exe=* | --ex=*)
 388     exec_prefix=$ac_optarg ;;
 389
 390   -gas | --gas | --ga | --g)
 391     # Obsolete; use --with-gas.
 392     with_gas=yes ;;
 393
 394   -help | --help | --hel | --he | -h)
 395     ac_init_help=long ;;
 396   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 397     ac_init_help=recursive ;;
 398   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 399     ac_init_help=short ;;
 400
 401   -host | --host | --hos | --ho)
 402     ac_prev=host_alias ;;
 403   -host=* | --host=* | --hos=* | --ho=*)
 404     host_alias=$ac_optarg ;;
 405
 406   -includedir | --includedir | --includedi | --included | --include \
 407   | --includ | --inclu | --incl | --inc)
 408     ac_prev=includedir ;;
 409   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 410   | --includ=* | --inclu=* | --incl=* | --inc=*)
 411     includedir=$ac_optarg ;;
 412
 413   -infodir | --infodir | --infodi | --infod | --info | --inf)
 414     ac_prev=infodir ;;
 415   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 416     infodir=$ac_optarg ;;
 417
 418   -libdir | --libdir | --libdi | --libd)
 419     ac_prev=libdir ;;
 420   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 421     libdir=$ac_optarg ;;
 422
 423   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 424   | --libexe | --libex | --libe)
 425     ac_prev=libexecdir ;;
 426   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 427   | --libexe=* | --libex=* | --libe=*)
 428     libexecdir=$ac_optarg ;;
 429
 430   -localstatedir | --localstatedir | --localstatedi | --localstated \
 431   | --localstate | --localstat | --localsta | --localst \
 432   | --locals | --local | --loca | --loc | --lo)
 433     ac_prev=localstatedir ;;
 434   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 435   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 436   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 437     localstatedir=$ac_optarg ;;
 438
 439   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 440     ac_prev=mandir ;;
 441   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 442     mandir=$ac_optarg ;;
 443
 444   -nfp | --nfp | --nf)
 445     # Obsolete; use --without-fp.
 446     with_fp=no ;;
 447
 448   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 449   | --no-cr | --no-c | -n)
 450     no_create=yes ;;
 451
 452   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 453   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 454     no_recursion=yes ;;
 455
 456   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 457   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 458   | --oldin | --oldi | --old | --ol | --o)
 459     ac_prev=oldincludedir ;;
 460   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 461   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 462   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 463     oldincludedir=$ac_optarg ;;
 464
 465   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 466     ac_prev=prefix ;;
 467   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 468     prefix=$ac_optarg ;;
 469
 470   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 471   | --program-pre | --program-pr | --program-p)
 472     ac_prev=program_prefix ;;
 473   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 474   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 475     program_prefix=$ac_optarg ;;
 476
 477   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 478   | --program-suf | --program-su | --program-s)
 479     ac_prev=program_suffix ;;
 480   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 481   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 482     program_suffix=$ac_optarg ;;
 483
 484   -program-transform-name | --program-transform-name \
 485   | --program-transform-nam | --program-transform-na \
 486   | --program-transform-n | --program-transform- \
 487   | --program-transform | --program-transfor \
 488   | --program-transfo | --program-transf \
 489   | --program-trans | --program-tran \
 490   | --progr-tra | --program-tr | --program-t)
 491     ac_prev=program_transform_name ;;
 492   -program-transform-name=* | --program-transform-name=* \
 493   | --program-transform-nam=* | --program-transform-na=* \
 494   | --program-transform-n=* | --program-transform-=* \
 495   | --program-transform=* | --program-transfor=* \
 496   | --program-transfo=* | --program-transf=* \
 497   | --program-trans=* | --program-tran=* \
 498   | --progr-tra=* | --program-tr=* | --program-t=*)
 499     program_transform_name=$ac_optarg ;;
 500
 501   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 502   | -silent | --silent | --silen | --sile | --sil)
 503     silent=yes ;;
 504
 505   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 506     ac_prev=sbindir ;;
 507   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 508   | --sbi=* | --sb=*)
 509     sbindir=$ac_optarg ;;
 510
 511   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 512   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 513   | --sharedst | --shareds | --shared | --share | --shar \
 514   | --sha | --sh)
 515     ac_prev=sharedstatedir ;;
 516   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 517   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 518   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 519   | --sha=* | --sh=*)
 520     sharedstatedir=$ac_optarg ;;
 521
 522   -site | --site | --sit)
 523     ac_prev=site ;;
 524   -site=* | --site=* | --sit=*)
 525     site=$ac_optarg ;;
 526
 527   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 528     ac_prev=srcdir ;;
 529   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 530     srcdir=$ac_optarg ;;
 531
 532   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 533   | --syscon | --sysco | --sysc | --sys | --sy)
 534     ac_prev=sysconfdir ;;
 535   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 536   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 537     sysconfdir=$ac_optarg ;;
 538
 539   -target | --target | --targe | --targ | --tar | --ta | --t)
 540     ac_prev=target_alias ;;
 541   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 542     target_alias=$ac_optarg ;;
 543
 544   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 545     verbose=yes ;;
 546
 547   -version | --version | --versio | --versi | --vers | -V)
 548     ac_init_version=: ;;
 549
 550   -with-* | --with-*)
 551     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 552     # Reject names that are not valid shell variable names.
 553     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 554       { echo "$as_me: error: invalid package name: $ac_package" >&2
 555    { (exit 1); exit 1; }; }
 556     ac_package=`echo $ac_package| sed 's/-/_/g'`
 557     case $ac_option in
 558       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 559       *) ac_optarg=yes ;;
 560     esac
 561     eval "with_$ac_package='$ac_optarg'" ;;
 562
 563   -without-* | --without-*)
 564     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 565     # Reject names that are not valid shell variable names.
 566     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 567       { echo "$as_me: error: invalid package name: $ac_package" >&2
 568    { (exit 1); exit 1; }; }
 569     ac_package=`echo $ac_package | sed 's/-/_/g'`
 570     eval "with_$ac_package=no" ;;
 571
 572   --x)
 573     # Obsolete; use --with-x.
 574     with_x=yes ;;
 575
 576   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 577   | --x-incl | --x-inc | --x-in | --x-i)
 578     ac_prev=x_includes ;;
 579   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 580   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 581     x_includes=$ac_optarg ;;
 582
 583   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 584   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 585     ac_prev=x_libraries ;;
 586   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 587   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 588     x_libraries=$ac_optarg ;;
 589
 590   -*) { echo "$as_me: error: unrecognized option: $ac_option
 591 Try \`$0 --help' for more information." >&2
 592    { (exit 1); exit 1; }; }
 593     ;;
 594
 595   *=*)
 596     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 597     # Reject names that are not valid shell variable names.
 598     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 599       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 600    { (exit 1); exit 1; }; }
 601     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 602     eval "$ac_envvar='$ac_optarg'"
 603     export $ac_envvar ;;
 604
 605   *)
 606     # FIXME: should be removed in autoconf 3.0.
 607     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 608     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 609       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 610     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 611     ;;
 612
 613   esac
 614 done
 615
 616 if test -n "$ac_prev"; then
 617   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 618   { echo "$as_me: error: missing argument to $ac_option" >&2
 619    { (exit 1); exit 1; }; }
 620 fi
 621
 622 # Be sure to have absolute paths.
 623 for ac_var in exec_prefix prefix
 624 do
 625   eval ac_val=$`echo $ac_var`
 626   case $ac_val in
 627     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 628     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 629    { (exit 1); exit 1; }; };;
 630   esac
 631 done
 632
 633 # Be sure to have absolute paths.
 634 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 635               localstatedir libdir includedir oldincludedir infodir mandir
 636 do
 637   eval ac_val=$`echo $ac_var`
 638   case $ac_val in
 639     [\\/$]* | ?:[\\/]* ) ;;
 640     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 641    { (exit 1); exit 1; }; };;
 642   esac
 643 done
 644
 645 # There might be people who depend on the old broken behavior: `$host'
 646 # used to hold the argument of --host etc.
 647 # FIXME: To remove some day.
 648 build=$build_alias
 649 host=$host_alias
 650 target=$target_alias
 651
 652 # FIXME: To remove some day.
 653 if test "x$host_alias" != x; then
 654   if test "x$build_alias" = x; then
 655     cross_compiling=maybe
 656     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 657     If a cross compiler is detected then cross compile mode will be used." >&2
 658   elif test "x$build_alias" != "x$host_alias"; then
 659     cross_compiling=yes
 660   fi
 661 fi
 662
 663 ac_tool_prefix=
 664 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 665
 666 test "$silent" = yes && exec 6>/dev/null
 667
 668
 669 # Find the source files, if location was not specified.
 670 if test -z "$srcdir"; then
 671   ac_srcdir_defaulted=yes
 672   # Try the directory containing this script, then its parent.
 673   ac_confdir=`(dirname "$0") 2>/dev/null ||
 674 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 675          X"$0" : 'X\(//\)[^/]' \| \
 676          X"$0" : 'X\(//\)$' \| \
 677          X"$0" : 'X\(/\)' \| \
 678          .     : '\(.\)' 2>/dev/null ||
 679 echo X"$0" |
 680     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 681           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 682           /^X\(\/\/\)$/{ s//\1/; q; }
 683           /^X\(\/\).*/{ s//\1/; q; }
 684           s/.*/./; q'`
 685   srcdir=$ac_confdir
 686   if test ! -r $srcdir/$ac_unique_file; then
 687     srcdir=..
 688   fi
 689 else
 690   ac_srcdir_defaulted=no
 691 fi
 692 if test ! -r $srcdir/$ac_unique_file; then
 693   if test "$ac_srcdir_defaulted" = yes; then
 694     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 695    { (exit 1); exit 1; }; }
 696   else
 697     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 698    { (exit 1); exit 1; }; }
 699   fi
 700 fi
 701 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 702   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 703    { (exit 1); exit 1; }; }
 704 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 705 ac_env_build_alias_set=${build_alias+set}
 706 ac_env_build_alias_value=$build_alias
 707 ac_cv_env_build_alias_set=${build_alias+set}
 708 ac_cv_env_build_alias_value=$build_alias
 709 ac_env_host_alias_set=${host_alias+set}
 710 ac_env_host_alias_value=$host_alias
 711 ac_cv_env_host_alias_set=${host_alias+set}
 712 ac_cv_env_host_alias_value=$host_alias
 713 ac_env_target_alias_set=${target_alias+set}
 714 ac_env_target_alias_value=$target_alias
 715 ac_cv_env_target_alias_set=${target_alias+set}
 716 ac_cv_env_target_alias_value=$target_alias
 717 ac_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 718
 719 ac_env_CC_set=${CC+set}
 720 ac_env_CC_value=$CC
 721 ac_cv_env_CC_set=${CC+set}
 722 ac_cv_env_CC_value=$CC
 723 ac_env_CFLAGS_set=${CFLAGS+set}
 724 ac_env_CFLAGS_value=$CFLAGS
 725 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 726 ac_cv_env_CFLAGS_value=$CFLAGS
 727 ac_env_LDFLAGS_set=${LDFLAGS+set}
 728 ac_env_LDFLAGS_value=$LDFLAGS
 729 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 730 ac_cv_env_LDFLAGS_value=$LDFLAGS
 731 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 732 ac_env_CPPFLAGS_value=$CPPFLAGS
 733 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 734 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 735 ac_env_CXX_set=${CXX+set}
 736 ac_env_CXX_value=$CXX
 737 ac_cv_env_CXX_set=${CXX+set}
 738 ac_cv_env_CXX_value=$CXX
 739 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 740 ac_env_CXXFLAGS_value=$CXXFLAGS
 741 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 742 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 743 ac_env_AR_set=${AR+set}
 744 ac_env_AR_value=$AR
 745 ac_cv_env_AR_set=${AR+set}
 746 ac_cv_env_AR_value=$AR
 747 ac_env_AS_set=${AS+set}
 748 ac_env_AS_value=$AS
 749 ac_cv_env_AS_set=${AS+set}
 750 ac_cv_env_AS_value=$AS
 751 ac_env_DLLTOOL_set=${DLLTOOL+set}
 752 ac_env_DLLTOOL_value=$DLLTOOL
 753 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 754 ac_cv_env_DLLTOOL_value=$DLLTOOL
 755 ac_env_LD_set=${LD+set}
 756 ac_env_LD_value=$LD
 757 ac_cv_env_LD_set=${LD+set}
 758 ac_cv_env_LD_value=$LD
 759 ac_env_LIPO_set=${LIPO+set}
 760 ac_env_LIPO_value=$LIPO
 761 ac_cv_env_LIPO_set=${LIPO+set}
 762 ac_cv_env_LIPO_value=$LIPO
 763 ac_env_NM_set=${NM+set}
 764 ac_env_NM_value=$NM
 765 ac_cv_env_NM_set=${NM+set}
 766 ac_cv_env_NM_value=$NM
 767 ac_env_RANLIB_set=${RANLIB+set}
 768 ac_env_RANLIB_value=$RANLIB
 769 ac_cv_env_RANLIB_set=${RANLIB+set}
 770 ac_cv_env_RANLIB_value=$RANLIB
 771 ac_env_STRIP_set=${STRIP+set}
 772 ac_env_STRIP_value=$STRIP
 773 ac_cv_env_STRIP_set=${STRIP+set}
 774 ac_cv_env_STRIP_value=$STRIP
 775 ac_env_WINDRES_set=${WINDRES+set}
 776 ac_env_WINDRES_value=$WINDRES
 777 ac_cv_env_WINDRES_set=${WINDRES+set}
 778 ac_cv_env_WINDRES_value=$WINDRES
 779 ac_env_WINDMC_set=${WINDMC+set}
 780 ac_env_WINDMC_value=$WINDMC
 781 ac_cv_env_WINDMC_set=${WINDMC+set}
 782 ac_cv_env_WINDMC_value=$WINDMC
 783 ac_env_OBJCOPY_set=${OBJCOPY+set}
 784 ac_env_OBJCOPY_value=$OBJCOPY
 785 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 786 ac_cv_env_OBJCOPY_value=$OBJCOPY
 787 ac_env_OBJDUMP_set=${OBJDUMP+set}
 788 ac_env_OBJDUMP_value=$OBJDUMP
 789 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 790 ac_cv_env_OBJDUMP_value=$OBJDUMP
 791 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 792 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 793 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 794 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 795 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 796 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 797 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 798 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 799 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 800 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 801 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 802 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 803 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 804 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 805 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 806 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 807 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 808 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 809 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 810 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 811 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 812 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 813 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 814 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 815 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 816 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 817 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 818 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 819 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 820 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 821 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 822 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 823 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 824 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 825 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 826 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 827 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 828 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 829 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 830 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 831 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 832 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 833 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 834 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 835 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 836 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 837 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 838 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 839 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 840 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 841 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 842 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 843 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 844 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 845 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 846 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 847 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 848 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 849 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 850 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 851 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 852 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 853 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 854 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 855
 856 #
 857 # Report the --help message.
 858 #
 859 if test "$ac_init_help" = "long"; then
 860   # Omit some internal or obsolete options to make the list less imposing.
 861   # This message is too long to be a string in the A/UX 3.1 sh.
 862   cat <<_ACEOF
 863 \`configure' configures this package to adapt to many kinds of systems.
 864
 865 Usage: $0 [OPTION]... [VAR=VALUE]...
 866
 867 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 868 VAR=VALUE.  See below for descriptions of some of the useful variables.
 869
 870 Defaults for the options are specified in brackets.
 871
 872 Configuration:
 873   -h, --help              display this help and exit
 874       --help=short        display options specific to this package
 875       --help=recursive    display the short help of all the included packages
 876   -V, --version           display version information and exit
 877   -q, --quiet, --silent   do not print \`checking...' messages
 878       --cache-file=FILE   cache test results in FILE [disabled]
 879   -C, --config-cache      alias for \`--cache-file=config.cache'
 880   -n, --no-create         do not create output files
 881       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 882
 883 _ACEOF
 884
 885   cat <<_ACEOF
 886 Installation directories:
 887   --prefix=PREFIX         install architecture-independent files in PREFIX
 888                           [$ac_default_prefix]
 889   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 890                           [PREFIX]
 891
 892 By default, \`make install' will install all the files in
 893 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 894 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 895 for instance \`--prefix=\$HOME'.
 896
 897 For better control, use the options below.
 898
 899 Fine tuning of the installation directories:
 900   --bindir=DIR           user executables [EPREFIX/bin]
 901   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 902   --libexecdir=DIR       program executables [EPREFIX/libexec]
 903   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 904   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 905   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 906   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 907   --libdir=DIR           object code libraries [EPREFIX/lib]
 908   --includedir=DIR       C header files [PREFIX/include]
 909   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 910   --infodir=DIR          info documentation [PREFIX/info]
 911   --mandir=DIR           man documentation [PREFIX/man]
 912 _ACEOF
 913
 914   cat <<\_ACEOF
 915
 916 Program names:
 917   --program-prefix=PREFIX            prepend PREFIX to installed program names
 918   --program-suffix=SUFFIX            append SUFFIX to installed program names
 919   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 920
 921 System types:
 922   --build=BUILD     configure for building on BUILD [guessed]
 923   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 924   --target=TARGET   configure for building compilers for TARGET [HOST]
 925 _ACEOF
 926 fi
 927
 928 if test -n "$ac_init_help"; then
 929
 930   cat <<\_ACEOF
 931
 932 Optional Features:
 933   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 934   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 935   --enable-gold           use gold instead of ld
 936   --enable-libada         build libada directory
 937   --enable-libssp         build libssp directory
 938   --disable-ppl-version-check    disable check for PPL version
 939   --disable-cloog-version-check  disable check for CLooG version
 940   --enable-stage1-languages[=all]   choose additional languages to build during
 941                           stage1.  Mostly useful for compiler development.
 942   --enable-objc-gc        enable use of Boehm's garbage collector with the
 943                           GNU Objective-C runtime
 944   --enable-bootstrap      enable bootstrapping [yes if native build]
 945   --enable-serial-[{host,target,build}-]configure
 946                           force sequential configuration of
 947                           sub-packages for the host, target or build
 948                           machine, or all sub-packages
 949   --enable-maintainer-mode enable make rules and dependencies not useful
 950                           (and sometimes confusing) to the casual installer
 951   --enable-stage1-checking[=all]   choose additional checking for stage1
 952                           of the compiler
 953   --enable-werror         enable -Werror in bootstrap stage2 and later
 954
 955 Optional Packages:
 956   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 957   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 958   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 959   --with-mpfr-dir=PATH    this option has been REMOVED
 960   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 961                           Equivalent to --with-mpfr-include=PATH/include
 962                           plus --with-mpfr-lib=PATH/lib
 963   --with-mpfr-include=PATH
 964                           specify directory for installed MPFR include files
 965   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 966   --with-gmp-dir=PATH     this option has been REMOVED
 967   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 968                           Equivalent to --with-gmp-include=PATH/include
 969                           plus --with-gmp-lib=PATH/lib
 970   --with-gmp-include=PATH specify directory for installed GMP include files
 971   --with-gmp-lib=PATH     specify directory for the installed GMP library
 972   --with-ppl=PATH         Specify prefix directory for the installed PPL package
 973                           Equivalent to --with-ppl-include=PATH/include
 974                           plus --with-ppl-lib=PATH/lib
 975   --with-ppl-include=PATH Specify directory for installed PPL include files
 976   --with-ppl-lib=PATH     Specify the directory for the installed PPL library
 977   --with-cloog=PATH       Specify prefix directory for the installed CLooG-PPL package
 978                           Equivalent to --with-cloog-include=PATH/include
 979                           plus --with-cloog-lib=PATH/lib
 980   --with-cloog-include=PATH Specify directory for installed CLooG include files
 981   --with-cloog-lib=PATH   Specify the directory for the installed CLooG library
 982   --with-cloog-polylib=PATH Specify prefix directory for the installed CLooG-PolyLib package
 983   --with-build-sysroot=SYSROOT
 984                           use sysroot as the system root during the build
 985   --with-debug-prefix-map='A=B C=D ...'
 986                              map A to B, C to D ... in debug information
 987   --with-build-time-tools=PATH
 988                           use given path to find target tools during the build
 989   --with-datarootdir      use datarootdir as the data root directory.
 990   --with-docdir           install documentation in this directory.
 991   --with-pdfdir           install pdf in this directory.
 992   --with-htmldir          install html in this directory.
 993
 994 Some influential environment variables:
 995   CC          C compiler command
 996   CFLAGS      C compiler flags
 997   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 998               nonstandard directory <lib dir>
 999   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
1000               headers in a nonstandard directory <include dir>
1001   CXX         C++ compiler command
1002   CXXFLAGS    C++ compiler flags
1003   AR          AR for the host
1004   AS          AS for the host
1005   DLLTOOL     DLLTOOL for the host
1006   LD          LD for the host
1007   LIPO        LIPO for the host
1008   NM          NM for the host
1009   RANLIB      RANLIB for the host
1010   STRIP       STRIP for the host
1011   WINDRES     WINDRES for the host
1012   WINDMC      WINDMC for the host
1013   OBJCOPY     OBJCOPY for the host
1014   OBJDUMP     OBJDUMP for the host
1015   CC_FOR_TARGET
1016               CC for the target
1017   CXX_FOR_TARGET
1018               CXX for the target
1019   GCC_FOR_TARGET
1020               GCC for the target
1021   GCJ_FOR_TARGET
1022               GCJ for the target
1023   GFORTRAN_FOR_TARGET
1024               GFORTRAN for the target
1025   AR_FOR_TARGET
1026               AR for the target
1027   AS_FOR_TARGET
1028               AS for the target
1029   DLLTOOL_FOR_TARGET
1030               DLLTOOL for the target
1031   LD_FOR_TARGET
1032               LD for the target
1033   LIPO_FOR_TARGET
1034               LIPO for the target
1035   NM_FOR_TARGET
1036               NM for the target
1037   OBJDUMP_FOR_TARGET
1038               OBJDUMP for the target
1039   RANLIB_FOR_TARGET
1040               RANLIB for the target
1041   STRIP_FOR_TARGET
1042               STRIP for the target
1043   WINDRES_FOR_TARGET
1044               WINDRES for the target
1045   WINDMC_FOR_TARGET
1046               WINDMC for the target
1047
1048 Use these variables to override the choices made by `configure' or to help
1049 it to find libraries and programs with nonstandard names/locations.
1050
1051 _ACEOF
1052 fi
1053
1054 if test "$ac_init_help" = "recursive"; then
1055   # If there are subdirs, report their specific --help.
1056   ac_popdir=`pwd`
1057   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1058     test -d $ac_dir || continue
1059     ac_builddir=.
1060
1061 if test "$ac_dir" != .; then
1062   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1063   # A "../" for each directory in $ac_dir_suffix.
1064   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1065 else
1066   ac_dir_suffix= ac_top_builddir=
1067 fi
1068
1069 case $srcdir in
1070   .)  # No --srcdir option.  We are building in place.
1071     ac_srcdir=.
1072     if test -z "$ac_top_builddir"; then
1073        ac_top_srcdir=.
1074     else
1075        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1076     fi ;;
1077   [\\/]* | ?:[\\/]* )  # Absolute path.
1078     ac_srcdir=$srcdir$ac_dir_suffix;
1079     ac_top_srcdir=$srcdir ;;
1080   *) # Relative path.
1081     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1082     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1083 esac
1084
1085 # Do not use `cd foo && pwd` to compute absolute paths, because
1086 # the directories may not exist.
1087 case `pwd` in
1088 .) ac_abs_builddir="$ac_dir";;
1089 *)
1090   case "$ac_dir" in
1091   .) ac_abs_builddir=`pwd`;;
1092   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1093   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1094   esac;;
1095 esac
1096 case $ac_abs_builddir in
1097 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1098 *)
1099   case ${ac_top_builddir}. in
1100   .) ac_abs_top_builddir=$ac_abs_builddir;;
1101   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1102   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1103   esac;;
1104 esac
1105 case $ac_abs_builddir in
1106 .) ac_abs_srcdir=$ac_srcdir;;
1107 *)
1108   case $ac_srcdir in
1109   .) ac_abs_srcdir=$ac_abs_builddir;;
1110   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1111   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1112   esac;;
1113 esac
1114 case $ac_abs_builddir in
1115 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1116 *)
1117   case $ac_top_srcdir in
1118   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1119   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1120   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1121   esac;;
1122 esac
1123
1124     cd $ac_dir
1125     # Check for guested configure; otherwise get Cygnus style configure.
1126     if test -f $ac_srcdir/configure.gnu; then
1127       echo
1128       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1129     elif test -f $ac_srcdir/configure; then
1130       echo
1131       $SHELL $ac_srcdir/configure  --help=recursive
1132     elif test -f $ac_srcdir/configure.ac ||
1133            test -f $ac_srcdir/configure.in; then
1134       echo
1135       $ac_configure --help
1136     else
1137       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1138     fi
1139     cd $ac_popdir
1140   done
1141 fi
1142
1143 test -n "$ac_init_help" && exit 0
1144 if $ac_init_version; then
1145   cat <<\_ACEOF
1146
1147 Copyright (C) 2003 Free Software Foundation, Inc.
1148 This configure script is free software; the Free Software Foundation
1149 gives unlimited permission to copy, distribute and modify it.
1150 _ACEOF
1151   exit 0
1152 fi
1153 exec 5>config.log
1154 cat >&5 <<_ACEOF
1155 This file contains any messages produced by compilers while
1156 running configure, to aid debugging if configure makes a mistake.
1157
1158 It was created by $as_me, which was
1159 generated by GNU Autoconf 2.59.  Invocation command line was
1160
1161   $ $0 $@
1162
1163 _ACEOF
1164 {
1165 cat <<_ASUNAME
1166 ## --------- ##
1167 ## Platform. ##
1168 ## --------- ##
1169
1170 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1171 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1172 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1173 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1174 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1175
1176 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1177 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1178
1179 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1180 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1181 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1182 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1183 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1184 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1185 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1186
1187 _ASUNAME
1188
1189 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1190 for as_dir in $PATH
1191 do
1192   IFS=$as_save_IFS
1193   test -z "$as_dir" && as_dir=.
1194   echo "PATH: $as_dir"
1195 done
1196
1197 } >&5
1198
1199 cat >&5 <<_ACEOF
1200
1201
1202 ## ----------- ##
1203 ## Core tests. ##
1204 ## ----------- ##
1205
1206 _ACEOF
1207
1208
1209 # Keep a trace of the command line.
1210 # Strip out --no-create and --no-recursion so they do not pile up.
1211 # Strip out --silent because we don't want to record it for future runs.
1212 # Also quote any args containing shell meta-characters.
1213 # Make two passes to allow for proper duplicate-argument suppression.
1214 ac_configure_args=
1215 ac_configure_args0=
1216 ac_configure_args1=
1217 ac_sep=
1218 ac_must_keep_next=false
1219 for ac_pass in 1 2
1220 do
1221   for ac_arg
1222   do
1223     case $ac_arg in
1224     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1225     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1226     | -silent | --silent | --silen | --sile | --sil)
1227       continue ;;
1228     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1229       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1230     esac
1231     case $ac_pass in
1232     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1233     2)
1234       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1235       if test $ac_must_keep_next = true; then
1236         ac_must_keep_next=false # Got value, back to normal.
1237       else
1238         case $ac_arg in
1239           *=* | --config-cache | -C | -disable-* | --disable-* \
1240           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1241           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1242           | -with-* | --with-* | -without-* | --without-* | --x)
1243             case "$ac_configure_args0 " in
1244               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1245             esac
1246             ;;
1247           -* ) ac_must_keep_next=true ;;
1248         esac
1249       fi
1250       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1251       # Get rid of the leading space.
1252       ac_sep=" "
1253       ;;
1254     esac
1255   done
1256 done
1257 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1258 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1259
1260 # When interrupted or exit'd, cleanup temporary files, and complete
1261 # config.log.  We remove comments because anyway the quotes in there
1262 # would cause problems or look ugly.
1263 # WARNING: Be sure not to use single quotes in there, as some shells,
1264 # such as our DU 5.0 friend, will then `close' the trap.
1265 trap 'exit_status=$?
1266   # Save into config.log some information that might help in debugging.
1267   {
1268     echo
1269
1270     cat <<\_ASBOX
1271 ## ---------------- ##
1272 ## Cache variables. ##
1273 ## ---------------- ##
1274 _ASBOX
1275     echo
1276     # The following way of writing the cache mishandles newlines in values,
1277 {
1278   (set) 2>&1 |
1279     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1280     *ac_space=\ *)
1281       sed -n \
1282         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1283           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1284       ;;
1285     *)
1286       sed -n \
1287         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1288       ;;
1289     esac;
1290 }
1291     echo
1292
1293     cat <<\_ASBOX
1294 ## ----------------- ##
1295 ## Output variables. ##
1296 ## ----------------- ##
1297 _ASBOX
1298     echo
1299     for ac_var in $ac_subst_vars
1300     do
1301       eval ac_val=$`echo $ac_var`
1302       echo "$ac_var='"'"'$ac_val'"'"'"
1303     done | sort
1304     echo
1305
1306     if test -n "$ac_subst_files"; then
1307       cat <<\_ASBOX
1308 ## ------------- ##
1309 ## Output files. ##
1310 ## ------------- ##
1311 _ASBOX
1312       echo
1313       for ac_var in $ac_subst_files
1314       do
1315         eval ac_val=$`echo $ac_var`
1316         echo "$ac_var='"'"'$ac_val'"'"'"
1317       done | sort
1318       echo
1319     fi
1320
1321     if test -s confdefs.h; then
1322       cat <<\_ASBOX
1323 ## ----------- ##
1324 ## confdefs.h. ##
1325 ## ----------- ##
1326 _ASBOX
1327       echo
1328       sed "/^$/d" confdefs.h | sort
1329       echo
1330     fi
1331     test "$ac_signal" != 0 &&
1332       echo "$as_me: caught signal $ac_signal"
1333     echo "$as_me: exit $exit_status"
1334   } >&5
1335   rm -f core *.core &&
1336   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1337     exit $exit_status
1338      ' 0
1339 for ac_signal in 1 2 13 15; do
1340   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1341 done
1342 ac_signal=0
1343
1344 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1345 rm -rf conftest* confdefs.h
1346 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1347 echo >confdefs.h
1348
1349 # Predefined preprocessor variables.
1350
1351 cat >>confdefs.h <<_ACEOF
1352 #define PACKAGE_NAME "$PACKAGE_NAME"
1353 _ACEOF
1354
1355
1356 cat >>confdefs.h <<_ACEOF
1357 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1358 _ACEOF
1359
1360
1361 cat >>confdefs.h <<_ACEOF
1362 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1363 _ACEOF
1364
1365
1366 cat >>confdefs.h <<_ACEOF
1367 #define PACKAGE_STRING "$PACKAGE_STRING"
1368 _ACEOF
1369
1370
1371 cat >>confdefs.h <<_ACEOF
1372 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1373 _ACEOF
1374
1375
1376 # Let the site file select an alternate cache file if it wants to.
1377 # Prefer explicitly selected file to automatically selected ones.
1378 if test -z "$CONFIG_SITE"; then
1379   if test "x$prefix" != xNONE; then
1380     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1381   else
1382     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1383   fi
1384 fi
1385 for ac_site_file in $CONFIG_SITE; do
1386   if test -r "$ac_site_file"; then
1387     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1388 echo "$as_me: loading site script $ac_site_file" >&6;}
1389     sed 's/^/| /' "$ac_site_file" >&5
1390     . "$ac_site_file"
1391   fi
1392 done
1393
1394 if test -r "$cache_file"; then
1395   # Some versions of bash will fail to source /dev/null (special
1396   # files actually), so we avoid doing that.
1397   if test -f "$cache_file"; then
1398     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1399 echo "$as_me: loading cache $cache_file" >&6;}
1400     case $cache_file in
1401       [\\/]* | ?:[\\/]* ) . $cache_file;;
1402       *)                      . ./$cache_file;;
1403     esac
1404   fi
1405 else
1406   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1407 echo "$as_me: creating cache $cache_file" >&6;}
1408   >$cache_file
1409 fi
1410
1411 # Check that the precious variables saved in the cache have kept the same
1412 # value.
1413 ac_cache_corrupted=false
1414 for ac_var in `(set) 2>&1 |
1415                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1416   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1417   eval ac_new_set=\$ac_env_${ac_var}_set
1418   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1419   eval ac_new_val="\$ac_env_${ac_var}_value"
1420   case $ac_old_set,$ac_new_set in
1421     set,)
1422       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1423 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1424       ac_cache_corrupted=: ;;
1425     ,set)
1426       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1427 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1428       ac_cache_corrupted=: ;;
1429     ,);;
1430     *)
1431       if test "x$ac_old_val" != "x$ac_new_val"; then
1432         # differences in whitespace do not lead to failure.
1433         ac_old_val_w=`echo x $ac_old_val`
1434         ac_new_val_w=`echo x $ac_new_val`
1435         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1436           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1437 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1438           ac_cache_corrupted=:
1439         else
1440           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1441 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1442           eval $ac_var=\$ac_old_val
1443         fi
1444         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1445 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1446         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1447 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1448       fi;;
1449   esac
1450   # Pass precious variables to config.status.
1451   if test "$ac_new_set" = set; then
1452     case $ac_new_val in
1453     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1454       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1455     *) ac_arg=$ac_var=$ac_new_val ;;
1456     esac
1457     case " $ac_configure_args " in
1458       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1459       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1460     esac
1461   fi
1462 done
1463 if $ac_cache_corrupted; then
1464   { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
1465 echo "$as_me: error: in \`$ac_pwd':" >&2;}
1466   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1467 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1468   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1469 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1470    { (exit 1); exit 1; }; }
1471 fi
1472
1473 ac_ext=c
1474 ac_cpp='$CPP $CPPFLAGS'
1475 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1476 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1477 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502 progname=$0
1503 # if PWD already has a value, it is probably wrong.
1504 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1505
1506 # Export original configure arguments for use by sub-configures.
1507 # Quote arguments with shell meta charatcers.
1508 TOPLEVEL_CONFIGURE_ARGUMENTS=
1509 set -- "$progname" "$@"
1510 for ac_arg
1511 do
1512   case "$ac_arg" in
1513   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1514     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1515     # if the argument is of the form -foo=baz, quote the baz part only
1516     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1517   *) ;;
1518   esac
1519   # Add the quoted argument to the list.
1520   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1521 done
1522 if test "$silent" = yes; then
1523   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1524 fi
1525 # Remove the initial space we just introduced and, as these will be
1526 # expanded by make, quote '$'.
1527 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1528
1529
1530 # Find the build, host, and target systems.
1531 ac_aux_dir=
1532 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1533   if test -f $ac_dir/install-sh; then
1534     ac_aux_dir=$ac_dir
1535     ac_install_sh="$ac_aux_dir/install-sh -c"
1536     break
1537   elif test -f $ac_dir/install.sh; then
1538     ac_aux_dir=$ac_dir
1539     ac_install_sh="$ac_aux_dir/install.sh -c"
1540     break
1541   elif test -f $ac_dir/shtool; then
1542     ac_aux_dir=$ac_dir
1543     ac_install_sh="$ac_aux_dir/shtool install -c"
1544     break
1545   fi
1546 done
1547 if test -z "$ac_aux_dir"; then
1548   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1549 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1550    { (exit 1); exit 1; }; }
1551 fi
1552 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1553 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1554 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1555
1556 # Make sure we can run config.sub.
1557 $ac_config_sub sun4 >/dev/null 2>&1 ||
1558   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1559 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1560    { (exit 1); exit 1; }; }
1561
1562 echo "$as_me:$LINENO: checking build system type" >&5
1563 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1564 if test "${ac_cv_build+set}" = set; then
1565   echo $ECHO_N "(cached) $ECHO_C" >&6
1566 else
1567   ac_cv_build_alias=$build_alias
1568 test -z "$ac_cv_build_alias" &&
1569   ac_cv_build_alias=`$ac_config_guess`
1570 test -z "$ac_cv_build_alias" &&
1571   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1572 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1573    { (exit 1); exit 1; }; }
1574 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1575   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1576 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1577    { (exit 1); exit 1; }; }
1578
1579 fi
1580 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1581 echo "${ECHO_T}$ac_cv_build" >&6
1582 build=$ac_cv_build
1583 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1584 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1585 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1586
1587
1588  case ${build_alias} in
1589   "") build_noncanonical=${build} ;;
1590   *) build_noncanonical=${build_alias} ;;
1591 esac
1592
1593
1594
1595  case ${host_alias} in
1596   "") host_noncanonical=${build_noncanonical} ;;
1597   *) host_noncanonical=${host_alias} ;;
1598 esac
1599
1600
1601
1602  case ${target_alias} in
1603   "") target_noncanonical=${host_noncanonical} ;;
1604   *) target_noncanonical=${target_alias} ;;
1605 esac
1606
1607
1608
1609
1610 test "$host_noncanonical" = "$target_noncanonical" &&
1611   test "$program_prefix$program_suffix$program_transform_name" = \
1612     NONENONEs,x,x, &&
1613   program_transform_name=s,y,y,
1614
1615 echo "$as_me:$LINENO: checking host system type" >&5
1616 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1617 if test "${ac_cv_host+set}" = set; then
1618   echo $ECHO_N "(cached) $ECHO_C" >&6
1619 else
1620   ac_cv_host_alias=$host_alias
1621 test -z "$ac_cv_host_alias" &&
1622   ac_cv_host_alias=$ac_cv_build_alias
1623 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1624   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1625 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1626    { (exit 1); exit 1; }; }
1627
1628 fi
1629 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1630 echo "${ECHO_T}$ac_cv_host" >&6
1631 host=$ac_cv_host
1632 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1633 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1634 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1635
1636
1637 echo "$as_me:$LINENO: checking target system type" >&5
1638 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1639 if test "${ac_cv_target+set}" = set; then
1640   echo $ECHO_N "(cached) $ECHO_C" >&6
1641 else
1642   ac_cv_target_alias=$target_alias
1643 test "x$ac_cv_target_alias" = "x" &&
1644   ac_cv_target_alias=$ac_cv_host_alias
1645 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1646   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1647 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1648    { (exit 1); exit 1; }; }
1649
1650 fi
1651 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1652 echo "${ECHO_T}$ac_cv_target" >&6
1653 target=$ac_cv_target
1654 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1655 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1656 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1657
1658
1659 # The aliases save the names the user supplied, while $host etc.
1660 # will get canonicalized.
1661 test -n "$target_alias" &&
1662   test "$program_prefix$program_suffix$program_transform_name" = \
1663     NONENONEs,x,x, &&
1664   program_prefix=${target_alias}-
1665 test "$program_prefix" != NONE &&
1666   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1667 # Use a double $ so make ignores it.
1668 test "$program_suffix" != NONE &&
1669   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1670 # Double any \ or $.  echo might interpret backslashes.
1671 # By default was `s,x,x', remove it if useless.
1672 cat <<\_ACEOF >conftest.sed
1673 s/[\\$]/&&/g;s/;s,x,x,$//
1674 _ACEOF
1675 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1676 rm conftest.sed
1677
1678
1679
1680 # Get 'install' or 'install-sh' and its variants.
1681 # Find a good install program.  We prefer a C program (faster),
1682 # so one script is as good as another.  But avoid the broken or
1683 # incompatible versions:
1684 # SysV /etc/install, /usr/sbin/install
1685 # SunOS /usr/etc/install
1686 # IRIX /sbin/install
1687 # AIX /bin/install
1688 # AmigaOS /C/install, which installs bootblocks on floppy discs
1689 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1690 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1691 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1692 # OS/2's system install, which has a completely different semantic
1693 # ./install, which can be erroneously created by make from ./install.sh.
1694 # Reject install programs that cannot install multiple files.
1695 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1696 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1697 if test -z "$INSTALL"; then
1698 if test "${ac_cv_path_install+set}" = set; then
1699   echo $ECHO_N "(cached) $ECHO_C" >&6
1700 else
1701   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1702 for as_dir in $PATH
1703 do
1704   IFS=$as_save_IFS
1705   test -z "$as_dir" && as_dir=.
1706   # Account for people who put trailing slashes in PATH elements.
1707 case $as_dir/ in
1708   ./ | .// | /cC/* | \
1709   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1710   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1711   /usr/ucb/* ) ;;
1712   *)
1713     # OSF1 and SCO ODT 3.0 have their own names for install.
1714     # Don't use installbsd from OSF since it installs stuff as root
1715     # by default.
1716     for ac_prog in ginstall scoinst install; do
1717       for ac_exec_ext in '' $ac_executable_extensions; do
1718         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1719           if test $ac_prog = install &&
1720             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1721             # AIX install.  It has an incompatible calling convention.
1722             :
1723           elif test $ac_prog = install &&
1724             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1725             # program-specific install script used by HP pwplus--don't use.
1726             :
1727           else
1728             rm -rf conftest.one conftest.two conftest.dir
1729             echo one > conftest.one
1730             echo two > conftest.two
1731             mkdir conftest.dir
1732             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1733               test -s conftest.one && test -s conftest.two &&
1734               test -s conftest.dir/conftest.one &&
1735               test -s conftest.dir/conftest.two
1736             then
1737               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1738               break 3
1739             fi
1740           fi
1741         fi
1742       done
1743     done
1744     ;;
1745 esac
1746 done
1747
1748 rm -rf conftest.one conftest.two conftest.dir
1749
1750 fi
1751   if test "${ac_cv_path_install+set}" = set; then
1752     INSTALL=$ac_cv_path_install
1753   else
1754     # As a last resort, use the slow shell script.  Don't cache a
1755     # value for INSTALL within a source directory, because that will
1756     # break other packages using the cache if that directory is
1757     # removed, or if the value is a relative name.
1758     INSTALL=$ac_install_sh
1759   fi
1760 fi
1761 echo "$as_me:$LINENO: result: $INSTALL" >&5
1762 echo "${ECHO_T}$INSTALL" >&6
1763
1764 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1765 # It thinks the first close brace ends the variable substitution.
1766 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1767
1768 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1769
1770 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1771
1772 echo "$as_me:$LINENO: checking whether ln works" >&5
1773 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1774 if test "${acx_cv_prog_LN+set}" = set; then
1775   echo $ECHO_N "(cached) $ECHO_C" >&6
1776 else
1777   rm -f conftestdata_t
1778 echo >conftestdata_f
1779 if ln conftestdata_f conftestdata_t 2>/dev/null
1780 then
1781   acx_cv_prog_LN=ln
1782 else
1783   acx_cv_prog_LN=no
1784 fi
1785 rm -f conftestdata_f conftestdata_t
1786
1787 fi
1788 if test $acx_cv_prog_LN = no; then
1789   LN="cp"
1790   echo "$as_me:$LINENO: result: no, using $LN" >&5
1791 echo "${ECHO_T}no, using $LN" >&6
1792 else
1793   LN="$acx_cv_prog_LN"
1794   echo "$as_me:$LINENO: result: yes" >&5
1795 echo "${ECHO_T}yes" >&6
1796 fi
1797
1798 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1799 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1800 LN_S=$as_ln_s
1801 if test "$LN_S" = "ln -s"; then
1802   echo "$as_me:$LINENO: result: yes" >&5
1803 echo "${ECHO_T}yes" >&6
1804 else
1805   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1806 echo "${ECHO_T}no, using $LN_S" >&6
1807 fi
1808
1809
1810 ### we might need to use some other shell than /bin/sh for running subshells
1811 ### If we are on Windows, search for the shell.  This will permit people
1812 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1813 ### without also having to set CONFIG_SHELL.  This code will work when
1814 ### using bash, which sets OSTYPE.
1815 case "${OSTYPE}" in
1816 *win32*)
1817   if test x${CONFIG_SHELL} = x ; then
1818     if test ! -f /bin/sh ; then
1819       if test x${SHELL} != x && test -f ${SHELL} ; then
1820         CONFIG_SHELL=${SHELL}
1821         export CONFIG_SHELL
1822       else
1823         for prog in sh sh.exe bash bash.exe; do
1824           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1825           for dir in $PATH; do
1826             test -z "$dir" && dir=.
1827             if test -f $dir/$prog; then
1828               CONFIG_SHELL=$dir/$prog
1829               export CONFIG_SHELL
1830               break
1831             fi
1832           done
1833           IFS="$save_ifs"
1834           test -n "${CONFIG_SHELL}" && break
1835         done
1836       fi
1837     fi
1838   fi
1839   ;;
1840 esac
1841
1842 config_shell=${CONFIG_SHELL-/bin/sh}
1843
1844 moveifchange=${srcdir}/move-if-change
1845
1846 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1847
1848 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1849 # a relative path.
1850 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1851   INSTALL="${srcpwd}/install-sh -c"
1852 fi
1853
1854 # Set srcdir to "." if that's what it is.
1855 # This is important for multilib support.
1856 pwd=`${PWDCMD-pwd}`
1857 if test "${pwd}" = "${srcpwd}" ; then
1858   srcdir=.
1859 fi
1860
1861 topsrcdir=$srcpwd
1862
1863 extra_host_args=
1864
1865 ### To add a new directory to the tree, first choose whether it is a target
1866 ### or a host dependent tool.  Then put it into the appropriate list
1867 ### (library or tools, host or target), doing a dependency sort.
1868
1869 # Subdirs will be configured in the order listed in build_configdirs,
1870 # configdirs, or target_configdirs; see the serialization section below.
1871
1872 # Dependency sorting is only needed when *configuration* must be done in
1873 # a particular order.  In all cases a dependency should be specified in
1874 # the Makefile, whether or not it's implicitly specified here.
1875
1876 # Double entries in build_configdirs, configdirs, or target_configdirs may
1877 # cause circular dependencies and break everything horribly.
1878
1879 # these library is used by various programs built for the build
1880 # environment
1881 #
1882 build_libs="build-libiberty"
1883
1884 # these tools are built for the build environment
1885 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1886
1887 # these libraries are used by various programs built for the host environment
1888 #
1889 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr ppl cloog"
1890
1891 # these tools are built for the host environment
1892 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1893 # know that we are building the simulator.
1894 # binutils, gas and ld appear in that order because it makes sense to run
1895 # "make check" in that particular order.
1896 # If --enable-gold is used, "gold" will replace "ld".
1897 host_tools="texinfo byacc flex bison binutils gas ld fixincludes gcc sid sim gdb make patch prms send-pr gprof etc expect dejagnu ash bash bzip2 m4 autoconf automake libtool diff rcs fileutils shellutils time textutils wdiff find uudecode hello tar gzip indent recode release sed utils guile perl gawk findutils gettext zip fastjar gnattools"
1898
1899 # libgcj represents the runtime libraries only used by gcj.
1900 libgcj="target-libffi \
1901         target-zlib \
1902         target-qthreads \
1903         target-libjava"
1904
1905 # these libraries are built for the target environment, and are built after
1906 # the host libraries and the host tools (which may be a cross compiler)
1907 #
1908 target_libraries="target-libgcc \
1909                 target-libiberty \
1910                 target-libgloss \
1911                 target-newlib \
1912                 target-libgomp \
1913                 target-libstdc++-v3 \
1914                 target-libmudflap \
1915                 target-libssp \
1916                 target-libgfortran \
1917                 target-boehm-gc \
1918                 ${libgcj} \
1919                 target-libobjc \
1920                 target-libada"
1921
1922 # these tools are built using the target libraries, and are intended to
1923 # run only in the target environment
1924 #
1925 # note: any program that *uses* libraries that are in the "target_libraries"
1926 # list belongs in this list.  those programs are also very likely
1927 # candidates for the "native_only" list which follows
1928 #
1929 target_tools="target-examples target-groff target-gperf target-rda"
1930
1931 ################################################################################
1932
1933 ## All tools belong in one of the four categories, and are assigned above
1934 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1935 ## is important because configure will choke if they ever get through.
1936 ## ${configdirs} is directories we build using the host tools.
1937 ## ${target_configdirs} is directories we build using the target tools.
1938 configdirs=`echo ${host_libs} ${host_tools}`
1939 target_configdirs=`echo ${target_libraries} ${target_tools}`
1940 build_configdirs=`echo ${build_libs} ${build_tools}`
1941
1942
1943
1944 ################################################################################
1945
1946 srcname="gnu development package"
1947
1948 # This gets set non-empty for some net releases of packages.
1949 appdirs=""
1950
1951 # Define is_cross_compiler to save on calls to 'test'.
1952 is_cross_compiler=
1953 if test x"${host}" = x"${target}" ; then
1954   is_cross_compiler=no
1955 else
1956   is_cross_compiler=yes
1957 fi
1958
1959 # Find the build and target subdir names.
1960
1961 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1962 # have matching libraries, they should use host libraries: Makefile.tpl
1963 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1964 # However, they still use the build modules, because the corresponding
1965 # host modules (e.g. bison) are only built for the host when bootstrap
1966 # finishes. So:
1967 # - build_subdir is where we find build modules, and never changes.
1968 # - build_libsubdir is where we find build libraries, and can be overridden.
1969
1970 # Prefix 'build-' so this never conflicts with target_subdir.
1971 build_subdir="build-${build_noncanonical}"
1972
1973 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1974 if test "${with_build_libsubdir+set}" = set; then
1975   withval="$with_build_libsubdir"
1976   build_libsubdir="$withval"
1977 else
1978   build_libsubdir="$build_subdir"
1979 fi;
1980 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1981 if ( test $srcdir = . && test -d gcc ) \
1982    || test -d $srcdir/../host-${host_noncanonical}; then
1983   host_subdir="host-${host_noncanonical}"
1984 else
1985   host_subdir=.
1986 fi
1987 # No prefix.
1988 target_subdir=${target_noncanonical}
1989
1990
1991 # Skipdirs are removed silently.
1992 skipdirs=
1993 # Noconfigdirs are removed loudly.
1994 noconfigdirs=""
1995
1996 use_gnu_ld=
1997 # Make sure we don't let GNU ld be added if we didn't want it.
1998 if test x$with_gnu_ld = xno ; then
1999   use_gnu_ld=no
2000   noconfigdirs="$noconfigdirs ld gold"
2001 fi
2002
2003 use_gnu_as=
2004 # Make sure we don't let GNU as be added if we didn't want it.
2005 if test x$with_gnu_as = xno ; then
2006   use_gnu_as=no
2007   noconfigdirs="$noconfigdirs gas"
2008 fi
2009
2010 # some tools are so dependent upon X11 that if we're not building with X,
2011 # it's not even worth trying to configure, much less build, that tool.
2012
2013 case ${with_x} in
2014   yes | "") ;; # the default value for this tree is that X11 is available
2015   no)
2016     skipdirs="${skipdirs} tk itcl libgui"
2017     # We won't be able to build gdbtk without X.
2018     enable_gdbtk=no
2019     ;;
2020   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2021 esac
2022
2023 # Some tools are only suitable for building in a "native" situation.
2024 # Remove these if host!=target.
2025 native_only="autoconf automake libtool fileutils find gawk gettext gzip hello indent m4 rcs recode sed shellutils tar textutils uudecode wdiff target-groff guile perl time ash bash bzip2 prms gnuserv target-gperf"
2026
2027 # Similarly, some are only suitable for cross toolchains.
2028 # Remove these if host=target.
2029 cross_only="target-libgloss target-newlib target-opcodes"
2030
2031 case $is_cross_compiler in
2032   no) skipdirs="${skipdirs} ${cross_only}" ;;
2033   yes) skipdirs="${skipdirs} ${native_only}" ;;
2034 esac
2035
2036 # If both --with-headers and --with-libs are specified, default to
2037 # --without-newlib.
2038 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2039    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2040   if test x"${with_newlib}" = x ; then
2041     with_newlib=no
2042   fi
2043 fi
2044
2045 # Recognize --with-newlib/--without-newlib.
2046 case ${with_newlib} in
2047   no) skipdirs="${skipdirs} target-newlib" ;;
2048   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2049 esac
2050
2051 # Handle --enable-gold.
2052
2053 # Check whether --enable-gold or --disable-gold was given.
2054 if test "${enable_gold+set}" = set; then
2055   enableval="$enable_gold"
2056   ENABLE_GOLD=$enableval
2057 else
2058   ENABLE_GOLD=no
2059 fi;
2060 if test "${ENABLE_GOLD}" = "yes"; then
2061   # Check for ELF target.
2062   is_elf=no
2063   case "${target}" in
2064     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2065     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2066     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2067       case "${target}" in
2068         *-*-linux*aout* | *-*-linux*oldld*)
2069           ;;
2070         *)
2071           is_elf=yes
2072           ;;
2073       esac
2074   esac
2075
2076   if test "$is_elf" = "yes"; then
2077     # Check for target supported by gold.
2078     case "${target}" in
2079       i?86-*-* | x86_64-*-* | sparc*-*-* | powerpc*-*-*)
2080         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2081         ;;
2082     esac
2083   fi
2084 fi
2085
2086 # Configure extra directories which are host specific
2087
2088 case "${host}" in
2089   *-cygwin*)
2090     configdirs="$configdirs libtermcap" ;;
2091 esac
2092
2093 # A target can indicate whether a language isn't supported for some reason.
2094 # Only spaces may be used in this macro; not newlines or tabs.
2095 unsupported_languages=
2096
2097 # Remove more programs from consideration, based on the host or
2098 # target this usually means that a port of the program doesn't
2099 # exist yet.
2100
2101 case "${host}" in
2102   hppa*64*-*-*)
2103     noconfigdirs="$noconfigdirs byacc"
2104     ;;
2105   i[3456789]86-*-vsta)
2106     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2107     ;;
2108   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2109     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2110     ;;
2111   x86_64-*-mingw*)
2112     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2113     ;;
2114   i[3456789]86-*-mingw32*)
2115     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2116     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2117     ;;
2118   i[3456789]86-*-beos*)
2119     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2120     ;;
2121   *-*-cygwin*)
2122     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2123     ;;
2124   *-*-netbsd*)
2125     noconfigdirs="$noconfigdirs rcs"
2126     ;;
2127   ppc*-*-pe)
2128     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2129     ;;
2130   powerpc-*-beos*)
2131     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2132     ;;
2133 esac
2134
2135
2136 # Check whether --enable-libada or --disable-libada was given.
2137 if test "${enable_libada+set}" = set; then
2138   enableval="$enable_libada"
2139   ENABLE_LIBADA=$enableval
2140 else
2141   ENABLE_LIBADA=yes
2142 fi;
2143 if test "${ENABLE_LIBADA}" != "yes" ; then
2144   noconfigdirs="$noconfigdirs gnattools"
2145 fi
2146
2147 # Check whether --enable-libssp or --disable-libssp was given.
2148 if test "${enable_libssp+set}" = set; then
2149   enableval="$enable_libssp"
2150   ENABLE_LIBSSP=$enableval
2151 else
2152   ENABLE_LIBSSP=yes
2153 fi;
2154
2155 # Save it here so that, even in case of --enable-libgcj, if the Java
2156 # front-end isn't enabled, we still get libgcj disabled.
2157 libgcj_saved=$libgcj
2158 case $enable_libgcj in
2159 yes)
2160   # If we reset it here, it won't get added to noconfigdirs in the
2161   # target-specific build rules, so it will be forcibly enabled
2162   # (unless the Java language itself isn't enabled).
2163   libgcj=
2164   ;;
2165 no)
2166   # Make sure we get it printed in the list of not supported target libs.
2167   noconfigdirs="$noconfigdirs ${libgcj}"
2168   ;;
2169 esac
2170
2171
2172 # Disable libmudflap on some systems.
2173 if test x$enable_libmudflap = x ; then
2174     case "${target}" in
2175     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2176         # Enable libmudflap by default in GNU and friends.
2177         ;;
2178     *-*-freebsd*)
2179         # Enable libmudflap by default in FreeBSD.
2180         ;;
2181     *)
2182         # Disable it by default everywhere else.
2183         noconfigdirs="$noconfigdirs target-libmudflap"
2184         ;;
2185     esac
2186 fi
2187
2188 # Disable libgomp on non POSIX hosted systems.
2189 if test x$enable_libgomp = x ; then
2190     # Enable libgomp by default on hosted POSIX systems.
2191     case "${target}" in
2192     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2193         ;;
2194     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2195         ;;
2196     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2197         ;;
2198     *-*-darwin* | *-*-aix*)
2199         ;;
2200     *)
2201         noconfigdirs="$noconfigdirs target-libgomp"
2202         ;;
2203     esac
2204 fi
2205
2206 # Default libgloss CPU subdirectory.
2207 libgloss_dir="$target_cpu"
2208
2209 case "${target}" in
2210   *-*-chorusos)
2211     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2212     ;;
2213   powerpc-*-darwin* | i[3456789]86-*-darwin* | x86_64-*-darwin9*)
2214     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2215     noconfigdirs="$noconfigdirs sim target-rda"
2216     ;;
2217   *-*-darwin*)
2218     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2219     noconfigdirs="$noconfigdirs sim target-rda"
2220     noconfigdirs="$noconfigdirs ${libgcj}"
2221     ;;
2222   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2223     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2224     ;;
2225   *-*-freebsd*)
2226     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2227     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2228         && test -f /usr/local/include/gmp.h; then
2229       with_gmp=/usr/local
2230     fi
2231
2232     # Skip some stuff that's unsupported on some FreeBSD configurations.
2233     case "${target}" in
2234       i*86-*-*) ;;
2235       alpha*-*-*) ;;
2236       *)
2237         noconfigdirs="$noconfigdirs ${libgcj}"
2238         ;;
2239     esac
2240     ;;
2241   *-*-kaos*)
2242     # Remove unsupported stuff on all kaOS configurations.
2243     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2244     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2245     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2246     noconfigdirs="$noconfigdirs target-libgloss"
2247     ;;
2248   *-*-netbsd*)
2249     # Skip some stuff on all NetBSD configurations.
2250     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2251
2252     # Skip some stuff that's unsupported on some NetBSD configurations.
2253     case "${target}" in
2254       i*86-*-netbsdelf*) ;;
2255       arm*-*-netbsdelf*) ;;
2256       *)
2257         noconfigdirs="$noconfigdirs ${libgcj}"
2258         ;;
2259     esac
2260     ;;
2261   *-*-netware*)
2262     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2263     ;;
2264   *-*-rtems*)
2265     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2266     ;;
2267     # The tpf target doesn't support gdb yet.
2268   *-*-tpf*)
2269     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2270     ;;
2271   *-*-uclinux*)
2272     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2273     ;;
2274   *-*-vxworks*)
2275     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2276     ;;
2277   alpha*-dec-osf*)
2278     # ld works, but does not support shared libraries.
2279     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2280     # gas doesn't generate exception information.
2281     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2282     ;;
2283   alpha*-*-*vms*)
2284     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2285     ;;
2286   alpha*-*-linux*)
2287     # newlib is not 64 bit ready
2288     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2289     ;;
2290   alpha*-*-*)
2291     # newlib is not 64 bit ready
2292     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2293     ;;
2294   am33_2.0-*-linux*)
2295     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2296     ;;
2297   sh-*-linux*)
2298     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2299     ;;
2300   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2301     noconfigdirs="$noconfigdirs ${libgcj}"
2302     noconfigdirs="$noconfigdirs target-examples"
2303     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2304     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2305     noconfigdirs="$noconfigdirs expect dejagnu"
2306     # the C++ libraries don't build on top of CE's C libraries
2307     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2308     noconfigdirs="$noconfigdirs target-newlib"
2309     case "${host}" in
2310       *-*-cygwin*) ;; # keep gdb and readline
2311       *) noconfigdirs="$noconfigdirs gdb readline"
2312          ;;
2313     esac
2314     libgloss_dir=wince
2315     ;;
2316   arc-*-*)
2317     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2318     ;;
2319   arm-semi-aof )
2320     ;;
2321   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2322     noconfigdirs="$noconfigdirs ${libgcj}"
2323     libgloss_dir=arm
2324     ;;
2325   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2326     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2327     libgloss_dir=arm
2328     ;;
2329   arm*-*-linux-gnueabi)
2330     noconfigdirs="$noconfigdirs target-qthreads"
2331     case ${with_newlib} in
2332       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2333     esac
2334     libgloss_dir=arm
2335     ;;
2336   arm*-*-symbianelf*)
2337     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2338     libgloss_dir=arm
2339     ;;
2340   arm-*-pe*)
2341     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2342     ;;
2343   thumb-*-coff)
2344     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2345     ;;
2346   thumb-*-elf)
2347     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2348     ;;
2349   thumb-*-pe)
2350     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2351     ;;
2352   arm-*-riscix*)
2353     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2354     ;;
2355   avr-*-*)
2356     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2357     ;;
2358   bfin-*-*)
2359     noconfigdirs="$noconfigdirs gdb"
2360     if test x${is_cross_compiler} != xno ; then
2361       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2362     fi
2363     ;;
2364   c4x-*-* | tic4x-*-*)
2365     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2366     ;;
2367   c54x*-*-* | tic54x-*-*)
2368     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2369     ;;
2370   cr16-*-*)
2371     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2372     ;;
2373   cris-*-* | crisv32-*-*)
2374     unsupported_languages="$unsupported_languages java"
2375     case "${target}" in
2376       *-*-aout)
2377         unsupported_languages="$unsupported_languages fortran"
2378         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2379       *-*-elf)
2380         noconfigdirs="$noconfigdirs target-boehm-gc";;
2381       *-*-linux*)
2382         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2383       *)
2384         unsupported_languages="$unsupported_languages fortran"
2385         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2386     esac
2387     libgloss_dir=cris
2388     ;;
2389   crx-*-*)
2390     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2391     ;;
2392   d10v-*-*)
2393     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2394     ;;
2395   d30v-*-*)
2396     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2397     ;;
2398   ep9312-*-elf | ep9312-*-coff)
2399     libgloss_dir=arm
2400     ;;
2401   fr30-*-elf*)
2402     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2403     ;;
2404   frv-*-*)
2405     noconfigdirs="$noconfigdirs ${libgcj}"
2406     ;;
2407   h8300*-*-*)
2408     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2409     ;;
2410   h8500-*-*)
2411     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2412     ;;
2413   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2414     ;;
2415   hppa*64*-*-linux* | parisc*64*-*-linux*)
2416     # In this case, it's because the hppa64-linux target is for
2417     # the kernel only at this point and has no libc, and thus no
2418     # headers, crt*.o, etc., all of which are needed by these.
2419     noconfigdirs="$noconfigdirs target-zlib"
2420     ;;
2421   parisc*-*-linux* | hppa*-*-linux*)
2422     ;;
2423   hppa*-*-*elf* | \
2424   hppa*-*-lites* | \
2425   hppa*-*-openbsd* | \
2426   hppa*64*-*-*)
2427     noconfigdirs="$noconfigdirs ${libgcj}"
2428     ;;
2429   hppa*-hp-hpux11*)
2430     noconfigdirs="$noconfigdirs ld shellutils"
2431     ;;
2432   hppa*-*-pro*)
2433     libgloss_dir=pa
2434     ;;
2435   hppa*-*-*)
2436     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2437     # build on HP-UX 10.20.
2438     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2439     ;;
2440   i960-*-*)
2441     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2442     ;;
2443   ia64*-*-elf*)
2444     # No gdb support yet.
2445     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2446     ;;
2447   ia64*-**-hpux*)
2448     # No gdb or ld support yet.
2449     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2450     ;;
2451   i370-*-opened*)
2452     ;;
2453   i[3456789]86-*-coff | i[3456789]86-*-elf)
2454     noconfigdirs="$noconfigdirs ${libgcj}"
2455     libgloss_dir=i386
2456     ;;
2457   i[3456789]86-*-linux*)
2458     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2459     # not build java stuff by default.
2460     case "${target}" in
2461       *-*-*libc1*)
2462         noconfigdirs="$noconfigdirs ${libgcj}";;
2463     esac
2464
2465     # This section makes it possible to build newlib natively on linux.
2466     # If we are using a cross compiler then don't configure newlib.
2467     if test x${is_cross_compiler} != xno ; then
2468       noconfigdirs="$noconfigdirs target-newlib"
2469     fi
2470     noconfigdirs="$noconfigdirs target-libgloss"
2471     # If we are not using a cross compiler, do configure newlib.
2472     # Note however, that newlib will only be configured in this situation
2473     # if the --with-newlib option has been given, because otherwise
2474     # 'target-newlib' will appear in skipdirs.
2475     ;;
2476   i[3456789]86-*-mingw32*)
2477     target_configdirs="$target_configdirs target-winsup"
2478     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2479     ;;
2480   x86_64-*-mingw*)
2481     target_configdirs="$target_configdirs target-winsup"
2482     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2483     ;;
2484   *-*-cygwin*)
2485     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2486     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2487     # always build newlib if winsup directory is present.
2488     if test -d "$srcdir/winsup/cygwin"; then
2489       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2490     elif test -d "$srcdir/newlib"; then
2491       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2492     fi
2493     ;;
2494   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2495   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2496     ;;
2497   i[3456789]86-*-pe)
2498     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2499     ;;
2500   i[3456789]86-*-sco3.2v5*)
2501     # The linker does not yet know about weak symbols in COFF,
2502     # and is not configured to handle mixed ELF and COFF.
2503     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2504     ;;
2505   i[3456789]86-*-sco*)
2506     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2507     ;;
2508   i[3456789]86-*-solaris2*)
2509     noconfigdirs="$noconfigdirs target-libgloss"
2510     ;;
2511   i[3456789]86-*-sysv4*)
2512     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2513     ;;
2514   i[3456789]86-*-beos*)
2515     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2516     ;;
2517   i[3456789]86-*-rdos*)
2518     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2519     ;;
2520   m32r-*-*)
2521     noconfigdirs="$noconfigdirs ${libgcj}"
2522     ;;
2523   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2524     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2525     libgloss_dir=m68hc11
2526     ;;
2527   m68k-*-elf*)
2528     noconfigdirs="$noconfigdirs ${libgcj}"
2529     ;;
2530   m68k-*-coff*)
2531     noconfigdirs="$noconfigdirs ${libgcj}"
2532     ;;
2533   m68*-*-* | fido-*-*)
2534     libgloss_dir=m68k
2535     ;;
2536   mcore-*-pe*)
2537   # The EPOC C++ environment does not support exceptions or rtti,
2538   # and so building libstdc++-v3 tends not to always work.
2539     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2540     ;;
2541   mmix-*-*)
2542     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2543     unsupported_languages="$unsupported_languages fortran java"
2544     ;;
2545   mn10200-*-*)
2546     noconfigdirs="$noconfigdirs ${libgcj}"
2547     ;;
2548   mn10300-*-*)
2549     noconfigdirs="$noconfigdirs ${libgcj}"
2550     ;;
2551   mt-*-*)
2552     noconfigdirs="$noconfigdirs sim"
2553     ;;
2554   powerpc-*-aix*)
2555     # copied from rs6000-*-* entry
2556     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2557     ;;
2558   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2559     target_configdirs="$target_configdirs target-winsup"
2560     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2561     # always build newlib.
2562     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2563     ;;
2564     # This is temporary until we can link against shared libraries
2565   powerpcle-*-solaris*)
2566     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2567     libgloss_dir=rs6000
2568     ;;
2569   powerpc-*-beos*)
2570     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2571     ;;
2572   powerpc-*-eabi)
2573     noconfigdirs="$noconfigdirs ${libgcj}"
2574     libgloss_dir=rs6000
2575     ;;
2576   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2577     libgloss_dir=rs6000
2578     ;;
2579   rs6000-*-lynxos*)
2580     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2581     ;;
2582   rs6000-*-aix*)
2583     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2584     ;;
2585   rs6000-*-*)
2586     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2587     ;;
2588   m68k-apollo-*)
2589     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2590     ;;
2591   mips*-sde-elf*)
2592     skipdirs="$skipdirs target-libiberty"
2593     noconfigdirs="$noconfigdirs ${libgcj}"
2594     if test x$with_newlib = xyes; then
2595       noconfigdirs="$noconfigdirs gprof"
2596     fi
2597     libgloss_dir=mips
2598     ;;
2599   mips*-*-irix5*)
2600     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2601     ;;
2602   mips*-*-irix6*)
2603     # Linking libjava exceeds command-line length limits on at least
2604     # IRIX 6.2, but not on IRIX 6.5.
2605     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2606     # <oldham@codesourcery.com>
2607     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2608     ;;
2609   mips*-*-bsd*)
2610     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2611     ;;
2612   mips*-*-linux*)
2613     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2614     ;;
2615   mips*-*-*)
2616     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2617     libgloss_dir=mips
2618     ;;
2619   romp-*-*)
2620     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2621     ;;
2622   sh-*-* | sh64-*-*)
2623     case "${host}" in
2624       i[3456789]86-*-vsta) ;; # don't add gprof back in
2625       i[3456789]86-*-go32*) ;; # don't add gprof back in
2626       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2627       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2628     esac
2629     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2630     ;;
2631   sparclet-*-aout* | sparc86x-*-*)
2632     libgloss_dir=sparc
2633     ;;
2634   sparc-*-elf*)
2635     noconfigdirs="$noconfigdirs ${libgcj}"
2636     ;;
2637   sparc64-*-elf*)
2638     noconfigdirs="$noconfigdirs ${libgcj}"
2639     libgloss_dir=sparc
2640     ;;
2641   sparclite-*-*)
2642     noconfigdirs="$noconfigdirs ${libgcj}"
2643     libgloss_dir=sparc
2644     ;;
2645   sparc-*-sunos4*)
2646     noconfigdirs="$noconfigdirs ${libgcj}"
2647     if test x${is_cross_compiler} != xno ; then
2648            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2649     else
2650            use_gnu_ld=no
2651     fi
2652     ;;
2653   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2654     noconfigdirs="$noconfigdirs ${libgcj}"
2655     ;;
2656   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2657     ;;
2658   spu-*-*)
2659     skipdirs="target-libssp"
2660     ;;
2661   v810-*-*)
2662     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2663     ;;
2664   v850-*-*)
2665     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2666     ;;
2667   v850e-*-*)
2668     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2669     ;;
2670   v850ea-*-*)
2671     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2672     ;;
2673   vax-*-vms)
2674     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2675     ;;
2676   vax-*-*)
2677     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2678     ;;
2679   xtensa*-*-*)
2680     noconfigdirs="$noconfigdirs ${libgcj}"
2681     ;;
2682   ip2k-*-*)
2683     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2684     ;;
2685   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2686     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2687     ;;
2688   *-*-lynxos*)
2689     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2690     ;;
2691   *-*-*)
2692     noconfigdirs="$noconfigdirs ${libgcj}"
2693     ;;
2694 esac
2695
2696 # If we aren't building newlib, then don't build libgloss, since libgloss
2697 # depends upon some newlib header files.
2698 case "${noconfigdirs}" in
2699   *target-libgloss*) ;;
2700   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2701 esac
2702
2703 # Work in distributions that contain no compiler tools, like Autoconf.
2704 tentative_cc=""
2705 host_makefile_frag=/dev/null
2706 if test -d ${srcdir}/config ; then
2707 case "${host}" in
2708   m68k-hp-hpux*)
2709     # Avoid "too much defining" errors from HPUX compiler.
2710     tentative_cc="cc -Wp,-H256000"
2711     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2712     # If it's HP/UX ar, this should be harmless.
2713     RANLIB="ar ts"
2714     ;;
2715   m68k-apollo-sysv*)
2716     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2717     ;;
2718   m68k-apollo-bsd*)
2719     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2720     # chokes on bfd, the compiler won't let you assign integers to enums, and
2721     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2722     # the apollo compiler" (the preferred version of GCC could be called cc,
2723     # or whatever), but I'm not sure leaving CC as cc is any better...
2724     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2725     # Used to have BISON=yacc.
2726     tentative_cc=gcc
2727     ;;
2728   m88k-dg-dgux*)
2729     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2730     ;;
2731   m88k-harris-cxux*)
2732     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2733     tentative_cc="cc -Xa"
2734     host_makefile_frag="config/mh-cxux"
2735     ;;
2736   m88k-motorola-sysv*)
2737     ;;
2738   mips*-dec-ultrix*)
2739     tentative_cc="cc -Wf,-XNg1000"
2740     host_makefile_frag="config/mh-decstation"
2741     ;;
2742   mips*-nec-sysv4*)
2743     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2744     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2745     host_makefile_frag="config/mh-necv4"
2746     ;;
2747   mips*-sgi-irix4*)
2748     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2749     # environment.  Also bump switch table size so that cp-parse will
2750     # compile.  Bump string length limit so linker builds.
2751     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2752     ;;
2753   mips*-*-sysv4*)
2754     host_makefile_frag="config/mh-sysv4"
2755     ;;
2756   mips*-*-sysv*)
2757     # This is for a MIPS running RISC/os 4.52C.
2758
2759     # This is needed for GDB, but needs to be in the top-level make because
2760     # if a library is compiled with the bsd headers and gets linked with the
2761     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2762     # a different size).
2763     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2764     # known except to select the sysv environment.  Could we use /proc instead?
2765     # These "sysv environments" and "bsd environments" often end up being a pain.
2766     #
2767     # This is not part of CFLAGS because perhaps not all C compilers have this
2768     # option.
2769     tentative_cc="cc -systype sysv"
2770     ;;
2771   i370-ibm-opened*)
2772     tentative_cc="c89"
2773     ;;
2774   i[3456789]86-*-sysv5*)
2775     host_makefile_frag="config/mh-sysv5"
2776     ;;
2777   i[3456789]86-*-dgux*)
2778     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2779     host_makefile_frag="config/mh-dgux386"
2780     ;;
2781   i[3456789]86-ncr-sysv4.3*)
2782     # The MetaWare compiler will generate a copyright message unless you
2783     # turn it off by adding the -Hnocopyr flag.
2784     tentative_cc="cc -Hnocopyr"
2785     ;;
2786   i[3456789]86-ncr-sysv4*)
2787     # for an NCR 3000 (i486/SVR4) system.
2788     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2789     # This compiler not only emits obnoxious copyright messages every time
2790     # you run it, but it chokes and dies on a whole bunch of GNU source
2791     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2792     tentative_cc="/usr/ccs/ATT/cc"
2793     host_makefile_frag="config/mh-ncr3000"
2794     ;;
2795   i[3456789]86-*-sco3.2v5*)
2796     ;;
2797   i[3456789]86-*-sco*)
2798     # The native C compiler botches some simple uses of const.  Unfortunately,
2799     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2800     tentative_cc="cc -Dconst="
2801     host_makefile_frag="config/mh-sco"
2802     ;;
2803   i[3456789]86-*-udk*)
2804     host_makefile_frag="config/mh-sysv5"
2805     ;;
2806   i[3456789]86-*-solaris2*)
2807     host_makefile_frag="config/mh-sysv4"
2808     ;;
2809   i[3456789]86-*-msdosdjgpp*)
2810     host_makefile_frag="config/mh-djgpp"
2811     ;;
2812   *-cygwin*)
2813
2814 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2815 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2816 echo a >cygwin-cat-check
2817 if test `cat cygwin-cat-check` == a ; then
2818   rm cygwin-cat-check
2819   echo "$as_me:$LINENO: result: yes" >&5
2820 echo "${ECHO_T}yes" >&6
2821 else
2822   rm cygwin-cat-check
2823   echo "$as_me:$LINENO: result: no" >&5
2824 echo "${ECHO_T}no" >&6
2825   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2826   Please either mount the build directory in binary mode or run the following
2827   commands before running any configure script:
2828 set -o igncr
2829 export SHELLOPTS
2830   " >&5
2831 echo "$as_me: error: The cat command does not ignore carriage return characters.
2832   Please either mount the build directory in binary mode or run the following
2833   commands before running any configure script:
2834 set -o igncr
2835 export SHELLOPTS
2836   " >&2;}
2837    { (exit 1); exit 1; }; }
2838 fi
2839
2840     host_makefile_frag="config/mh-cygwin"
2841     ;;
2842   *-mingw*)
2843     host_makefile_frag="config/mh-mingw"
2844     ;;
2845   *-interix*)
2846     host_makefile_frag="config/mh-interix"
2847     ;;
2848   vax-*-ultrix2*)
2849     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2850     tentative_cc=gcc
2851     ;;
2852   *-*-solaris2*)
2853     host_makefile_frag="config/mh-solaris"
2854     ;;
2855   m68k-sun-sunos*)
2856     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2857     # without overflowing the jump tables (-J says to use a 32 bit table)
2858     tentative_cc="cc -J"
2859     ;;
2860   hppa*-hp-hpux10*)
2861     tentative_cc="cc -Wp,-H256000"
2862     host_makefile_frag="config/mh-pa-hpux10"
2863     ;;
2864   hppa*-hp-hpux* | hppa*-*-hiux*)
2865     tentative_cc="cc -Wp,-H256000"
2866     host_makefile_frag="config/mh-pa"
2867     ;;
2868   hppa*-*)
2869     host_makefile_frag="config/mh-pa"
2870     ;;
2871   *-hp-hpux* | *-*-hiux*)
2872     tentative_cc="cc -Wp,-H256000"
2873     ;;
2874   rs6000-*-lynxos*)
2875     # /bin/cc is less than useful for our purposes.  Always use GCC
2876     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2877     host_makefile_frag="config/mh-lynxrs6k"
2878     ;;
2879   powerpc-*-darwin*)
2880     host_makefile_frag="config/mh-ppc-darwin"
2881     ;;
2882   powerpc-*-aix*)
2883     host_makefile_frag="config/mh-ppc-aix"
2884     ;;
2885   rs6000-*-aix*)
2886     host_makefile_frag="config/mh-ppc-aix"
2887     ;;
2888   *-*-lynxos*)
2889     # /bin/cc is less than useful for our purposes.  Always use GCC
2890     tentative_cc="/bin/gcc"
2891     ;;
2892   *-*-sysv4*)
2893     host_makefile_frag="config/mh-sysv4"
2894     ;;
2895   # This is placed last to prevent interfering with the cases above.
2896   i[3456789]86-*-*)
2897     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2898     host_makefile_frag="config/mh-x86omitfp"
2899     ;;
2900 esac
2901 fi
2902
2903 # If we aren't going to be using gcc, see if we can extract a definition
2904 # of CC from the fragment.
2905 # Actually, use the 'pre-extracted' version above.
2906 if test -z "${CC}" && test "${build}" = "${host}" ; then
2907   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2908   found=
2909   for dir in $PATH; do
2910     test -z "$dir" && dir=.
2911     if test -f $dir/gcc; then
2912       found=yes
2913       break
2914     fi
2915   done
2916   IFS="$save_ifs"
2917   if test -z "${found}" && test -n "${tentative_cc}" ; then
2918     CC=$tentative_cc
2919   fi
2920 fi
2921
2922 if test "${build}" != "${host}" ; then
2923   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2924   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2925   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2926   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2927   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2928   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2929   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2930   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2931   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2932   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2933   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2934   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2935 else
2936   AR_FOR_BUILD="\$(AR)"
2937   AS_FOR_BUILD="\$(AS)"
2938   CC_FOR_BUILD="\$(CC)"
2939   CXX_FOR_BUILD="\$(CXX)"
2940   GCJ_FOR_BUILD="\$(GCJ)"
2941   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2942   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2943   LD_FOR_BUILD="\$(LD)"
2944   NM_FOR_BUILD="\$(NM)"
2945   RANLIB_FOR_BUILD="\$(RANLIB)"
2946   WINDRES_FOR_BUILD="\$(WINDRES)"
2947   WINDMC_FOR_BUILD="\$(WINDMC)"
2948 fi
2949
2950 ac_ext=c
2951 ac_cpp='$CPP $CPPFLAGS'
2952 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2953 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2954 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2955 if test -n "$ac_tool_prefix"; then
2956   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2957 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2958 echo "$as_me:$LINENO: checking for $ac_word" >&5
2959 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2960 if test "${ac_cv_prog_CC+set}" = set; then
2961   echo $ECHO_N "(cached) $ECHO_C" >&6
2962 else
2963   if test -n "$CC"; then
2964   ac_cv_prog_CC="$CC" # Let the user override the test.
2965 else
2966 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2967 for as_dir in $PATH
2968 do
2969   IFS=$as_save_IFS
2970   test -z "$as_dir" && as_dir=.
2971   for ac_exec_ext in '' $ac_executable_extensions; do
2972   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2973     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2974     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2975     break 2
2976   fi
2977 done
2978 done
2979
2980 fi
2981 fi
2982 CC=$ac_cv_prog_CC
2983 if test -n "$CC"; then
2984   echo "$as_me:$LINENO: result: $CC" >&5
2985 echo "${ECHO_T}$CC" >&6
2986 else
2987   echo "$as_me:$LINENO: result: no" >&5
2988 echo "${ECHO_T}no" >&6
2989 fi
2990
2991 fi
2992 if test -z "$ac_cv_prog_CC"; then
2993   ac_ct_CC=$CC
2994   # Extract the first word of "gcc", so it can be a program name with args.
2995 set dummy gcc; ac_word=$2
2996 echo "$as_me:$LINENO: checking for $ac_word" >&5
2997 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2998 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2999   echo $ECHO_N "(cached) $ECHO_C" >&6
3000 else
3001   if test -n "$ac_ct_CC"; then
3002   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3003 else
3004 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3005 for as_dir in $PATH
3006 do
3007   IFS=$as_save_IFS
3008   test -z "$as_dir" && as_dir=.
3009   for ac_exec_ext in '' $ac_executable_extensions; do
3010   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3011     ac_cv_prog_ac_ct_CC="gcc"
3012     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3013     break 2
3014   fi
3015 done
3016 done
3017
3018 fi
3019 fi
3020 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3021 if test -n "$ac_ct_CC"; then
3022   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3023 echo "${ECHO_T}$ac_ct_CC" >&6
3024 else
3025   echo "$as_me:$LINENO: result: no" >&5
3026 echo "${ECHO_T}no" >&6
3027 fi
3028
3029   CC=$ac_ct_CC
3030 else
3031   CC="$ac_cv_prog_CC"
3032 fi
3033
3034 if test -z "$CC"; then
3035   if test -n "$ac_tool_prefix"; then
3036   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3037 set dummy ${ac_tool_prefix}cc; ac_word=$2
3038 echo "$as_me:$LINENO: checking for $ac_word" >&5
3039 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3040 if test "${ac_cv_prog_CC+set}" = set; then
3041   echo $ECHO_N "(cached) $ECHO_C" >&6
3042 else
3043   if test -n "$CC"; then
3044   ac_cv_prog_CC="$CC" # Let the user override the test.
3045 else
3046 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3047 for as_dir in $PATH
3048 do
3049   IFS=$as_save_IFS
3050   test -z "$as_dir" && as_dir=.
3051   for ac_exec_ext in '' $ac_executable_extensions; do
3052   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3053     ac_cv_prog_CC="${ac_tool_prefix}cc"
3054     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3055     break 2
3056   fi
3057 done
3058 done
3059
3060 fi
3061 fi
3062 CC=$ac_cv_prog_CC
3063 if test -n "$CC"; then
3064   echo "$as_me:$LINENO: result: $CC" >&5
3065 echo "${ECHO_T}$CC" >&6
3066 else
3067   echo "$as_me:$LINENO: result: no" >&5
3068 echo "${ECHO_T}no" >&6
3069 fi
3070
3071 fi
3072 if test -z "$ac_cv_prog_CC"; then
3073   ac_ct_CC=$CC
3074   # Extract the first word of "cc", so it can be a program name with args.
3075 set dummy cc; ac_word=$2
3076 echo "$as_me:$LINENO: checking for $ac_word" >&5
3077 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3078 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3079   echo $ECHO_N "(cached) $ECHO_C" >&6
3080 else
3081   if test -n "$ac_ct_CC"; then
3082   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3083 else
3084 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3085 for as_dir in $PATH
3086 do
3087   IFS=$as_save_IFS
3088   test -z "$as_dir" && as_dir=.
3089   for ac_exec_ext in '' $ac_executable_extensions; do
3090   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3091     ac_cv_prog_ac_ct_CC="cc"
3092     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3093     break 2
3094   fi
3095 done
3096 done
3097
3098 fi
3099 fi
3100 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3101 if test -n "$ac_ct_CC"; then
3102   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3103 echo "${ECHO_T}$ac_ct_CC" >&6
3104 else
3105   echo "$as_me:$LINENO: result: no" >&5
3106 echo "${ECHO_T}no" >&6
3107 fi
3108
3109   CC=$ac_ct_CC
3110 else
3111   CC="$ac_cv_prog_CC"
3112 fi
3113
3114 fi
3115 if test -z "$CC"; then
3116   # Extract the first word of "cc", so it can be a program name with args.
3117 set dummy cc; ac_word=$2
3118 echo "$as_me:$LINENO: checking for $ac_word" >&5
3119 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3120 if test "${ac_cv_prog_CC+set}" = set; then
3121   echo $ECHO_N "(cached) $ECHO_C" >&6
3122 else
3123   if test -n "$CC"; then
3124   ac_cv_prog_CC="$CC" # Let the user override the test.
3125 else
3126   ac_prog_rejected=no
3127 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3128 for as_dir in $PATH
3129 do
3130   IFS=$as_save_IFS
3131   test -z "$as_dir" && as_dir=.
3132   for ac_exec_ext in '' $ac_executable_extensions; do
3133   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3134     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3135        ac_prog_rejected=yes
3136        continue
3137      fi
3138     ac_cv_prog_CC="cc"
3139     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3140     break 2
3141   fi
3142 done
3143 done
3144
3145 if test $ac_prog_rejected = yes; then
3146   # We found a bogon in the path, so make sure we never use it.
3147   set dummy $ac_cv_prog_CC
3148   shift
3149   if test $# != 0; then
3150     # We chose a different compiler from the bogus one.
3151     # However, it has the same basename, so the bogon will be chosen
3152     # first if we set CC to just the basename; use the full file name.
3153     shift
3154     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3155   fi
3156 fi
3157 fi
3158 fi
3159 CC=$ac_cv_prog_CC
3160 if test -n "$CC"; then
3161   echo "$as_me:$LINENO: result: $CC" >&5
3162 echo "${ECHO_T}$CC" >&6
3163 else
3164   echo "$as_me:$LINENO: result: no" >&5
3165 echo "${ECHO_T}no" >&6
3166 fi
3167
3168 fi
3169 if test -z "$CC"; then
3170   if test -n "$ac_tool_prefix"; then
3171   for ac_prog in cl
3172   do
3173     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3174 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3175 echo "$as_me:$LINENO: checking for $ac_word" >&5
3176 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3177 if test "${ac_cv_prog_CC+set}" = set; then
3178   echo $ECHO_N "(cached) $ECHO_C" >&6
3179 else
3180   if test -n "$CC"; then
3181   ac_cv_prog_CC="$CC" # Let the user override the test.
3182 else
3183 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3184 for as_dir in $PATH
3185 do
3186   IFS=$as_save_IFS
3187   test -z "$as_dir" && as_dir=.
3188   for ac_exec_ext in '' $ac_executable_extensions; do
3189   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3190     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3191     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3192     break 2
3193   fi
3194 done
3195 done
3196
3197 fi
3198 fi
3199 CC=$ac_cv_prog_CC
3200 if test -n "$CC"; then
3201   echo "$as_me:$LINENO: result: $CC" >&5
3202 echo "${ECHO_T}$CC" >&6
3203 else
3204   echo "$as_me:$LINENO: result: no" >&5
3205 echo "${ECHO_T}no" >&6
3206 fi
3207
3208     test -n "$CC" && break
3209   done
3210 fi
3211 if test -z "$CC"; then
3212   ac_ct_CC=$CC
3213   for ac_prog in cl
3214 do
3215   # Extract the first word of "$ac_prog", so it can be a program name with args.
3216 set dummy $ac_prog; ac_word=$2
3217 echo "$as_me:$LINENO: checking for $ac_word" >&5
3218 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3219 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3220   echo $ECHO_N "(cached) $ECHO_C" >&6
3221 else
3222   if test -n "$ac_ct_CC"; then
3223   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3224 else
3225 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3226 for as_dir in $PATH
3227 do
3228   IFS=$as_save_IFS
3229   test -z "$as_dir" && as_dir=.
3230   for ac_exec_ext in '' $ac_executable_extensions; do
3231   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3232     ac_cv_prog_ac_ct_CC="$ac_prog"
3233     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3234     break 2
3235   fi
3236 done
3237 done
3238
3239 fi
3240 fi
3241 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3242 if test -n "$ac_ct_CC"; then
3243   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3244 echo "${ECHO_T}$ac_ct_CC" >&6
3245 else
3246   echo "$as_me:$LINENO: result: no" >&5
3247 echo "${ECHO_T}no" >&6
3248 fi
3249
3250   test -n "$ac_ct_CC" && break
3251 done
3252
3253   CC=$ac_ct_CC
3254 fi
3255
3256 fi
3257
3258
3259 test -z "$CC" && { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3260 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3261 { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3262 See \`config.log' for more details." >&5
3263 echo "$as_me: error: no acceptable C compiler found in \$PATH
3264 See \`config.log' for more details." >&2;}
3265    { (exit 1); exit 1; }; }; }
3266
3267 # Provide some information about the compiler.
3268 echo "$as_me:$LINENO:" \
3269      "checking for C compiler version" >&5
3270 ac_compiler=`set X $ac_compile; echo $2`
3271 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3272   (eval $ac_compiler --version </dev/null >&5) 2>&5
3273   ac_status=$?
3274   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3275   (exit $ac_status); }
3276 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3277   (eval $ac_compiler -v </dev/null >&5) 2>&5
3278   ac_status=$?
3279   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3280   (exit $ac_status); }
3281 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3282   (eval $ac_compiler -V </dev/null >&5) 2>&5
3283   ac_status=$?
3284   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3285   (exit $ac_status); }
3286
3287 cat >conftest.$ac_ext <<_ACEOF
3288 /* confdefs.h.  */
3289 _ACEOF
3290 cat confdefs.h >>conftest.$ac_ext
3291 cat >>conftest.$ac_ext <<_ACEOF
3292 /* end confdefs.h.  */
3293
3294 int
3295 main ()
3296 {
3297
3298   ;
3299   return 0;
3300 }
3301 _ACEOF
3302 ac_clean_files_save=$ac_clean_files
3303 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3304 # Try to create an executable without -o first, disregard a.out.
3305 # It will help us diagnose broken compilers, and finding out an intuition
3306 # of exeext.
3307 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3308 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3309 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3310 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3311   (eval $ac_link_default) 2>&5
3312   ac_status=$?
3313   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3314   (exit $ac_status); }; then
3315   # Find the output, starting from the most likely.  This scheme is
3316 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3317 # resort.
3318
3319 # Be careful to initialize this variable, since it used to be cached.
3320 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3321 ac_cv_exeext=
3322 # b.out is created by i960 compilers.
3323 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3324 do
3325   test -f "$ac_file" || continue
3326   case $ac_file in
3327     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3328         ;;
3329     conftest.$ac_ext )
3330         # This is the source file.
3331         ;;
3332     [ab].out )
3333         # We found the default executable, but exeext='' is most
3334         # certainly right.
3335         break;;
3336     *.* )
3337         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3338         # FIXME: I believe we export ac_cv_exeext for Libtool,
3339         # but it would be cool to find out if it's true.  Does anybody
3340         # maintain Libtool? --akim.
3341         export ac_cv_exeext
3342         break;;
3343     * )
3344         break;;
3345   esac
3346 done
3347 else
3348   echo "$as_me: failed program was:" >&5
3349 sed 's/^/| /' conftest.$ac_ext >&5
3350
3351 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3352 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3353 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3354 See \`config.log' for more details." >&5
3355 echo "$as_me: error: C compiler cannot create executables
3356 See \`config.log' for more details." >&2;}
3357    { (exit 77); exit 77; }; }; }
3358 fi
3359
3360 ac_exeext=$ac_cv_exeext
3361 echo "$as_me:$LINENO: result: $ac_file" >&5
3362 echo "${ECHO_T}$ac_file" >&6
3363
3364 # Check the compiler produces executables we can run.  If not, either
3365 # the compiler is broken, or we cross compile.
3366 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3367 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3368 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3369 # If not cross compiling, check that we can run a simple program.
3370 if test "$cross_compiling" != yes; then
3371   if { ac_try='./$ac_file'
3372   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3373   (eval $ac_try) 2>&5
3374   ac_status=$?
3375   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3376   (exit $ac_status); }; }; then
3377     cross_compiling=no
3378   else
3379     if test "$cross_compiling" = maybe; then
3380         cross_compiling=yes
3381     else
3382         { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3383 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3384 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3385 If you meant to cross compile, use \`--host'.
3386 See \`config.log' for more details." >&5
3387 echo "$as_me: error: cannot run C compiled programs.
3388 If you meant to cross compile, use \`--host'.
3389 See \`config.log' for more details." >&2;}
3390    { (exit 1); exit 1; }; }; }
3391     fi
3392   fi
3393 fi
3394 echo "$as_me:$LINENO: result: yes" >&5
3395 echo "${ECHO_T}yes" >&6
3396
3397 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3398 ac_clean_files=$ac_clean_files_save
3399 # Check the compiler produces executables we can run.  If not, either
3400 # the compiler is broken, or we cross compile.
3401 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3402 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3403 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3404 echo "${ECHO_T}$cross_compiling" >&6
3405
3406 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3407 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3408 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3409   (eval $ac_link) 2>&5
3410   ac_status=$?
3411   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3412   (exit $ac_status); }; then
3413   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3414 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3415 # work properly (i.e., refer to `conftest.exe'), while it won't with
3416 # `rm'.
3417 for ac_file in conftest.exe conftest conftest.*; do
3418   test -f "$ac_file" || continue
3419   case $ac_file in
3420     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3421     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3422           export ac_cv_exeext
3423           break;;
3424     * ) break;;
3425   esac
3426 done
3427 else
3428   { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3429 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3430 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3431 See \`config.log' for more details." >&5
3432 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3433 See \`config.log' for more details." >&2;}
3434    { (exit 1); exit 1; }; }; }
3435 fi
3436
3437 rm -f conftest$ac_cv_exeext
3438 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3439 echo "${ECHO_T}$ac_cv_exeext" >&6
3440
3441 rm -f conftest.$ac_ext
3442 EXEEXT=$ac_cv_exeext
3443 ac_exeext=$EXEEXT
3444 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3445 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3446 if test "${ac_cv_objext+set}" = set; then
3447   echo $ECHO_N "(cached) $ECHO_C" >&6
3448 else
3449   cat >conftest.$ac_ext <<_ACEOF
3450 /* confdefs.h.  */
3451 _ACEOF
3452 cat confdefs.h >>conftest.$ac_ext
3453 cat >>conftest.$ac_ext <<_ACEOF
3454 /* end confdefs.h.  */
3455
3456 int
3457 main ()
3458 {
3459
3460   ;
3461   return 0;
3462 }
3463 _ACEOF
3464 rm -f conftest.o conftest.obj
3465 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3466   (eval $ac_compile) 2>&5
3467   ac_status=$?
3468   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3469   (exit $ac_status); }; then
3470   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3471   case $ac_file in
3472     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3473     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3474        break;;
3475   esac
3476 done
3477 else
3478   echo "$as_me: failed program was:" >&5
3479 sed 's/^/| /' conftest.$ac_ext >&5
3480
3481 { { echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3482 echo "$as_me: error: in \`$ac_pwd':" >&2;}
3483 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3484 See \`config.log' for more details." >&5
3485 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3486 See \`config.log' for more details." >&2;}
3487    { (exit 1); exit 1; }; }; }
3488 fi
3489
3490 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3491 fi
3492 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3493 echo "${ECHO_T}$ac_cv_objext" >&6
3494 OBJEXT=$ac_cv_objext
3495 ac_objext=$OBJEXT
3496 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3497 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3498 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3499   echo $ECHO_N "(cached) $ECHO_C" >&6
3500 else
3501   cat >conftest.$ac_ext <<_ACEOF
3502 /* confdefs.h.  */
3503 _ACEOF
3504 cat confdefs.h >>conftest.$ac_ext
3505 cat >>conftest.$ac_ext <<_ACEOF
3506 /* end confdefs.h.  */
3507
3508 int
3509 main ()
3510 {
3511 #ifndef __GNUC__
3512        choke me
3513 #endif
3514
3515   ;
3516   return 0;
3517 }
3518 _ACEOF
3519 rm -f conftest.$ac_objext
3520 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3521   (eval $ac_compile) 2>conftest.er1
3522   ac_status=$?
3523   grep -v '^ *+' conftest.er1 >conftest.err
3524   rm -f conftest.er1
3525   cat conftest.err >&5
3526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3527   (exit $ac_status); } &&
3528          { ac_try='test -z "$ac_c_werror_flag"
3529                          || test ! -s conftest.err'
3530   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3531   (eval $ac_try) 2>&5
3532   ac_status=$?
3533   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3534   (exit $ac_status); }; } &&
3535          { ac_try='test -s conftest.$ac_objext'
3536   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3537   (eval $ac_try) 2>&5
3538   ac_status=$?
3539   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3540   (exit $ac_status); }; }; then
3541   ac_compiler_gnu=yes
3542 else
3543   echo "$as_me: failed program was:" >&5
3544 sed 's/^/| /' conftest.$ac_ext >&5
3545
3546 ac_compiler_gnu=no
3547 fi
3548 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3549 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3550
3551 fi
3552 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3553 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3554 GCC=`test $ac_compiler_gnu = yes && echo yes`
3555 ac_test_CFLAGS=${CFLAGS+set}
3556 ac_save_CFLAGS=$CFLAGS
3557 CFLAGS="-g"
3558 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3559 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3560 if test "${ac_cv_prog_cc_g+set}" = set; then
3561   echo $ECHO_N "(cached) $ECHO_C" >&6
3562 else
3563   cat >conftest.$ac_ext <<_ACEOF
3564 /* confdefs.h.  */
3565 _ACEOF
3566 cat confdefs.h >>conftest.$ac_ext
3567 cat >>conftest.$ac_ext <<_ACEOF
3568 /* end confdefs.h.  */
3569
3570 int
3571 main ()
3572 {
3573
3574   ;
3575   return 0;
3576 }
3577 _ACEOF
3578 rm -f conftest.$ac_objext
3579 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3580   (eval $ac_compile) 2>conftest.er1
3581   ac_status=$?
3582   grep -v '^ *+' conftest.er1 >conftest.err
3583   rm -f conftest.er1
3584   cat conftest.err >&5
3585   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3586   (exit $ac_status); } &&
3587          { ac_try='test -z "$ac_c_werror_flag"
3588                          || test ! -s conftest.err'
3589   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3590   (eval $ac_try) 2>&5
3591   ac_status=$?
3592   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3593   (exit $ac_status); }; } &&
3594          { ac_try='test -s conftest.$ac_objext'
3595   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3596   (eval $ac_try) 2>&5
3597   ac_status=$?
3598   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3599   (exit $ac_status); }; }; then
3600   ac_cv_prog_cc_g=yes
3601 else
3602   echo "$as_me: failed program was:" >&5
3603 sed 's/^/| /' conftest.$ac_ext >&5
3604
3605 ac_cv_prog_cc_g=no
3606 fi
3607 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3608 fi
3609 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3610 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3611 if test "$ac_test_CFLAGS" = set; then
3612   CFLAGS=$ac_save_CFLAGS
3613 elif test $ac_cv_prog_cc_g = yes; then
3614   if test "$GCC" = yes; then
3615     CFLAGS="-g -O2"
3616   else
3617     CFLAGS="-g"
3618   fi
3619 else
3620   if test "$GCC" = yes; then
3621     CFLAGS="-O2"
3622   else
3623     CFLAGS=
3624   fi
3625 fi
3626 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3627 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3628 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3629   echo $ECHO_N "(cached) $ECHO_C" >&6
3630 else
3631   ac_cv_prog_cc_stdc=no
3632 ac_save_CC=$CC
3633 cat >conftest.$ac_ext <<_ACEOF
3634 /* confdefs.h.  */
3635 _ACEOF
3636 cat confdefs.h >>conftest.$ac_ext
3637 cat >>conftest.$ac_ext <<_ACEOF
3638 /* end confdefs.h.  */
3639 #include <stdarg.h>
3640 #include <stdio.h>
3641 #include <sys/types.h>
3642 #include <sys/stat.h>
3643 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3644 struct buf { int x; };
3645 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3646 static char *e (p, i)
3647      char **p;
3648      int i;
3649 {
3650   return p[i];
3651 }
3652 static char *f (char * (*g) (char **, int), char **p, ...)
3653 {
3654   char *s;
3655   va_list v;
3656   va_start (v,p);
3657   s = g (p, va_arg (v,int));
3658   va_end (v);
3659   return s;
3660 }
3661
3662 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3663    function prototypes and stuff, but not '\xHH' hex character constants.
3664    These don't provoke an error unfortunately, instead are silently treated
3665    as 'x'.  The following induces an error, until -std1 is added to get
3666    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3667    array size at least.  It's necessary to write '\x00'==0 to get something
3668    that's true only with -std1.  */
3669 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3670
3671 int test (int i, double x);
3672 struct s1 {int (*f) (int a);};
3673 struct s2 {int (*f) (double a);};
3674 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3675 int argc;
3676 char **argv;
3677 int
3678 main ()
3679 {
3680 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3681   ;
3682   return 0;
3683 }
3684 _ACEOF
3685 # Don't try gcc -ansi; that turns off useful extensions and
3686 # breaks some systems' header files.
3687 # AIX                   -qlanglvl=ansi
3688 # Ultrix and OSF/1      -std1
3689 # HP-UX 10.20 and later -Ae
3690 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3691 # SVR4                  -Xc -D__EXTENSIONS__
3692 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3693 do
3694   CC="$ac_save_CC $ac_arg"
3695   rm -f conftest.$ac_objext
3696 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3697   (eval $ac_compile) 2>conftest.er1
3698   ac_status=$?
3699   grep -v '^ *+' conftest.er1 >conftest.err
3700   rm -f conftest.er1
3701   cat conftest.err >&5
3702   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3703   (exit $ac_status); } &&
3704          { ac_try='test -z "$ac_c_werror_flag"
3705                          || test ! -s conftest.err'
3706   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3707   (eval $ac_try) 2>&5
3708   ac_status=$?
3709   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3710   (exit $ac_status); }; } &&
3711          { ac_try='test -s conftest.$ac_objext'
3712   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3713   (eval $ac_try) 2>&5
3714   ac_status=$?
3715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3716   (exit $ac_status); }; }; then
3717   ac_cv_prog_cc_stdc=$ac_arg
3718 break
3719 else
3720   echo "$as_me: failed program was:" >&5
3721 sed 's/^/| /' conftest.$ac_ext >&5
3722
3723 fi
3724 rm -f conftest.err conftest.$ac_objext
3725 done
3726 rm -f conftest.$ac_ext conftest.$ac_objext
3727 CC=$ac_save_CC
3728
3729 fi
3730
3731 case "x$ac_cv_prog_cc_stdc" in
3732   x|xno)
3733     echo "$as_me:$LINENO: result: none needed" >&5
3734 echo "${ECHO_T}none needed" >&6 ;;
3735   *)
3736     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3737 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3738     CC="$CC $ac_cv_prog_cc_stdc" ;;
3739 esac
3740
3741 # Some people use a C++ compiler to compile C.  Since we use `exit',
3742 # in C++ we need to declare it.  In case someone uses the same compiler
3743 # for both compiling C and C++ we need to have the C++ compiler decide
3744 # the declaration of exit, since it's the most demanding environment.
3745 cat >conftest.$ac_ext <<_ACEOF
3746 #ifndef __cplusplus
3747   choke me
3748 #endif
3749 _ACEOF
3750 rm -f conftest.$ac_objext
3751 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3752   (eval $ac_compile) 2>conftest.er1
3753   ac_status=$?
3754   grep -v '^ *+' conftest.er1 >conftest.err
3755   rm -f conftest.er1
3756   cat conftest.err >&5
3757   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3758   (exit $ac_status); } &&
3759          { ac_try='test -z "$ac_c_werror_flag"
3760                          || test ! -s conftest.err'
3761   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3762   (eval $ac_try) 2>&5
3763   ac_status=$?
3764   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3765   (exit $ac_status); }; } &&
3766          { ac_try='test -s conftest.$ac_objext'
3767   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3768   (eval $ac_try) 2>&5
3769   ac_status=$?
3770   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3771   (exit $ac_status); }; }; then
3772   for ac_declaration in \
3773    '' \
3774    'extern "C" void std::exit (int) throw (); using std::exit;' \
3775    'extern "C" void std::exit (int); using std::exit;' \
3776    'extern "C" void exit (int) throw ();' \
3777    'extern "C" void exit (int);' \
3778    'void exit (int);'
3779 do
3780   cat >conftest.$ac_ext <<_ACEOF
3781 /* confdefs.h.  */
3782 _ACEOF
3783 cat confdefs.h >>conftest.$ac_ext
3784 cat >>conftest.$ac_ext <<_ACEOF
3785 /* end confdefs.h.  */
3786 $ac_declaration
3787 #include <stdlib.h>
3788 int
3789 main ()
3790 {
3791 exit (42);
3792   ;
3793   return 0;
3794 }
3795 _ACEOF
3796 rm -f conftest.$ac_objext
3797 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3798   (eval $ac_compile) 2>conftest.er1
3799   ac_status=$?
3800   grep -v '^ *+' conftest.er1 >conftest.err
3801   rm -f conftest.er1
3802   cat conftest.err >&5
3803   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3804   (exit $ac_status); } &&
3805          { ac_try='test -z "$ac_c_werror_flag"
3806                          || test ! -s conftest.err'
3807   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3808   (eval $ac_try) 2>&5
3809   ac_status=$?
3810   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3811   (exit $ac_status); }; } &&
3812          { ac_try='test -s conftest.$ac_objext'
3813   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3814   (eval $ac_try) 2>&5
3815   ac_status=$?
3816   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3817   (exit $ac_status); }; }; then
3818   :
3819 else
3820   echo "$as_me: failed program was:" >&5
3821 sed 's/^/| /' conftest.$ac_ext >&5
3822
3823 continue
3824 fi
3825 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3826   cat >conftest.$ac_ext <<_ACEOF
3827 /* confdefs.h.  */
3828 _ACEOF
3829 cat confdefs.h >>conftest.$ac_ext
3830 cat >>conftest.$ac_ext <<_ACEOF
3831 /* end confdefs.h.  */
3832 $ac_declaration
3833 int
3834 main ()
3835 {
3836 exit (42);
3837   ;
3838   return 0;
3839 }
3840 _ACEOF
3841 rm -f conftest.$ac_objext
3842 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3843   (eval $ac_compile) 2>conftest.er1
3844   ac_status=$?
3845   grep -v '^ *+' conftest.er1 >conftest.err
3846   rm -f conftest.er1
3847   cat conftest.err >&5
3848   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3849   (exit $ac_status); } &&
3850          { ac_try='test -z "$ac_c_werror_flag"
3851                          || test ! -s conftest.err'
3852   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3853   (eval $ac_try) 2>&5
3854   ac_status=$?
3855   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3856   (exit $ac_status); }; } &&
3857          { ac_try='test -s conftest.$ac_objext'
3858   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3859   (eval $ac_try) 2>&5
3860   ac_status=$?
3861   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3862   (exit $ac_status); }; }; then
3863   break
3864 else
3865   echo "$as_me: failed program was:" >&5
3866 sed 's/^/| /' conftest.$ac_ext >&5
3867
3868 fi
3869 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3870 done
3871 rm -f conftest*
3872 if test -n "$ac_declaration"; then
3873   echo '#ifdef __cplusplus' >>confdefs.h
3874   echo $ac_declaration      >>confdefs.h
3875   echo '#endif'             >>confdefs.h
3876 fi
3877
3878 else
3879   echo "$as_me: failed program was:" >&5
3880 sed 's/^/| /' conftest.$ac_ext >&5
3881
3882 fi
3883 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3884 ac_ext=c
3885 ac_cpp='$CPP $CPPFLAGS'
3886 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3887 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3888 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3889
3890 ac_ext=cc
3891 ac_cpp='$CXXCPP $CPPFLAGS'
3892 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3893 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3894 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3895 if test -n "$ac_tool_prefix"; then
3896   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3897   do
3898     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3899 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3900 echo "$as_me:$LINENO: checking for $ac_word" >&5
3901 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3902 if test "${ac_cv_prog_CXX+set}" = set; then
3903   echo $ECHO_N "(cached) $ECHO_C" >&6
3904 else
3905   if test -n "$CXX"; then
3906   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3907 else
3908 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3909 for as_dir in $PATH
3910 do
3911   IFS=$as_save_IFS
3912   test -z "$as_dir" && as_dir=.
3913   for ac_exec_ext in '' $ac_executable_extensions; do
3914   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3915     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3916     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3917     break 2
3918   fi
3919 done
3920 done
3921
3922 fi
3923 fi
3924 CXX=$ac_cv_prog_CXX
3925 if test -n "$CXX"; then
3926   echo "$as_me:$LINENO: result: $CXX" >&5
3927 echo "${ECHO_T}$CXX" >&6
3928 else
3929   echo "$as_me:$LINENO: result: no" >&5
3930 echo "${ECHO_T}no" >&6
3931 fi
3932
3933     test -n "$CXX" && break
3934   done
3935 fi
3936 if test -z "$CXX"; then
3937   ac_ct_CXX=$CXX
3938   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3939 do
3940   # Extract the first word of "$ac_prog", so it can be a program name with args.
3941 set dummy $ac_prog; ac_word=$2
3942 echo "$as_me:$LINENO: checking for $ac_word" >&5
3943 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3944 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3945   echo $ECHO_N "(cached) $ECHO_C" >&6
3946 else
3947   if test -n "$ac_ct_CXX"; then
3948   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3949 else
3950 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3951 for as_dir in $PATH
3952 do
3953   IFS=$as_save_IFS
3954   test -z "$as_dir" && as_dir=.
3955   for ac_exec_ext in '' $ac_executable_extensions; do
3956   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3957     ac_cv_prog_ac_ct_CXX="$ac_prog"
3958     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3959     break 2
3960   fi
3961 done
3962 done
3963
3964 fi
3965 fi
3966 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3967 if test -n "$ac_ct_CXX"; then
3968   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3969 echo "${ECHO_T}$ac_ct_CXX" >&6
3970 else
3971   echo "$as_me:$LINENO: result: no" >&5
3972 echo "${ECHO_T}no" >&6
3973 fi
3974
3975   test -n "$ac_ct_CXX" && break
3976 done
3977 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3978
3979   CXX=$ac_ct_CXX
3980 fi
3981
3982
3983 # Provide some information about the compiler.
3984 echo "$as_me:$LINENO:" \
3985      "checking for C++ compiler version" >&5
3986 ac_compiler=`set X $ac_compile; echo $2`
3987 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3988   (eval $ac_compiler --version </dev/null >&5) 2>&5
3989   ac_status=$?
3990   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3991   (exit $ac_status); }
3992 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3993   (eval $ac_compiler -v </dev/null >&5) 2>&5
3994   ac_status=$?
3995   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3996   (exit $ac_status); }
3997 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3998   (eval $ac_compiler -V </dev/null >&5) 2>&5
3999   ac_status=$?
4000   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4001   (exit $ac_status); }
4002
4003 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
4004 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
4005 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
4006   echo $ECHO_N "(cached) $ECHO_C" >&6
4007 else
4008   cat >conftest.$ac_ext <<_ACEOF
4009 /* confdefs.h.  */
4010 _ACEOF
4011 cat confdefs.h >>conftest.$ac_ext
4012 cat >>conftest.$ac_ext <<_ACEOF
4013 /* end confdefs.h.  */
4014
4015 int
4016 main ()
4017 {
4018 #ifndef __GNUC__
4019        choke me
4020 #endif
4021
4022   ;
4023   return 0;
4024 }
4025 _ACEOF
4026 rm -f conftest.$ac_objext
4027 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4028   (eval $ac_compile) 2>conftest.er1
4029   ac_status=$?
4030   grep -v '^ *+' conftest.er1 >conftest.err
4031   rm -f conftest.er1
4032   cat conftest.err >&5
4033   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4034   (exit $ac_status); } &&
4035          { ac_try='test -z "$ac_cxx_werror_flag"
4036                          || test ! -s conftest.err'
4037   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4038   (eval $ac_try) 2>&5
4039   ac_status=$?
4040   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4041   (exit $ac_status); }; } &&
4042          { ac_try='test -s conftest.$ac_objext'
4043   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4044   (eval $ac_try) 2>&5
4045   ac_status=$?
4046   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4047   (exit $ac_status); }; }; then
4048   ac_compiler_gnu=yes
4049 else
4050   echo "$as_me: failed program was:" >&5
4051 sed 's/^/| /' conftest.$ac_ext >&5
4052
4053 ac_compiler_gnu=no
4054 fi
4055 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4056 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4057
4058 fi
4059 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4060 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4061 GXX=`test $ac_compiler_gnu = yes && echo yes`
4062 ac_test_CXXFLAGS=${CXXFLAGS+set}
4063 ac_save_CXXFLAGS=$CXXFLAGS
4064 CXXFLAGS="-g"
4065 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4066 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4067 if test "${ac_cv_prog_cxx_g+set}" = set; then
4068   echo $ECHO_N "(cached) $ECHO_C" >&6
4069 else
4070   cat >conftest.$ac_ext <<_ACEOF
4071 /* confdefs.h.  */
4072 _ACEOF
4073 cat confdefs.h >>conftest.$ac_ext
4074 cat >>conftest.$ac_ext <<_ACEOF
4075 /* end confdefs.h.  */
4076
4077 int
4078 main ()
4079 {
4080
4081   ;
4082   return 0;
4083 }
4084 _ACEOF
4085 rm -f conftest.$ac_objext
4086 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4087   (eval $ac_compile) 2>conftest.er1
4088   ac_status=$?
4089   grep -v '^ *+' conftest.er1 >conftest.err
4090   rm -f conftest.er1
4091   cat conftest.err >&5
4092   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4093   (exit $ac_status); } &&
4094          { ac_try='test -z "$ac_cxx_werror_flag"
4095                          || test ! -s conftest.err'
4096   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4097   (eval $ac_try) 2>&5
4098   ac_status=$?
4099   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4100   (exit $ac_status); }; } &&
4101          { ac_try='test -s conftest.$ac_objext'
4102   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4103   (eval $ac_try) 2>&5
4104   ac_status=$?
4105   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4106   (exit $ac_status); }; }; then
4107   ac_cv_prog_cxx_g=yes
4108 else
4109   echo "$as_me: failed program was:" >&5
4110 sed 's/^/| /' conftest.$ac_ext >&5
4111
4112 ac_cv_prog_cxx_g=no
4113 fi
4114 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4115 fi
4116 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4117 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4118 if test "$ac_test_CXXFLAGS" = set; then
4119   CXXFLAGS=$ac_save_CXXFLAGS
4120 elif test $ac_cv_prog_cxx_g = yes; then
4121   if test "$GXX" = yes; then
4122     CXXFLAGS="-g -O2"
4123   else
4124     CXXFLAGS="-g"
4125   fi
4126 else
4127   if test "$GXX" = yes; then
4128     CXXFLAGS="-O2"
4129   else
4130     CXXFLAGS=
4131   fi
4132 fi
4133 for ac_declaration in \
4134    '' \
4135    'extern "C" void std::exit (int) throw (); using std::exit;' \
4136    'extern "C" void std::exit (int); using std::exit;' \
4137    'extern "C" void exit (int) throw ();' \
4138    'extern "C" void exit (int);' \
4139    'void exit (int);'
4140 do
4141   cat >conftest.$ac_ext <<_ACEOF
4142 /* confdefs.h.  */
4143 _ACEOF
4144 cat confdefs.h >>conftest.$ac_ext
4145 cat >>conftest.$ac_ext <<_ACEOF
4146 /* end confdefs.h.  */
4147 $ac_declaration
4148 #include <stdlib.h>
4149 int
4150 main ()
4151 {
4152 exit (42);
4153   ;
4154   return 0;
4155 }
4156 _ACEOF
4157 rm -f conftest.$ac_objext
4158 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4159   (eval $ac_compile) 2>conftest.er1
4160   ac_status=$?
4161   grep -v '^ *+' conftest.er1 >conftest.err
4162   rm -f conftest.er1
4163   cat conftest.err >&5
4164   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4165   (exit $ac_status); } &&
4166          { ac_try='test -z "$ac_cxx_werror_flag"
4167                          || test ! -s conftest.err'
4168   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4169   (eval $ac_try) 2>&5
4170   ac_status=$?
4171   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4172   (exit $ac_status); }; } &&
4173          { ac_try='test -s conftest.$ac_objext'
4174   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4175   (eval $ac_try) 2>&5
4176   ac_status=$?
4177   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4178   (exit $ac_status); }; }; then
4179   :
4180 else
4181   echo "$as_me: failed program was:" >&5
4182 sed 's/^/| /' conftest.$ac_ext >&5
4183
4184 continue
4185 fi
4186 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4187   cat >conftest.$ac_ext <<_ACEOF
4188 /* confdefs.h.  */
4189 _ACEOF
4190 cat confdefs.h >>conftest.$ac_ext
4191 cat >>conftest.$ac_ext <<_ACEOF
4192 /* end confdefs.h.  */
4193 $ac_declaration
4194 int
4195 main ()
4196 {
4197 exit (42);
4198   ;
4199   return 0;
4200 }
4201 _ACEOF
4202 rm -f conftest.$ac_objext
4203 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4204   (eval $ac_compile) 2>conftest.er1
4205   ac_status=$?
4206   grep -v '^ *+' conftest.er1 >conftest.err
4207   rm -f conftest.er1
4208   cat conftest.err >&5
4209   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4210   (exit $ac_status); } &&
4211          { ac_try='test -z "$ac_cxx_werror_flag"
4212                          || test ! -s conftest.err'
4213   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4214   (eval $ac_try) 2>&5
4215   ac_status=$?
4216   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4217   (exit $ac_status); }; } &&
4218          { ac_try='test -s conftest.$ac_objext'
4219   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4220   (eval $ac_try) 2>&5
4221   ac_status=$?
4222   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4223   (exit $ac_status); }; }; then
4224   break
4225 else
4226   echo "$as_me: failed program was:" >&5
4227 sed 's/^/| /' conftest.$ac_ext >&5
4228
4229 fi
4230 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4231 done
4232 rm -f conftest*
4233 if test -n "$ac_declaration"; then
4234   echo '#ifdef __cplusplus' >>confdefs.h
4235   echo $ac_declaration      >>confdefs.h
4236   echo '#endif'             >>confdefs.h
4237 fi
4238
4239 ac_ext=c
4240 ac_cpp='$CPP $CPPFLAGS'
4241 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4242 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4243 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4244
4245
4246 # We must set the default linker to the linker used by gcc for the correct
4247 # operation of libtool.  If LD is not defined and we are using gcc, try to
4248 # set the LD default to the ld used by gcc.
4249 if test -z "$LD"; then
4250   if test "$GCC" = yes; then
4251     case $build in
4252     *-*-mingw*)
4253       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4254     *)
4255       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4256     esac
4257     case $gcc_prog_ld in
4258     # Accept absolute paths.
4259     [\\/]* | [A-Za-z]:[\\/]*)
4260       LD="$gcc_prog_ld" ;;
4261     esac
4262   fi
4263 fi
4264
4265
4266
4267
4268 if test -n "$ac_tool_prefix"; then
4269   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4270 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4271 echo "$as_me:$LINENO: checking for $ac_word" >&5
4272 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4273 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4274   echo $ECHO_N "(cached) $ECHO_C" >&6
4275 else
4276   if test -n "$GNATBIND"; then
4277   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4278 else
4279 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4280 for as_dir in $PATH
4281 do
4282   IFS=$as_save_IFS
4283   test -z "$as_dir" && as_dir=.
4284   for ac_exec_ext in '' $ac_executable_extensions; do
4285   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4286     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4287     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4288     break 2
4289   fi
4290 done
4291 done
4292
4293 fi
4294 fi
4295 GNATBIND=$ac_cv_prog_GNATBIND
4296 if test -n "$GNATBIND"; then
4297   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4298 echo "${ECHO_T}$GNATBIND" >&6
4299 else
4300   echo "$as_me:$LINENO: result: no" >&5
4301 echo "${ECHO_T}no" >&6
4302 fi
4303
4304 fi
4305 if test -z "$ac_cv_prog_GNATBIND"; then
4306   ac_ct_GNATBIND=$GNATBIND
4307   # Extract the first word of "gnatbind", so it can be a program name with args.
4308 set dummy gnatbind; ac_word=$2
4309 echo "$as_me:$LINENO: checking for $ac_word" >&5
4310 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4311 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4312   echo $ECHO_N "(cached) $ECHO_C" >&6
4313 else
4314   if test -n "$ac_ct_GNATBIND"; then
4315   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4316 else
4317 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4318 for as_dir in $PATH
4319 do
4320   IFS=$as_save_IFS
4321   test -z "$as_dir" && as_dir=.
4322   for ac_exec_ext in '' $ac_executable_extensions; do
4323   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4324     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4325     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4326     break 2
4327   fi
4328 done
4329 done
4330
4331   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4332 fi
4333 fi
4334 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4335 if test -n "$ac_ct_GNATBIND"; then
4336   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4337 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4338 else
4339   echo "$as_me:$LINENO: result: no" >&5
4340 echo "${ECHO_T}no" >&6
4341 fi
4342
4343   GNATBIND=$ac_ct_GNATBIND
4344 else
4345   GNATBIND="$ac_cv_prog_GNATBIND"
4346 fi
4347
4348 if test -n "$ac_tool_prefix"; then
4349   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4350 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4351 echo "$as_me:$LINENO: checking for $ac_word" >&5
4352 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4353 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4354   echo $ECHO_N "(cached) $ECHO_C" >&6
4355 else
4356   if test -n "$GNATMAKE"; then
4357   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4358 else
4359 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4360 for as_dir in $PATH
4361 do
4362   IFS=$as_save_IFS
4363   test -z "$as_dir" && as_dir=.
4364   for ac_exec_ext in '' $ac_executable_extensions; do
4365   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4366     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4367     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4368     break 2
4369   fi
4370 done
4371 done
4372
4373 fi
4374 fi
4375 GNATMAKE=$ac_cv_prog_GNATMAKE
4376 if test -n "$GNATMAKE"; then
4377   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4378 echo "${ECHO_T}$GNATMAKE" >&6
4379 else
4380   echo "$as_me:$LINENO: result: no" >&5
4381 echo "${ECHO_T}no" >&6
4382 fi
4383
4384 fi
4385 if test -z "$ac_cv_prog_GNATMAKE"; then
4386   ac_ct_GNATMAKE=$GNATMAKE
4387   # Extract the first word of "gnatmake", so it can be a program name with args.
4388 set dummy gnatmake; ac_word=$2
4389 echo "$as_me:$LINENO: checking for $ac_word" >&5
4390 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4391 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4392   echo $ECHO_N "(cached) $ECHO_C" >&6
4393 else
4394   if test -n "$ac_ct_GNATMAKE"; then
4395   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4396 else
4397 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4398 for as_dir in $PATH
4399 do
4400   IFS=$as_save_IFS
4401   test -z "$as_dir" && as_dir=.
4402   for ac_exec_ext in '' $ac_executable_extensions; do
4403   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4404     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4405     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4406     break 2
4407   fi
4408 done
4409 done
4410
4411   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4412 fi
4413 fi
4414 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4415 if test -n "$ac_ct_GNATMAKE"; then
4416   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4417 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4418 else
4419   echo "$as_me:$LINENO: result: no" >&5
4420 echo "${ECHO_T}no" >&6
4421 fi
4422
4423   GNATMAKE=$ac_ct_GNATMAKE
4424 else
4425   GNATMAKE="$ac_cv_prog_GNATMAKE"
4426 fi
4427
4428 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4429 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4430 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4431   echo $ECHO_N "(cached) $ECHO_C" >&6
4432 else
4433   cat >conftest.adb <<EOF
4434 procedure conftest is begin null; end conftest;
4435 EOF
4436 acx_cv_cc_gcc_supports_ada=no
4437 # There is a bug in old released versions of GCC which causes the
4438 # driver to exit successfully when the appropriate language module
4439 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4440 # Therefore we must check for the error message as well as an
4441 # unsuccessful exit.
4442 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4443 # given a .adb file, but produce no object file.  So we must check
4444 # if an object file was really produced to guard against this.
4445 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4446 if test x"$errors" = x && test -f conftest.$ac_objext; then
4447   acx_cv_cc_gcc_supports_ada=yes
4448 fi
4449 rm -f conftest.*
4450 fi
4451 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4452 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4453
4454 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4455   have_gnat=yes
4456 else
4457   have_gnat=no
4458 fi
4459
4460 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4461 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4462 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4463   echo $ECHO_N "(cached) $ECHO_C" >&6
4464 else
4465    echo abfoo >t1
4466   echo cdfoo >t2
4467   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4468   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4469     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4470       :
4471     else
4472       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4473     fi
4474   fi
4475   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4476     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4477       :
4478     else
4479       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4480     fi
4481   fi
4482   rm t1 t2
4483
4484 fi
4485 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4486 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4487 do_compare="$gcc_cv_prog_cmp_skip"
4488
4489
4490
4491 # Check for GMP and MPFR
4492 gmplibs="-lmpfr -lgmp"
4493 gmpinc=
4494 have_gmp=no
4495
4496 # Specify a location for mpfr
4497 # check for this first so it ends up on the link line before gmp.
4498
4499 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4500 if test "${with_mpfr_dir+set}" = set; then
4501   withval="$with_mpfr_dir"
4502   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4503 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4504 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4505 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4506    { (exit 1); exit 1; }; }
4507 fi;
4508
4509
4510 # Check whether --with-mpfr or --without-mpfr was given.
4511 if test "${with_mpfr+set}" = set; then
4512   withval="$with_mpfr"
4513
4514 fi;
4515
4516 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4517 if test "${with_mpfr_include+set}" = set; then
4518   withval="$with_mpfr_include"
4519
4520 fi;
4521
4522 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4523 if test "${with_mpfr_lib+set}" = set; then
4524   withval="$with_mpfr_lib"
4525
4526 fi;
4527
4528 if test "x$with_mpfr" != x; then
4529   gmplibs="-L$with_mpfr/lib $gmplibs"
4530   gmpinc="-I$with_mpfr/include"
4531 fi
4532 if test "x$with_mpfr_include" != x; then
4533   gmpinc="-I$with_mpfr_include"
4534 fi
4535 if test "x$with_mpfr_lib" != x; then
4536   gmplibs="-L$with_mpfr_lib $gmplibs"
4537 fi
4538 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4539   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4540   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4541   # Do not test the mpfr version.  Assume that it is sufficient, since
4542   # it is in the source tree, and the library has not been built yet
4543   # but it would be included on the link line in the version check below
4544   # hence making the test fail.
4545   have_gmp=yes
4546 fi
4547
4548 # Specify a location for gmp
4549
4550 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4551 if test "${with_gmp_dir+set}" = set; then
4552   withval="$with_gmp_dir"
4553   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4554 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4555 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4556 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4557    { (exit 1); exit 1; }; }
4558 fi;
4559
4560
4561 # Check whether --with-gmp or --without-gmp was given.
4562 if test "${with_gmp+set}" = set; then
4563   withval="$with_gmp"
4564
4565 fi;
4566
4567 # Check whether --with-gmp_include or --without-gmp_include was given.
4568 if test "${with_gmp_include+set}" = set; then
4569   withval="$with_gmp_include"
4570
4571 fi;
4572
4573 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4574 if test "${with_gmp_lib+set}" = set; then
4575   withval="$with_gmp_lib"
4576
4577 fi;
4578
4579
4580 if test "x$with_gmp" != x; then
4581   gmplibs="-L$with_gmp/lib $gmplibs"
4582   gmpinc="-I$with_gmp/include $gmpinc"
4583 fi
4584 if test "x$with_gmp_include" != x; then
4585   gmpinc="-I$with_gmp_include $gmpinc"
4586 fi
4587 if test "x$with_gmp_lib" != x; then
4588   gmplibs="-L$with_gmp_lib $gmplibs"
4589 fi
4590 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4591   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4592   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4593   # Do not test the gmp version.  Assume that it is sufficient, since
4594   # it is in the source tree, and the library has not been built yet
4595   # but it would be included on the link line in the version check below
4596   # hence making the test fail.
4597   have_gmp=yes
4598 fi
4599
4600 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4601   have_gmp=yes
4602   saved_CFLAGS="$CFLAGS"
4603   CFLAGS="$CFLAGS $gmpinc"
4604   # Check GMP actually works
4605   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4606 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4607
4608 cat >conftest.$ac_ext <<_ACEOF
4609 /* confdefs.h.  */
4610 _ACEOF
4611 cat confdefs.h >>conftest.$ac_ext
4612 cat >>conftest.$ac_ext <<_ACEOF
4613 /* end confdefs.h.  */
4614 #include "gmp.h"
4615 int
4616 main ()
4617 {
4618
4619   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4620   choke me
4621   #endif
4622
4623   ;
4624   return 0;
4625 }
4626 _ACEOF
4627 rm -f conftest.$ac_objext
4628 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4629   (eval $ac_compile) 2>conftest.er1
4630   ac_status=$?
4631   grep -v '^ *+' conftest.er1 >conftest.err
4632   rm -f conftest.er1
4633   cat conftest.err >&5
4634   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4635   (exit $ac_status); } &&
4636          { ac_try='test -z "$ac_c_werror_flag"
4637                          || test ! -s conftest.err'
4638   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4639   (eval $ac_try) 2>&5
4640   ac_status=$?
4641   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4642   (exit $ac_status); }; } &&
4643          { ac_try='test -s conftest.$ac_objext'
4644   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4645   (eval $ac_try) 2>&5
4646   ac_status=$?
4647   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4648   (exit $ac_status); }; }; then
4649   echo "$as_me:$LINENO: result: yes" >&5
4650 echo "${ECHO_T}yes" >&6
4651 else
4652   echo "$as_me: failed program was:" >&5
4653 sed 's/^/| /' conftest.$ac_ext >&5
4654
4655 echo "$as_me:$LINENO: result: no" >&5
4656 echo "${ECHO_T}no" >&6; have_gmp=no
4657 fi
4658 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4659
4660   if test x"$have_gmp" = xyes; then
4661     saved_LIBS="$LIBS"
4662     LIBS="$LIBS $gmplibs"
4663         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4664 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4665     cat >conftest.$ac_ext <<_ACEOF
4666 /* confdefs.h.  */
4667 _ACEOF
4668 cat confdefs.h >>conftest.$ac_ext
4669 cat >>conftest.$ac_ext <<_ACEOF
4670 /* end confdefs.h.  */
4671 #include <gmp.h>
4672     #include <mpfr.h>
4673 int
4674 main ()
4675 {
4676
4677     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4678     choke me
4679     #endif
4680     mpfr_t n;
4681     mpfr_t x;
4682     int t;
4683     mpfr_init (n);
4684     mpfr_init (x);
4685     mpfr_atan2 (n, n, x, GMP_RNDN);
4686     mpfr_erfc (n, x, GMP_RNDN);
4687     mpfr_subnormalize (x, t, GMP_RNDN);
4688
4689   ;
4690   return 0;
4691 }
4692 _ACEOF
4693 rm -f conftest.$ac_objext conftest$ac_exeext
4694 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4695   (eval $ac_link) 2>conftest.er1
4696   ac_status=$?
4697   grep -v '^ *+' conftest.er1 >conftest.err
4698   rm -f conftest.er1
4699   cat conftest.err >&5
4700   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4701   (exit $ac_status); } &&
4702          { ac_try='test -z "$ac_c_werror_flag"
4703                          || test ! -s conftest.err'
4704   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4705   (eval $ac_try) 2>&5
4706   ac_status=$?
4707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4708   (exit $ac_status); }; } &&
4709          { ac_try='test -s conftest$ac_exeext'
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); }; }; then
4715   cat >conftest.$ac_ext <<_ACEOF
4716 /* confdefs.h.  */
4717 _ACEOF
4718 cat confdefs.h >>conftest.$ac_ext
4719 cat >>conftest.$ac_ext <<_ACEOF
4720 /* end confdefs.h.  */
4721 #include <gmp.h>
4722     #include <mpfr.h>
4723 int
4724 main ()
4725 {
4726
4727     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4728     choke me
4729     #endif
4730     mpfr_t n; mpfr_init(n);
4731
4732   ;
4733   return 0;
4734 }
4735 _ACEOF
4736 rm -f conftest.$ac_objext conftest$ac_exeext
4737 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4738   (eval $ac_link) 2>conftest.er1
4739   ac_status=$?
4740   grep -v '^ *+' conftest.er1 >conftest.err
4741   rm -f conftest.er1
4742   cat conftest.err >&5
4743   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4744   (exit $ac_status); } &&
4745          { ac_try='test -z "$ac_c_werror_flag"
4746                          || test ! -s conftest.err'
4747   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4748   (eval $ac_try) 2>&5
4749   ac_status=$?
4750   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4751   (exit $ac_status); }; } &&
4752          { ac_try='test -s conftest$ac_exeext'
4753   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4754   (eval $ac_try) 2>&5
4755   ac_status=$?
4756   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4757   (exit $ac_status); }; }; then
4758   echo "$as_me:$LINENO: result: yes" >&5
4759 echo "${ECHO_T}yes" >&6
4760 else
4761   echo "$as_me: failed program was:" >&5
4762 sed 's/^/| /' conftest.$ac_ext >&5
4763
4764 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4765 echo "${ECHO_T}buggy but acceptable" >&6
4766 fi
4767 rm -f conftest.err conftest.$ac_objext \
4768       conftest$ac_exeext conftest.$ac_ext
4769 else
4770   echo "$as_me: failed program was:" >&5
4771 sed 's/^/| /' conftest.$ac_ext >&5
4772
4773 echo "$as_me:$LINENO: result: no" >&5
4774 echo "${ECHO_T}no" >&6; have_gmp=no
4775 fi
4776 rm -f conftest.err conftest.$ac_objext \
4777       conftest$ac_exeext conftest.$ac_ext
4778       LIBS="$saved_LIBS"
4779   fi
4780   CFLAGS="$saved_CFLAGS"
4781
4782   if test x$have_gmp != xyes; then
4783     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4784 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4785 Copies of these libraries' source code can be found at their respective
4786 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4787 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4788 If you obtained GMP and/or MPFR from a vendor distribution package, make
4789 sure that you have installed both the libraries and the header files.
4790 They may be located in separate packages." >&5
4791 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4792 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4793 Copies of these libraries' source code can be found at their respective
4794 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4795 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4796 If you obtained GMP and/or MPFR from a vendor distribution package, make
4797 sure that you have installed both the libraries and the header files.
4798 They may be located in separate packages." >&2;}
4799    { (exit 1); exit 1; }; }
4800   fi
4801 fi
4802
4803 # Flags needed for both GMP and/or MPFR
4804
4805
4806
4807
4808 # Check for PPL
4809 ppl_major_version=0
4810 ppl_minor_version=10
4811 ppllibs=
4812 pplinc=
4813
4814
4815 # Check whether --with-ppl or --without-ppl was given.
4816 if test "${with_ppl+set}" = set; then
4817   withval="$with_ppl"
4818
4819 fi;
4820
4821 # Check whether --with-ppl_include or --without-ppl_include was given.
4822 if test "${with_ppl_include+set}" = set; then
4823   withval="$with_ppl_include"
4824
4825 fi;
4826
4827 # Check whether --with-ppl_lib or --without-ppl_lib was given.
4828 if test "${with_ppl_lib+set}" = set; then
4829   withval="$with_ppl_lib"
4830
4831 fi;
4832
4833 if test "x$with_ppl" != x; then
4834   ppllibs="-L$with_ppl/lib -lppl_c -lppl -lgmpxx"
4835   pplinc="-I$with_ppl/include $pplinc"
4836   LIBS="$ppllibs $LIBS"
4837 fi
4838 if test "x$with_ppl_include" != x; then
4839   pplinc="-I$with_ppl_include $pplinc"
4840 fi
4841 if test "x$with_ppl_lib" != x; then
4842   ppllibs="-L$with_ppl_lib -lppl_c -lppl -lgmpxx"
4843   LIBS="$ppllibs $LIBS"
4844 fi
4845 if test "x$with_ppl$with_ppl_include$with_ppl_lib" = x && test -d ${srcdir}/ppl; then
4846   ppllibs='-L$$r/$(HOST_SUBDIR)/ppl/.libs -L$$r/$(HOST_SUBDIR)/ppl/_libs -lppl_c -lppl -lgmpxx '
4847   pplinc='-I$$r/$(HOST_SUBDIR)/ppl/include -I$$s/ppl/include '
4848   LIBS="$ppllibs $LIBS"
4849 fi
4850
4851 # Check whether --enable-ppl-version-check or --disable-ppl-version-check was given.
4852 if test "${enable_ppl_version_check+set}" = set; then
4853   enableval="$enable_ppl_version_check"
4854   ENABLE_PPL_CHECK=$enableval
4855 else
4856   ENABLE_PPL_CHECK=yes
4857 fi;
4858
4859 if test "${ENABLE_PPL_CHECK}" = "yes"; then
4860   saved_CFLAGS="$CFLAGS"
4861   CFLAGS="$CFLAGS $pplinc $gmpinc"
4862   echo "$as_me:$LINENO: checking for version $ppl_major_version.$ppl_minor_version of PPL" >&5
4863 echo $ECHO_N "checking for version $ppl_major_version.$ppl_minor_version of PPL... $ECHO_C" >&6
4864   cat >conftest.$ac_ext <<_ACEOF
4865 /* confdefs.h.  */
4866 _ACEOF
4867 cat confdefs.h >>conftest.$ac_ext
4868 cat >>conftest.$ac_ext <<_ACEOF
4869 /* end confdefs.h.  */
4870 #include "ppl_c.h"
4871 int
4872 main ()
4873 {
4874
4875   #if PPL_VERSION_MAJOR != $ppl_major_version || PPL_VERSION_MINOR != $ppl_minor_version
4876   choke me
4877   #endif
4878
4879   ;
4880   return 0;
4881 }
4882 _ACEOF
4883 rm -f conftest.$ac_objext
4884 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4885   (eval $ac_compile) 2>conftest.er1
4886   ac_status=$?
4887   grep -v '^ *+' conftest.er1 >conftest.err
4888   rm -f conftest.er1
4889   cat conftest.err >&5
4890   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4891   (exit $ac_status); } &&
4892          { ac_try='test -z "$ac_c_werror_flag"
4893                          || test ! -s conftest.err'
4894   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4895   (eval $ac_try) 2>&5
4896   ac_status=$?
4897   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4898   (exit $ac_status); }; } &&
4899          { ac_try='test -s conftest.$ac_objext'
4900   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4901   (eval $ac_try) 2>&5
4902   ac_status=$?
4903   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4904   (exit $ac_status); }; }; then
4905   echo "$as_me:$LINENO: result: yes" >&5
4906 echo "${ECHO_T}yes" >&6
4907 else
4908   echo "$as_me: failed program was:" >&5
4909 sed 's/^/| /' conftest.$ac_ext >&5
4910
4911 echo "$as_me:$LINENO: result: no" >&5
4912 echo "${ECHO_T}no" >&6; ppllibs= ; pplinc=
4913 fi
4914 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4915   CFLAGS="$saved_CFLAGS"
4916 fi
4917
4918 # Flags needed for PPL
4919
4920
4921
4922
4923 # Check for CLOOG
4924 clooglibs=" -lcloog "
4925 clooginc=" -DCLOOG_PPL_BACKEND "
4926
4927
4928 # Check whether --with-cloog or --without-cloog was given.
4929 if test "${with_cloog+set}" = set; then
4930   withval="$with_cloog"
4931
4932 fi;
4933
4934 # Check whether --with-cloog_include or --without-cloog_include was given.
4935 if test "${with_cloog_include+set}" = set; then
4936   withval="$with_cloog_include"
4937
4938 fi;
4939
4940 # Check whether --with-cloog_lib or --without-cloog_lib was given.
4941 if test "${with_cloog_lib+set}" = set; then
4942   withval="$with_cloog_lib"
4943
4944 fi;
4945
4946 # Check whether --with-cloog-polylib or --without-cloog-polylib was given.
4947 if test "${with_cloog_polylib+set}" = set; then
4948   withval="$with_cloog_polylib"
4949
4950 fi;
4951
4952 if test "x$with_cloog" != x; then
4953   clooglibs="-L$with_cloog/lib -lcloog"
4954   clooginc="-I$with_cloog/include -DCLOOG_PPL_BACKEND "
4955   LIBS="$clooglibs $LIBS"
4956 fi
4957 if test "x$with_cloog_polylib" != x; then
4958   clooglibs="-L$with_cloog/lib -lcloog"
4959   clooginc="-I$with_cloog/include "
4960   LIBS="$clooglibs $LIBS"
4961 fi
4962 if test "x$with_cloog_include" != x; then
4963   clooginc="-I$with_cloog_include -DCLOOG_PPL_BACKEND "
4964 fi
4965 if test "x$with_cloog_lib" != x; then
4966   clooglibs="-L$with_cloog_lib -lcloog"
4967   LIBS="$clooglibs $LIBS"
4968 fi
4969 if test "x$with_cloog$with_cloog_include$with_cloog_lib" = x && test -d ${srcdir}/cloog; then
4970   clooglibs='-L$$r/$(HOST_SUBDIR)/cloog/.libs -L$$r/$(HOST_SUBDIR)/cloog/_libs -lcloog '
4971   clooginc='-I$$r/$(HOST_SUBDIR)/cloog/include -I$$s/cloog/include -DCLOOG_PPL_BACKEND '
4972   LIBS="$clooglibs $LIBS"
4973 fi
4974
4975 # Check whether --enable-cloog-version-check or --disable-cloog-version-check was given.
4976 if test "${enable_cloog_version_check+set}" = set; then
4977   enableval="$enable_cloog_version_check"
4978   ENABLE_CLOOG_CHECK=$enableval
4979 else
4980   ENABLE_CLOOG_CHECK=yes
4981 fi;
4982
4983 if test "${ENABLE_CLOOG_CHECK}" = "yes"; then
4984   saved_CFLAGS="$CFLAGS"
4985   CFLAGS="$CFLAGS $clooginc $gmpinc $pplinc"
4986   echo "$as_me:$LINENO: checking for correct version of CLooG" >&5
4987 echo $ECHO_N "checking for correct version of CLooG... $ECHO_C" >&6
4988   cat >conftest.$ac_ext <<_ACEOF
4989 /* confdefs.h.  */
4990 _ACEOF
4991 cat confdefs.h >>conftest.$ac_ext
4992 cat >>conftest.$ac_ext <<_ACEOF
4993 /* end confdefs.h.  */
4994 #include "cloog/cloog.h"
4995 int
4996 main ()
4997 {
4998
4999   #if CLOOG_VERSION_MAJOR != 0 || CLOOG_VERSION_MINOR != 15
5000   choke me
5001   #endif
5002
5003   ;
5004   return 0;
5005 }
5006 _ACEOF
5007 rm -f conftest.$ac_objext
5008 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5009   (eval $ac_compile) 2>conftest.er1
5010   ac_status=$?
5011   grep -v '^ *+' conftest.er1 >conftest.err
5012   rm -f conftest.er1
5013   cat conftest.err >&5
5014   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5015   (exit $ac_status); } &&
5016          { ac_try='test -z "$ac_c_werror_flag"
5017                          || test ! -s conftest.err'
5018   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5019   (eval $ac_try) 2>&5
5020   ac_status=$?
5021   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5022   (exit $ac_status); }; } &&
5023          { ac_try='test -s conftest.$ac_objext'
5024   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5025   (eval $ac_try) 2>&5
5026   ac_status=$?
5027   echo "$as_me:$LINENO: \$? = $ac_status" >&5
5028   (exit $ac_status); }; }; then
5029   echo "$as_me:$LINENO: result: yes" >&5
5030 echo "${ECHO_T}yes" >&6
5031 else
5032   echo "$as_me: failed program was:" >&5
5033 sed 's/^/| /' conftest.$ac_ext >&5
5034
5035 echo "$as_me:$LINENO: result: no" >&5
5036 echo "${ECHO_T}no" >&6; clooglibs= ; clooginc=
5037 fi
5038 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5039   CFLAGS="$saved_CFLAGS"
5040 fi
5041
5042 # Flags needed for CLOOG
5043
5044
5045
5046
5047 # By default, C is the only stage 1 language.
5048 stage1_languages=,c,
5049
5050 # Figure out what language subdirectories are present.
5051 # Look if the user specified --enable-languages="..."; if not, use
5052 # the environment variable $LANGUAGES if defined. $LANGUAGES might
5053 # go away some day.
5054 # NB:  embedded tabs in this IF block -- do not untabify
5055 if test -d ${srcdir}/gcc; then
5056   if test x"${enable_languages+set}" != xset; then
5057     if test x"${LANGUAGES+set}" = xset; then
5058       enable_languages="${LANGUAGES}"
5059         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
5060     else
5061       enable_languages=all
5062     fi
5063   else
5064     if test x"${enable_languages}" = x ||
5065        test x"${enable_languages}" = xyes;
5066        then
5067       echo configure.in: --enable-languages needs at least one language argument 1>&2
5068       exit 1
5069     fi
5070   fi
5071   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
5072
5073   # 'f95' is the old name for the 'fortran' language. We issue a warning
5074   # and make the substitution.
5075   case ,${enable_languages}, in
5076     *,f95,*)
5077       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
5078       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
5079       ;;
5080   esac
5081
5082   # First scan to see if an enabled language requires some other language.
5083   # We assume that a given config-lang.in will list all the language
5084   # front ends it requires, even if some are required indirectly.
5085   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5086     case ${lang_frag} in
5087       ..) ;;
5088       # The odd quoting in the next line works around
5089       # an apparent bug in bash 1.12 on linux.
5090       ${srcdir}/gcc/[*]/config-lang.in) ;;
5091       *)
5092         # From the config-lang.in, get $language, $lang_requires
5093         language=
5094         lang_requires=
5095         . ${lang_frag}
5096         for other in ${lang_requires} ; do
5097           case ,${enable_languages}, in
5098             *,$other,*) ;;
5099             *,all,*) ;;
5100             *,$language,*)
5101               echo " \`$other' language required by \`$language'; enabling" 1>&2
5102               enable_languages="${enable_languages},${other}"
5103               ;;
5104           esac
5105         done
5106         ;;
5107     esac
5108   done
5109
5110   new_enable_languages=,c,
5111   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
5112   potential_languages=,c,
5113
5114   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
5115     case ${lang_frag} in
5116       ..) ;;
5117       # The odd quoting in the next line works around
5118       # an apparent bug in bash 1.12 on linux.
5119       ${srcdir}/gcc/[*]/config-lang.in) ;;
5120       *)
5121         # From the config-lang.in, get $language, $target_libs,
5122         # $lang_dirs, $boot_language, and $build_by_default
5123         language=
5124         target_libs=
5125         lang_dirs=
5126         subdir_requires=
5127         boot_language=no
5128         build_by_default=yes
5129         . ${lang_frag}
5130         if test x${language} = x; then
5131           echo "${lang_frag} doesn't set \$language." 1>&2
5132           exit 1
5133         fi
5134
5135         case ,${enable_languages}, in
5136           *,${language},*)
5137             # Language was explicitly selected; include it.
5138             add_this_lang=yes
5139             ;;
5140           *,all,*)
5141             # 'all' was selected, select it if it is a default language
5142             add_this_lang=${build_by_default}
5143             ;;
5144           *)
5145             add_this_lang=no
5146             ;;
5147         esac
5148
5149         # Disable languages that need other directories if these aren't available.
5150         for i in $subdir_requires; do
5151           test -f "$srcdir/gcc/$i/config-lang.in" && continue
5152           case ,${enable_languages}, in
5153             *,${language},*)
5154               # Specifically requested language; tell them.
5155               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
5156 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
5157    { (exit 1); exit 1; }; }
5158               ;;
5159             *)
5160               # Silently disable.
5161               add_this_lang=unsupported
5162               ;;
5163           esac
5164         done
5165
5166         # Disable Ada if no preexisting GNAT is available.
5167         case ,${enable_languages},:${language}:${have_gnat} in
5168           *,${language},*:ada:no)
5169             # Specifically requested language; tell them.
5170             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
5171 echo "$as_me: error: GNAT is required to build $language" >&2;}
5172    { (exit 1); exit 1; }; }
5173             ;;
5174           *:ada:no)
5175             # Silently disable.
5176             add_this_lang=unsupported
5177             ;;
5178         esac
5179
5180         # Disable a language that is unsupported by the target.
5181         case " $unsupported_languages " in
5182           *" $language "*)
5183             add_this_lang=unsupported
5184             ;;
5185         esac
5186
5187         case $add_this_lang in
5188           unsupported)
5189             # Remove language-dependent dirs.
5190             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5191             ;;
5192           no)
5193             # Remove language-dependent dirs; still show language as supported.
5194             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
5195             potential_languages="${potential_languages}${language},"
5196             ;;
5197           yes)
5198             new_enable_languages="${new_enable_languages}${language},"
5199             potential_languages="${potential_languages}${language},"
5200             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
5201             case ${boot_language} in
5202               yes)
5203                 # Add to (comma-separated) list of stage 1 languages.
5204                 stage1_languages="${stage1_languages}${language},"
5205                 ;;
5206             esac
5207             ;;
5208         esac
5209         ;;
5210     esac
5211   done
5212
5213   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
5214 if test "${enable_stage1_languages+set}" = set; then
5215   enableval="$enable_stage1_languages"
5216   case ,${enable_stage1_languages}, in
5217     ,no,|,,)
5218       # Set it to something that will have no effect in the loop below
5219       enable_stage1_languages=c ;;
5220     ,yes,)
5221       enable_stage1_languages=`echo $new_enable_languages | \
5222         sed -e "s/^,//" -e "s/,$//" ` ;;
5223     *,all,*)
5224       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
5225         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
5226   esac
5227
5228   # Add "good" languages from enable_stage1_languages to stage1_languages,
5229   # while "bad" languages go in missing_languages.  Leave no duplicates.
5230   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
5231     case $potential_languages in
5232       *,$i,*)
5233         case $stage1_languages in
5234           *,$i,*) ;;
5235           *) stage1_languages="$stage1_languages$i," ;;
5236         esac ;;
5237       *)
5238         case $missing_languages in
5239           *,$i,*) ;;
5240           *) missing_languages="$missing_languages$i," ;;
5241         esac ;;
5242      esac
5243   done
5244 fi;
5245
5246   # Remove leading/trailing commas that were added for simplicity
5247   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
5248   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
5249   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
5250   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
5251
5252   if test "x$missing_languages" != x; then
5253     { { echo "$as_me:$LINENO: error:
5254 The following requested languages could not be built: ${missing_languages}
5255 Supported languages are: ${potential_languages}" >&5
5256 echo "$as_me: error:
5257 The following requested languages could not be built: ${missing_languages}
5258 Supported languages are: ${potential_languages}" >&2;}
5259    { (exit 1); exit 1; }; }
5260   fi
5261   if test "x$new_enable_languages" != "x$enable_languages"; then
5262     echo The following languages will be built: ${new_enable_languages}
5263     enable_languages="$new_enable_languages"
5264   fi
5265
5266
5267   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
5268 fi
5269
5270 # Handle --disable-<component> generically.
5271 for dir in $configdirs $build_configdirs $target_configdirs ; do
5272   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
5273   varname=`echo $dirname | sed -e s/+/_/g`
5274   if eval test x\${enable_${varname}} "=" xno ; then
5275     noconfigdirs="$noconfigdirs $dir"
5276   fi
5277 done
5278
5279 # Check for Boehm's garbage collector
5280 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5281 if test "${enable_objc_gc+set}" = set; then
5282   enableval="$enable_objc_gc"
5283   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5284   *,objc,*:*:yes:*target-boehm-gc*)
5285     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5286 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5287    { (exit 1); exit 1; }; }
5288     ;;
5289 esac
5290 fi;
5291
5292 # Make sure we only build Boehm's garbage collector if required.
5293 case ,${enable_languages},:${enable_objc_gc} in
5294   *,objc,*:yes)
5295     # Keep target-boehm-gc if requested for Objective-C.
5296     ;;
5297   *)
5298     # Otherwise remove target-boehm-gc depending on target-libjava.
5299     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5300       noconfigdirs="$noconfigdirs target-boehm-gc"
5301     fi
5302     ;;
5303 esac
5304
5305 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5306 # $build_configdirs and $target_configdirs.
5307 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5308
5309 notsupp=""
5310 for dir in . $skipdirs $noconfigdirs ; do
5311   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5312   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5313     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5314     if test -r $srcdir/$dirname/configure ; then
5315       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5316         true
5317       else
5318         notsupp="$notsupp $dir"
5319       fi
5320     fi
5321   fi
5322   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5323     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5324     if test -r $srcdir/$dirname/configure ; then
5325       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5326         true
5327       else
5328         notsupp="$notsupp $dir"
5329       fi
5330     fi
5331   fi
5332   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5333     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5334     if test -r $srcdir/$dirname/configure ; then
5335       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5336         true
5337       else
5338         notsupp="$notsupp $dir"
5339       fi
5340     fi
5341   fi
5342 done
5343
5344 # Sometimes the tools are distributed with libiberty but with no other
5345 # libraries.  In that case, we don't want to build target-libiberty.
5346 # Don't let libgcc imply libiberty either.
5347 if test -n "${target_configdirs}" ; then
5348   libgcc=
5349   others=
5350   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5351     if test "$i" = "libgcc"; then
5352       libgcc=target-libgcc
5353     elif test "$i" != "libiberty" ; then
5354       if test -r $srcdir/$i/configure ; then
5355         others=yes;
5356         break;
5357       fi
5358     fi
5359   done
5360   if test -z "${others}" ; then
5361     target_configdirs=$libgcc
5362   fi
5363 fi
5364
5365 # Quietly strip out all directories which aren't configurable in this tree.
5366 # This relies on all configurable subdirectories being autoconfiscated, which
5367 # is now the case.
5368 build_configdirs_all="$build_configdirs"
5369 build_configdirs=
5370 for i in ${build_configdirs_all} ; do
5371   j=`echo $i | sed -e s/build-//g`
5372   if test -f ${srcdir}/$j/configure ; then
5373     build_configdirs="${build_configdirs} $i"
5374   fi
5375 done
5376
5377 configdirs_all="$configdirs"
5378 configdirs=
5379 for i in ${configdirs_all} ; do
5380   if test -f ${srcdir}/$i/configure ; then
5381     configdirs="${configdirs} $i"
5382   fi
5383 done
5384
5385 target_configdirs_all="$target_configdirs"
5386 target_configdirs=
5387 for i in ${target_configdirs_all} ; do
5388   j=`echo $i | sed -e s/target-//g`
5389   if test -f ${srcdir}/$j/configure ; then
5390     target_configdirs="${target_configdirs} $i"
5391   fi
5392 done
5393
5394 # Produce a warning message for the subdirs we can't configure.
5395 # This isn't especially interesting in the Cygnus tree, but in the individual
5396 # FSF releases, it's important to let people know when their machine isn't
5397 # supported by the one or two programs in a package.
5398
5399 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5400   # If $appdirs is non-empty, at least one of those directories must still
5401   # be configured, or we error out.  (E.g., if the gas release supports a
5402   # specified target in some subdirs but not the gas subdir, we shouldn't
5403   # pretend that all is well.)
5404   if test -n "$appdirs" ; then
5405     for dir in $appdirs ; do
5406       if test -r $dir/Makefile.in ; then
5407         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5408           appdirs=""
5409           break
5410         fi
5411         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5412           appdirs=""
5413           break
5414         fi
5415       fi
5416     done
5417     if test -n "$appdirs" ; then
5418       echo "*** This configuration is not supported by this package." 1>&2
5419       exit 1
5420     fi
5421   fi
5422   # Okay, some application will build, or we don't care to check.  Still
5423   # notify of subdirs not getting built.
5424   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5425   echo "    ${notsupp}" 1>&2
5426   echo "    (Any other directories should still work fine.)" 1>&2
5427 fi
5428
5429 case "$host" in
5430   *msdosdjgpp*)
5431     enable_gdbtk=no ;;
5432 esac
5433
5434 # To find our prefix, in gcc_cv_tool_prefix.
5435
5436 # The user is always right.
5437 if test "${PATH_SEPARATOR+set}" != set; then
5438   echo "#! /bin/sh" >conf$$.sh
5439   echo  "exit 0"   >>conf$$.sh
5440   chmod +x conf$$.sh
5441   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5442     PATH_SEPARATOR=';'
5443   else
5444     PATH_SEPARATOR=:
5445   fi
5446   rm -f conf$$.sh
5447 fi
5448
5449
5450
5451 if test "x$exec_prefix" = xNONE; then
5452         if test "x$prefix" = xNONE; then
5453                 gcc_cv_tool_prefix=$ac_default_prefix
5454         else
5455                 gcc_cv_tool_prefix=$prefix
5456         fi
5457 else
5458         gcc_cv_tool_prefix=$exec_prefix
5459 fi
5460
5461 # If there is no compiler in the tree, use the PATH only.  In any
5462 # case, if there is no compiler in the tree nobody should use
5463 # AS_FOR_TARGET and LD_FOR_TARGET.
5464 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5465     gcc_version=`cat $srcdir/gcc/BASE-VER`
5466     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5467     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5468     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5469     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5470     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5471     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5472 else
5473     gcc_cv_tool_dirs=
5474 fi
5475
5476 if test x$build = x$target && test -n "$md_exec_prefix"; then
5477         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5478 fi
5479
5480
5481
5482 copy_dirs=
5483
5484
5485 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5486 if test "${with_build_sysroot+set}" = set; then
5487   withval="$with_build_sysroot"
5488   if test x"$withval" != x ; then
5489      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5490    fi
5491 else
5492   SYSROOT_CFLAGS_FOR_TARGET=
5493 fi;
5494
5495
5496
5497 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5498 if test "${with_debug_prefix_map+set}" = set; then
5499   withval="$with_debug_prefix_map"
5500   if test x"$withval" != x; then
5501      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5502      for debug_map in $withval; do
5503        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5504      done
5505    fi
5506 else
5507   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5508 fi;
5509
5510
5511 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5512 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5513 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5514 # We want to ensure that TARGET libraries (which we know are built with
5515 # gcc) are built with "-O2 -g", so include those options when setting
5516 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5517 if test "x$CFLAGS_FOR_TARGET" = x; then
5518   CFLAGS_FOR_TARGET=$CFLAGS
5519   case " $CFLAGS " in
5520     *" -O2 "*) ;;
5521     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5522   esac
5523   case " $CFLAGS " in
5524     *" -g "* | *" -g3 "*) ;;
5525     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5526   esac
5527 fi
5528
5529
5530 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5531   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5532   case " $CXXFLAGS " in
5533     *" -O2 "*) ;;
5534     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5535   esac
5536   case " $CXXFLAGS " in
5537     *" -g "* | *" -g3 "*) ;;
5538     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5539   esac
5540 fi
5541
5542
5543 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5544 # the named directory are copied to $(tooldir)/sys-include.
5545 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5546   if test x${is_cross_compiler} = xno ; then
5547     echo 1>&2 '***' --with-headers is only supported when cross compiling
5548     exit 1
5549   fi
5550   if test x"${with_headers}" != xyes ; then
5551     x=${gcc_cv_tool_prefix}
5552     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5553   fi
5554 fi
5555
5556 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5557 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5558 # are permitted.
5559 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5560   if test x${is_cross_compiler} = xno ; then
5561     echo 1>&2 '***' --with-libs is only supported when cross compiling
5562     exit 1
5563   fi
5564   if test x"${with_libs}" != xyes ; then
5565     # Copy the libraries in reverse order, so that files in the first named
5566     # library override files in subsequent libraries.
5567     x=${gcc_cv_tool_prefix}
5568     for l in ${with_libs}; do
5569       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5570     done
5571   fi
5572 fi
5573
5574 # Set with_gnu_as and with_gnu_ld as appropriate.
5575 #
5576 # This is done by determining whether or not the appropriate directory
5577 # is available, and by checking whether or not specific configurations
5578 # have requested that this magic not happen.
5579 #
5580 # The command line options always override the explicit settings in
5581 # configure.in, and the settings in configure.in override this magic.
5582 #
5583 # If the default for a toolchain is to use GNU as and ld, and you don't
5584 # want to do that, then you should use the --without-gnu-as and
5585 # --without-gnu-ld options for the configure script.
5586
5587 if test x${use_gnu_as} = x &&
5588    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5589   with_gnu_as=yes
5590   extra_host_args="$extra_host_args --with-gnu-as"
5591 fi
5592
5593 if test x${use_gnu_ld} = x &&
5594    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5595   with_gnu_ld=yes
5596   extra_host_args="$extra_host_args --with-gnu-ld"
5597 fi
5598
5599 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5600 # can detect this case.
5601
5602 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5603   with_newlib=yes
5604   extra_host_args="$extra_host_args --with-newlib"
5605 fi
5606
5607 # Handle ${copy_dirs}
5608 set fnord ${copy_dirs}
5609 shift
5610 while test $# != 0 ; do
5611   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5612     :
5613   else
5614     echo Copying $1 to $2
5615
5616     # Use the install script to create the directory and all required
5617     # parent directories.
5618     if test -d $2 ; then
5619       :
5620     else
5621       echo >config.temp
5622       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5623     fi
5624
5625     # Copy the directory, assuming we have tar.
5626     # FIXME: Should we use B in the second tar?  Not all systems support it.
5627     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5628
5629     # It is the responsibility of the user to correctly adjust all
5630     # symlinks.  If somebody can figure out how to handle them correctly
5631     # here, feel free to add the code.
5632
5633     echo $1 > $2/COPIED
5634   fi
5635   shift; shift
5636 done
5637
5638 # Determine a target-dependent exec_prefix that the installed
5639 # gcc will search in.  Keep this list sorted by triplet, with
5640 # the *-*-osname triplets last.
5641 md_exec_prefix=
5642 case "${target}" in
5643   alpha*-*-*vms*)
5644     md_exec_prefix=/gnu/lib/gcc-lib
5645     ;;
5646   i[34567]86-pc-msdosdjgpp*)
5647     md_exec_prefix=/dev/env/DJDIR/bin
5648     ;;
5649   i[34567]86-*-sco3.2v5*)
5650     if test $with_gnu_as = yes; then
5651       md_exec_prefix=/usr/gnu/bin
5652     else
5653       md_exec_prefix=/usr/ccs/bin/elf
5654     fi
5655     ;;
5656
5657   mn10300-*-* | \
5658   powerpc-*-chorusos* | \
5659   powerpc*-*-eabi* | \
5660   powerpc*-*-sysv* | \
5661   powerpc*-*-kaos* | \
5662   s390x-ibm-tpf*)
5663     md_exec_prefix=/usr/ccs/bin
5664     ;;
5665   sparc64-*-elf*)
5666     ;;
5667   v850*-*-*)
5668     md_exec_prefix=/usr/ccs/bin
5669     ;;
5670   xtensa*-*-elf*)
5671     ;;
5672
5673   *-*-beos* | \
5674   *-*-elf* | \
5675   *-*-hpux* | \
5676   *-*-netware* | \
5677   *-*-nto-qnx* | \
5678   *-*-rtems* | \
5679   *-*-solaris2* | \
5680   *-*-sysv[45]* | \
5681   *-*-vxworks* | \
5682   *-wrs-windiss)
5683     md_exec_prefix=/usr/ccs/bin
5684     ;;
5685 esac
5686
5687 extra_arflags_for_target=
5688 extra_nmflags_for_target=
5689 extra_ranlibflags_for_target=
5690 target_makefile_frag=/dev/null
5691 case "${target}" in
5692   mep*-*-*)
5693     target_makefile_frag="config/mt-mep"
5694     ;;
5695   spu-*-*)
5696     target_makefile_frag="config/mt-spu"
5697     ;;
5698   mips*-sde-elf*)
5699     target_makefile_frag="config/mt-sde"
5700     ;;
5701   mipsisa*-*-elfoabi*)
5702     target_makefile_frag="config/mt-mips-elfoabi"
5703     ;;
5704   mips*-*-*linux* | mips*-*-gnu*)
5705     target_makefile_frag="config/mt-mips-gnu"
5706     ;;
5707   *-*-netware*)
5708     target_makefile_frag="config/mt-netware"
5709     ;;
5710   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5711     target_makefile_frag="config/mt-gnu"
5712     ;;
5713   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5714     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5715     # commands to handle both 32-bit and 64-bit objects.  These flags are
5716     # harmless if we're using GNU nm or ar.
5717     extra_arflags_for_target=" -X32_64"
5718     extra_nmflags_for_target=" -B -X32_64"
5719     ;;
5720   *-*-darwin*)
5721     # ranlib from Darwin requires the -c flag to look at common symbols.
5722     extra_ranlibflags_for_target=" -c"
5723     ;;
5724   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5725     target_makefile_frag="config/mt-wince"
5726     ;;
5727 esac
5728
5729 alphaieee_frag=/dev/null
5730 case $target in
5731   alpha*-*-*)
5732     # This just makes sure to use the -mieee option to build target libs.
5733     # This should probably be set individually by each library.
5734     alphaieee_frag="config/mt-alphaieee"
5735     ;;
5736 esac
5737
5738 # If --enable-target-optspace always use -Os instead of -O2 to build
5739 # the target libraries, similarly if it is not specified, use -Os
5740 # on selected platforms.
5741 ospace_frag=/dev/null
5742 case "${enable_target_optspace}:${target}" in
5743   yes:*)
5744     ospace_frag="config/mt-ospace"
5745     ;;
5746   :d30v-*)
5747     ospace_frag="config/mt-d30v"
5748     ;;
5749   :m32r-* | :d10v-* | :fr30-*)
5750     ospace_frag="config/mt-ospace"
5751     ;;
5752   no:* | :*)
5753     ;;
5754   *)
5755     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5756     ;;
5757 esac
5758
5759 # Default to using --with-stabs for certain targets.
5760 if test x${with_stabs} = x ; then
5761   case "${target}" in
5762   mips*-*-irix[56]*)
5763     ;;
5764   mips*-*-* | alpha*-*-osf*)
5765     with_stabs=yes;
5766     extra_host_args="${extra_host_args} --with-stabs"
5767     ;;
5768   esac
5769 fi
5770
5771 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5772 # them automatically.
5773 case "${host}" in
5774   hppa*64*-*-hpux11*)
5775     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5776     ;;
5777 esac
5778
5779 # Some systems (e.g., one of the i386-aix systems the gas testers are
5780 # using) don't handle "\$" correctly, so don't use it here.
5781 tooldir='${exec_prefix}'/${target_noncanonical}
5782 build_tooldir=${tooldir}
5783
5784 # Create a .gdbinit file which runs the one in srcdir
5785 # and tells GDB to look there for source files.
5786
5787 if test -r ${srcdir}/.gdbinit ; then
5788   case ${srcdir} in
5789     .) ;;
5790     *) cat > ./.gdbinit <<EOF
5791 # ${NO_EDIT}
5792 dir ${srcdir}
5793 dir .
5794 source ${srcdir}/.gdbinit
5795 EOF
5796     ;;
5797   esac
5798 fi
5799
5800 # Make sure that the compiler is able to generate an executable.  If it
5801 # can't, we are probably in trouble.  We don't care whether we can run the
5802 # executable--we might be using a cross compiler--we only care whether it
5803 # can be created.  At this point the main configure script has set CC.
5804 we_are_ok=no
5805 echo "int main () { return 0; }" > conftest.c
5806 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5807 if test $? = 0 ; then
5808   if test -s conftest || test -s conftest.exe ; then
5809     we_are_ok=yes
5810   fi
5811 fi
5812 case $we_are_ok in
5813   no)
5814     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5815     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5816     rm -f conftest*
5817     exit 1
5818     ;;
5819 esac
5820 rm -f conftest*
5821
5822 # The Solaris /usr/ucb/cc compiler does not appear to work.
5823 case "${host}" in
5824   sparc-sun-solaris2*)
5825       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5826       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5827           could_use=
5828           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5829           if test -d /opt/cygnus/bin ; then
5830               if test "$could_use" = "" ; then
5831                   could_use="/opt/cygnus/bin"
5832               else
5833                   could_use="$could_use or /opt/cygnus/bin"
5834               fi
5835           fi
5836         if test "$could_use" = "" ; then
5837             echo "Warning: compilation may fail because you're using"
5838             echo "/usr/ucb/cc.  You should change your PATH or CC "
5839             echo "variable and rerun configure."
5840         else
5841             echo "Warning: compilation may fail because you're using"
5842             echo "/usr/ucb/cc, when you should use the C compiler from"
5843             echo "$could_use.  You should change your"
5844             echo "PATH or CC variable and rerun configure."
5845         fi
5846       fi
5847   ;;
5848 esac
5849
5850 # Decide which environment variable is used to find dynamic libraries.
5851 case "${host}" in
5852   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5853   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5854   *-*-mingw* | *-*-cygwin ) RPATH_ENVVAR=PATH ;;
5855   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5856 esac
5857
5858 # On systems where the dynamic library environment variable is PATH,
5859 # gcc/ will put dynamic libraries into a subdirectory to avoid adding
5860 # built executables to PATH.
5861 if test "$RPATH_ENVVAR" = PATH; then
5862   GCC_SHLIB_SUBDIR=/shlib
5863 else
5864   GCC_SHLIB_SUBDIR=
5865 fi
5866
5867 # Record target_configdirs and the configure arguments for target and
5868 # build configuration in Makefile.
5869 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5870 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5871
5872 # Determine whether gdb needs tk/tcl or not.
5873 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5874 # and in that case we want gdb to be built without tk.  Ugh!
5875 # In fact I believe gdb is the *only* package directly dependent on tk,
5876 # so we should be able to put the 'maybe's in unconditionally and
5877 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5878 # 100% sure that that's safe though.
5879
5880 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5881 case "$enable_gdbtk" in
5882   no)
5883     GDB_TK="" ;;
5884   yes)
5885     GDB_TK="${gdb_tk}" ;;
5886   *)
5887     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5888     # distro.  Eventually someone will fix this and move Insight, nee
5889     # gdbtk to a separate directory.
5890     if test -d ${srcdir}/gdb/gdbtk ; then
5891       GDB_TK="${gdb_tk}"
5892     else
5893       GDB_TK=""
5894     fi
5895     ;;
5896 esac
5897 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5898 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5899
5900 # Strip out unwanted targets.
5901
5902 # While at that, we remove Makefiles if we were started for recursive
5903 # configuration, so that the top-level Makefile reconfigures them,
5904 # like we used to do when configure itself was recursive.
5905
5906 # Loop over modules.  $extrasub must be used with care, limiting as
5907 # much as possible the usage of range addresses.  That's because autoconf
5908 # splits the sed script to overcome limits in the number of commands,
5909 # and relying on carefully-timed sed passes may turn out to be very hard
5910 # to maintain later.  In this particular case, you just have to be careful
5911 # not to nest @if/@endif pairs, because configure will not warn you at all.
5912
5913 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5914 if test "${enable_bootstrap+set}" = set; then
5915   enableval="$enable_bootstrap"
5916
5917 else
5918   enable_bootstrap=default
5919 fi;
5920
5921 # Issue errors and warnings for invalid/strange bootstrap combinations.
5922 case "$configdirs" in
5923   *gcc*) have_compiler=yes ;;
5924   *) have_compiler=no ;;
5925 esac
5926
5927 case "$have_compiler:$host:$target:$enable_bootstrap" in
5928   *:*:*:no) ;;
5929
5930   # Default behavior.  Enable bootstrap if we have a compiler
5931   # and we are in a native configuration.
5932   yes:$build:$build:default)
5933     enable_bootstrap=yes ;;
5934
5935   *:*:*:default)
5936     enable_bootstrap=no ;;
5937
5938   # We have a compiler and we are in a native configuration, bootstrap is ok
5939   yes:$build:$build:yes)
5940     ;;
5941
5942   # Other configurations, but we have a compiler.  Assume the user knows
5943   # what he's doing.
5944   yes:*:*:yes)
5945     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5946 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5947     ;;
5948
5949   # No compiler: if they passed --enable-bootstrap explicitly, fail
5950   no:*:*:yes)
5951     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5952 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5953    { (exit 1); exit 1; }; } ;;
5954
5955   # Fail if wrong command line
5956   *)
5957     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5958 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5959    { (exit 1); exit 1; }; }
5960     ;;
5961 esac
5962
5963 # Adjust the toplevel makefile according to whether bootstrap was selected.
5964 case "$enable_bootstrap" in
5965   yes)
5966     bootstrap_suffix=bootstrap ;;
5967   no)
5968     bootstrap_suffix=no-bootstrap ;;
5969 esac
5970
5971 for module in ${build_configdirs} ; do
5972   if test -z "${no_recursion}" \
5973      && test -f ${build_subdir}/${module}/Makefile; then
5974     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5975     rm -f ${build_subdir}/${module}/Makefile
5976   fi
5977   extrasub="$extrasub
5978 /^@if build-$module\$/d
5979 /^@endif build-$module\$/d
5980 /^@if build-$module-$bootstrap_suffix\$/d
5981 /^@endif build-$module-$bootstrap_suffix\$/d"
5982 done
5983 for module in ${configdirs} ; do
5984   if test -z "${no_recursion}"; then
5985     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5986       if test -f ${file}; then
5987         echo 1>&2 "*** removing ${file} to force reconfigure"
5988         rm -f ${file}
5989       fi
5990     done
5991   fi
5992   extrasub="$extrasub
5993 /^@if $module\$/d
5994 /^@endif $module\$/d
5995 /^@if $module-$bootstrap_suffix\$/d
5996 /^@endif $module-$bootstrap_suffix\$/d"
5997 done
5998 for module in ${target_configdirs} ; do
5999   if test -z "${no_recursion}" \
6000      && test -f ${target_subdir}/${module}/Makefile; then
6001     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
6002     rm -f ${target_subdir}/${module}/Makefile
6003   fi
6004   extrasub="$extrasub
6005 /^@if target-$module\$/d
6006 /^@endif target-$module\$/d
6007 /^@if target-$module-$bootstrap_suffix\$/d
6008 /^@endif target-$module-$bootstrap_suffix\$/d"
6009 done
6010
6011 extrasub="$extrasub
6012 /^@if /,/^@endif /d"
6013
6014 # Create the serialization dependencies.  This uses a temporary file.
6015
6016 # Check whether --enable-serial-configure or --disable-serial-configure was given.
6017 if test "${enable_serial_configure+set}" = set; then
6018   enableval="$enable_serial_configure"
6019
6020 fi;
6021
6022 case ${enable_serial_configure} in
6023   yes)
6024     enable_serial_build_configure=yes
6025     enable_serial_host_configure=yes
6026     enable_serial_target_configure=yes
6027     ;;
6028 esac
6029
6030 # These force 'configure's to be done one at a time, to avoid problems
6031 # with contention over a shared config.cache.
6032 rm -f serdep.tmp
6033 echo '# serdep.tmp' > serdep.tmp
6034 olditem=
6035 test "x${enable_serial_build_configure}" = xyes &&
6036 for item in ${build_configdirs} ; do
6037   case ${olditem} in
6038     "") ;;
6039     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
6040   esac
6041   olditem=${item}
6042 done
6043 olditem=
6044 test "x${enable_serial_host_configure}" = xyes &&
6045 for item in ${configdirs} ; do
6046   case ${olditem} in
6047     "") ;;
6048     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
6049   esac
6050   olditem=${item}
6051 done
6052 olditem=
6053 test "x${enable_serial_target_configure}" = xyes &&
6054 for item in ${target_configdirs} ; do
6055   case ${olditem} in
6056     "") ;;
6057     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
6058   esac
6059   olditem=${item}
6060 done
6061 serialization_dependencies=serdep.tmp
6062
6063
6064 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
6065 # target, nonopt, and variable assignments.  These are the ones we
6066 # might not want to pass down to subconfigures.  Also strip
6067 # program-prefix, program-suffix, and program-transform-name, so that
6068 # we can pass down a consistent program-transform-name.
6069 baseargs=
6070 keep_next=no
6071 skip_next=no
6072 eval "set -- $ac_configure_args"
6073 for ac_arg
6074 do
6075   if test X"$skip_next" = X"yes"; then
6076     skip_next=no
6077     continue
6078   fi
6079   if test X"$keep_next" = X"yes"; then
6080     case $ac_arg in
6081       *\'*)
6082         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6083     esac
6084     baseargs="$baseargs '$ac_arg'"
6085     keep_next=no
6086     continue
6087   fi
6088
6089   # Handle separated arguments.  Based on the logic generated by
6090   # autoconf 2.59.
6091   case $ac_arg in
6092     *=* | --config-cache | -C | -disable-* | --disable-* \
6093       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
6094       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
6095       | -with-* | --with-* | -without-* | --without-* | --x)
6096       separate_arg=no
6097       ;;
6098     -*)
6099       separate_arg=yes
6100       ;;
6101     *)
6102       separate_arg=no
6103       ;;
6104   esac
6105
6106   case "$ac_arg" in
6107     --no*)
6108       continue
6109       ;;
6110     --c* | \
6111     --sr* | \
6112     --ho* | \
6113     --bu* | \
6114     --t* | \
6115     --program-* | \
6116     -cache_file* | \
6117     -srcdir* | \
6118     -host* | \
6119     -build* | \
6120     -target* | \
6121     -program-prefix* | \
6122     -program-suffix* | \
6123     -program-transform-name* )
6124       skip_next=$separate_arg
6125       continue
6126       ;;
6127     -*)
6128       # An option.  Add it.
6129       case $ac_arg in
6130         *\'*)
6131           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
6132       esac
6133       baseargs="$baseargs '$ac_arg'"
6134       keep_next=$separate_arg
6135       ;;
6136     *)
6137       # Either a variable assignment, or a nonopt (triplet).  Don't
6138       # pass it down; let the Makefile handle this.
6139       continue
6140       ;;
6141   esac
6142 done
6143 # Remove the initial space we just introduced and, as these will be
6144 # expanded by make, quote '$'.
6145 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
6146
6147 # Add in --program-transform-name, after --program-prefix and
6148 # --program-suffix have been applied to it.  Autoconf has already
6149 # doubled dollar signs and backslashes in program_transform_name; we want
6150 # the backslashes un-doubled, and then the entire thing wrapped in single
6151 # quotes, because this will be expanded first by make and then by the shell.
6152 # Also, because we want to override the logic in subdir configure scripts to
6153 # choose program_transform_name, replace any s,x,x, with s,y,y,.
6154 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
6155 ${program_transform_name}
6156 EOF_SED
6157 gcc_transform_name=`cat conftestsed.out`
6158 rm -f conftestsed.out
6159 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
6160 if test "$silent" = yes; then
6161   baseargs="$baseargs --silent"
6162 fi
6163
6164 # For the build-side libraries, we just need to pretend we're native,
6165 # and not use the same cache file.  Multilibs are neither needed nor
6166 # desired.
6167 build_configargs="--cache-file=../config.cache ${baseargs}"
6168
6169 # For host modules, accept cache file option, or specification as blank.
6170 case "${cache_file}" in
6171 "") # empty
6172   cache_file_option="" ;;
6173 /* | [A-Za-z]:[\\/]* ) # absolute path
6174   cache_file_option="--cache-file=${cache_file}" ;;
6175 *) # relative path
6176   cache_file_option="--cache-file=../${cache_file}" ;;
6177 esac
6178
6179 # Host dirs don't like to share a cache file either, horribly enough.
6180 # This seems to be due to autoconf 2.5x stupidity.
6181 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
6182
6183 target_configargs=${baseargs}
6184
6185 # Passing a --with-cross-host argument lets the target libraries know
6186 # whether they are being built with a cross-compiler or being built
6187 # native.  However, it would be better to use other mechanisms to make the
6188 # sorts of decisions they want to make on this basis.  Please consider
6189 # this option to be deprecated.  FIXME.
6190 if test x${is_cross_compiler} = xyes ; then
6191   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
6192 fi
6193
6194 # Default to --enable-multilib.
6195 if test x${enable_multilib} = x ; then
6196   target_configargs="--enable-multilib ${target_configargs}"
6197 fi
6198
6199 # Pass --with-newlib if appropriate.  Note that target_configdirs has
6200 # changed from the earlier setting of with_newlib.
6201 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
6202   target_configargs="--with-newlib ${target_configargs}"
6203 fi
6204
6205 # Different target subdirs use different values of certain variables
6206 # (notably CXX).  Worse, multilibs use *lots* of different values.
6207 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
6208 # it doesn't automatically accept command-line overrides of them.
6209 # This means it's not safe for target subdirs to share a cache file,
6210 # which is disgusting, but there you have it.  Hopefully this can be
6211 # fixed in future.  It's still worthwhile to use a cache file for each
6212 # directory.  I think.
6213
6214 # Pass the appropriate --build, --host, --target and --cache-file arguments.
6215 # We need to pass --target, as newer autoconf's requires consistency
6216 # for target_alias and gcc doesn't manage it consistently.
6217 target_configargs="--cache-file=./config.cache ${target_configargs}"
6218
6219 FLAGS_FOR_TARGET=
6220 case " $target_configdirs " in
6221  *" newlib "*)
6222   case " $target_configargs " in
6223   *" --with-newlib "*)
6224    case "$target" in
6225    *-cygwin*)
6226      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' ;;
6227    esac
6228
6229    # If we're not building GCC, don't discard standard headers.
6230    if test -d ${srcdir}/gcc; then
6231      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
6232
6233      if test "${build}" != "${host}"; then
6234        # On Canadian crosses, CC_FOR_TARGET will have already been set
6235        # by `configure', so we won't have an opportunity to add -Bgcc/
6236        # to it.  This is right: we don't want to search that directory
6237        # for binaries, but we want the header files in there, so add
6238        # them explicitly.
6239        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
6240
6241        # Someone might think of using the pre-installed headers on
6242        # Canadian crosses, in case the installed compiler is not fully
6243        # compatible with the compiler being built.  In this case, it
6244        # would be better to flag an error than risking having
6245        # incompatible object files being constructed.  We can't
6246        # guarantee that an error will be flagged, but let's hope the
6247        # compiler will do it, when presented with incompatible header
6248        # files.
6249      fi
6250    fi
6251
6252    case "${target}-${is_cross_compiler}" in
6253    i[3456789]86-*-linux*-no)
6254       # Here host == target, so we don't need to build gcc,
6255       # so we don't want to discard standard headers.
6256       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
6257       ;;
6258    *)
6259       # If we're building newlib, use its generic headers last, but search
6260       # for any libc-related directories first (so make it the last -B
6261       # switch).
6262       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
6263
6264       # If we're building libgloss, find the startup file, simulator library
6265       # and linker script.
6266       case " $target_configdirs " in
6267         *" libgloss "*)
6268         # Look for startup file, simulator library and maybe linker script.
6269         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
6270         # Look for libnosys.a in case the target needs it.
6271         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
6272         # Most targets have the linker script in the source directory.
6273         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
6274         ;;
6275       esac
6276       ;;
6277    esac
6278    ;;
6279   esac
6280   ;;
6281 esac
6282 case "$target" in
6283 *-mingw*)
6284   # Can't be handled as Cygwin above since Mingw does not use newlib.
6285   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' ;;
6286 esac
6287
6288 # Allow the user to override the flags for
6289 # our build compiler if desired.
6290 if test x"${build}" = x"${host}" ; then
6291   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6292   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6293   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6294 fi
6295
6296 # On Canadian crosses, we'll be searching the right directories for
6297 # the previously-installed cross compiler, so don't bother to add
6298 # flags for directories within the install tree of the compiler
6299 # being built; programs in there won't even run.
6300 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6301   # Search for pre-installed headers if nothing else fits.
6302   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6303 fi
6304
6305 if test "x${use_gnu_ld}" = x &&
6306    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6307   # Arrange for us to find uninstalled linker scripts.
6308   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6309 fi
6310
6311 # Search for other target-specific linker scripts and such.
6312 case "${target}" in
6313   mep*)
6314     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6315     ;;
6316 esac
6317
6318 # Makefile fragments.
6319 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6320 do
6321   eval fragval=\$$frag
6322   if test $fragval != /dev/null; then
6323     eval $frag=${srcdir}/$fragval
6324   fi
6325 done
6326
6327
6328
6329
6330
6331 # Miscellanea: directories, flags, etc.
6332
6333
6334
6335
6336
6337
6338
6339
6340 # Build module lists & subconfigure args.
6341
6342
6343
6344 # Host module lists & subconfigure args.
6345
6346
6347
6348 # Target module lists & subconfigure args.
6349
6350
6351
6352 # Build tools.
6353
6354
6355
6356
6357
6358
6359
6360
6361
6362
6363
6364
6365
6366
6367
6368
6369
6370 # Generate default definitions for YACC, M4, LEX and other programs that run
6371 # on the build machine.  These are used if the Makefile can't locate these
6372 # programs in objdir.
6373 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6374
6375 for ac_prog in 'bison -y' byacc yacc
6376 do
6377   # Extract the first word of "$ac_prog", so it can be a program name with args.
6378 set dummy $ac_prog; ac_word=$2
6379 echo "$as_me:$LINENO: checking for $ac_word" >&5
6380 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6381 if test "${ac_cv_prog_YACC+set}" = set; then
6382   echo $ECHO_N "(cached) $ECHO_C" >&6
6383 else
6384   if test -n "$YACC"; then
6385   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6386 else
6387 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6388 for as_dir in $PATH
6389 do
6390   IFS=$as_save_IFS
6391   test -z "$as_dir" && as_dir=.
6392   for ac_exec_ext in '' $ac_executable_extensions; do
6393   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6394     ac_cv_prog_YACC="$ac_prog"
6395     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6396     break 2
6397   fi
6398 done
6399 done
6400
6401 fi
6402 fi
6403 YACC=$ac_cv_prog_YACC
6404 if test -n "$YACC"; then
6405   echo "$as_me:$LINENO: result: $YACC" >&5
6406 echo "${ECHO_T}$YACC" >&6
6407 else
6408   echo "$as_me:$LINENO: result: no" >&5
6409 echo "${ECHO_T}no" >&6
6410 fi
6411
6412   test -n "$YACC" && break
6413 done
6414 test -n "$YACC" || YACC="$MISSING bison -y"
6415
6416 case " $build_configdirs " in
6417   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6418   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6419 esac
6420
6421 for ac_prog in bison
6422 do
6423   # Extract the first word of "$ac_prog", so it can be a program name with args.
6424 set dummy $ac_prog; ac_word=$2
6425 echo "$as_me:$LINENO: checking for $ac_word" >&5
6426 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6427 if test "${ac_cv_prog_BISON+set}" = set; then
6428   echo $ECHO_N "(cached) $ECHO_C" >&6
6429 else
6430   if test -n "$BISON"; then
6431   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6432 else
6433 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6434 for as_dir in $PATH
6435 do
6436   IFS=$as_save_IFS
6437   test -z "$as_dir" && as_dir=.
6438   for ac_exec_ext in '' $ac_executable_extensions; do
6439   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6440     ac_cv_prog_BISON="$ac_prog"
6441     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6442     break 2
6443   fi
6444 done
6445 done
6446
6447 fi
6448 fi
6449 BISON=$ac_cv_prog_BISON
6450 if test -n "$BISON"; then
6451   echo "$as_me:$LINENO: result: $BISON" >&5
6452 echo "${ECHO_T}$BISON" >&6
6453 else
6454   echo "$as_me:$LINENO: result: no" >&5
6455 echo "${ECHO_T}no" >&6
6456 fi
6457
6458   test -n "$BISON" && break
6459 done
6460 test -n "$BISON" || BISON="$MISSING bison"
6461
6462 case " $build_configdirs " in
6463   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6464 esac
6465
6466 for ac_prog in gm4 gnum4 m4
6467 do
6468   # Extract the first word of "$ac_prog", so it can be a program name with args.
6469 set dummy $ac_prog; ac_word=$2
6470 echo "$as_me:$LINENO: checking for $ac_word" >&5
6471 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6472 if test "${ac_cv_prog_M4+set}" = set; then
6473   echo $ECHO_N "(cached) $ECHO_C" >&6
6474 else
6475   if test -n "$M4"; then
6476   ac_cv_prog_M4="$M4" # Let the user override the test.
6477 else
6478 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6479 for as_dir in $PATH
6480 do
6481   IFS=$as_save_IFS
6482   test -z "$as_dir" && as_dir=.
6483   for ac_exec_ext in '' $ac_executable_extensions; do
6484   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6485     ac_cv_prog_M4="$ac_prog"
6486     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6487     break 2
6488   fi
6489 done
6490 done
6491
6492 fi
6493 fi
6494 M4=$ac_cv_prog_M4
6495 if test -n "$M4"; then
6496   echo "$as_me:$LINENO: result: $M4" >&5
6497 echo "${ECHO_T}$M4" >&6
6498 else
6499   echo "$as_me:$LINENO: result: no" >&5
6500 echo "${ECHO_T}no" >&6
6501 fi
6502
6503   test -n "$M4" && break
6504 done
6505 test -n "$M4" || M4="$MISSING m4"
6506
6507 case " $build_configdirs " in
6508   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6509 esac
6510
6511 for ac_prog in flex lex
6512 do
6513   # Extract the first word of "$ac_prog", so it can be a program name with args.
6514 set dummy $ac_prog; ac_word=$2
6515 echo "$as_me:$LINENO: checking for $ac_word" >&5
6516 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6517 if test "${ac_cv_prog_LEX+set}" = set; then
6518   echo $ECHO_N "(cached) $ECHO_C" >&6
6519 else
6520   if test -n "$LEX"; then
6521   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6522 else
6523 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6524 for as_dir in $PATH
6525 do
6526   IFS=$as_save_IFS
6527   test -z "$as_dir" && as_dir=.
6528   for ac_exec_ext in '' $ac_executable_extensions; do
6529   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6530     ac_cv_prog_LEX="$ac_prog"
6531     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6532     break 2
6533   fi
6534 done
6535 done
6536
6537 fi
6538 fi
6539 LEX=$ac_cv_prog_LEX
6540 if test -n "$LEX"; then
6541   echo "$as_me:$LINENO: result: $LEX" >&5
6542 echo "${ECHO_T}$LEX" >&6
6543 else
6544   echo "$as_me:$LINENO: result: no" >&5
6545 echo "${ECHO_T}no" >&6
6546 fi
6547
6548   test -n "$LEX" && break
6549 done
6550 test -n "$LEX" || LEX="$MISSING flex"
6551
6552 case " $build_configdirs " in
6553   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6554   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6555 esac
6556
6557 for ac_prog in flex
6558 do
6559   # Extract the first word of "$ac_prog", so it can be a program name with args.
6560 set dummy $ac_prog; ac_word=$2
6561 echo "$as_me:$LINENO: checking for $ac_word" >&5
6562 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6563 if test "${ac_cv_prog_FLEX+set}" = set; then
6564   echo $ECHO_N "(cached) $ECHO_C" >&6
6565 else
6566   if test -n "$FLEX"; then
6567   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6568 else
6569 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6570 for as_dir in $PATH
6571 do
6572   IFS=$as_save_IFS
6573   test -z "$as_dir" && as_dir=.
6574   for ac_exec_ext in '' $ac_executable_extensions; do
6575   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6576     ac_cv_prog_FLEX="$ac_prog"
6577     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6578     break 2
6579   fi
6580 done
6581 done
6582
6583 fi
6584 fi
6585 FLEX=$ac_cv_prog_FLEX
6586 if test -n "$FLEX"; then
6587   echo "$as_me:$LINENO: result: $FLEX" >&5
6588 echo "${ECHO_T}$FLEX" >&6
6589 else
6590   echo "$as_me:$LINENO: result: no" >&5
6591 echo "${ECHO_T}no" >&6
6592 fi
6593
6594   test -n "$FLEX" && break
6595 done
6596 test -n "$FLEX" || FLEX="$MISSING flex"
6597
6598 case " $build_configdirs " in
6599   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6600 esac
6601
6602 for ac_prog in makeinfo
6603 do
6604   # Extract the first word of "$ac_prog", so it can be a program name with args.
6605 set dummy $ac_prog; ac_word=$2
6606 echo "$as_me:$LINENO: checking for $ac_word" >&5
6607 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6608 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6609   echo $ECHO_N "(cached) $ECHO_C" >&6
6610 else
6611   if test -n "$MAKEINFO"; then
6612   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6613 else
6614 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6615 for as_dir in $PATH
6616 do
6617   IFS=$as_save_IFS
6618   test -z "$as_dir" && as_dir=.
6619   for ac_exec_ext in '' $ac_executable_extensions; do
6620   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6621     ac_cv_prog_MAKEINFO="$ac_prog"
6622     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6623     break 2
6624   fi
6625 done
6626 done
6627
6628 fi
6629 fi
6630 MAKEINFO=$ac_cv_prog_MAKEINFO
6631 if test -n "$MAKEINFO"; then
6632   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6633 echo "${ECHO_T}$MAKEINFO" >&6
6634 else
6635   echo "$as_me:$LINENO: result: no" >&5
6636 echo "${ECHO_T}no" >&6
6637 fi
6638
6639   test -n "$MAKEINFO" && break
6640 done
6641 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6642
6643 case " $build_configdirs " in
6644   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6645   *)
6646
6647     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6648     # higher, else we use the "missing" dummy.
6649     if ${MAKEINFO} --version \
6650        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6651       :
6652     else
6653       MAKEINFO="$MISSING makeinfo"
6654     fi
6655     ;;
6656
6657 esac
6658
6659 # FIXME: expect and dejagnu may become build tools?
6660
6661 for ac_prog in expect
6662 do
6663   # Extract the first word of "$ac_prog", so it can be a program name with args.
6664 set dummy $ac_prog; ac_word=$2
6665 echo "$as_me:$LINENO: checking for $ac_word" >&5
6666 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6667 if test "${ac_cv_prog_EXPECT+set}" = set; then
6668   echo $ECHO_N "(cached) $ECHO_C" >&6
6669 else
6670   if test -n "$EXPECT"; then
6671   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6672 else
6673 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6674 for as_dir in $PATH
6675 do
6676   IFS=$as_save_IFS
6677   test -z "$as_dir" && as_dir=.
6678   for ac_exec_ext in '' $ac_executable_extensions; do
6679   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6680     ac_cv_prog_EXPECT="$ac_prog"
6681     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6682     break 2
6683   fi
6684 done
6685 done
6686
6687 fi
6688 fi
6689 EXPECT=$ac_cv_prog_EXPECT
6690 if test -n "$EXPECT"; then
6691   echo "$as_me:$LINENO: result: $EXPECT" >&5
6692 echo "${ECHO_T}$EXPECT" >&6
6693 else
6694   echo "$as_me:$LINENO: result: no" >&5
6695 echo "${ECHO_T}no" >&6
6696 fi
6697
6698   test -n "$EXPECT" && break
6699 done
6700 test -n "$EXPECT" || EXPECT="expect"
6701
6702 case " $configdirs " in
6703   *" expect "*)
6704     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6705     ;;
6706 esac
6707
6708 for ac_prog in runtest
6709 do
6710   # Extract the first word of "$ac_prog", so it can be a program name with args.
6711 set dummy $ac_prog; ac_word=$2
6712 echo "$as_me:$LINENO: checking for $ac_word" >&5
6713 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6714 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6715   echo $ECHO_N "(cached) $ECHO_C" >&6
6716 else
6717   if test -n "$RUNTEST"; then
6718   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6719 else
6720 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6721 for as_dir in $PATH
6722 do
6723   IFS=$as_save_IFS
6724   test -z "$as_dir" && as_dir=.
6725   for ac_exec_ext in '' $ac_executable_extensions; do
6726   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6727     ac_cv_prog_RUNTEST="$ac_prog"
6728     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6729     break 2
6730   fi
6731 done
6732 done
6733
6734 fi
6735 fi
6736 RUNTEST=$ac_cv_prog_RUNTEST
6737 if test -n "$RUNTEST"; then
6738   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6739 echo "${ECHO_T}$RUNTEST" >&6
6740 else
6741   echo "$as_me:$LINENO: result: no" >&5
6742 echo "${ECHO_T}no" >&6
6743 fi
6744
6745   test -n "$RUNTEST" && break
6746 done
6747 test -n "$RUNTEST" || RUNTEST="runtest"
6748
6749 case " $configdirs " in
6750   *" dejagnu "*)
6751     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6752     ;;
6753 esac
6754
6755
6756 # Host tools.
6757 ncn_tool_prefix=
6758 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6759 ncn_target_tool_prefix=
6760 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6761
6762
6763
6764 if test -n "$AR"; then
6765   ac_cv_prog_AR=$AR
6766 elif test -n "$ac_cv_prog_AR"; then
6767   AR=$ac_cv_prog_AR
6768 fi
6769
6770 if test -n "$ac_cv_prog_AR"; then
6771   for ncn_progname in ar; do
6772     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6773 set dummy ${ncn_progname}; ac_word=$2
6774 echo "$as_me:$LINENO: checking for $ac_word" >&5
6775 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6776 if test "${ac_cv_prog_AR+set}" = set; then
6777   echo $ECHO_N "(cached) $ECHO_C" >&6
6778 else
6779   if test -n "$AR"; then
6780   ac_cv_prog_AR="$AR" # Let the user override the test.
6781 else
6782 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6783 for as_dir in $PATH
6784 do
6785   IFS=$as_save_IFS
6786   test -z "$as_dir" && as_dir=.
6787   for ac_exec_ext in '' $ac_executable_extensions; do
6788   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6789     ac_cv_prog_AR="${ncn_progname}"
6790     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6791     break 2
6792   fi
6793 done
6794 done
6795
6796 fi
6797 fi
6798 AR=$ac_cv_prog_AR
6799 if test -n "$AR"; then
6800   echo "$as_me:$LINENO: result: $AR" >&5
6801 echo "${ECHO_T}$AR" >&6
6802 else
6803   echo "$as_me:$LINENO: result: no" >&5
6804 echo "${ECHO_T}no" >&6
6805 fi
6806
6807   done
6808 fi
6809
6810 for ncn_progname in ar; do
6811   if test -n "$ncn_tool_prefix"; then
6812     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6813 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6814 echo "$as_me:$LINENO: checking for $ac_word" >&5
6815 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6816 if test "${ac_cv_prog_AR+set}" = set; then
6817   echo $ECHO_N "(cached) $ECHO_C" >&6
6818 else
6819   if test -n "$AR"; then
6820   ac_cv_prog_AR="$AR" # Let the user override the test.
6821 else
6822 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6823 for as_dir in $PATH
6824 do
6825   IFS=$as_save_IFS
6826   test -z "$as_dir" && as_dir=.
6827   for ac_exec_ext in '' $ac_executable_extensions; do
6828   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6829     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6830     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6831     break 2
6832   fi
6833 done
6834 done
6835
6836 fi
6837 fi
6838 AR=$ac_cv_prog_AR
6839 if test -n "$AR"; then
6840   echo "$as_me:$LINENO: result: $AR" >&5
6841 echo "${ECHO_T}$AR" >&6
6842 else
6843   echo "$as_me:$LINENO: result: no" >&5
6844 echo "${ECHO_T}no" >&6
6845 fi
6846
6847   fi
6848   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6849     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6850 set dummy ${ncn_progname}; ac_word=$2
6851 echo "$as_me:$LINENO: checking for $ac_word" >&5
6852 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6853 if test "${ac_cv_prog_AR+set}" = set; then
6854   echo $ECHO_N "(cached) $ECHO_C" >&6
6855 else
6856   if test -n "$AR"; then
6857   ac_cv_prog_AR="$AR" # Let the user override the test.
6858 else
6859 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6860 for as_dir in $PATH
6861 do
6862   IFS=$as_save_IFS
6863   test -z "$as_dir" && as_dir=.
6864   for ac_exec_ext in '' $ac_executable_extensions; do
6865   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6866     ac_cv_prog_AR="${ncn_progname}"
6867     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6868     break 2
6869   fi
6870 done
6871 done
6872
6873 fi
6874 fi
6875 AR=$ac_cv_prog_AR
6876 if test -n "$AR"; then
6877   echo "$as_me:$LINENO: result: $AR" >&5
6878 echo "${ECHO_T}$AR" >&6
6879 else
6880   echo "$as_me:$LINENO: result: no" >&5
6881 echo "${ECHO_T}no" >&6
6882 fi
6883
6884   fi
6885   test -n "$ac_cv_prog_AR" && break
6886 done
6887
6888 if test -z "$ac_cv_prog_AR" ; then
6889   set dummy ar
6890   if test $build = $host ; then
6891     AR="$2"
6892   else
6893     AR="${ncn_tool_prefix}$2"
6894   fi
6895 fi
6896
6897
6898
6899 if test -n "$AS"; then
6900   ac_cv_prog_AS=$AS
6901 elif test -n "$ac_cv_prog_AS"; then
6902   AS=$ac_cv_prog_AS
6903 fi
6904
6905 if test -n "$ac_cv_prog_AS"; then
6906   for ncn_progname in as; do
6907     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6908 set dummy ${ncn_progname}; ac_word=$2
6909 echo "$as_me:$LINENO: checking for $ac_word" >&5
6910 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6911 if test "${ac_cv_prog_AS+set}" = set; then
6912   echo $ECHO_N "(cached) $ECHO_C" >&6
6913 else
6914   if test -n "$AS"; then
6915   ac_cv_prog_AS="$AS" # Let the user override the test.
6916 else
6917 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6918 for as_dir in $PATH
6919 do
6920   IFS=$as_save_IFS
6921   test -z "$as_dir" && as_dir=.
6922   for ac_exec_ext in '' $ac_executable_extensions; do
6923   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6924     ac_cv_prog_AS="${ncn_progname}"
6925     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6926     break 2
6927   fi
6928 done
6929 done
6930
6931 fi
6932 fi
6933 AS=$ac_cv_prog_AS
6934 if test -n "$AS"; then
6935   echo "$as_me:$LINENO: result: $AS" >&5
6936 echo "${ECHO_T}$AS" >&6
6937 else
6938   echo "$as_me:$LINENO: result: no" >&5
6939 echo "${ECHO_T}no" >&6
6940 fi
6941
6942   done
6943 fi
6944
6945 for ncn_progname in as; do
6946   if test -n "$ncn_tool_prefix"; then
6947     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6948 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6949 echo "$as_me:$LINENO: checking for $ac_word" >&5
6950 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6951 if test "${ac_cv_prog_AS+set}" = set; then
6952   echo $ECHO_N "(cached) $ECHO_C" >&6
6953 else
6954   if test -n "$AS"; then
6955   ac_cv_prog_AS="$AS" # Let the user override the test.
6956 else
6957 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6958 for as_dir in $PATH
6959 do
6960   IFS=$as_save_IFS
6961   test -z "$as_dir" && as_dir=.
6962   for ac_exec_ext in '' $ac_executable_extensions; do
6963   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6964     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6965     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6966     break 2
6967   fi
6968 done
6969 done
6970
6971 fi
6972 fi
6973 AS=$ac_cv_prog_AS
6974 if test -n "$AS"; then
6975   echo "$as_me:$LINENO: result: $AS" >&5
6976 echo "${ECHO_T}$AS" >&6
6977 else
6978   echo "$as_me:$LINENO: result: no" >&5
6979 echo "${ECHO_T}no" >&6
6980 fi
6981
6982   fi
6983   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6984     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6985 set dummy ${ncn_progname}; ac_word=$2
6986 echo "$as_me:$LINENO: checking for $ac_word" >&5
6987 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6988 if test "${ac_cv_prog_AS+set}" = set; then
6989   echo $ECHO_N "(cached) $ECHO_C" >&6
6990 else
6991   if test -n "$AS"; then
6992   ac_cv_prog_AS="$AS" # Let the user override the test.
6993 else
6994 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6995 for as_dir in $PATH
6996 do
6997   IFS=$as_save_IFS
6998   test -z "$as_dir" && as_dir=.
6999   for ac_exec_ext in '' $ac_executable_extensions; do
7000   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7001     ac_cv_prog_AS="${ncn_progname}"
7002     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7003     break 2
7004   fi
7005 done
7006 done
7007
7008 fi
7009 fi
7010 AS=$ac_cv_prog_AS
7011 if test -n "$AS"; then
7012   echo "$as_me:$LINENO: result: $AS" >&5
7013 echo "${ECHO_T}$AS" >&6
7014 else
7015   echo "$as_me:$LINENO: result: no" >&5
7016 echo "${ECHO_T}no" >&6
7017 fi
7018
7019   fi
7020   test -n "$ac_cv_prog_AS" && break
7021 done
7022
7023 if test -z "$ac_cv_prog_AS" ; then
7024   set dummy as
7025   if test $build = $host ; then
7026     AS="$2"
7027   else
7028     AS="${ncn_tool_prefix}$2"
7029   fi
7030 fi
7031
7032
7033
7034 if test -n "$DLLTOOL"; then
7035   ac_cv_prog_DLLTOOL=$DLLTOOL
7036 elif test -n "$ac_cv_prog_DLLTOOL"; then
7037   DLLTOOL=$ac_cv_prog_DLLTOOL
7038 fi
7039
7040 if test -n "$ac_cv_prog_DLLTOOL"; then
7041   for ncn_progname in dlltool; do
7042     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7043 set dummy ${ncn_progname}; ac_word=$2
7044 echo "$as_me:$LINENO: checking for $ac_word" >&5
7045 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7046 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7047   echo $ECHO_N "(cached) $ECHO_C" >&6
7048 else
7049   if test -n "$DLLTOOL"; then
7050   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7051 else
7052 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7053 for as_dir in $PATH
7054 do
7055   IFS=$as_save_IFS
7056   test -z "$as_dir" && as_dir=.
7057   for ac_exec_ext in '' $ac_executable_extensions; do
7058   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7059     ac_cv_prog_DLLTOOL="${ncn_progname}"
7060     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7061     break 2
7062   fi
7063 done
7064 done
7065
7066 fi
7067 fi
7068 DLLTOOL=$ac_cv_prog_DLLTOOL
7069 if test -n "$DLLTOOL"; then
7070   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7071 echo "${ECHO_T}$DLLTOOL" >&6
7072 else
7073   echo "$as_me:$LINENO: result: no" >&5
7074 echo "${ECHO_T}no" >&6
7075 fi
7076
7077   done
7078 fi
7079
7080 for ncn_progname in dlltool; do
7081   if test -n "$ncn_tool_prefix"; then
7082     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7083 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7084 echo "$as_me:$LINENO: checking for $ac_word" >&5
7085 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7086 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7087   echo $ECHO_N "(cached) $ECHO_C" >&6
7088 else
7089   if test -n "$DLLTOOL"; then
7090   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7091 else
7092 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7093 for as_dir in $PATH
7094 do
7095   IFS=$as_save_IFS
7096   test -z "$as_dir" && as_dir=.
7097   for ac_exec_ext in '' $ac_executable_extensions; do
7098   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7099     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
7100     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7101     break 2
7102   fi
7103 done
7104 done
7105
7106 fi
7107 fi
7108 DLLTOOL=$ac_cv_prog_DLLTOOL
7109 if test -n "$DLLTOOL"; then
7110   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7111 echo "${ECHO_T}$DLLTOOL" >&6
7112 else
7113   echo "$as_me:$LINENO: result: no" >&5
7114 echo "${ECHO_T}no" >&6
7115 fi
7116
7117   fi
7118   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
7119     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7120 set dummy ${ncn_progname}; ac_word=$2
7121 echo "$as_me:$LINENO: checking for $ac_word" >&5
7122 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7123 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
7124   echo $ECHO_N "(cached) $ECHO_C" >&6
7125 else
7126   if test -n "$DLLTOOL"; then
7127   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
7128 else
7129 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7130 for as_dir in $PATH
7131 do
7132   IFS=$as_save_IFS
7133   test -z "$as_dir" && as_dir=.
7134   for ac_exec_ext in '' $ac_executable_extensions; do
7135   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7136     ac_cv_prog_DLLTOOL="${ncn_progname}"
7137     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7138     break 2
7139   fi
7140 done
7141 done
7142
7143 fi
7144 fi
7145 DLLTOOL=$ac_cv_prog_DLLTOOL
7146 if test -n "$DLLTOOL"; then
7147   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
7148 echo "${ECHO_T}$DLLTOOL" >&6
7149 else
7150   echo "$as_me:$LINENO: result: no" >&5
7151 echo "${ECHO_T}no" >&6
7152 fi
7153
7154   fi
7155   test -n "$ac_cv_prog_DLLTOOL" && break
7156 done
7157
7158 if test -z "$ac_cv_prog_DLLTOOL" ; then
7159   set dummy dlltool
7160   if test $build = $host ; then
7161     DLLTOOL="$2"
7162   else
7163     DLLTOOL="${ncn_tool_prefix}$2"
7164   fi
7165 fi
7166
7167
7168
7169 if test -n "$LD"; then
7170   ac_cv_prog_LD=$LD
7171 elif test -n "$ac_cv_prog_LD"; then
7172   LD=$ac_cv_prog_LD
7173 fi
7174
7175 if test -n "$ac_cv_prog_LD"; then
7176   for ncn_progname in ld; do
7177     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7178 set dummy ${ncn_progname}; ac_word=$2
7179 echo "$as_me:$LINENO: checking for $ac_word" >&5
7180 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7181 if test "${ac_cv_prog_LD+set}" = set; then
7182   echo $ECHO_N "(cached) $ECHO_C" >&6
7183 else
7184   if test -n "$LD"; then
7185   ac_cv_prog_LD="$LD" # Let the user override the test.
7186 else
7187 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7188 for as_dir in $PATH
7189 do
7190   IFS=$as_save_IFS
7191   test -z "$as_dir" && as_dir=.
7192   for ac_exec_ext in '' $ac_executable_extensions; do
7193   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7194     ac_cv_prog_LD="${ncn_progname}"
7195     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7196     break 2
7197   fi
7198 done
7199 done
7200
7201 fi
7202 fi
7203 LD=$ac_cv_prog_LD
7204 if test -n "$LD"; then
7205   echo "$as_me:$LINENO: result: $LD" >&5
7206 echo "${ECHO_T}$LD" >&6
7207 else
7208   echo "$as_me:$LINENO: result: no" >&5
7209 echo "${ECHO_T}no" >&6
7210 fi
7211
7212   done
7213 fi
7214
7215 for ncn_progname in ld; do
7216   if test -n "$ncn_tool_prefix"; then
7217     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7218 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7219 echo "$as_me:$LINENO: checking for $ac_word" >&5
7220 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7221 if test "${ac_cv_prog_LD+set}" = set; then
7222   echo $ECHO_N "(cached) $ECHO_C" >&6
7223 else
7224   if test -n "$LD"; then
7225   ac_cv_prog_LD="$LD" # Let the user override the test.
7226 else
7227 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7228 for as_dir in $PATH
7229 do
7230   IFS=$as_save_IFS
7231   test -z "$as_dir" && as_dir=.
7232   for ac_exec_ext in '' $ac_executable_extensions; do
7233   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7234     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
7235     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7236     break 2
7237   fi
7238 done
7239 done
7240
7241 fi
7242 fi
7243 LD=$ac_cv_prog_LD
7244 if test -n "$LD"; then
7245   echo "$as_me:$LINENO: result: $LD" >&5
7246 echo "${ECHO_T}$LD" >&6
7247 else
7248   echo "$as_me:$LINENO: result: no" >&5
7249 echo "${ECHO_T}no" >&6
7250 fi
7251
7252   fi
7253   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
7254     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7255 set dummy ${ncn_progname}; ac_word=$2
7256 echo "$as_me:$LINENO: checking for $ac_word" >&5
7257 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7258 if test "${ac_cv_prog_LD+set}" = set; then
7259   echo $ECHO_N "(cached) $ECHO_C" >&6
7260 else
7261   if test -n "$LD"; then
7262   ac_cv_prog_LD="$LD" # Let the user override the test.
7263 else
7264 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7265 for as_dir in $PATH
7266 do
7267   IFS=$as_save_IFS
7268   test -z "$as_dir" && as_dir=.
7269   for ac_exec_ext in '' $ac_executable_extensions; do
7270   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7271     ac_cv_prog_LD="${ncn_progname}"
7272     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7273     break 2
7274   fi
7275 done
7276 done
7277
7278 fi
7279 fi
7280 LD=$ac_cv_prog_LD
7281 if test -n "$LD"; then
7282   echo "$as_me:$LINENO: result: $LD" >&5
7283 echo "${ECHO_T}$LD" >&6
7284 else
7285   echo "$as_me:$LINENO: result: no" >&5
7286 echo "${ECHO_T}no" >&6
7287 fi
7288
7289   fi
7290   test -n "$ac_cv_prog_LD" && break
7291 done
7292
7293 if test -z "$ac_cv_prog_LD" ; then
7294   set dummy ld
7295   if test $build = $host ; then
7296     LD="$2"
7297   else
7298     LD="${ncn_tool_prefix}$2"
7299   fi
7300 fi
7301
7302
7303
7304 if test -n "$LIPO"; then
7305   ac_cv_prog_LIPO=$LIPO
7306 elif test -n "$ac_cv_prog_LIPO"; then
7307   LIPO=$ac_cv_prog_LIPO
7308 fi
7309
7310 if test -n "$ac_cv_prog_LIPO"; then
7311   for ncn_progname in lipo; do
7312     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7313 set dummy ${ncn_progname}; ac_word=$2
7314 echo "$as_me:$LINENO: checking for $ac_word" >&5
7315 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7316 if test "${ac_cv_prog_LIPO+set}" = set; then
7317   echo $ECHO_N "(cached) $ECHO_C" >&6
7318 else
7319   if test -n "$LIPO"; then
7320   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7321 else
7322 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7323 for as_dir in $PATH
7324 do
7325   IFS=$as_save_IFS
7326   test -z "$as_dir" && as_dir=.
7327   for ac_exec_ext in '' $ac_executable_extensions; do
7328   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7329     ac_cv_prog_LIPO="${ncn_progname}"
7330     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7331     break 2
7332   fi
7333 done
7334 done
7335
7336 fi
7337 fi
7338 LIPO=$ac_cv_prog_LIPO
7339 if test -n "$LIPO"; then
7340   echo "$as_me:$LINENO: result: $LIPO" >&5
7341 echo "${ECHO_T}$LIPO" >&6
7342 else
7343   echo "$as_me:$LINENO: result: no" >&5
7344 echo "${ECHO_T}no" >&6
7345 fi
7346
7347   done
7348 fi
7349
7350 for ncn_progname in lipo; do
7351   if test -n "$ncn_tool_prefix"; then
7352     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7353 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7354 echo "$as_me:$LINENO: checking for $ac_word" >&5
7355 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7356 if test "${ac_cv_prog_LIPO+set}" = set; then
7357   echo $ECHO_N "(cached) $ECHO_C" >&6
7358 else
7359   if test -n "$LIPO"; then
7360   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7361 else
7362 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7363 for as_dir in $PATH
7364 do
7365   IFS=$as_save_IFS
7366   test -z "$as_dir" && as_dir=.
7367   for ac_exec_ext in '' $ac_executable_extensions; do
7368   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7369     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7370     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7371     break 2
7372   fi
7373 done
7374 done
7375
7376 fi
7377 fi
7378 LIPO=$ac_cv_prog_LIPO
7379 if test -n "$LIPO"; then
7380   echo "$as_me:$LINENO: result: $LIPO" >&5
7381 echo "${ECHO_T}$LIPO" >&6
7382 else
7383   echo "$as_me:$LINENO: result: no" >&5
7384 echo "${ECHO_T}no" >&6
7385 fi
7386
7387   fi
7388   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7389     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7390 set dummy ${ncn_progname}; ac_word=$2
7391 echo "$as_me:$LINENO: checking for $ac_word" >&5
7392 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7393 if test "${ac_cv_prog_LIPO+set}" = set; then
7394   echo $ECHO_N "(cached) $ECHO_C" >&6
7395 else
7396   if test -n "$LIPO"; then
7397   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7398 else
7399 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7400 for as_dir in $PATH
7401 do
7402   IFS=$as_save_IFS
7403   test -z "$as_dir" && as_dir=.
7404   for ac_exec_ext in '' $ac_executable_extensions; do
7405   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7406     ac_cv_prog_LIPO="${ncn_progname}"
7407     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7408     break 2
7409   fi
7410 done
7411 done
7412
7413 fi
7414 fi
7415 LIPO=$ac_cv_prog_LIPO
7416 if test -n "$LIPO"; then
7417   echo "$as_me:$LINENO: result: $LIPO" >&5
7418 echo "${ECHO_T}$LIPO" >&6
7419 else
7420   echo "$as_me:$LINENO: result: no" >&5
7421 echo "${ECHO_T}no" >&6
7422 fi
7423
7424   fi
7425   test -n "$ac_cv_prog_LIPO" && break
7426 done
7427
7428 if test -z "$ac_cv_prog_LIPO" ; then
7429   set dummy lipo
7430   if test $build = $host ; then
7431     LIPO="$2"
7432   else
7433     LIPO="${ncn_tool_prefix}$2"
7434   fi
7435 fi
7436
7437
7438
7439 if test -n "$NM"; then
7440   ac_cv_prog_NM=$NM
7441 elif test -n "$ac_cv_prog_NM"; then
7442   NM=$ac_cv_prog_NM
7443 fi
7444
7445 if test -n "$ac_cv_prog_NM"; then
7446   for ncn_progname in nm; do
7447     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7448 set dummy ${ncn_progname}; ac_word=$2
7449 echo "$as_me:$LINENO: checking for $ac_word" >&5
7450 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7451 if test "${ac_cv_prog_NM+set}" = set; then
7452   echo $ECHO_N "(cached) $ECHO_C" >&6
7453 else
7454   if test -n "$NM"; then
7455   ac_cv_prog_NM="$NM" # Let the user override the test.
7456 else
7457 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7458 for as_dir in $PATH
7459 do
7460   IFS=$as_save_IFS
7461   test -z "$as_dir" && as_dir=.
7462   for ac_exec_ext in '' $ac_executable_extensions; do
7463   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7464     ac_cv_prog_NM="${ncn_progname}"
7465     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7466     break 2
7467   fi
7468 done
7469 done
7470
7471 fi
7472 fi
7473 NM=$ac_cv_prog_NM
7474 if test -n "$NM"; then
7475   echo "$as_me:$LINENO: result: $NM" >&5
7476 echo "${ECHO_T}$NM" >&6
7477 else
7478   echo "$as_me:$LINENO: result: no" >&5
7479 echo "${ECHO_T}no" >&6
7480 fi
7481
7482   done
7483 fi
7484
7485 for ncn_progname in nm; do
7486   if test -n "$ncn_tool_prefix"; then
7487     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7488 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7489 echo "$as_me:$LINENO: checking for $ac_word" >&5
7490 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7491 if test "${ac_cv_prog_NM+set}" = set; then
7492   echo $ECHO_N "(cached) $ECHO_C" >&6
7493 else
7494   if test -n "$NM"; then
7495   ac_cv_prog_NM="$NM" # Let the user override the test.
7496 else
7497 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7498 for as_dir in $PATH
7499 do
7500   IFS=$as_save_IFS
7501   test -z "$as_dir" && as_dir=.
7502   for ac_exec_ext in '' $ac_executable_extensions; do
7503   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7504     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7505     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7506     break 2
7507   fi
7508 done
7509 done
7510
7511 fi
7512 fi
7513 NM=$ac_cv_prog_NM
7514 if test -n "$NM"; then
7515   echo "$as_me:$LINENO: result: $NM" >&5
7516 echo "${ECHO_T}$NM" >&6
7517 else
7518   echo "$as_me:$LINENO: result: no" >&5
7519 echo "${ECHO_T}no" >&6
7520 fi
7521
7522   fi
7523   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7524     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7525 set dummy ${ncn_progname}; ac_word=$2
7526 echo "$as_me:$LINENO: checking for $ac_word" >&5
7527 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7528 if test "${ac_cv_prog_NM+set}" = set; then
7529   echo $ECHO_N "(cached) $ECHO_C" >&6
7530 else
7531   if test -n "$NM"; then
7532   ac_cv_prog_NM="$NM" # Let the user override the test.
7533 else
7534 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7535 for as_dir in $PATH
7536 do
7537   IFS=$as_save_IFS
7538   test -z "$as_dir" && as_dir=.
7539   for ac_exec_ext in '' $ac_executable_extensions; do
7540   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7541     ac_cv_prog_NM="${ncn_progname}"
7542     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7543     break 2
7544   fi
7545 done
7546 done
7547
7548 fi
7549 fi
7550 NM=$ac_cv_prog_NM
7551 if test -n "$NM"; then
7552   echo "$as_me:$LINENO: result: $NM" >&5
7553 echo "${ECHO_T}$NM" >&6
7554 else
7555   echo "$as_me:$LINENO: result: no" >&5
7556 echo "${ECHO_T}no" >&6
7557 fi
7558
7559   fi
7560   test -n "$ac_cv_prog_NM" && break
7561 done
7562
7563 if test -z "$ac_cv_prog_NM" ; then
7564   set dummy nm
7565   if test $build = $host ; then
7566     NM="$2"
7567   else
7568     NM="${ncn_tool_prefix}$2"
7569   fi
7570 fi
7571
7572
7573
7574 if test -n "$RANLIB"; then
7575   ac_cv_prog_RANLIB=$RANLIB
7576 elif test -n "$ac_cv_prog_RANLIB"; then
7577   RANLIB=$ac_cv_prog_RANLIB
7578 fi
7579
7580 if test -n "$ac_cv_prog_RANLIB"; then
7581   for ncn_progname in ranlib; do
7582     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7583 set dummy ${ncn_progname}; ac_word=$2
7584 echo "$as_me:$LINENO: checking for $ac_word" >&5
7585 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7586 if test "${ac_cv_prog_RANLIB+set}" = set; then
7587   echo $ECHO_N "(cached) $ECHO_C" >&6
7588 else
7589   if test -n "$RANLIB"; then
7590   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7591 else
7592 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7593 for as_dir in $PATH
7594 do
7595   IFS=$as_save_IFS
7596   test -z "$as_dir" && as_dir=.
7597   for ac_exec_ext in '' $ac_executable_extensions; do
7598   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7599     ac_cv_prog_RANLIB="${ncn_progname}"
7600     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7601     break 2
7602   fi
7603 done
7604 done
7605
7606 fi
7607 fi
7608 RANLIB=$ac_cv_prog_RANLIB
7609 if test -n "$RANLIB"; then
7610   echo "$as_me:$LINENO: result: $RANLIB" >&5
7611 echo "${ECHO_T}$RANLIB" >&6
7612 else
7613   echo "$as_me:$LINENO: result: no" >&5
7614 echo "${ECHO_T}no" >&6
7615 fi
7616
7617   done
7618 fi
7619
7620 for ncn_progname in ranlib; do
7621   if test -n "$ncn_tool_prefix"; then
7622     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7623 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7624 echo "$as_me:$LINENO: checking for $ac_word" >&5
7625 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7626 if test "${ac_cv_prog_RANLIB+set}" = set; then
7627   echo $ECHO_N "(cached) $ECHO_C" >&6
7628 else
7629   if test -n "$RANLIB"; then
7630   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7631 else
7632 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7633 for as_dir in $PATH
7634 do
7635   IFS=$as_save_IFS
7636   test -z "$as_dir" && as_dir=.
7637   for ac_exec_ext in '' $ac_executable_extensions; do
7638   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7639     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7640     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7641     break 2
7642   fi
7643 done
7644 done
7645
7646 fi
7647 fi
7648 RANLIB=$ac_cv_prog_RANLIB
7649 if test -n "$RANLIB"; then
7650   echo "$as_me:$LINENO: result: $RANLIB" >&5
7651 echo "${ECHO_T}$RANLIB" >&6
7652 else
7653   echo "$as_me:$LINENO: result: no" >&5
7654 echo "${ECHO_T}no" >&6
7655 fi
7656
7657   fi
7658   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7659     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7660 set dummy ${ncn_progname}; ac_word=$2
7661 echo "$as_me:$LINENO: checking for $ac_word" >&5
7662 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7663 if test "${ac_cv_prog_RANLIB+set}" = set; then
7664   echo $ECHO_N "(cached) $ECHO_C" >&6
7665 else
7666   if test -n "$RANLIB"; then
7667   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7668 else
7669 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7670 for as_dir in $PATH
7671 do
7672   IFS=$as_save_IFS
7673   test -z "$as_dir" && as_dir=.
7674   for ac_exec_ext in '' $ac_executable_extensions; do
7675   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7676     ac_cv_prog_RANLIB="${ncn_progname}"
7677     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7678     break 2
7679   fi
7680 done
7681 done
7682
7683 fi
7684 fi
7685 RANLIB=$ac_cv_prog_RANLIB
7686 if test -n "$RANLIB"; then
7687   echo "$as_me:$LINENO: result: $RANLIB" >&5
7688 echo "${ECHO_T}$RANLIB" >&6
7689 else
7690   echo "$as_me:$LINENO: result: no" >&5
7691 echo "${ECHO_T}no" >&6
7692 fi
7693
7694   fi
7695   test -n "$ac_cv_prog_RANLIB" && break
7696 done
7697
7698 if test -z "$ac_cv_prog_RANLIB" ; then
7699   RANLIB=":"
7700 fi
7701
7702
7703
7704 if test -n "$STRIP"; then
7705   ac_cv_prog_STRIP=$STRIP
7706 elif test -n "$ac_cv_prog_STRIP"; then
7707   STRIP=$ac_cv_prog_STRIP
7708 fi
7709
7710 if test -n "$ac_cv_prog_STRIP"; then
7711   for ncn_progname in strip; do
7712     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7713 set dummy ${ncn_progname}; ac_word=$2
7714 echo "$as_me:$LINENO: checking for $ac_word" >&5
7715 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7716 if test "${ac_cv_prog_STRIP+set}" = set; then
7717   echo $ECHO_N "(cached) $ECHO_C" >&6
7718 else
7719   if test -n "$STRIP"; then
7720   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7721 else
7722 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7723 for as_dir in $PATH
7724 do
7725   IFS=$as_save_IFS
7726   test -z "$as_dir" && as_dir=.
7727   for ac_exec_ext in '' $ac_executable_extensions; do
7728   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7729     ac_cv_prog_STRIP="${ncn_progname}"
7730     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7731     break 2
7732   fi
7733 done
7734 done
7735
7736 fi
7737 fi
7738 STRIP=$ac_cv_prog_STRIP
7739 if test -n "$STRIP"; then
7740   echo "$as_me:$LINENO: result: $STRIP" >&5
7741 echo "${ECHO_T}$STRIP" >&6
7742 else
7743   echo "$as_me:$LINENO: result: no" >&5
7744 echo "${ECHO_T}no" >&6
7745 fi
7746
7747   done
7748 fi
7749
7750 for ncn_progname in strip; do
7751   if test -n "$ncn_tool_prefix"; then
7752     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7753 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7754 echo "$as_me:$LINENO: checking for $ac_word" >&5
7755 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7756 if test "${ac_cv_prog_STRIP+set}" = set; then
7757   echo $ECHO_N "(cached) $ECHO_C" >&6
7758 else
7759   if test -n "$STRIP"; then
7760   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7761 else
7762 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7763 for as_dir in $PATH
7764 do
7765   IFS=$as_save_IFS
7766   test -z "$as_dir" && as_dir=.
7767   for ac_exec_ext in '' $ac_executable_extensions; do
7768   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7769     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7770     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7771     break 2
7772   fi
7773 done
7774 done
7775
7776 fi
7777 fi
7778 STRIP=$ac_cv_prog_STRIP
7779 if test -n "$STRIP"; then
7780   echo "$as_me:$LINENO: result: $STRIP" >&5
7781 echo "${ECHO_T}$STRIP" >&6
7782 else
7783   echo "$as_me:$LINENO: result: no" >&5
7784 echo "${ECHO_T}no" >&6
7785 fi
7786
7787   fi
7788   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7789     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7790 set dummy ${ncn_progname}; ac_word=$2
7791 echo "$as_me:$LINENO: checking for $ac_word" >&5
7792 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7793 if test "${ac_cv_prog_STRIP+set}" = set; then
7794   echo $ECHO_N "(cached) $ECHO_C" >&6
7795 else
7796   if test -n "$STRIP"; then
7797   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7798 else
7799 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7800 for as_dir in $PATH
7801 do
7802   IFS=$as_save_IFS
7803   test -z "$as_dir" && as_dir=.
7804   for ac_exec_ext in '' $ac_executable_extensions; do
7805   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7806     ac_cv_prog_STRIP="${ncn_progname}"
7807     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7808     break 2
7809   fi
7810 done
7811 done
7812
7813 fi
7814 fi
7815 STRIP=$ac_cv_prog_STRIP
7816 if test -n "$STRIP"; then
7817   echo "$as_me:$LINENO: result: $STRIP" >&5
7818 echo "${ECHO_T}$STRIP" >&6
7819 else
7820   echo "$as_me:$LINENO: result: no" >&5
7821 echo "${ECHO_T}no" >&6
7822 fi
7823
7824   fi
7825   test -n "$ac_cv_prog_STRIP" && break
7826 done
7827
7828 if test -z "$ac_cv_prog_STRIP" ; then
7829   STRIP=":"
7830 fi
7831
7832
7833
7834 if test -n "$WINDRES"; then
7835   ac_cv_prog_WINDRES=$WINDRES
7836 elif test -n "$ac_cv_prog_WINDRES"; then
7837   WINDRES=$ac_cv_prog_WINDRES
7838 fi
7839
7840 if test -n "$ac_cv_prog_WINDRES"; then
7841   for ncn_progname in windres; do
7842     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7843 set dummy ${ncn_progname}; ac_word=$2
7844 echo "$as_me:$LINENO: checking for $ac_word" >&5
7845 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7846 if test "${ac_cv_prog_WINDRES+set}" = set; then
7847   echo $ECHO_N "(cached) $ECHO_C" >&6
7848 else
7849   if test -n "$WINDRES"; then
7850   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7851 else
7852 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7853 for as_dir in $PATH
7854 do
7855   IFS=$as_save_IFS
7856   test -z "$as_dir" && as_dir=.
7857   for ac_exec_ext in '' $ac_executable_extensions; do
7858   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7859     ac_cv_prog_WINDRES="${ncn_progname}"
7860     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7861     break 2
7862   fi
7863 done
7864 done
7865
7866 fi
7867 fi
7868 WINDRES=$ac_cv_prog_WINDRES
7869 if test -n "$WINDRES"; then
7870   echo "$as_me:$LINENO: result: $WINDRES" >&5
7871 echo "${ECHO_T}$WINDRES" >&6
7872 else
7873   echo "$as_me:$LINENO: result: no" >&5
7874 echo "${ECHO_T}no" >&6
7875 fi
7876
7877   done
7878 fi
7879
7880 for ncn_progname in windres; do
7881   if test -n "$ncn_tool_prefix"; then
7882     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7883 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7884 echo "$as_me:$LINENO: checking for $ac_word" >&5
7885 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7886 if test "${ac_cv_prog_WINDRES+set}" = set; then
7887   echo $ECHO_N "(cached) $ECHO_C" >&6
7888 else
7889   if test -n "$WINDRES"; then
7890   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7891 else
7892 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7893 for as_dir in $PATH
7894 do
7895   IFS=$as_save_IFS
7896   test -z "$as_dir" && as_dir=.
7897   for ac_exec_ext in '' $ac_executable_extensions; do
7898   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7899     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7900     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7901     break 2
7902   fi
7903 done
7904 done
7905
7906 fi
7907 fi
7908 WINDRES=$ac_cv_prog_WINDRES
7909 if test -n "$WINDRES"; then
7910   echo "$as_me:$LINENO: result: $WINDRES" >&5
7911 echo "${ECHO_T}$WINDRES" >&6
7912 else
7913   echo "$as_me:$LINENO: result: no" >&5
7914 echo "${ECHO_T}no" >&6
7915 fi
7916
7917   fi
7918   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7919     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7920 set dummy ${ncn_progname}; ac_word=$2
7921 echo "$as_me:$LINENO: checking for $ac_word" >&5
7922 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7923 if test "${ac_cv_prog_WINDRES+set}" = set; then
7924   echo $ECHO_N "(cached) $ECHO_C" >&6
7925 else
7926   if test -n "$WINDRES"; then
7927   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7928 else
7929 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7930 for as_dir in $PATH
7931 do
7932   IFS=$as_save_IFS
7933   test -z "$as_dir" && as_dir=.
7934   for ac_exec_ext in '' $ac_executable_extensions; do
7935   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7936     ac_cv_prog_WINDRES="${ncn_progname}"
7937     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7938     break 2
7939   fi
7940 done
7941 done
7942
7943 fi
7944 fi
7945 WINDRES=$ac_cv_prog_WINDRES
7946 if test -n "$WINDRES"; then
7947   echo "$as_me:$LINENO: result: $WINDRES" >&5
7948 echo "${ECHO_T}$WINDRES" >&6
7949 else
7950   echo "$as_me:$LINENO: result: no" >&5
7951 echo "${ECHO_T}no" >&6
7952 fi
7953
7954   fi
7955   test -n "$ac_cv_prog_WINDRES" && break
7956 done
7957
7958 if test -z "$ac_cv_prog_WINDRES" ; then
7959   set dummy windres
7960   if test $build = $host ; then
7961     WINDRES="$2"
7962   else
7963     WINDRES="${ncn_tool_prefix}$2"
7964   fi
7965 fi
7966
7967
7968
7969 if test -n "$WINDMC"; then
7970   ac_cv_prog_WINDMC=$WINDMC
7971 elif test -n "$ac_cv_prog_WINDMC"; then
7972   WINDMC=$ac_cv_prog_WINDMC
7973 fi
7974
7975 if test -n "$ac_cv_prog_WINDMC"; then
7976   for ncn_progname in windmc; do
7977     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7978 set dummy ${ncn_progname}; ac_word=$2
7979 echo "$as_me:$LINENO: checking for $ac_word" >&5
7980 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7981 if test "${ac_cv_prog_WINDMC+set}" = set; then
7982   echo $ECHO_N "(cached) $ECHO_C" >&6
7983 else
7984   if test -n "$WINDMC"; then
7985   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7986 else
7987 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7988 for as_dir in $PATH
7989 do
7990   IFS=$as_save_IFS
7991   test -z "$as_dir" && as_dir=.
7992   for ac_exec_ext in '' $ac_executable_extensions; do
7993   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7994     ac_cv_prog_WINDMC="${ncn_progname}"
7995     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7996     break 2
7997   fi
7998 done
7999 done
8000
8001 fi
8002 fi
8003 WINDMC=$ac_cv_prog_WINDMC
8004 if test -n "$WINDMC"; then
8005   echo "$as_me:$LINENO: result: $WINDMC" >&5
8006 echo "${ECHO_T}$WINDMC" >&6
8007 else
8008   echo "$as_me:$LINENO: result: no" >&5
8009 echo "${ECHO_T}no" >&6
8010 fi
8011
8012   done
8013 fi
8014
8015 for ncn_progname in windmc; do
8016   if test -n "$ncn_tool_prefix"; then
8017     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8018 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8019 echo "$as_me:$LINENO: checking for $ac_word" >&5
8020 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8021 if test "${ac_cv_prog_WINDMC+set}" = set; then
8022   echo $ECHO_N "(cached) $ECHO_C" >&6
8023 else
8024   if test -n "$WINDMC"; then
8025   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8026 else
8027 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8028 for as_dir in $PATH
8029 do
8030   IFS=$as_save_IFS
8031   test -z "$as_dir" && as_dir=.
8032   for ac_exec_ext in '' $ac_executable_extensions; do
8033   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8034     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
8035     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8036     break 2
8037   fi
8038 done
8039 done
8040
8041 fi
8042 fi
8043 WINDMC=$ac_cv_prog_WINDMC
8044 if test -n "$WINDMC"; then
8045   echo "$as_me:$LINENO: result: $WINDMC" >&5
8046 echo "${ECHO_T}$WINDMC" >&6
8047 else
8048   echo "$as_me:$LINENO: result: no" >&5
8049 echo "${ECHO_T}no" >&6
8050 fi
8051
8052   fi
8053   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
8054     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8055 set dummy ${ncn_progname}; ac_word=$2
8056 echo "$as_me:$LINENO: checking for $ac_word" >&5
8057 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8058 if test "${ac_cv_prog_WINDMC+set}" = set; then
8059   echo $ECHO_N "(cached) $ECHO_C" >&6
8060 else
8061   if test -n "$WINDMC"; then
8062   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
8063 else
8064 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8065 for as_dir in $PATH
8066 do
8067   IFS=$as_save_IFS
8068   test -z "$as_dir" && as_dir=.
8069   for ac_exec_ext in '' $ac_executable_extensions; do
8070   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8071     ac_cv_prog_WINDMC="${ncn_progname}"
8072     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8073     break 2
8074   fi
8075 done
8076 done
8077
8078 fi
8079 fi
8080 WINDMC=$ac_cv_prog_WINDMC
8081 if test -n "$WINDMC"; then
8082   echo "$as_me:$LINENO: result: $WINDMC" >&5
8083 echo "${ECHO_T}$WINDMC" >&6
8084 else
8085   echo "$as_me:$LINENO: result: no" >&5
8086 echo "${ECHO_T}no" >&6
8087 fi
8088
8089   fi
8090   test -n "$ac_cv_prog_WINDMC" && break
8091 done
8092
8093 if test -z "$ac_cv_prog_WINDMC" ; then
8094   set dummy windmc
8095   if test $build = $host ; then
8096     WINDMC="$2"
8097   else
8098     WINDMC="${ncn_tool_prefix}$2"
8099   fi
8100 fi
8101
8102
8103
8104 if test -n "$OBJCOPY"; then
8105   ac_cv_prog_OBJCOPY=$OBJCOPY
8106 elif test -n "$ac_cv_prog_OBJCOPY"; then
8107   OBJCOPY=$ac_cv_prog_OBJCOPY
8108 fi
8109
8110 if test -n "$ac_cv_prog_OBJCOPY"; then
8111   for ncn_progname in objcopy; 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_OBJCOPY+set}" = set; then
8117   echo $ECHO_N "(cached) $ECHO_C" >&6
8118 else
8119   if test -n "$OBJCOPY"; then
8120   ac_cv_prog_OBJCOPY="$OBJCOPY" # 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_OBJCOPY="${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 OBJCOPY=$ac_cv_prog_OBJCOPY
8139 if test -n "$OBJCOPY"; then
8140   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8141 echo "${ECHO_T}$OBJCOPY" >&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 for ncn_progname in objcopy; do
8151   if test -n "$ncn_tool_prefix"; then
8152     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8153 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8154 echo "$as_me:$LINENO: checking for $ac_word" >&5
8155 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8156 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8157   echo $ECHO_N "(cached) $ECHO_C" >&6
8158 else
8159   if test -n "$OBJCOPY"; then
8160   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8161 else
8162 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8163 for as_dir in $PATH
8164 do
8165   IFS=$as_save_IFS
8166   test -z "$as_dir" && as_dir=.
8167   for ac_exec_ext in '' $ac_executable_extensions; do
8168   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8169     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
8170     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8171     break 2
8172   fi
8173 done
8174 done
8175
8176 fi
8177 fi
8178 OBJCOPY=$ac_cv_prog_OBJCOPY
8179 if test -n "$OBJCOPY"; then
8180   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8181 echo "${ECHO_T}$OBJCOPY" >&6
8182 else
8183   echo "$as_me:$LINENO: result: no" >&5
8184 echo "${ECHO_T}no" >&6
8185 fi
8186
8187   fi
8188   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
8189     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8190 set dummy ${ncn_progname}; ac_word=$2
8191 echo "$as_me:$LINENO: checking for $ac_word" >&5
8192 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8193 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
8194   echo $ECHO_N "(cached) $ECHO_C" >&6
8195 else
8196   if test -n "$OBJCOPY"; then
8197   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
8198 else
8199 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8200 for as_dir in $PATH
8201 do
8202   IFS=$as_save_IFS
8203   test -z "$as_dir" && as_dir=.
8204   for ac_exec_ext in '' $ac_executable_extensions; do
8205   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8206     ac_cv_prog_OBJCOPY="${ncn_progname}"
8207     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8208     break 2
8209   fi
8210 done
8211 done
8212
8213 fi
8214 fi
8215 OBJCOPY=$ac_cv_prog_OBJCOPY
8216 if test -n "$OBJCOPY"; then
8217   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
8218 echo "${ECHO_T}$OBJCOPY" >&6
8219 else
8220   echo "$as_me:$LINENO: result: no" >&5
8221 echo "${ECHO_T}no" >&6
8222 fi
8223
8224   fi
8225   test -n "$ac_cv_prog_OBJCOPY" && break
8226 done
8227
8228 if test -z "$ac_cv_prog_OBJCOPY" ; then
8229   set dummy objcopy
8230   if test $build = $host ; then
8231     OBJCOPY="$2"
8232   else
8233     OBJCOPY="${ncn_tool_prefix}$2"
8234   fi
8235 fi
8236
8237
8238
8239 if test -n "$OBJDUMP"; then
8240   ac_cv_prog_OBJDUMP=$OBJDUMP
8241 elif test -n "$ac_cv_prog_OBJDUMP"; then
8242   OBJDUMP=$ac_cv_prog_OBJDUMP
8243 fi
8244
8245 if test -n "$ac_cv_prog_OBJDUMP"; then
8246   for ncn_progname in objdump; do
8247     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8248 set dummy ${ncn_progname}; ac_word=$2
8249 echo "$as_me:$LINENO: checking for $ac_word" >&5
8250 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8251 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8252   echo $ECHO_N "(cached) $ECHO_C" >&6
8253 else
8254   if test -n "$OBJDUMP"; then
8255   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8256 else
8257 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8258 for as_dir in $PATH
8259 do
8260   IFS=$as_save_IFS
8261   test -z "$as_dir" && as_dir=.
8262   for ac_exec_ext in '' $ac_executable_extensions; do
8263   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8264     ac_cv_prog_OBJDUMP="${ncn_progname}"
8265     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8266     break 2
8267   fi
8268 done
8269 done
8270
8271 fi
8272 fi
8273 OBJDUMP=$ac_cv_prog_OBJDUMP
8274 if test -n "$OBJDUMP"; then
8275   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8276 echo "${ECHO_T}$OBJDUMP" >&6
8277 else
8278   echo "$as_me:$LINENO: result: no" >&5
8279 echo "${ECHO_T}no" >&6
8280 fi
8281
8282   done
8283 fi
8284
8285 for ncn_progname in objdump; do
8286   if test -n "$ncn_tool_prefix"; then
8287     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
8288 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
8289 echo "$as_me:$LINENO: checking for $ac_word" >&5
8290 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8291 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8292   echo $ECHO_N "(cached) $ECHO_C" >&6
8293 else
8294   if test -n "$OBJDUMP"; then
8295   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8296 else
8297 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8298 for as_dir in $PATH
8299 do
8300   IFS=$as_save_IFS
8301   test -z "$as_dir" && as_dir=.
8302   for ac_exec_ext in '' $ac_executable_extensions; do
8303   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8304     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8305     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8306     break 2
8307   fi
8308 done
8309 done
8310
8311 fi
8312 fi
8313 OBJDUMP=$ac_cv_prog_OBJDUMP
8314 if test -n "$OBJDUMP"; then
8315   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8316 echo "${ECHO_T}$OBJDUMP" >&6
8317 else
8318   echo "$as_me:$LINENO: result: no" >&5
8319 echo "${ECHO_T}no" >&6
8320 fi
8321
8322   fi
8323   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8324     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8325 set dummy ${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_OBJDUMP+set}" = set; then
8329   echo $ECHO_N "(cached) $ECHO_C" >&6
8330 else
8331   if test -n "$OBJDUMP"; then
8332   ac_cv_prog_OBJDUMP="$OBJDUMP" # 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_OBJDUMP="${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 OBJDUMP=$ac_cv_prog_OBJDUMP
8351 if test -n "$OBJDUMP"; then
8352   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8353 echo "${ECHO_T}$OBJDUMP" >&6
8354 else
8355   echo "$as_me:$LINENO: result: no" >&5
8356 echo "${ECHO_T}no" >&6
8357 fi
8358
8359   fi
8360   test -n "$ac_cv_prog_OBJDUMP" && break
8361 done
8362
8363 if test -z "$ac_cv_prog_OBJDUMP" ; then
8364   set dummy objdump
8365   if test $build = $host ; then
8366     OBJDUMP="$2"
8367   else
8368     OBJDUMP="${ncn_tool_prefix}$2"
8369   fi
8370 fi
8371
8372
8373
8374
8375
8376
8377 # Target tools.
8378
8379 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8380 if test "${with_build_time_tools+set}" = set; then
8381   withval="$with_build_time_tools"
8382   case x"$withval" in
8383      x/*) ;;
8384      *)
8385        with_build_time_tools=
8386        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8387 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8388        ;;
8389    esac
8390 else
8391   with_build_time_tools=
8392 fi;
8393
8394
8395
8396 if test -n "$CC_FOR_TARGET"; then
8397   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8398 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8399   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8400 fi
8401
8402 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8403   for ncn_progname in cc gcc; do
8404     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8405 set dummy ${ncn_progname}; ac_word=$2
8406 echo "$as_me:$LINENO: checking for $ac_word" >&5
8407 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8408 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8409   echo $ECHO_N "(cached) $ECHO_C" >&6
8410 else
8411   if test -n "$CC_FOR_TARGET"; then
8412   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8413 else
8414 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8415 for as_dir in $PATH
8416 do
8417   IFS=$as_save_IFS
8418   test -z "$as_dir" && as_dir=.
8419   for ac_exec_ext in '' $ac_executable_extensions; do
8420   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8421     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8422     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8423     break 2
8424   fi
8425 done
8426 done
8427
8428 fi
8429 fi
8430 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8431 if test -n "$CC_FOR_TARGET"; then
8432   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8433 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8434 else
8435   echo "$as_me:$LINENO: result: no" >&5
8436 echo "${ECHO_T}no" >&6
8437 fi
8438
8439   done
8440 fi
8441
8442 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8443   for ncn_progname in cc gcc; do
8444     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8445 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8446     if test -x $with_build_time_tools/${ncn_progname}; then
8447       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8448       echo "$as_me:$LINENO: result: yes" >&5
8449 echo "${ECHO_T}yes" >&6
8450       break
8451     else
8452       echo "$as_me:$LINENO: result: no" >&5
8453 echo "${ECHO_T}no" >&6
8454     fi
8455   done
8456 fi
8457
8458 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8459   for ncn_progname in cc gcc; do
8460     if test -n "$ncn_target_tool_prefix"; then
8461       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8462 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8463 echo "$as_me:$LINENO: checking for $ac_word" >&5
8464 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8465 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8466   echo $ECHO_N "(cached) $ECHO_C" >&6
8467 else
8468   if test -n "$CC_FOR_TARGET"; then
8469   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8470 else
8471 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8472 for as_dir in $PATH
8473 do
8474   IFS=$as_save_IFS
8475   test -z "$as_dir" && as_dir=.
8476   for ac_exec_ext in '' $ac_executable_extensions; do
8477   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8478     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8479     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8480     break 2
8481   fi
8482 done
8483 done
8484
8485 fi
8486 fi
8487 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8488 if test -n "$CC_FOR_TARGET"; then
8489   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8490 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8491 else
8492   echo "$as_me:$LINENO: result: no" >&5
8493 echo "${ECHO_T}no" >&6
8494 fi
8495
8496     fi
8497     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8498       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8499 set dummy ${ncn_progname}; ac_word=$2
8500 echo "$as_me:$LINENO: checking for $ac_word" >&5
8501 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8502 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8503   echo $ECHO_N "(cached) $ECHO_C" >&6
8504 else
8505   if test -n "$CC_FOR_TARGET"; then
8506   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8507 else
8508 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8509 for as_dir in $PATH
8510 do
8511   IFS=$as_save_IFS
8512   test -z "$as_dir" && as_dir=.
8513   for ac_exec_ext in '' $ac_executable_extensions; do
8514   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8515     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8516     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8517     break 2
8518   fi
8519 done
8520 done
8521
8522 fi
8523 fi
8524 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8525 if test -n "$CC_FOR_TARGET"; then
8526   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8527 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8528 else
8529   echo "$as_me:$LINENO: result: no" >&5
8530 echo "${ECHO_T}no" >&6
8531 fi
8532
8533     fi
8534     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8535   done
8536 fi
8537
8538 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8539   set dummy cc gcc
8540   if test $build = $target ; then
8541     CC_FOR_TARGET="$2"
8542   else
8543     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8544   fi
8545 else
8546   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8547 fi
8548
8549
8550
8551 if test -n "$CXX_FOR_TARGET"; then
8552   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8553 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8554   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8555 fi
8556
8557 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8558   for ncn_progname in c++ g++ cxx gxx; do
8559     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8560 set dummy ${ncn_progname}; ac_word=$2
8561 echo "$as_me:$LINENO: checking for $ac_word" >&5
8562 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8563 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8564   echo $ECHO_N "(cached) $ECHO_C" >&6
8565 else
8566   if test -n "$CXX_FOR_TARGET"; then
8567   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8568 else
8569 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8570 for as_dir in $PATH
8571 do
8572   IFS=$as_save_IFS
8573   test -z "$as_dir" && as_dir=.
8574   for ac_exec_ext in '' $ac_executable_extensions; do
8575   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8576     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8577     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8578     break 2
8579   fi
8580 done
8581 done
8582
8583 fi
8584 fi
8585 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8586 if test -n "$CXX_FOR_TARGET"; then
8587   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8588 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8589 else
8590   echo "$as_me:$LINENO: result: no" >&5
8591 echo "${ECHO_T}no" >&6
8592 fi
8593
8594   done
8595 fi
8596
8597 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8598   for ncn_progname in c++ g++ cxx gxx; do
8599     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8600 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8601     if test -x $with_build_time_tools/${ncn_progname}; then
8602       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8603       echo "$as_me:$LINENO: result: yes" >&5
8604 echo "${ECHO_T}yes" >&6
8605       break
8606     else
8607       echo "$as_me:$LINENO: result: no" >&5
8608 echo "${ECHO_T}no" >&6
8609     fi
8610   done
8611 fi
8612
8613 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8614   for ncn_progname in c++ g++ cxx gxx; do
8615     if test -n "$ncn_target_tool_prefix"; then
8616       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8617 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8618 echo "$as_me:$LINENO: checking for $ac_word" >&5
8619 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8620 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8621   echo $ECHO_N "(cached) $ECHO_C" >&6
8622 else
8623   if test -n "$CXX_FOR_TARGET"; then
8624   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8625 else
8626 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8627 for as_dir in $PATH
8628 do
8629   IFS=$as_save_IFS
8630   test -z "$as_dir" && as_dir=.
8631   for ac_exec_ext in '' $ac_executable_extensions; do
8632   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8633     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8634     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8635     break 2
8636   fi
8637 done
8638 done
8639
8640 fi
8641 fi
8642 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8643 if test -n "$CXX_FOR_TARGET"; then
8644   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8645 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8646 else
8647   echo "$as_me:$LINENO: result: no" >&5
8648 echo "${ECHO_T}no" >&6
8649 fi
8650
8651     fi
8652     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8653       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8654 set dummy ${ncn_progname}; ac_word=$2
8655 echo "$as_me:$LINENO: checking for $ac_word" >&5
8656 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8657 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8658   echo $ECHO_N "(cached) $ECHO_C" >&6
8659 else
8660   if test -n "$CXX_FOR_TARGET"; then
8661   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8662 else
8663 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8664 for as_dir in $PATH
8665 do
8666   IFS=$as_save_IFS
8667   test -z "$as_dir" && as_dir=.
8668   for ac_exec_ext in '' $ac_executable_extensions; do
8669   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8670     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8671     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8672     break 2
8673   fi
8674 done
8675 done
8676
8677 fi
8678 fi
8679 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8680 if test -n "$CXX_FOR_TARGET"; then
8681   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8682 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8683 else
8684   echo "$as_me:$LINENO: result: no" >&5
8685 echo "${ECHO_T}no" >&6
8686 fi
8687
8688     fi
8689     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8690   done
8691 fi
8692
8693 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8694   set dummy c++ g++ cxx gxx
8695   if test $build = $target ; then
8696     CXX_FOR_TARGET="$2"
8697   else
8698     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8699   fi
8700 else
8701   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8702 fi
8703
8704
8705
8706 if test -n "$GCC_FOR_TARGET"; then
8707   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8708 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8709   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8710 fi
8711
8712 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8713   for ncn_progname in gcc; do
8714     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8715 set dummy ${ncn_progname}; ac_word=$2
8716 echo "$as_me:$LINENO: checking for $ac_word" >&5
8717 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8718 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8719   echo $ECHO_N "(cached) $ECHO_C" >&6
8720 else
8721   if test -n "$GCC_FOR_TARGET"; then
8722   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8723 else
8724 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8725 for as_dir in $PATH
8726 do
8727   IFS=$as_save_IFS
8728   test -z "$as_dir" && as_dir=.
8729   for ac_exec_ext in '' $ac_executable_extensions; do
8730   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8731     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8732     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8733     break 2
8734   fi
8735 done
8736 done
8737
8738 fi
8739 fi
8740 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8741 if test -n "$GCC_FOR_TARGET"; then
8742   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8743 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8744 else
8745   echo "$as_me:$LINENO: result: no" >&5
8746 echo "${ECHO_T}no" >&6
8747 fi
8748
8749   done
8750 fi
8751
8752 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8753   for ncn_progname in gcc; do
8754     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8755 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8756     if test -x $with_build_time_tools/${ncn_progname}; then
8757       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8758       echo "$as_me:$LINENO: result: yes" >&5
8759 echo "${ECHO_T}yes" >&6
8760       break
8761     else
8762       echo "$as_me:$LINENO: result: no" >&5
8763 echo "${ECHO_T}no" >&6
8764     fi
8765   done
8766 fi
8767
8768 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8769   for ncn_progname in gcc; do
8770     if test -n "$ncn_target_tool_prefix"; then
8771       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8772 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8773 echo "$as_me:$LINENO: checking for $ac_word" >&5
8774 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8775 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8776   echo $ECHO_N "(cached) $ECHO_C" >&6
8777 else
8778   if test -n "$GCC_FOR_TARGET"; then
8779   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8780 else
8781 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8782 for as_dir in $PATH
8783 do
8784   IFS=$as_save_IFS
8785   test -z "$as_dir" && as_dir=.
8786   for ac_exec_ext in '' $ac_executable_extensions; do
8787   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8788     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8789     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8790     break 2
8791   fi
8792 done
8793 done
8794
8795 fi
8796 fi
8797 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8798 if test -n "$GCC_FOR_TARGET"; then
8799   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8800 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8801 else
8802   echo "$as_me:$LINENO: result: no" >&5
8803 echo "${ECHO_T}no" >&6
8804 fi
8805
8806     fi
8807     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8808       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8809 set dummy ${ncn_progname}; ac_word=$2
8810 echo "$as_me:$LINENO: checking for $ac_word" >&5
8811 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8812 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8813   echo $ECHO_N "(cached) $ECHO_C" >&6
8814 else
8815   if test -n "$GCC_FOR_TARGET"; then
8816   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8817 else
8818 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8819 for as_dir in $PATH
8820 do
8821   IFS=$as_save_IFS
8822   test -z "$as_dir" && as_dir=.
8823   for ac_exec_ext in '' $ac_executable_extensions; do
8824   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8825     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8826     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8827     break 2
8828   fi
8829 done
8830 done
8831
8832 fi
8833 fi
8834 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8835 if test -n "$GCC_FOR_TARGET"; then
8836   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8837 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8838 else
8839   echo "$as_me:$LINENO: result: no" >&5
8840 echo "${ECHO_T}no" >&6
8841 fi
8842
8843     fi
8844     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8845   done
8846 fi
8847
8848 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8849   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8850 else
8851   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8852 fi
8853
8854
8855
8856 if test -n "$GCJ_FOR_TARGET"; then
8857   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8858 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8859   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8860 fi
8861
8862 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8863   for ncn_progname in gcj; do
8864     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8865 set dummy ${ncn_progname}; ac_word=$2
8866 echo "$as_me:$LINENO: checking for $ac_word" >&5
8867 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8868 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8869   echo $ECHO_N "(cached) $ECHO_C" >&6
8870 else
8871   if test -n "$GCJ_FOR_TARGET"; then
8872   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8873 else
8874 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8875 for as_dir in $PATH
8876 do
8877   IFS=$as_save_IFS
8878   test -z "$as_dir" && as_dir=.
8879   for ac_exec_ext in '' $ac_executable_extensions; do
8880   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8881     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8882     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8883     break 2
8884   fi
8885 done
8886 done
8887
8888 fi
8889 fi
8890 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8891 if test -n "$GCJ_FOR_TARGET"; then
8892   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8893 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8894 else
8895   echo "$as_me:$LINENO: result: no" >&5
8896 echo "${ECHO_T}no" >&6
8897 fi
8898
8899   done
8900 fi
8901
8902 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8903   for ncn_progname in gcj; do
8904     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8905 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8906     if test -x $with_build_time_tools/${ncn_progname}; then
8907       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8908       echo "$as_me:$LINENO: result: yes" >&5
8909 echo "${ECHO_T}yes" >&6
8910       break
8911     else
8912       echo "$as_me:$LINENO: result: no" >&5
8913 echo "${ECHO_T}no" >&6
8914     fi
8915   done
8916 fi
8917
8918 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8919   for ncn_progname in gcj; do
8920     if test -n "$ncn_target_tool_prefix"; then
8921       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8922 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8923 echo "$as_me:$LINENO: checking for $ac_word" >&5
8924 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8925 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8926   echo $ECHO_N "(cached) $ECHO_C" >&6
8927 else
8928   if test -n "$GCJ_FOR_TARGET"; then
8929   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8930 else
8931 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8932 for as_dir in $PATH
8933 do
8934   IFS=$as_save_IFS
8935   test -z "$as_dir" && as_dir=.
8936   for ac_exec_ext in '' $ac_executable_extensions; do
8937   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8938     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8939     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8940     break 2
8941   fi
8942 done
8943 done
8944
8945 fi
8946 fi
8947 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8948 if test -n "$GCJ_FOR_TARGET"; then
8949   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8950 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8951 else
8952   echo "$as_me:$LINENO: result: no" >&5
8953 echo "${ECHO_T}no" >&6
8954 fi
8955
8956     fi
8957     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8958       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8959 set dummy ${ncn_progname}; ac_word=$2
8960 echo "$as_me:$LINENO: checking for $ac_word" >&5
8961 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8962 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8963   echo $ECHO_N "(cached) $ECHO_C" >&6
8964 else
8965   if test -n "$GCJ_FOR_TARGET"; then
8966   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8967 else
8968 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8969 for as_dir in $PATH
8970 do
8971   IFS=$as_save_IFS
8972   test -z "$as_dir" && as_dir=.
8973   for ac_exec_ext in '' $ac_executable_extensions; do
8974   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8975     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8976     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8977     break 2
8978   fi
8979 done
8980 done
8981
8982 fi
8983 fi
8984 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8985 if test -n "$GCJ_FOR_TARGET"; then
8986   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8987 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8988 else
8989   echo "$as_me:$LINENO: result: no" >&5
8990 echo "${ECHO_T}no" >&6
8991 fi
8992
8993     fi
8994     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8995   done
8996 fi
8997
8998 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8999   set dummy gcj
9000   if test $build = $target ; then
9001     GCJ_FOR_TARGET="$2"
9002   else
9003     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
9004   fi
9005 else
9006   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
9007 fi
9008
9009
9010
9011 if test -n "$GFORTRAN_FOR_TARGET"; then
9012   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
9013 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9014   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9015 fi
9016
9017 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9018   for ncn_progname in gfortran; do
9019     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9020 set dummy ${ncn_progname}; ac_word=$2
9021 echo "$as_me:$LINENO: checking for $ac_word" >&5
9022 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9023 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9024   echo $ECHO_N "(cached) $ECHO_C" >&6
9025 else
9026   if test -n "$GFORTRAN_FOR_TARGET"; then
9027   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9028 else
9029 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9030 for as_dir in $PATH
9031 do
9032   IFS=$as_save_IFS
9033   test -z "$as_dir" && as_dir=.
9034   for ac_exec_ext in '' $ac_executable_extensions; do
9035   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9036     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9037     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9038     break 2
9039   fi
9040 done
9041 done
9042
9043 fi
9044 fi
9045 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9046 if test -n "$GFORTRAN_FOR_TARGET"; then
9047   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9048 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9049 else
9050   echo "$as_me:$LINENO: result: no" >&5
9051 echo "${ECHO_T}no" >&6
9052 fi
9053
9054   done
9055 fi
9056
9057 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
9058   for ncn_progname in gfortran; do
9059     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9060 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9061     if test -x $with_build_time_tools/${ncn_progname}; then
9062       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9063       echo "$as_me:$LINENO: result: yes" >&5
9064 echo "${ECHO_T}yes" >&6
9065       break
9066     else
9067       echo "$as_me:$LINENO: result: no" >&5
9068 echo "${ECHO_T}no" >&6
9069     fi
9070   done
9071 fi
9072
9073 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
9074   for ncn_progname in gfortran; do
9075     if test -n "$ncn_target_tool_prefix"; then
9076       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9077 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9078 echo "$as_me:$LINENO: checking for $ac_word" >&5
9079 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9080 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9081   echo $ECHO_N "(cached) $ECHO_C" >&6
9082 else
9083   if test -n "$GFORTRAN_FOR_TARGET"; then
9084   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9085 else
9086 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9087 for as_dir in $PATH
9088 do
9089   IFS=$as_save_IFS
9090   test -z "$as_dir" && as_dir=.
9091   for ac_exec_ext in '' $ac_executable_extensions; do
9092   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9093     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9094     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9095     break 2
9096   fi
9097 done
9098 done
9099
9100 fi
9101 fi
9102 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9103 if test -n "$GFORTRAN_FOR_TARGET"; then
9104   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9105 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9106 else
9107   echo "$as_me:$LINENO: result: no" >&5
9108 echo "${ECHO_T}no" >&6
9109 fi
9110
9111     fi
9112     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
9113       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9114 set dummy ${ncn_progname}; ac_word=$2
9115 echo "$as_me:$LINENO: checking for $ac_word" >&5
9116 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9117 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
9118   echo $ECHO_N "(cached) $ECHO_C" >&6
9119 else
9120   if test -n "$GFORTRAN_FOR_TARGET"; then
9121   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
9122 else
9123 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9124 for as_dir in $PATH
9125 do
9126   IFS=$as_save_IFS
9127   test -z "$as_dir" && as_dir=.
9128   for ac_exec_ext in '' $ac_executable_extensions; do
9129   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9130     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
9131     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9132     break 2
9133   fi
9134 done
9135 done
9136
9137 fi
9138 fi
9139 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
9140 if test -n "$GFORTRAN_FOR_TARGET"; then
9141   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
9142 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
9143 else
9144   echo "$as_me:$LINENO: result: no" >&5
9145 echo "${ECHO_T}no" >&6
9146 fi
9147
9148     fi
9149     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
9150   done
9151 fi
9152
9153 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
9154   set dummy gfortran
9155   if test $build = $target ; then
9156     GFORTRAN_FOR_TARGET="$2"
9157   else
9158     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
9159   fi
9160 else
9161   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
9162 fi
9163
9164
9165
9166 cat > conftest.c << \EOF
9167 #ifdef __GNUC__
9168   gcc_yay;
9169 #endif
9170 EOF
9171 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
9172   have_gcc_for_target=yes
9173 else
9174   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
9175   have_gcc_for_target=no
9176 fi
9177 rm conftest.c
9178
9179
9180
9181
9182 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9183   if test -n "$with_build_time_tools"; then
9184     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
9185 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
9186     if test -x $with_build_time_tools/ar; then
9187       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
9188       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9189       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
9190 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
9191     else
9192       echo "$as_me:$LINENO: result: no" >&5
9193 echo "${ECHO_T}no" >&6
9194     fi
9195   elif test $build != $host && test $have_gcc_for_target = yes; then
9196     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
9197     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
9198     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
9199   fi
9200 fi
9201 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9202   # Extract the first word of "ar", so it can be a program name with args.
9203 set dummy ar; ac_word=$2
9204 echo "$as_me:$LINENO: checking for $ac_word" >&5
9205 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9206 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
9207   echo $ECHO_N "(cached) $ECHO_C" >&6
9208 else
9209   case $AR_FOR_TARGET in
9210   [\\/]* | ?:[\\/]*)
9211   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
9212   ;;
9213   *)
9214   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9215 for as_dir in $gcc_cv_tool_dirs
9216 do
9217   IFS=$as_save_IFS
9218   test -z "$as_dir" && as_dir=.
9219   for ac_exec_ext in '' $ac_executable_extensions; do
9220   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9221     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9222     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9223     break 2
9224   fi
9225 done
9226 done
9227
9228   ;;
9229 esac
9230 fi
9231 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9232
9233 if test -n "$AR_FOR_TARGET"; then
9234   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9235 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9236 else
9237   echo "$as_me:$LINENO: result: no" >&5
9238 echo "${ECHO_T}no" >&6
9239 fi
9240
9241 fi
9242 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
9243
9244
9245 if test -n "$AR_FOR_TARGET"; then
9246   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
9247 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9248   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9249 fi
9250
9251 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
9252   for ncn_progname in ar; do
9253     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9254 set dummy ${ncn_progname}; ac_word=$2
9255 echo "$as_me:$LINENO: checking for $ac_word" >&5
9256 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9257 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9258   echo $ECHO_N "(cached) $ECHO_C" >&6
9259 else
9260   if test -n "$AR_FOR_TARGET"; then
9261   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9262 else
9263 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9264 for as_dir in $PATH
9265 do
9266   IFS=$as_save_IFS
9267   test -z "$as_dir" && as_dir=.
9268   for ac_exec_ext in '' $ac_executable_extensions; do
9269   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9270     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9271     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9272     break 2
9273   fi
9274 done
9275 done
9276
9277 fi
9278 fi
9279 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9280 if test -n "$AR_FOR_TARGET"; then
9281   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9282 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9283 else
9284   echo "$as_me:$LINENO: result: no" >&5
9285 echo "${ECHO_T}no" >&6
9286 fi
9287
9288   done
9289 fi
9290
9291 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9292   for ncn_progname in ar; do
9293     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9294 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9295     if test -x $with_build_time_tools/${ncn_progname}; then
9296       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9297       echo "$as_me:$LINENO: result: yes" >&5
9298 echo "${ECHO_T}yes" >&6
9299       break
9300     else
9301       echo "$as_me:$LINENO: result: no" >&5
9302 echo "${ECHO_T}no" >&6
9303     fi
9304   done
9305 fi
9306
9307 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9308   for ncn_progname in ar; do
9309     if test -n "$ncn_target_tool_prefix"; then
9310       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9311 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9312 echo "$as_me:$LINENO: checking for $ac_word" >&5
9313 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9314 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9315   echo $ECHO_N "(cached) $ECHO_C" >&6
9316 else
9317   if test -n "$AR_FOR_TARGET"; then
9318   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9319 else
9320 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9321 for as_dir in $PATH
9322 do
9323   IFS=$as_save_IFS
9324   test -z "$as_dir" && as_dir=.
9325   for ac_exec_ext in '' $ac_executable_extensions; do
9326   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9327     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9328     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9329     break 2
9330   fi
9331 done
9332 done
9333
9334 fi
9335 fi
9336 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9337 if test -n "$AR_FOR_TARGET"; then
9338   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9339 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9340 else
9341   echo "$as_me:$LINENO: result: no" >&5
9342 echo "${ECHO_T}no" >&6
9343 fi
9344
9345     fi
9346     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9347       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9348 set dummy ${ncn_progname}; ac_word=$2
9349 echo "$as_me:$LINENO: checking for $ac_word" >&5
9350 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9351 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9352   echo $ECHO_N "(cached) $ECHO_C" >&6
9353 else
9354   if test -n "$AR_FOR_TARGET"; then
9355   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9356 else
9357 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9358 for as_dir in $PATH
9359 do
9360   IFS=$as_save_IFS
9361   test -z "$as_dir" && as_dir=.
9362   for ac_exec_ext in '' $ac_executable_extensions; do
9363   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9364     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9365     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9366     break 2
9367   fi
9368 done
9369 done
9370
9371 fi
9372 fi
9373 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9374 if test -n "$AR_FOR_TARGET"; then
9375   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9376 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9377 else
9378   echo "$as_me:$LINENO: result: no" >&5
9379 echo "${ECHO_T}no" >&6
9380 fi
9381
9382     fi
9383     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9384   done
9385 fi
9386
9387 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9388   set dummy ar
9389   if test $build = $target ; then
9390     AR_FOR_TARGET="$2"
9391   else
9392     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9393   fi
9394 else
9395   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9396 fi
9397
9398 else
9399   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9400 fi
9401
9402
9403
9404
9405 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9406   if test -n "$with_build_time_tools"; then
9407     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9408 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9409     if test -x $with_build_time_tools/as; then
9410       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9411       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9412       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9413 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9414     else
9415       echo "$as_me:$LINENO: result: no" >&5
9416 echo "${ECHO_T}no" >&6
9417     fi
9418   elif test $build != $host && test $have_gcc_for_target = yes; then
9419     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9420     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9421     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9422   fi
9423 fi
9424 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9425   # Extract the first word of "as", so it can be a program name with args.
9426 set dummy as; ac_word=$2
9427 echo "$as_me:$LINENO: checking for $ac_word" >&5
9428 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9429 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9430   echo $ECHO_N "(cached) $ECHO_C" >&6
9431 else
9432   case $AS_FOR_TARGET in
9433   [\\/]* | ?:[\\/]*)
9434   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9435   ;;
9436   *)
9437   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9438 for as_dir in $gcc_cv_tool_dirs
9439 do
9440   IFS=$as_save_IFS
9441   test -z "$as_dir" && as_dir=.
9442   for ac_exec_ext in '' $ac_executable_extensions; do
9443   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9444     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9445     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9446     break 2
9447   fi
9448 done
9449 done
9450
9451   ;;
9452 esac
9453 fi
9454 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9455
9456 if test -n "$AS_FOR_TARGET"; then
9457   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9458 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9459 else
9460   echo "$as_me:$LINENO: result: no" >&5
9461 echo "${ECHO_T}no" >&6
9462 fi
9463
9464 fi
9465 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9466
9467
9468 if test -n "$AS_FOR_TARGET"; then
9469   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9470 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9471   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9472 fi
9473
9474 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9475   for ncn_progname in as; do
9476     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9477 set dummy ${ncn_progname}; ac_word=$2
9478 echo "$as_me:$LINENO: checking for $ac_word" >&5
9479 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9480 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9481   echo $ECHO_N "(cached) $ECHO_C" >&6
9482 else
9483   if test -n "$AS_FOR_TARGET"; then
9484   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9485 else
9486 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9487 for as_dir in $PATH
9488 do
9489   IFS=$as_save_IFS
9490   test -z "$as_dir" && as_dir=.
9491   for ac_exec_ext in '' $ac_executable_extensions; do
9492   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9493     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9494     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9495     break 2
9496   fi
9497 done
9498 done
9499
9500 fi
9501 fi
9502 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9503 if test -n "$AS_FOR_TARGET"; then
9504   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9505 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9506 else
9507   echo "$as_me:$LINENO: result: no" >&5
9508 echo "${ECHO_T}no" >&6
9509 fi
9510
9511   done
9512 fi
9513
9514 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9515   for ncn_progname in as; do
9516     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9517 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9518     if test -x $with_build_time_tools/${ncn_progname}; then
9519       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9520       echo "$as_me:$LINENO: result: yes" >&5
9521 echo "${ECHO_T}yes" >&6
9522       break
9523     else
9524       echo "$as_me:$LINENO: result: no" >&5
9525 echo "${ECHO_T}no" >&6
9526     fi
9527   done
9528 fi
9529
9530 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9531   for ncn_progname in as; do
9532     if test -n "$ncn_target_tool_prefix"; then
9533       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9534 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9535 echo "$as_me:$LINENO: checking for $ac_word" >&5
9536 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9537 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9538   echo $ECHO_N "(cached) $ECHO_C" >&6
9539 else
9540   if test -n "$AS_FOR_TARGET"; then
9541   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9542 else
9543 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9544 for as_dir in $PATH
9545 do
9546   IFS=$as_save_IFS
9547   test -z "$as_dir" && as_dir=.
9548   for ac_exec_ext in '' $ac_executable_extensions; do
9549   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9550     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9551     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9552     break 2
9553   fi
9554 done
9555 done
9556
9557 fi
9558 fi
9559 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9560 if test -n "$AS_FOR_TARGET"; then
9561   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9562 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9563 else
9564   echo "$as_me:$LINENO: result: no" >&5
9565 echo "${ECHO_T}no" >&6
9566 fi
9567
9568     fi
9569     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9570       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9571 set dummy ${ncn_progname}; ac_word=$2
9572 echo "$as_me:$LINENO: checking for $ac_word" >&5
9573 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9574 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9575   echo $ECHO_N "(cached) $ECHO_C" >&6
9576 else
9577   if test -n "$AS_FOR_TARGET"; then
9578   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9579 else
9580 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9581 for as_dir in $PATH
9582 do
9583   IFS=$as_save_IFS
9584   test -z "$as_dir" && as_dir=.
9585   for ac_exec_ext in '' $ac_executable_extensions; do
9586   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9587     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9588     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9589     break 2
9590   fi
9591 done
9592 done
9593
9594 fi
9595 fi
9596 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9597 if test -n "$AS_FOR_TARGET"; then
9598   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9599 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9600 else
9601   echo "$as_me:$LINENO: result: no" >&5
9602 echo "${ECHO_T}no" >&6
9603 fi
9604
9605     fi
9606     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9607   done
9608 fi
9609
9610 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9611   set dummy as
9612   if test $build = $target ; then
9613     AS_FOR_TARGET="$2"
9614   else
9615     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9616   fi
9617 else
9618   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9619 fi
9620
9621 else
9622   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9623 fi
9624
9625
9626
9627
9628 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9629   if test -n "$with_build_time_tools"; then
9630     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9631 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9632     if test -x $with_build_time_tools/dlltool; then
9633       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9634       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9635       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9636 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9637     else
9638       echo "$as_me:$LINENO: result: no" >&5
9639 echo "${ECHO_T}no" >&6
9640     fi
9641   elif test $build != $host && test $have_gcc_for_target = yes; then
9642     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9643     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9644     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9645   fi
9646 fi
9647 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9648   # Extract the first word of "dlltool", so it can be a program name with args.
9649 set dummy dlltool; ac_word=$2
9650 echo "$as_me:$LINENO: checking for $ac_word" >&5
9651 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9652 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9653   echo $ECHO_N "(cached) $ECHO_C" >&6
9654 else
9655   case $DLLTOOL_FOR_TARGET in
9656   [\\/]* | ?:[\\/]*)
9657   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9658   ;;
9659   *)
9660   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9661 for as_dir in $gcc_cv_tool_dirs
9662 do
9663   IFS=$as_save_IFS
9664   test -z "$as_dir" && as_dir=.
9665   for ac_exec_ext in '' $ac_executable_extensions; do
9666   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9667     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9668     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9669     break 2
9670   fi
9671 done
9672 done
9673
9674   ;;
9675 esac
9676 fi
9677 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9678
9679 if test -n "$DLLTOOL_FOR_TARGET"; then
9680   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9681 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9682 else
9683   echo "$as_me:$LINENO: result: no" >&5
9684 echo "${ECHO_T}no" >&6
9685 fi
9686
9687 fi
9688 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9689
9690
9691 if test -n "$DLLTOOL_FOR_TARGET"; then
9692   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9693 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9694   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9695 fi
9696
9697 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9698   for ncn_progname in dlltool; do
9699     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9700 set dummy ${ncn_progname}; ac_word=$2
9701 echo "$as_me:$LINENO: checking for $ac_word" >&5
9702 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9703 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9704   echo $ECHO_N "(cached) $ECHO_C" >&6
9705 else
9706   if test -n "$DLLTOOL_FOR_TARGET"; then
9707   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9708 else
9709 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9710 for as_dir in $PATH
9711 do
9712   IFS=$as_save_IFS
9713   test -z "$as_dir" && as_dir=.
9714   for ac_exec_ext in '' $ac_executable_extensions; do
9715   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9716     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9717     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9718     break 2
9719   fi
9720 done
9721 done
9722
9723 fi
9724 fi
9725 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9726 if test -n "$DLLTOOL_FOR_TARGET"; then
9727   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9728 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9729 else
9730   echo "$as_me:$LINENO: result: no" >&5
9731 echo "${ECHO_T}no" >&6
9732 fi
9733
9734   done
9735 fi
9736
9737 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9738   for ncn_progname in dlltool; do
9739     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9740 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9741     if test -x $with_build_time_tools/${ncn_progname}; then
9742       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9743       echo "$as_me:$LINENO: result: yes" >&5
9744 echo "${ECHO_T}yes" >&6
9745       break
9746     else
9747       echo "$as_me:$LINENO: result: no" >&5
9748 echo "${ECHO_T}no" >&6
9749     fi
9750   done
9751 fi
9752
9753 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9754   for ncn_progname in dlltool; do
9755     if test -n "$ncn_target_tool_prefix"; then
9756       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9757 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9758 echo "$as_me:$LINENO: checking for $ac_word" >&5
9759 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9760 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9761   echo $ECHO_N "(cached) $ECHO_C" >&6
9762 else
9763   if test -n "$DLLTOOL_FOR_TARGET"; then
9764   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9765 else
9766 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9767 for as_dir in $PATH
9768 do
9769   IFS=$as_save_IFS
9770   test -z "$as_dir" && as_dir=.
9771   for ac_exec_ext in '' $ac_executable_extensions; do
9772   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9773     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9774     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9775     break 2
9776   fi
9777 done
9778 done
9779
9780 fi
9781 fi
9782 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9783 if test -n "$DLLTOOL_FOR_TARGET"; then
9784   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9785 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9786 else
9787   echo "$as_me:$LINENO: result: no" >&5
9788 echo "${ECHO_T}no" >&6
9789 fi
9790
9791     fi
9792     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9793       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9794 set dummy ${ncn_progname}; ac_word=$2
9795 echo "$as_me:$LINENO: checking for $ac_word" >&5
9796 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9797 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9798   echo $ECHO_N "(cached) $ECHO_C" >&6
9799 else
9800   if test -n "$DLLTOOL_FOR_TARGET"; then
9801   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9802 else
9803 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9804 for as_dir in $PATH
9805 do
9806   IFS=$as_save_IFS
9807   test -z "$as_dir" && as_dir=.
9808   for ac_exec_ext in '' $ac_executable_extensions; do
9809   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9810     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9811     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9812     break 2
9813   fi
9814 done
9815 done
9816
9817 fi
9818 fi
9819 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9820 if test -n "$DLLTOOL_FOR_TARGET"; then
9821   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9822 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9823 else
9824   echo "$as_me:$LINENO: result: no" >&5
9825 echo "${ECHO_T}no" >&6
9826 fi
9827
9828     fi
9829     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9830   done
9831 fi
9832
9833 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9834   set dummy dlltool
9835   if test $build = $target ; then
9836     DLLTOOL_FOR_TARGET="$2"
9837   else
9838     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9839   fi
9840 else
9841   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9842 fi
9843
9844 else
9845   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9846 fi
9847
9848
9849
9850
9851 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9852   if test -n "$with_build_time_tools"; then
9853     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9854 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9855     if test -x $with_build_time_tools/ld; then
9856       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9857       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9858       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9859 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9860     else
9861       echo "$as_me:$LINENO: result: no" >&5
9862 echo "${ECHO_T}no" >&6
9863     fi
9864   elif test $build != $host && test $have_gcc_for_target = yes; then
9865     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9866     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9867     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9868   fi
9869 fi
9870 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9871   # Extract the first word of "ld", so it can be a program name with args.
9872 set dummy ld; ac_word=$2
9873 echo "$as_me:$LINENO: checking for $ac_word" >&5
9874 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9875 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9876   echo $ECHO_N "(cached) $ECHO_C" >&6
9877 else
9878   case $LD_FOR_TARGET in
9879   [\\/]* | ?:[\\/]*)
9880   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9881   ;;
9882   *)
9883   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9884 for as_dir in $gcc_cv_tool_dirs
9885 do
9886   IFS=$as_save_IFS
9887   test -z "$as_dir" && as_dir=.
9888   for ac_exec_ext in '' $ac_executable_extensions; do
9889   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9890     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9891     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9892     break 2
9893   fi
9894 done
9895 done
9896
9897   ;;
9898 esac
9899 fi
9900 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9901
9902 if test -n "$LD_FOR_TARGET"; then
9903   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9904 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9905 else
9906   echo "$as_me:$LINENO: result: no" >&5
9907 echo "${ECHO_T}no" >&6
9908 fi
9909
9910 fi
9911 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9912
9913
9914 if test -n "$LD_FOR_TARGET"; then
9915   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9916 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9917   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9918 fi
9919
9920 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9921   for ncn_progname in ld; do
9922     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9923 set dummy ${ncn_progname}; ac_word=$2
9924 echo "$as_me:$LINENO: checking for $ac_word" >&5
9925 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9926 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9927   echo $ECHO_N "(cached) $ECHO_C" >&6
9928 else
9929   if test -n "$LD_FOR_TARGET"; then
9930   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9931 else
9932 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9933 for as_dir in $PATH
9934 do
9935   IFS=$as_save_IFS
9936   test -z "$as_dir" && as_dir=.
9937   for ac_exec_ext in '' $ac_executable_extensions; do
9938   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9939     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9940     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9941     break 2
9942   fi
9943 done
9944 done
9945
9946 fi
9947 fi
9948 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9949 if test -n "$LD_FOR_TARGET"; then
9950   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9951 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9952 else
9953   echo "$as_me:$LINENO: result: no" >&5
9954 echo "${ECHO_T}no" >&6
9955 fi
9956
9957   done
9958 fi
9959
9960 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9961   for ncn_progname in ld; do
9962     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9963 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9964     if test -x $with_build_time_tools/${ncn_progname}; then
9965       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9966       echo "$as_me:$LINENO: result: yes" >&5
9967 echo "${ECHO_T}yes" >&6
9968       break
9969     else
9970       echo "$as_me:$LINENO: result: no" >&5
9971 echo "${ECHO_T}no" >&6
9972     fi
9973   done
9974 fi
9975
9976 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9977   for ncn_progname in ld; do
9978     if test -n "$ncn_target_tool_prefix"; then
9979       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9980 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9981 echo "$as_me:$LINENO: checking for $ac_word" >&5
9982 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9983 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9984   echo $ECHO_N "(cached) $ECHO_C" >&6
9985 else
9986   if test -n "$LD_FOR_TARGET"; then
9987   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9988 else
9989 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9990 for as_dir in $PATH
9991 do
9992   IFS=$as_save_IFS
9993   test -z "$as_dir" && as_dir=.
9994   for ac_exec_ext in '' $ac_executable_extensions; do
9995   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9996     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9997     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9998     break 2
9999   fi
10000 done
10001 done
10002
10003 fi
10004 fi
10005 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10006 if test -n "$LD_FOR_TARGET"; then
10007   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10008 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10009 else
10010   echo "$as_me:$LINENO: result: no" >&5
10011 echo "${ECHO_T}no" >&6
10012 fi
10013
10014     fi
10015     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
10016       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10017 set dummy ${ncn_progname}; ac_word=$2
10018 echo "$as_me:$LINENO: checking for $ac_word" >&5
10019 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10020 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
10021   echo $ECHO_N "(cached) $ECHO_C" >&6
10022 else
10023   if test -n "$LD_FOR_TARGET"; then
10024   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
10025 else
10026 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10027 for as_dir in $PATH
10028 do
10029   IFS=$as_save_IFS
10030   test -z "$as_dir" && as_dir=.
10031   for ac_exec_ext in '' $ac_executable_extensions; do
10032   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10033     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
10034     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10035     break 2
10036   fi
10037 done
10038 done
10039
10040 fi
10041 fi
10042 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
10043 if test -n "$LD_FOR_TARGET"; then
10044   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
10045 echo "${ECHO_T}$LD_FOR_TARGET" >&6
10046 else
10047   echo "$as_me:$LINENO: result: no" >&5
10048 echo "${ECHO_T}no" >&6
10049 fi
10050
10051     fi
10052     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
10053   done
10054 fi
10055
10056 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
10057   set dummy ld
10058   if test $build = $target ; then
10059     LD_FOR_TARGET="$2"
10060   else
10061     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
10062   fi
10063 else
10064   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
10065 fi
10066
10067 else
10068   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
10069 fi
10070
10071
10072
10073
10074 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10075   if test -n "$with_build_time_tools"; then
10076     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
10077 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
10078     if test -x $with_build_time_tools/lipo; then
10079       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
10080       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10081       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
10082 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
10083     else
10084       echo "$as_me:$LINENO: result: no" >&5
10085 echo "${ECHO_T}no" >&6
10086     fi
10087   elif test $build != $host && test $have_gcc_for_target = yes; then
10088     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
10089     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
10090     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10091   fi
10092 fi
10093 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10094   # Extract the first word of "lipo", so it can be a program name with args.
10095 set dummy lipo; ac_word=$2
10096 echo "$as_me:$LINENO: checking for $ac_word" >&5
10097 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10098 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
10099   echo $ECHO_N "(cached) $ECHO_C" >&6
10100 else
10101   case $LIPO_FOR_TARGET in
10102   [\\/]* | ?:[\\/]*)
10103   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
10104   ;;
10105   *)
10106   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10107 for as_dir in $gcc_cv_tool_dirs
10108 do
10109   IFS=$as_save_IFS
10110   test -z "$as_dir" && as_dir=.
10111   for ac_exec_ext in '' $ac_executable_extensions; do
10112   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10113     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10114     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10115     break 2
10116   fi
10117 done
10118 done
10119
10120   ;;
10121 esac
10122 fi
10123 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10124
10125 if test -n "$LIPO_FOR_TARGET"; then
10126   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10127 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10128 else
10129   echo "$as_me:$LINENO: result: no" >&5
10130 echo "${ECHO_T}no" >&6
10131 fi
10132
10133 fi
10134 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
10135
10136
10137 if test -n "$LIPO_FOR_TARGET"; then
10138   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
10139 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10140   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10141 fi
10142
10143 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
10144   for ncn_progname in lipo; do
10145     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10146 set dummy ${ncn_progname}; ac_word=$2
10147 echo "$as_me:$LINENO: checking for $ac_word" >&5
10148 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10149 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10150   echo $ECHO_N "(cached) $ECHO_C" >&6
10151 else
10152   if test -n "$LIPO_FOR_TARGET"; then
10153   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10154 else
10155 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10156 for as_dir in $PATH
10157 do
10158   IFS=$as_save_IFS
10159   test -z "$as_dir" && as_dir=.
10160   for ac_exec_ext in '' $ac_executable_extensions; do
10161   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10162     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10163     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10164     break 2
10165   fi
10166 done
10167 done
10168
10169 fi
10170 fi
10171 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10172 if test -n "$LIPO_FOR_TARGET"; then
10173   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10174 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10175 else
10176   echo "$as_me:$LINENO: result: no" >&5
10177 echo "${ECHO_T}no" >&6
10178 fi
10179
10180   done
10181 fi
10182
10183 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
10184   for ncn_progname in lipo; do
10185     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10186 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10187     if test -x $with_build_time_tools/${ncn_progname}; then
10188       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10189       echo "$as_me:$LINENO: result: yes" >&5
10190 echo "${ECHO_T}yes" >&6
10191       break
10192     else
10193       echo "$as_me:$LINENO: result: no" >&5
10194 echo "${ECHO_T}no" >&6
10195     fi
10196   done
10197 fi
10198
10199 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
10200   for ncn_progname in lipo; do
10201     if test -n "$ncn_target_tool_prefix"; then
10202       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10203 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10204 echo "$as_me:$LINENO: checking for $ac_word" >&5
10205 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10206 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10207   echo $ECHO_N "(cached) $ECHO_C" >&6
10208 else
10209   if test -n "$LIPO_FOR_TARGET"; then
10210   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10211 else
10212 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10213 for as_dir in $PATH
10214 do
10215   IFS=$as_save_IFS
10216   test -z "$as_dir" && as_dir=.
10217   for ac_exec_ext in '' $ac_executable_extensions; do
10218   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10219     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10220     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10221     break 2
10222   fi
10223 done
10224 done
10225
10226 fi
10227 fi
10228 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10229 if test -n "$LIPO_FOR_TARGET"; then
10230   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10231 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10232 else
10233   echo "$as_me:$LINENO: result: no" >&5
10234 echo "${ECHO_T}no" >&6
10235 fi
10236
10237     fi
10238     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
10239       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10240 set dummy ${ncn_progname}; ac_word=$2
10241 echo "$as_me:$LINENO: checking for $ac_word" >&5
10242 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10243 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
10244   echo $ECHO_N "(cached) $ECHO_C" >&6
10245 else
10246   if test -n "$LIPO_FOR_TARGET"; then
10247   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
10248 else
10249 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10250 for as_dir in $PATH
10251 do
10252   IFS=$as_save_IFS
10253   test -z "$as_dir" && as_dir=.
10254   for ac_exec_ext in '' $ac_executable_extensions; do
10255   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10256     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
10257     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10258     break 2
10259   fi
10260 done
10261 done
10262
10263 fi
10264 fi
10265 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
10266 if test -n "$LIPO_FOR_TARGET"; then
10267   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
10268 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
10269 else
10270   echo "$as_me:$LINENO: result: no" >&5
10271 echo "${ECHO_T}no" >&6
10272 fi
10273
10274     fi
10275     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
10276   done
10277 fi
10278
10279 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
10280   set dummy lipo
10281   if test $build = $target ; then
10282     LIPO_FOR_TARGET="$2"
10283   else
10284     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
10285   fi
10286 else
10287   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
10288 fi
10289
10290 else
10291   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10292 fi
10293
10294
10295
10296
10297 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10298   if test -n "$with_build_time_tools"; then
10299     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10300 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10301     if test -x $with_build_time_tools/nm; then
10302       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10303       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10304       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10305 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10306     else
10307       echo "$as_me:$LINENO: result: no" >&5
10308 echo "${ECHO_T}no" >&6
10309     fi
10310   elif test $build != $host && test $have_gcc_for_target = yes; then
10311     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10312     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10313     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10314   fi
10315 fi
10316 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10317   # Extract the first word of "nm", so it can be a program name with args.
10318 set dummy nm; ac_word=$2
10319 echo "$as_me:$LINENO: checking for $ac_word" >&5
10320 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10321 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10322   echo $ECHO_N "(cached) $ECHO_C" >&6
10323 else
10324   case $NM_FOR_TARGET in
10325   [\\/]* | ?:[\\/]*)
10326   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10327   ;;
10328   *)
10329   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10330 for as_dir in $gcc_cv_tool_dirs
10331 do
10332   IFS=$as_save_IFS
10333   test -z "$as_dir" && as_dir=.
10334   for ac_exec_ext in '' $ac_executable_extensions; do
10335   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10336     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10337     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10338     break 2
10339   fi
10340 done
10341 done
10342
10343   ;;
10344 esac
10345 fi
10346 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10347
10348 if test -n "$NM_FOR_TARGET"; then
10349   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10350 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10351 else
10352   echo "$as_me:$LINENO: result: no" >&5
10353 echo "${ECHO_T}no" >&6
10354 fi
10355
10356 fi
10357 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10358
10359
10360 if test -n "$NM_FOR_TARGET"; then
10361   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10362 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10363   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10364 fi
10365
10366 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10367   for ncn_progname in nm; do
10368     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10369 set dummy ${ncn_progname}; ac_word=$2
10370 echo "$as_me:$LINENO: checking for $ac_word" >&5
10371 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10372 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10373   echo $ECHO_N "(cached) $ECHO_C" >&6
10374 else
10375   if test -n "$NM_FOR_TARGET"; then
10376   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10377 else
10378 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10379 for as_dir in $PATH
10380 do
10381   IFS=$as_save_IFS
10382   test -z "$as_dir" && as_dir=.
10383   for ac_exec_ext in '' $ac_executable_extensions; do
10384   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10385     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10386     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10387     break 2
10388   fi
10389 done
10390 done
10391
10392 fi
10393 fi
10394 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10395 if test -n "$NM_FOR_TARGET"; then
10396   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10397 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10398 else
10399   echo "$as_me:$LINENO: result: no" >&5
10400 echo "${ECHO_T}no" >&6
10401 fi
10402
10403   done
10404 fi
10405
10406 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10407   for ncn_progname in nm; do
10408     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10409 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10410     if test -x $with_build_time_tools/${ncn_progname}; then
10411       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10412       echo "$as_me:$LINENO: result: yes" >&5
10413 echo "${ECHO_T}yes" >&6
10414       break
10415     else
10416       echo "$as_me:$LINENO: result: no" >&5
10417 echo "${ECHO_T}no" >&6
10418     fi
10419   done
10420 fi
10421
10422 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10423   for ncn_progname in nm; do
10424     if test -n "$ncn_target_tool_prefix"; then
10425       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10426 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10427 echo "$as_me:$LINENO: checking for $ac_word" >&5
10428 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10429 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10430   echo $ECHO_N "(cached) $ECHO_C" >&6
10431 else
10432   if test -n "$NM_FOR_TARGET"; then
10433   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10434 else
10435 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10436 for as_dir in $PATH
10437 do
10438   IFS=$as_save_IFS
10439   test -z "$as_dir" && as_dir=.
10440   for ac_exec_ext in '' $ac_executable_extensions; do
10441   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10442     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10443     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10444     break 2
10445   fi
10446 done
10447 done
10448
10449 fi
10450 fi
10451 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10452 if test -n "$NM_FOR_TARGET"; then
10453   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10454 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10455 else
10456   echo "$as_me:$LINENO: result: no" >&5
10457 echo "${ECHO_T}no" >&6
10458 fi
10459
10460     fi
10461     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10462       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10463 set dummy ${ncn_progname}; ac_word=$2
10464 echo "$as_me:$LINENO: checking for $ac_word" >&5
10465 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10466 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10467   echo $ECHO_N "(cached) $ECHO_C" >&6
10468 else
10469   if test -n "$NM_FOR_TARGET"; then
10470   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10471 else
10472 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10473 for as_dir in $PATH
10474 do
10475   IFS=$as_save_IFS
10476   test -z "$as_dir" && as_dir=.
10477   for ac_exec_ext in '' $ac_executable_extensions; do
10478   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10479     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10480     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10481     break 2
10482   fi
10483 done
10484 done
10485
10486 fi
10487 fi
10488 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10489 if test -n "$NM_FOR_TARGET"; then
10490   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10491 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10492 else
10493   echo "$as_me:$LINENO: result: no" >&5
10494 echo "${ECHO_T}no" >&6
10495 fi
10496
10497     fi
10498     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10499   done
10500 fi
10501
10502 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10503   set dummy nm
10504   if test $build = $target ; then
10505     NM_FOR_TARGET="$2"
10506   else
10507     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10508   fi
10509 else
10510   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10511 fi
10512
10513 else
10514   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10515 fi
10516
10517
10518
10519
10520 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10521   if test -n "$with_build_time_tools"; then
10522     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10523 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10524     if test -x $with_build_time_tools/objdump; then
10525       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10526       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10527       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10528 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10529     else
10530       echo "$as_me:$LINENO: result: no" >&5
10531 echo "${ECHO_T}no" >&6
10532     fi
10533   elif test $build != $host && test $have_gcc_for_target = yes; then
10534     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10535     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10536     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10537   fi
10538 fi
10539 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10540   # Extract the first word of "objdump", so it can be a program name with args.
10541 set dummy objdump; ac_word=$2
10542 echo "$as_me:$LINENO: checking for $ac_word" >&5
10543 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10544 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10545   echo $ECHO_N "(cached) $ECHO_C" >&6
10546 else
10547   case $OBJDUMP_FOR_TARGET in
10548   [\\/]* | ?:[\\/]*)
10549   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10550   ;;
10551   *)
10552   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10553 for as_dir in $gcc_cv_tool_dirs
10554 do
10555   IFS=$as_save_IFS
10556   test -z "$as_dir" && as_dir=.
10557   for ac_exec_ext in '' $ac_executable_extensions; do
10558   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10559     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10560     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10561     break 2
10562   fi
10563 done
10564 done
10565
10566   ;;
10567 esac
10568 fi
10569 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10570
10571 if test -n "$OBJDUMP_FOR_TARGET"; then
10572   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10573 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10574 else
10575   echo "$as_me:$LINENO: result: no" >&5
10576 echo "${ECHO_T}no" >&6
10577 fi
10578
10579 fi
10580 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10581
10582
10583 if test -n "$OBJDUMP_FOR_TARGET"; then
10584   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10585 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10586   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10587 fi
10588
10589 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10590   for ncn_progname in objdump; do
10591     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10592 set dummy ${ncn_progname}; ac_word=$2
10593 echo "$as_me:$LINENO: checking for $ac_word" >&5
10594 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10595 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10596   echo $ECHO_N "(cached) $ECHO_C" >&6
10597 else
10598   if test -n "$OBJDUMP_FOR_TARGET"; then
10599   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10600 else
10601 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10602 for as_dir in $PATH
10603 do
10604   IFS=$as_save_IFS
10605   test -z "$as_dir" && as_dir=.
10606   for ac_exec_ext in '' $ac_executable_extensions; do
10607   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10608     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10609     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10610     break 2
10611   fi
10612 done
10613 done
10614
10615 fi
10616 fi
10617 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10618 if test -n "$OBJDUMP_FOR_TARGET"; then
10619   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10620 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10621 else
10622   echo "$as_me:$LINENO: result: no" >&5
10623 echo "${ECHO_T}no" >&6
10624 fi
10625
10626   done
10627 fi
10628
10629 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10630   for ncn_progname in objdump; do
10631     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10632 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10633     if test -x $with_build_time_tools/${ncn_progname}; then
10634       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10635       echo "$as_me:$LINENO: result: yes" >&5
10636 echo "${ECHO_T}yes" >&6
10637       break
10638     else
10639       echo "$as_me:$LINENO: result: no" >&5
10640 echo "${ECHO_T}no" >&6
10641     fi
10642   done
10643 fi
10644
10645 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10646   for ncn_progname in objdump; do
10647     if test -n "$ncn_target_tool_prefix"; then
10648       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10649 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10650 echo "$as_me:$LINENO: checking for $ac_word" >&5
10651 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10652 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10653   echo $ECHO_N "(cached) $ECHO_C" >&6
10654 else
10655   if test -n "$OBJDUMP_FOR_TARGET"; then
10656   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10657 else
10658 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10659 for as_dir in $PATH
10660 do
10661   IFS=$as_save_IFS
10662   test -z "$as_dir" && as_dir=.
10663   for ac_exec_ext in '' $ac_executable_extensions; do
10664   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10665     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10666     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10667     break 2
10668   fi
10669 done
10670 done
10671
10672 fi
10673 fi
10674 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10675 if test -n "$OBJDUMP_FOR_TARGET"; then
10676   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10677 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10678 else
10679   echo "$as_me:$LINENO: result: no" >&5
10680 echo "${ECHO_T}no" >&6
10681 fi
10682
10683     fi
10684     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10685       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10686 set dummy ${ncn_progname}; ac_word=$2
10687 echo "$as_me:$LINENO: checking for $ac_word" >&5
10688 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10689 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10690   echo $ECHO_N "(cached) $ECHO_C" >&6
10691 else
10692   if test -n "$OBJDUMP_FOR_TARGET"; then
10693   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10694 else
10695 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10696 for as_dir in $PATH
10697 do
10698   IFS=$as_save_IFS
10699   test -z "$as_dir" && as_dir=.
10700   for ac_exec_ext in '' $ac_executable_extensions; do
10701   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10702     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10703     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10704     break 2
10705   fi
10706 done
10707 done
10708
10709 fi
10710 fi
10711 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10712 if test -n "$OBJDUMP_FOR_TARGET"; then
10713   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10714 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10715 else
10716   echo "$as_me:$LINENO: result: no" >&5
10717 echo "${ECHO_T}no" >&6
10718 fi
10719
10720     fi
10721     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10722   done
10723 fi
10724
10725 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10726   set dummy objdump
10727   if test $build = $target ; then
10728     OBJDUMP_FOR_TARGET="$2"
10729   else
10730     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10731   fi
10732 else
10733   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10734 fi
10735
10736 else
10737   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10738 fi
10739
10740
10741
10742
10743 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10744   if test -n "$with_build_time_tools"; then
10745     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10746 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10747     if test -x $with_build_time_tools/ranlib; then
10748       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10749       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10750       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10751 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10752     else
10753       echo "$as_me:$LINENO: result: no" >&5
10754 echo "${ECHO_T}no" >&6
10755     fi
10756   elif test $build != $host && test $have_gcc_for_target = yes; then
10757     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10758     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10759     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10760   fi
10761 fi
10762 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10763   # Extract the first word of "ranlib", so it can be a program name with args.
10764 set dummy ranlib; ac_word=$2
10765 echo "$as_me:$LINENO: checking for $ac_word" >&5
10766 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10767 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10768   echo $ECHO_N "(cached) $ECHO_C" >&6
10769 else
10770   case $RANLIB_FOR_TARGET in
10771   [\\/]* | ?:[\\/]*)
10772   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10773   ;;
10774   *)
10775   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10776 for as_dir in $gcc_cv_tool_dirs
10777 do
10778   IFS=$as_save_IFS
10779   test -z "$as_dir" && as_dir=.
10780   for ac_exec_ext in '' $ac_executable_extensions; do
10781   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10782     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10783     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10784     break 2
10785   fi
10786 done
10787 done
10788
10789   ;;
10790 esac
10791 fi
10792 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10793
10794 if test -n "$RANLIB_FOR_TARGET"; then
10795   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10796 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10797 else
10798   echo "$as_me:$LINENO: result: no" >&5
10799 echo "${ECHO_T}no" >&6
10800 fi
10801
10802 fi
10803 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10804
10805
10806 if test -n "$RANLIB_FOR_TARGET"; then
10807   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10808 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10809   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10810 fi
10811
10812 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10813   for ncn_progname in ranlib; do
10814     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10815 set dummy ${ncn_progname}; ac_word=$2
10816 echo "$as_me:$LINENO: checking for $ac_word" >&5
10817 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10818 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10819   echo $ECHO_N "(cached) $ECHO_C" >&6
10820 else
10821   if test -n "$RANLIB_FOR_TARGET"; then
10822   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10823 else
10824 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10825 for as_dir in $PATH
10826 do
10827   IFS=$as_save_IFS
10828   test -z "$as_dir" && as_dir=.
10829   for ac_exec_ext in '' $ac_executable_extensions; do
10830   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10831     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10832     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10833     break 2
10834   fi
10835 done
10836 done
10837
10838 fi
10839 fi
10840 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10841 if test -n "$RANLIB_FOR_TARGET"; then
10842   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10843 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10844 else
10845   echo "$as_me:$LINENO: result: no" >&5
10846 echo "${ECHO_T}no" >&6
10847 fi
10848
10849   done
10850 fi
10851
10852 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10853   for ncn_progname in ranlib; do
10854     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10855 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10856     if test -x $with_build_time_tools/${ncn_progname}; then
10857       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10858       echo "$as_me:$LINENO: result: yes" >&5
10859 echo "${ECHO_T}yes" >&6
10860       break
10861     else
10862       echo "$as_me:$LINENO: result: no" >&5
10863 echo "${ECHO_T}no" >&6
10864     fi
10865   done
10866 fi
10867
10868 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10869   for ncn_progname in ranlib; do
10870     if test -n "$ncn_target_tool_prefix"; then
10871       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10872 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10873 echo "$as_me:$LINENO: checking for $ac_word" >&5
10874 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10875 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10876   echo $ECHO_N "(cached) $ECHO_C" >&6
10877 else
10878   if test -n "$RANLIB_FOR_TARGET"; then
10879   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10880 else
10881 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10882 for as_dir in $PATH
10883 do
10884   IFS=$as_save_IFS
10885   test -z "$as_dir" && as_dir=.
10886   for ac_exec_ext in '' $ac_executable_extensions; do
10887   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10888     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10889     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10890     break 2
10891   fi
10892 done
10893 done
10894
10895 fi
10896 fi
10897 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10898 if test -n "$RANLIB_FOR_TARGET"; then
10899   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10900 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10901 else
10902   echo "$as_me:$LINENO: result: no" >&5
10903 echo "${ECHO_T}no" >&6
10904 fi
10905
10906     fi
10907     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10908       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10909 set dummy ${ncn_progname}; ac_word=$2
10910 echo "$as_me:$LINENO: checking for $ac_word" >&5
10911 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10912 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10913   echo $ECHO_N "(cached) $ECHO_C" >&6
10914 else
10915   if test -n "$RANLIB_FOR_TARGET"; then
10916   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10917 else
10918 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10919 for as_dir in $PATH
10920 do
10921   IFS=$as_save_IFS
10922   test -z "$as_dir" && as_dir=.
10923   for ac_exec_ext in '' $ac_executable_extensions; do
10924   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10925     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10926     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10927     break 2
10928   fi
10929 done
10930 done
10931
10932 fi
10933 fi
10934 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10935 if test -n "$RANLIB_FOR_TARGET"; then
10936   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10937 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10938 else
10939   echo "$as_me:$LINENO: result: no" >&5
10940 echo "${ECHO_T}no" >&6
10941 fi
10942
10943     fi
10944     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10945   done
10946 fi
10947
10948 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10949   set dummy ranlib
10950   if test $build = $target ; then
10951     RANLIB_FOR_TARGET="$2"
10952   else
10953     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10954   fi
10955 else
10956   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10957 fi
10958
10959 else
10960   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10961 fi
10962
10963
10964
10965
10966 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10967   if test -n "$with_build_time_tools"; then
10968     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10969 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10970     if test -x $with_build_time_tools/strip; then
10971       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10972       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10973       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10974 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10975     else
10976       echo "$as_me:$LINENO: result: no" >&5
10977 echo "${ECHO_T}no" >&6
10978     fi
10979   elif test $build != $host && test $have_gcc_for_target = yes; then
10980     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10981     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10982     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10983   fi
10984 fi
10985 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10986   # Extract the first word of "strip", so it can be a program name with args.
10987 set dummy strip; ac_word=$2
10988 echo "$as_me:$LINENO: checking for $ac_word" >&5
10989 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10990 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10991   echo $ECHO_N "(cached) $ECHO_C" >&6
10992 else
10993   case $STRIP_FOR_TARGET in
10994   [\\/]* | ?:[\\/]*)
10995   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10996   ;;
10997   *)
10998   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10999 for as_dir in $gcc_cv_tool_dirs
11000 do
11001   IFS=$as_save_IFS
11002   test -z "$as_dir" && as_dir=.
11003   for ac_exec_ext in '' $ac_executable_extensions; do
11004   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11005     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11006     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11007     break 2
11008   fi
11009 done
11010 done
11011
11012   ;;
11013 esac
11014 fi
11015 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11016
11017 if test -n "$STRIP_FOR_TARGET"; then
11018   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11019 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11020 else
11021   echo "$as_me:$LINENO: result: no" >&5
11022 echo "${ECHO_T}no" >&6
11023 fi
11024
11025 fi
11026 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
11027
11028
11029 if test -n "$STRIP_FOR_TARGET"; then
11030   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
11031 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11032   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11033 fi
11034
11035 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
11036   for ncn_progname in strip; do
11037     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11038 set dummy ${ncn_progname}; ac_word=$2
11039 echo "$as_me:$LINENO: checking for $ac_word" >&5
11040 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11041 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11042   echo $ECHO_N "(cached) $ECHO_C" >&6
11043 else
11044   if test -n "$STRIP_FOR_TARGET"; then
11045   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11046 else
11047 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11048 for as_dir in $PATH
11049 do
11050   IFS=$as_save_IFS
11051   test -z "$as_dir" && as_dir=.
11052   for ac_exec_ext in '' $ac_executable_extensions; do
11053   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11054     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11055     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11056     break 2
11057   fi
11058 done
11059 done
11060
11061 fi
11062 fi
11063 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11064 if test -n "$STRIP_FOR_TARGET"; then
11065   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11066 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11067 else
11068   echo "$as_me:$LINENO: result: no" >&5
11069 echo "${ECHO_T}no" >&6
11070 fi
11071
11072   done
11073 fi
11074
11075 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
11076   for ncn_progname in strip; do
11077     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11078 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11079     if test -x $with_build_time_tools/${ncn_progname}; then
11080       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11081       echo "$as_me:$LINENO: result: yes" >&5
11082 echo "${ECHO_T}yes" >&6
11083       break
11084     else
11085       echo "$as_me:$LINENO: result: no" >&5
11086 echo "${ECHO_T}no" >&6
11087     fi
11088   done
11089 fi
11090
11091 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
11092   for ncn_progname in strip; do
11093     if test -n "$ncn_target_tool_prefix"; then
11094       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11095 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11096 echo "$as_me:$LINENO: checking for $ac_word" >&5
11097 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11098 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11099   echo $ECHO_N "(cached) $ECHO_C" >&6
11100 else
11101   if test -n "$STRIP_FOR_TARGET"; then
11102   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11103 else
11104 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11105 for as_dir in $PATH
11106 do
11107   IFS=$as_save_IFS
11108   test -z "$as_dir" && as_dir=.
11109   for ac_exec_ext in '' $ac_executable_extensions; do
11110   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11111     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11112     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11113     break 2
11114   fi
11115 done
11116 done
11117
11118 fi
11119 fi
11120 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11121 if test -n "$STRIP_FOR_TARGET"; then
11122   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11123 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11124 else
11125   echo "$as_me:$LINENO: result: no" >&5
11126 echo "${ECHO_T}no" >&6
11127 fi
11128
11129     fi
11130     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
11131       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11132 set dummy ${ncn_progname}; ac_word=$2
11133 echo "$as_me:$LINENO: checking for $ac_word" >&5
11134 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11135 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
11136   echo $ECHO_N "(cached) $ECHO_C" >&6
11137 else
11138   if test -n "$STRIP_FOR_TARGET"; then
11139   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
11140 else
11141 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11142 for as_dir in $PATH
11143 do
11144   IFS=$as_save_IFS
11145   test -z "$as_dir" && as_dir=.
11146   for ac_exec_ext in '' $ac_executable_extensions; do
11147   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11148     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
11149     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11150     break 2
11151   fi
11152 done
11153 done
11154
11155 fi
11156 fi
11157 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
11158 if test -n "$STRIP_FOR_TARGET"; then
11159   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
11160 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
11161 else
11162   echo "$as_me:$LINENO: result: no" >&5
11163 echo "${ECHO_T}no" >&6
11164 fi
11165
11166     fi
11167     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
11168   done
11169 fi
11170
11171 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
11172   set dummy strip
11173   if test $build = $target ; then
11174     STRIP_FOR_TARGET="$2"
11175   else
11176     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
11177   fi
11178 else
11179   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
11180 fi
11181
11182 else
11183   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
11184 fi
11185
11186
11187
11188
11189 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11190   if test -n "$with_build_time_tools"; then
11191     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
11192 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
11193     if test -x $with_build_time_tools/windres; then
11194       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
11195       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11196       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
11197 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
11198     else
11199       echo "$as_me:$LINENO: result: no" >&5
11200 echo "${ECHO_T}no" >&6
11201     fi
11202   elif test $build != $host && test $have_gcc_for_target = yes; then
11203     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
11204     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
11205     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11206   fi
11207 fi
11208 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11209   # Extract the first word of "windres", so it can be a program name with args.
11210 set dummy windres; ac_word=$2
11211 echo "$as_me:$LINENO: checking for $ac_word" >&5
11212 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11213 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
11214   echo $ECHO_N "(cached) $ECHO_C" >&6
11215 else
11216   case $WINDRES_FOR_TARGET in
11217   [\\/]* | ?:[\\/]*)
11218   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
11219   ;;
11220   *)
11221   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11222 for as_dir in $gcc_cv_tool_dirs
11223 do
11224   IFS=$as_save_IFS
11225   test -z "$as_dir" && as_dir=.
11226   for ac_exec_ext in '' $ac_executable_extensions; do
11227   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11228     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11229     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11230     break 2
11231   fi
11232 done
11233 done
11234
11235   ;;
11236 esac
11237 fi
11238 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11239
11240 if test -n "$WINDRES_FOR_TARGET"; then
11241   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11242 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11243 else
11244   echo "$as_me:$LINENO: result: no" >&5
11245 echo "${ECHO_T}no" >&6
11246 fi
11247
11248 fi
11249 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
11250
11251
11252 if test -n "$WINDRES_FOR_TARGET"; then
11253   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
11254 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11255   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11256 fi
11257
11258 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11259   for ncn_progname in windres; do
11260     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11261 set dummy ${ncn_progname}; ac_word=$2
11262 echo "$as_me:$LINENO: checking for $ac_word" >&5
11263 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11264 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11265   echo $ECHO_N "(cached) $ECHO_C" >&6
11266 else
11267   if test -n "$WINDRES_FOR_TARGET"; then
11268   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11269 else
11270 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11271 for as_dir in $PATH
11272 do
11273   IFS=$as_save_IFS
11274   test -z "$as_dir" && as_dir=.
11275   for ac_exec_ext in '' $ac_executable_extensions; do
11276   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11277     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11278     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11279     break 2
11280   fi
11281 done
11282 done
11283
11284 fi
11285 fi
11286 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11287 if test -n "$WINDRES_FOR_TARGET"; then
11288   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11289 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11290 else
11291   echo "$as_me:$LINENO: result: no" >&5
11292 echo "${ECHO_T}no" >&6
11293 fi
11294
11295   done
11296 fi
11297
11298 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11299   for ncn_progname in windres; do
11300     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11301 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11302     if test -x $with_build_time_tools/${ncn_progname}; then
11303       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11304       echo "$as_me:$LINENO: result: yes" >&5
11305 echo "${ECHO_T}yes" >&6
11306       break
11307     else
11308       echo "$as_me:$LINENO: result: no" >&5
11309 echo "${ECHO_T}no" >&6
11310     fi
11311   done
11312 fi
11313
11314 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11315   for ncn_progname in windres; do
11316     if test -n "$ncn_target_tool_prefix"; then
11317       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11318 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11319 echo "$as_me:$LINENO: checking for $ac_word" >&5
11320 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11321 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11322   echo $ECHO_N "(cached) $ECHO_C" >&6
11323 else
11324   if test -n "$WINDRES_FOR_TARGET"; then
11325   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11326 else
11327 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11328 for as_dir in $PATH
11329 do
11330   IFS=$as_save_IFS
11331   test -z "$as_dir" && as_dir=.
11332   for ac_exec_ext in '' $ac_executable_extensions; do
11333   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11334     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11335     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11336     break 2
11337   fi
11338 done
11339 done
11340
11341 fi
11342 fi
11343 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11344 if test -n "$WINDRES_FOR_TARGET"; then
11345   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11346 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11347 else
11348   echo "$as_me:$LINENO: result: no" >&5
11349 echo "${ECHO_T}no" >&6
11350 fi
11351
11352     fi
11353     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11354       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11355 set dummy ${ncn_progname}; ac_word=$2
11356 echo "$as_me:$LINENO: checking for $ac_word" >&5
11357 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11358 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11359   echo $ECHO_N "(cached) $ECHO_C" >&6
11360 else
11361   if test -n "$WINDRES_FOR_TARGET"; then
11362   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11363 else
11364 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11365 for as_dir in $PATH
11366 do
11367   IFS=$as_save_IFS
11368   test -z "$as_dir" && as_dir=.
11369   for ac_exec_ext in '' $ac_executable_extensions; do
11370   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11371     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11372     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11373     break 2
11374   fi
11375 done
11376 done
11377
11378 fi
11379 fi
11380 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11381 if test -n "$WINDRES_FOR_TARGET"; then
11382   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11383 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11384 else
11385   echo "$as_me:$LINENO: result: no" >&5
11386 echo "${ECHO_T}no" >&6
11387 fi
11388
11389     fi
11390     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11391   done
11392 fi
11393
11394 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11395   set dummy windres
11396   if test $build = $target ; then
11397     WINDRES_FOR_TARGET="$2"
11398   else
11399     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11400   fi
11401 else
11402   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11403 fi
11404
11405 else
11406   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11407 fi
11408
11409
11410
11411
11412 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11413   if test -n "$with_build_time_tools"; then
11414     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11415 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11416     if test -x $with_build_time_tools/windmc; then
11417       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11418       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11419       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11420 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11421     else
11422       echo "$as_me:$LINENO: result: no" >&5
11423 echo "${ECHO_T}no" >&6
11424     fi
11425   elif test $build != $host && test $have_gcc_for_target = yes; then
11426     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11427     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11428     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11429   fi
11430 fi
11431 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11432   # Extract the first word of "windmc", so it can be a program name with args.
11433 set dummy windmc; ac_word=$2
11434 echo "$as_me:$LINENO: checking for $ac_word" >&5
11435 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11436 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11437   echo $ECHO_N "(cached) $ECHO_C" >&6
11438 else
11439   case $WINDMC_FOR_TARGET in
11440   [\\/]* | ?:[\\/]*)
11441   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11442   ;;
11443   *)
11444   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11445 for as_dir in $gcc_cv_tool_dirs
11446 do
11447   IFS=$as_save_IFS
11448   test -z "$as_dir" && as_dir=.
11449   for ac_exec_ext in '' $ac_executable_extensions; do
11450   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11451     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11452     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11453     break 2
11454   fi
11455 done
11456 done
11457
11458   ;;
11459 esac
11460 fi
11461 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11462
11463 if test -n "$WINDMC_FOR_TARGET"; then
11464   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11465 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11466 else
11467   echo "$as_me:$LINENO: result: no" >&5
11468 echo "${ECHO_T}no" >&6
11469 fi
11470
11471 fi
11472 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11473
11474
11475 if test -n "$WINDMC_FOR_TARGET"; then
11476   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11477 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11478   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11479 fi
11480
11481 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11482   for ncn_progname in windmc; do
11483     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11484 set dummy ${ncn_progname}; ac_word=$2
11485 echo "$as_me:$LINENO: checking for $ac_word" >&5
11486 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11487 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11488   echo $ECHO_N "(cached) $ECHO_C" >&6
11489 else
11490   if test -n "$WINDMC_FOR_TARGET"; then
11491   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11492 else
11493 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11494 for as_dir in $PATH
11495 do
11496   IFS=$as_save_IFS
11497   test -z "$as_dir" && as_dir=.
11498   for ac_exec_ext in '' $ac_executable_extensions; do
11499   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11500     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11501     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11502     break 2
11503   fi
11504 done
11505 done
11506
11507 fi
11508 fi
11509 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11510 if test -n "$WINDMC_FOR_TARGET"; then
11511   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11512 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11513 else
11514   echo "$as_me:$LINENO: result: no" >&5
11515 echo "${ECHO_T}no" >&6
11516 fi
11517
11518   done
11519 fi
11520
11521 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11522   for ncn_progname in windmc; do
11523     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11524 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11525     if test -x $with_build_time_tools/${ncn_progname}; then
11526       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11527       echo "$as_me:$LINENO: result: yes" >&5
11528 echo "${ECHO_T}yes" >&6
11529       break
11530     else
11531       echo "$as_me:$LINENO: result: no" >&5
11532 echo "${ECHO_T}no" >&6
11533     fi
11534   done
11535 fi
11536
11537 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11538   for ncn_progname in windmc; do
11539     if test -n "$ncn_target_tool_prefix"; then
11540       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11541 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11542 echo "$as_me:$LINENO: checking for $ac_word" >&5
11543 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11544 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11545   echo $ECHO_N "(cached) $ECHO_C" >&6
11546 else
11547   if test -n "$WINDMC_FOR_TARGET"; then
11548   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11549 else
11550 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11551 for as_dir in $PATH
11552 do
11553   IFS=$as_save_IFS
11554   test -z "$as_dir" && as_dir=.
11555   for ac_exec_ext in '' $ac_executable_extensions; do
11556   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11557     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11558     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11559     break 2
11560   fi
11561 done
11562 done
11563
11564 fi
11565 fi
11566 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11567 if test -n "$WINDMC_FOR_TARGET"; then
11568   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11569 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11570 else
11571   echo "$as_me:$LINENO: result: no" >&5
11572 echo "${ECHO_T}no" >&6
11573 fi
11574
11575     fi
11576     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11577       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11578 set dummy ${ncn_progname}; ac_word=$2
11579 echo "$as_me:$LINENO: checking for $ac_word" >&5
11580 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11581 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11582   echo $ECHO_N "(cached) $ECHO_C" >&6
11583 else
11584   if test -n "$WINDMC_FOR_TARGET"; then
11585   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11586 else
11587 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11588 for as_dir in $PATH
11589 do
11590   IFS=$as_save_IFS
11591   test -z "$as_dir" && as_dir=.
11592   for ac_exec_ext in '' $ac_executable_extensions; do
11593   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11594     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11595     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11596     break 2
11597   fi
11598 done
11599 done
11600
11601 fi
11602 fi
11603 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11604 if test -n "$WINDMC_FOR_TARGET"; then
11605   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11606 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11607 else
11608   echo "$as_me:$LINENO: result: no" >&5
11609 echo "${ECHO_T}no" >&6
11610 fi
11611
11612     fi
11613     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11614   done
11615 fi
11616
11617 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11618   set dummy windmc
11619   if test $build = $target ; then
11620     WINDMC_FOR_TARGET="$2"
11621   else
11622     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11623   fi
11624 else
11625   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11626 fi
11627
11628 else
11629   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11630 fi
11631
11632
11633 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11634
11635 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11636 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11637 if test "x${build}" != "x${host}" ; then
11638   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11639     # We already found the complete path
11640     ac_dir=`dirname $AR_FOR_TARGET`
11641     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11642 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11643   else
11644     # Canadian cross, just use what we found
11645     echo "$as_me:$LINENO: result: pre-installed" >&5
11646 echo "${ECHO_T}pre-installed" >&6
11647   fi
11648 else
11649   ok=yes
11650   case " ${configdirs} " in
11651     *" binutils "*) ;;
11652     *) ok=no ;;
11653   esac
11654
11655   if test $ok = yes; then
11656     # An in-tree tool is available and we can use it
11657     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11658     echo "$as_me:$LINENO: result: just compiled" >&5
11659 echo "${ECHO_T}just compiled" >&6
11660   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11661     # We already found the complete path
11662     ac_dir=`dirname $AR_FOR_TARGET`
11663     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11664 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11665   elif test "x$target" = "x$host"; then
11666     # We can use an host tool
11667     AR_FOR_TARGET='$(AR)'
11668     echo "$as_me:$LINENO: result: host tool" >&5
11669 echo "${ECHO_T}host tool" >&6
11670   else
11671     # We need a cross tool
11672     echo "$as_me:$LINENO: result: pre-installed" >&5
11673 echo "${ECHO_T}pre-installed" >&6
11674   fi
11675 fi
11676
11677 echo "$as_me:$LINENO: checking where to find the target as" >&5
11678 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11679 if test "x${build}" != "x${host}" ; then
11680   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11681     # We already found the complete path
11682     ac_dir=`dirname $AS_FOR_TARGET`
11683     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11684 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11685   else
11686     # Canadian cross, just use what we found
11687     echo "$as_me:$LINENO: result: pre-installed" >&5
11688 echo "${ECHO_T}pre-installed" >&6
11689   fi
11690 else
11691   ok=yes
11692   case " ${configdirs} " in
11693     *" gas "*) ;;
11694     *) ok=no ;;
11695   esac
11696
11697   if test $ok = yes; then
11698     # An in-tree tool is available and we can use it
11699     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11700     echo "$as_me:$LINENO: result: just compiled" >&5
11701 echo "${ECHO_T}just compiled" >&6
11702   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11703     # We already found the complete path
11704     ac_dir=`dirname $AS_FOR_TARGET`
11705     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11706 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11707   elif test "x$target" = "x$host"; then
11708     # We can use an host tool
11709     AS_FOR_TARGET='$(AS)'
11710     echo "$as_me:$LINENO: result: host tool" >&5
11711 echo "${ECHO_T}host tool" >&6
11712   else
11713     # We need a cross tool
11714     echo "$as_me:$LINENO: result: pre-installed" >&5
11715 echo "${ECHO_T}pre-installed" >&6
11716   fi
11717 fi
11718
11719 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11720 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11721 if test "x${build}" != "x${host}" ; then
11722   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11723     # We already found the complete path
11724     ac_dir=`dirname $CC_FOR_TARGET`
11725     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11726 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11727   else
11728     # Canadian cross, just use what we found
11729     echo "$as_me:$LINENO: result: pre-installed" >&5
11730 echo "${ECHO_T}pre-installed" >&6
11731   fi
11732 else
11733   ok=yes
11734   case " ${configdirs} " in
11735     *" gcc "*) ;;
11736     *) ok=no ;;
11737   esac
11738
11739   if test $ok = yes; then
11740     # An in-tree tool is available and we can use it
11741     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11742     echo "$as_me:$LINENO: result: just compiled" >&5
11743 echo "${ECHO_T}just compiled" >&6
11744   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11745     # We already found the complete path
11746     ac_dir=`dirname $CC_FOR_TARGET`
11747     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11748 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11749   elif test "x$target" = "x$host"; then
11750     # We can use an host tool
11751     CC_FOR_TARGET='$(CC)'
11752     echo "$as_me:$LINENO: result: host tool" >&5
11753 echo "${ECHO_T}host tool" >&6
11754   else
11755     # We need a cross tool
11756     echo "$as_me:$LINENO: result: pre-installed" >&5
11757 echo "${ECHO_T}pre-installed" >&6
11758   fi
11759 fi
11760
11761 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11762 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11763 if test "x${build}" != "x${host}" ; then
11764   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11765     # We already found the complete path
11766     ac_dir=`dirname $CXX_FOR_TARGET`
11767     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11768 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11769   else
11770     # Canadian cross, just use what we found
11771     echo "$as_me:$LINENO: result: pre-installed" >&5
11772 echo "${ECHO_T}pre-installed" >&6
11773   fi
11774 else
11775   ok=yes
11776   case " ${configdirs} " in
11777     *" gcc "*) ;;
11778     *) ok=no ;;
11779   esac
11780   case ,${enable_languages}, in
11781     *,c++,*) ;;
11782     *) ok=no ;;
11783   esac
11784   if test $ok = yes; then
11785     # An in-tree tool is available and we can use it
11786     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'
11787     echo "$as_me:$LINENO: result: just compiled" >&5
11788 echo "${ECHO_T}just compiled" >&6
11789   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11790     # We already found the complete path
11791     ac_dir=`dirname $CXX_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     CXX_FOR_TARGET='$(CXX)'
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 c++ for libstdc++" >&5
11807 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11808 if test "x${build}" != "x${host}" ; then
11809   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11810     # We already found the complete path
11811     ac_dir=`dirname $RAW_CXX_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     *" gcc "*) ;;
11823     *) ok=no ;;
11824   esac
11825   case ,${enable_languages}, in
11826     *,c++,*) ;;
11827     *) ok=no ;;
11828   esac
11829   if test $ok = yes; then
11830     # An in-tree tool is available and we can use it
11831     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'
11832     echo "$as_me:$LINENO: result: just compiled" >&5
11833 echo "${ECHO_T}just compiled" >&6
11834   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11835     # We already found the complete path
11836     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11837     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11838 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11839   elif test "x$target" = "x$host"; then
11840     # We can use an host tool
11841     RAW_CXX_FOR_TARGET='$(CXX)'
11842     echo "$as_me:$LINENO: result: host tool" >&5
11843 echo "${ECHO_T}host tool" >&6
11844   else
11845     # We need a cross tool
11846     echo "$as_me:$LINENO: result: pre-installed" >&5
11847 echo "${ECHO_T}pre-installed" >&6
11848   fi
11849 fi
11850
11851 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11852 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11853 if test "x${build}" != "x${host}" ; then
11854   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11855     # We already found the complete path
11856     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11857     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11858 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11859   else
11860     # Canadian cross, just use what we found
11861     echo "$as_me:$LINENO: result: pre-installed" >&5
11862 echo "${ECHO_T}pre-installed" >&6
11863   fi
11864 else
11865   ok=yes
11866   case " ${configdirs} " in
11867     *" binutils "*) ;;
11868     *) ok=no ;;
11869   esac
11870
11871   if test $ok = yes; then
11872     # An in-tree tool is available and we can use it
11873     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11874     echo "$as_me:$LINENO: result: just compiled" >&5
11875 echo "${ECHO_T}just compiled" >&6
11876   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11877     # We already found the complete path
11878     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11879     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11880 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11881   elif test "x$target" = "x$host"; then
11882     # We can use an host tool
11883     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11884     echo "$as_me:$LINENO: result: host tool" >&5
11885 echo "${ECHO_T}host tool" >&6
11886   else
11887     # We need a cross tool
11888     echo "$as_me:$LINENO: result: pre-installed" >&5
11889 echo "${ECHO_T}pre-installed" >&6
11890   fi
11891 fi
11892
11893 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11894 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11895 if test "x${build}" != "x${host}" ; then
11896   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11897     # We already found the complete path
11898     ac_dir=`dirname $GCC_FOR_TARGET`
11899     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11900 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11901   else
11902     # Canadian cross, just use what we found
11903     echo "$as_me:$LINENO: result: pre-installed" >&5
11904 echo "${ECHO_T}pre-installed" >&6
11905   fi
11906 else
11907   ok=yes
11908   case " ${configdirs} " in
11909     *" gcc "*) ;;
11910     *) ok=no ;;
11911   esac
11912
11913   if test $ok = yes; then
11914     # An in-tree tool is available and we can use it
11915     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11916     echo "$as_me:$LINENO: result: just compiled" >&5
11917 echo "${ECHO_T}just compiled" >&6
11918   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11919     # We already found the complete path
11920     ac_dir=`dirname $GCC_FOR_TARGET`
11921     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11922 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11923   elif test "x$target" = "x$host"; then
11924     # We can use an host tool
11925     GCC_FOR_TARGET='$()'
11926     echo "$as_me:$LINENO: result: host tool" >&5
11927 echo "${ECHO_T}host tool" >&6
11928   else
11929     # We need a cross tool
11930     echo "$as_me:$LINENO: result: pre-installed" >&5
11931 echo "${ECHO_T}pre-installed" >&6
11932   fi
11933 fi
11934
11935 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11936 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11937 if test "x${build}" != "x${host}" ; then
11938   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11939     # We already found the complete path
11940     ac_dir=`dirname $GCJ_FOR_TARGET`
11941     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11942 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11943   else
11944     # Canadian cross, just use what we found
11945     echo "$as_me:$LINENO: result: pre-installed" >&5
11946 echo "${ECHO_T}pre-installed" >&6
11947   fi
11948 else
11949   ok=yes
11950   case " ${configdirs} " in
11951     *" gcc "*) ;;
11952     *) ok=no ;;
11953   esac
11954   case ,${enable_languages}, in
11955     *,java,*) ;;
11956     *) ok=no ;;
11957   esac
11958   if test $ok = yes; then
11959     # An in-tree tool is available and we can use it
11960     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11961     echo "$as_me:$LINENO: result: just compiled" >&5
11962 echo "${ECHO_T}just compiled" >&6
11963   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11964     # We already found the complete path
11965     ac_dir=`dirname $GCJ_FOR_TARGET`
11966     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11967 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11968   elif test "x$target" = "x$host"; then
11969     # We can use an host tool
11970     GCJ_FOR_TARGET='$(GCJ)'
11971     echo "$as_me:$LINENO: result: host tool" >&5
11972 echo "${ECHO_T}host tool" >&6
11973   else
11974     # We need a cross tool
11975     echo "$as_me:$LINENO: result: pre-installed" >&5
11976 echo "${ECHO_T}pre-installed" >&6
11977   fi
11978 fi
11979
11980 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11981 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11982 if test "x${build}" != "x${host}" ; then
11983   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11984     # We already found the complete path
11985     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11986     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11987 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11988   else
11989     # Canadian cross, just use what we found
11990     echo "$as_me:$LINENO: result: pre-installed" >&5
11991 echo "${ECHO_T}pre-installed" >&6
11992   fi
11993 else
11994   ok=yes
11995   case " ${configdirs} " in
11996     *" gcc "*) ;;
11997     *) ok=no ;;
11998   esac
11999   case ,${enable_languages}, in
12000     *,fortran,*) ;;
12001     *) ok=no ;;
12002   esac
12003   if test $ok = yes; then
12004     # An in-tree tool is available and we can use it
12005     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
12006     echo "$as_me:$LINENO: result: just compiled" >&5
12007 echo "${ECHO_T}just compiled" >&6
12008   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
12009     # We already found the complete path
12010     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
12011     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12012 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12013   elif test "x$target" = "x$host"; then
12014     # We can use an host tool
12015     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
12016     echo "$as_me:$LINENO: result: host tool" >&5
12017 echo "${ECHO_T}host tool" >&6
12018   else
12019     # We need a cross tool
12020     echo "$as_me:$LINENO: result: pre-installed" >&5
12021 echo "${ECHO_T}pre-installed" >&6
12022   fi
12023 fi
12024
12025 echo "$as_me:$LINENO: checking where to find the target ld" >&5
12026 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
12027 if test "x${build}" != "x${host}" ; then
12028   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12029     # We already found the complete path
12030     ac_dir=`dirname $LD_FOR_TARGET`
12031     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12032 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12033   else
12034     # Canadian cross, just use what we found
12035     echo "$as_me:$LINENO: result: pre-installed" >&5
12036 echo "${ECHO_T}pre-installed" >&6
12037   fi
12038 else
12039   ok=yes
12040   case " ${configdirs} " in
12041     *" ld "*) ;;
12042     *) ok=no ;;
12043   esac
12044
12045   if test $ok = yes; then
12046     # An in-tree tool is available and we can use it
12047     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
12048     echo "$as_me:$LINENO: result: just compiled" >&5
12049 echo "${ECHO_T}just compiled" >&6
12050   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
12051     # We already found the complete path
12052     ac_dir=`dirname $LD_FOR_TARGET`
12053     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12054 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12055   elif test "x$target" = "x$host"; then
12056     # We can use an host tool
12057     LD_FOR_TARGET='$(LD)'
12058     echo "$as_me:$LINENO: result: host tool" >&5
12059 echo "${ECHO_T}host tool" >&6
12060   else
12061     # We need a cross tool
12062     echo "$as_me:$LINENO: result: pre-installed" >&5
12063 echo "${ECHO_T}pre-installed" >&6
12064   fi
12065 fi
12066
12067 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
12068 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
12069 if test "x${build}" != "x${host}" ; then
12070   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12071     # We already found the complete path
12072     ac_dir=`dirname $LIPO_FOR_TARGET`
12073     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12074 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12075   else
12076     # Canadian cross, just use what we found
12077     echo "$as_me:$LINENO: result: pre-installed" >&5
12078 echo "${ECHO_T}pre-installed" >&6
12079   fi
12080 else
12081   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
12082     # We already found the complete path
12083     ac_dir=`dirname $LIPO_FOR_TARGET`
12084     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12085 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12086   elif test "x$target" = "x$host"; then
12087     # We can use an host tool
12088     LIPO_FOR_TARGET='$(LIPO)'
12089     echo "$as_me:$LINENO: result: host tool" >&5
12090 echo "${ECHO_T}host tool" >&6
12091   else
12092     # We need a cross tool
12093     echo "$as_me:$LINENO: result: pre-installed" >&5
12094 echo "${ECHO_T}pre-installed" >&6
12095   fi
12096 fi
12097
12098 echo "$as_me:$LINENO: checking where to find the target nm" >&5
12099 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
12100 if test "x${build}" != "x${host}" ; then
12101   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12102     # We already found the complete path
12103     ac_dir=`dirname $NM_FOR_TARGET`
12104     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12105 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12106   else
12107     # Canadian cross, just use what we found
12108     echo "$as_me:$LINENO: result: pre-installed" >&5
12109 echo "${ECHO_T}pre-installed" >&6
12110   fi
12111 else
12112   ok=yes
12113   case " ${configdirs} " in
12114     *" binutils "*) ;;
12115     *) ok=no ;;
12116   esac
12117
12118   if test $ok = yes; then
12119     # An in-tree tool is available and we can use it
12120     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
12121     echo "$as_me:$LINENO: result: just compiled" >&5
12122 echo "${ECHO_T}just compiled" >&6
12123   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
12124     # We already found the complete path
12125     ac_dir=`dirname $NM_FOR_TARGET`
12126     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12127 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12128   elif test "x$target" = "x$host"; then
12129     # We can use an host tool
12130     NM_FOR_TARGET='$(NM)'
12131     echo "$as_me:$LINENO: result: host tool" >&5
12132 echo "${ECHO_T}host tool" >&6
12133   else
12134     # We need a cross tool
12135     echo "$as_me:$LINENO: result: pre-installed" >&5
12136 echo "${ECHO_T}pre-installed" >&6
12137   fi
12138 fi
12139
12140 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
12141 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
12142 if test "x${build}" != "x${host}" ; then
12143   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12144     # We already found the complete path
12145     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12146     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12147 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12148   else
12149     # Canadian cross, just use what we found
12150     echo "$as_me:$LINENO: result: pre-installed" >&5
12151 echo "${ECHO_T}pre-installed" >&6
12152   fi
12153 else
12154   ok=yes
12155   case " ${configdirs} " in
12156     *" binutils "*) ;;
12157     *) ok=no ;;
12158   esac
12159
12160   if test $ok = yes; then
12161     # An in-tree tool is available and we can use it
12162     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
12163     echo "$as_me:$LINENO: result: just compiled" >&5
12164 echo "${ECHO_T}just compiled" >&6
12165   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
12166     # We already found the complete path
12167     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
12168     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12169 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12170   elif test "x$target" = "x$host"; then
12171     # We can use an host tool
12172     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
12173     echo "$as_me:$LINENO: result: host tool" >&5
12174 echo "${ECHO_T}host tool" >&6
12175   else
12176     # We need a cross tool
12177     echo "$as_me:$LINENO: result: pre-installed" >&5
12178 echo "${ECHO_T}pre-installed" >&6
12179   fi
12180 fi
12181
12182 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
12183 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
12184 if test "x${build}" != "x${host}" ; then
12185   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12186     # We already found the complete path
12187     ac_dir=`dirname $RANLIB_FOR_TARGET`
12188     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12189 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12190   else
12191     # Canadian cross, just use what we found
12192     echo "$as_me:$LINENO: result: pre-installed" >&5
12193 echo "${ECHO_T}pre-installed" >&6
12194   fi
12195 else
12196   ok=yes
12197   case " ${configdirs} " in
12198     *" binutils "*) ;;
12199     *) ok=no ;;
12200   esac
12201
12202   if test $ok = yes; then
12203     # An in-tree tool is available and we can use it
12204     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
12205     echo "$as_me:$LINENO: result: just compiled" >&5
12206 echo "${ECHO_T}just compiled" >&6
12207   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
12208     # We already found the complete path
12209     ac_dir=`dirname $RANLIB_FOR_TARGET`
12210     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12211 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12212   elif test "x$target" = "x$host"; then
12213     # We can use an host tool
12214     RANLIB_FOR_TARGET='$(RANLIB)'
12215     echo "$as_me:$LINENO: result: host tool" >&5
12216 echo "${ECHO_T}host tool" >&6
12217   else
12218     # We need a cross tool
12219     echo "$as_me:$LINENO: result: pre-installed" >&5
12220 echo "${ECHO_T}pre-installed" >&6
12221   fi
12222 fi
12223
12224 echo "$as_me:$LINENO: checking where to find the target strip" >&5
12225 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
12226 if test "x${build}" != "x${host}" ; then
12227   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12228     # We already found the complete path
12229     ac_dir=`dirname $STRIP_FOR_TARGET`
12230     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12231 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12232   else
12233     # Canadian cross, just use what we found
12234     echo "$as_me:$LINENO: result: pre-installed" >&5
12235 echo "${ECHO_T}pre-installed" >&6
12236   fi
12237 else
12238   ok=yes
12239   case " ${configdirs} " in
12240     *" binutils "*) ;;
12241     *) ok=no ;;
12242   esac
12243
12244   if test $ok = yes; then
12245     # An in-tree tool is available and we can use it
12246     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
12247     echo "$as_me:$LINENO: result: just compiled" >&5
12248 echo "${ECHO_T}just compiled" >&6
12249   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
12250     # We already found the complete path
12251     ac_dir=`dirname $STRIP_FOR_TARGET`
12252     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12253 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12254   elif test "x$target" = "x$host"; then
12255     # We can use an host tool
12256     STRIP_FOR_TARGET='$(STRIP)'
12257     echo "$as_me:$LINENO: result: host tool" >&5
12258 echo "${ECHO_T}host tool" >&6
12259   else
12260     # We need a cross tool
12261     echo "$as_me:$LINENO: result: pre-installed" >&5
12262 echo "${ECHO_T}pre-installed" >&6
12263   fi
12264 fi
12265
12266 echo "$as_me:$LINENO: checking where to find the target windres" >&5
12267 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
12268 if test "x${build}" != "x${host}" ; then
12269   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12270     # We already found the complete path
12271     ac_dir=`dirname $WINDRES_FOR_TARGET`
12272     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12273 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12274   else
12275     # Canadian cross, just use what we found
12276     echo "$as_me:$LINENO: result: pre-installed" >&5
12277 echo "${ECHO_T}pre-installed" >&6
12278   fi
12279 else
12280   ok=yes
12281   case " ${configdirs} " in
12282     *" binutils "*) ;;
12283     *) ok=no ;;
12284   esac
12285
12286   if test $ok = yes; then
12287     # An in-tree tool is available and we can use it
12288     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
12289     echo "$as_me:$LINENO: result: just compiled" >&5
12290 echo "${ECHO_T}just compiled" >&6
12291   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12292     # We already found the complete path
12293     ac_dir=`dirname $WINDRES_FOR_TARGET`
12294     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12295 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12296   elif test "x$target" = "x$host"; then
12297     # We can use an host tool
12298     WINDRES_FOR_TARGET='$(WINDRES)'
12299     echo "$as_me:$LINENO: result: host tool" >&5
12300 echo "${ECHO_T}host tool" >&6
12301   else
12302     # We need a cross tool
12303     echo "$as_me:$LINENO: result: pre-installed" >&5
12304 echo "${ECHO_T}pre-installed" >&6
12305   fi
12306 fi
12307
12308 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12309 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12310 if test "x${build}" != "x${host}" ; then
12311   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12312     # We already found the complete path
12313     ac_dir=`dirname $WINDMC_FOR_TARGET`
12314     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12315 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12316   else
12317     # Canadian cross, just use what we found
12318     echo "$as_me:$LINENO: result: pre-installed" >&5
12319 echo "${ECHO_T}pre-installed" >&6
12320   fi
12321 else
12322   ok=yes
12323   case " ${configdirs} " in
12324     *" binutils "*) ;;
12325     *) ok=no ;;
12326   esac
12327
12328   if test $ok = yes; then
12329     # An in-tree tool is available and we can use it
12330     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12331     echo "$as_me:$LINENO: result: just compiled" >&5
12332 echo "${ECHO_T}just compiled" >&6
12333   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12334     # We already found the complete path
12335     ac_dir=`dirname $WINDMC_FOR_TARGET`
12336     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12337 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12338   elif test "x$target" = "x$host"; then
12339     # We can use an host tool
12340     WINDMC_FOR_TARGET='$(WINDMC)'
12341     echo "$as_me:$LINENO: result: host tool" >&5
12342 echo "${ECHO_T}host tool" >&6
12343   else
12344     # We need a cross tool
12345     echo "$as_me:$LINENO: result: pre-installed" >&5
12346 echo "${ECHO_T}pre-installed" >&6
12347   fi
12348 fi
12349
12350
12351
12352
12353
12354 # Certain tools may need extra flags.
12355 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12356 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12357 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12358
12359 # When building target libraries, except in a Canadian cross, we use
12360 # the same toolchain as the compiler we just built.
12361 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12362 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12363 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12364 if test $host = $build; then
12365   case " $configdirs " in
12366     *" gcc "*)
12367       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12368       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12369       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12370       ;;
12371   esac
12372 fi
12373
12374
12375
12376
12377
12378 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12379 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12380 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12381 if test "${enable_maintainer_mode+set}" = set; then
12382   enableval="$enable_maintainer_mode"
12383   USE_MAINTAINER_MODE=$enableval
12384 else
12385   USE_MAINTAINER_MODE=no
12386 fi;
12387 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12388 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12389
12390
12391 if test "$USE_MAINTAINER_MODE" = yes; then
12392   MAINTAINER_MODE_TRUE=
12393   MAINTAINER_MODE_FALSE='#'
12394 else
12395   MAINTAINER_MODE_TRUE='#'
12396   MAINTAINER_MODE_FALSE=
12397 fi
12398 MAINT=$MAINTAINER_MODE_TRUE
12399
12400 # ---------------------
12401 # GCC bootstrap support
12402 # ---------------------
12403
12404 # Stage specific cflags for build.
12405 stage1_cflags="-g"
12406 case $build in
12407   vax-*-*)
12408     case ${GCC} in
12409       yes) stage1_cflags="-g -Wa,-J" ;;
12410       *) stage1_cflags="-g -J" ;;
12411     esac ;;
12412 esac
12413
12414 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12415 if test "$GCC" = yes; then
12416   saved_CFLAGS="$CFLAGS"
12417
12418   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12419   CFLAGS="$CFLAGS -fkeep-inline-functions"
12420   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12421 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12422   cat >conftest.$ac_ext <<_ACEOF
12423 /* confdefs.h.  */
12424 _ACEOF
12425 cat confdefs.h >>conftest.$ac_ext
12426 cat >>conftest.$ac_ext <<_ACEOF
12427 /* end confdefs.h.  */
12428
12429 #if (__GNUC__ < 3) \
12430     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12431                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12432 #error http://gcc.gnu.org/PR29382
12433 #endif
12434
12435 int
12436 main ()
12437 {
12438
12439   ;
12440   return 0;
12441 }
12442 _ACEOF
12443 rm -f conftest.$ac_objext
12444 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12445   (eval $ac_compile) 2>conftest.er1
12446   ac_status=$?
12447   grep -v '^ *+' conftest.er1 >conftest.err
12448   rm -f conftest.er1
12449   cat conftest.err >&5
12450   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12451   (exit $ac_status); } &&
12452          { ac_try='test -z "$ac_c_werror_flag"
12453                          || test ! -s conftest.err'
12454   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12455   (eval $ac_try) 2>&5
12456   ac_status=$?
12457   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12458   (exit $ac_status); }; } &&
12459          { ac_try='test -s conftest.$ac_objext'
12460   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12461   (eval $ac_try) 2>&5
12462   ac_status=$?
12463   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12464   (exit $ac_status); }; }; then
12465   echo "$as_me:$LINENO: result: yes" >&5
12466 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12467 else
12468   echo "$as_me: failed program was:" >&5
12469 sed 's/^/| /' conftest.$ac_ext >&5
12470
12471 echo "$as_me:$LINENO: result: no" >&5
12472 echo "${ECHO_T}no" >&6
12473 fi
12474 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12475
12476   CFLAGS="$saved_CFLAGS"
12477 fi
12478
12479
12480
12481 # Enable --enable-checking in stage1 of the compiler.
12482 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12483 if test "${enable_stage1_checking+set}" = set; then
12484   enableval="$enable_stage1_checking"
12485   stage1_checking=--enable-checking=${enable_stage1_checking}
12486 else
12487   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12488   stage1_checking=--enable-checking=yes,types
12489 else
12490   stage1_checking=--enable-checking=$enable_checking,types
12491 fi
12492 fi;
12493
12494
12495 # Enable -Werror in bootstrap stage2 and later.
12496 # Check whether --enable-werror or --disable-werror was given.
12497 if test "${enable_werror+set}" = set; then
12498   enableval="$enable_werror"
12499
12500 else
12501   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12502   enable_werror=yes
12503 else
12504   enable_werror=no
12505 fi
12506 fi;
12507 case ${enable_werror} in
12508   yes) stage2_werror_flag="--enable-werror-always" ;;
12509   *) stage2_werror_flag="" ;;
12510 esac
12511
12512
12513 # Flags needed to enable html installing and building
12514
12515 # Check whether --with-datarootdir or --without-datarootdir was given.
12516 if test "${with_datarootdir+set}" = set; then
12517   withval="$with_datarootdir"
12518   datarootdir="\${prefix}/${withval}"
12519 else
12520   datarootdir="\${prefix}/share"
12521 fi;
12522
12523
12524 # Check whether --with-docdir or --without-docdir was given.
12525 if test "${with_docdir+set}" = set; then
12526   withval="$with_docdir"
12527   docdir="\${prefix}/${withval}"
12528 else
12529   docdir="\${datarootdir}/doc"
12530 fi;
12531
12532
12533 # Check whether --with-pdfdir or --without-pdfdir was given.
12534 if test "${with_pdfdir+set}" = set; then
12535   withval="$with_pdfdir"
12536   pdfdir="\${prefix}/${withval}"
12537 else
12538   pdfdir="\${docdir}"
12539 fi;
12540
12541
12542 # Check whether --with-htmldir or --without-htmldir was given.
12543 if test "${with_htmldir+set}" = set; then
12544   withval="$with_htmldir"
12545   htmldir="\${prefix}/${withval}"
12546 else
12547   htmldir="\${docdir}"
12548 fi;
12549
12550
12551
12552
12553
12554
12555           ac_config_files="$ac_config_files Makefile"
12556 cat >confcache <<\_ACEOF
12557 # This file is a shell script that caches the results of configure
12558 # tests run on this system so they can be shared between configure
12559 # scripts and configure runs, see configure's option --config-cache.
12560 # It is not useful on other systems.  If it contains results you don't
12561 # want to keep, you may remove or edit it.
12562 #
12563 # config.status only pays attention to the cache file if you give it
12564 # the --recheck option to rerun configure.
12565 #
12566 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12567 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12568 # following values.
12569
12570 _ACEOF
12571
12572 # The following way of writing the cache mishandles newlines in values,
12573 # but we know of no workaround that is simple, portable, and efficient.
12574 # So, don't put newlines in cache variables' values.
12575 # Ultrix sh set writes to stderr and can't be redirected directly,
12576 # and sets the high bit in the cache file unless we assign to the vars.
12577 {
12578   (set) 2>&1 |
12579     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12580     *ac_space=\ *)
12581       # `set' does not quote correctly, so add quotes (double-quote
12582       # substitution turns \\\\ into \\, and sed turns \\ into \).
12583       sed -n \
12584         "s/'/'\\\\''/g;
12585           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12586       ;;
12587     *)
12588       # `set' quotes correctly as required by POSIX, so do not add quotes.
12589       sed -n \
12590         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12591       ;;
12592     esac;
12593 } |
12594   sed '
12595      t clear
12596      : clear
12597      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12598      t end
12599      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12600      : end' >>confcache
12601 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12602   if test -w $cache_file; then
12603     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12604     cat confcache >$cache_file
12605   else
12606     echo "not updating unwritable cache $cache_file"
12607   fi
12608 fi
12609 rm -f confcache
12610
12611 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12612 # Let make expand exec_prefix.
12613 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12614
12615 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12616 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12617 # trailing colons and then remove the whole line if VPATH becomes empty
12618 # (actually we leave an empty line to preserve line numbers).
12619 if test "x$srcdir" = x.; then
12620   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12621 s/:*\$(srcdir):*/:/;
12622 s/:*\${srcdir}:*/:/;
12623 s/:*@srcdir@:*/:/;
12624 s/^\([^=]*=[     ]*\):*/\1/;
12625 s/:*$//;
12626 s/^[^=]*=[       ]*$//;
12627 }'
12628 fi
12629
12630 # Transform confdefs.h into DEFS.
12631 # Protect against shell expansion while executing Makefile rules.
12632 # Protect against Makefile macro expansion.
12633 #
12634 # If the first sed substitution is executed (which looks for macros that
12635 # take arguments), then we branch to the quote section.  Otherwise,
12636 # look for a macro that doesn't take arguments.
12637 cat >confdef2opt.sed <<\_ACEOF
12638 t clear
12639 : clear
12640 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12641 t quote
12642 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12643 t quote
12644 d
12645 : quote
12646 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12647 s,\[,\\&,g
12648 s,\],\\&,g
12649 s,\$,$$,g
12650 p
12651 _ACEOF
12652 # We use echo to avoid assuming a particular line-breaking character.
12653 # The extra dot is to prevent the shell from consuming trailing
12654 # line-breaks from the sub-command output.  A line-break within
12655 # single-quotes doesn't work because, if this script is created in a
12656 # platform that uses two characters for line-breaks (e.g., DOS), tr
12657 # would break.
12658 ac_LF_and_DOT=`echo; echo .`
12659 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12660 rm -f confdef2opt.sed
12661
12662
12663 ac_libobjs=
12664 ac_ltlibobjs=
12665 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12666   # 1. Remove the extension, and $U if already installed.
12667   ac_i=`echo "$ac_i" |
12668          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12669   # 2. Add them.
12670   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12671   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12672 done
12673 LIBOBJS=$ac_libobjs
12674
12675 LTLIBOBJS=$ac_ltlibobjs
12676
12677
12678
12679 : ${CONFIG_STATUS=./config.status}
12680 ac_clean_files_save=$ac_clean_files
12681 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12682 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12683 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12684 cat >$CONFIG_STATUS <<_ACEOF
12685 #! $SHELL
12686 # Generated by $as_me.
12687 # Run this file to recreate the current configuration.
12688 # Compiler output produced by configure, useful for debugging
12689 # configure, is in config.log if it exists.
12690
12691 debug=false
12692 ac_cs_recheck=false
12693 ac_cs_silent=false
12694 SHELL=\${CONFIG_SHELL-$SHELL}
12695 _ACEOF
12696
12697 cat >>$CONFIG_STATUS <<\_ACEOF
12698 ## --------------------- ##
12699 ## M4sh Initialization.  ##
12700 ## --------------------- ##
12701
12702 # Be Bourne compatible
12703 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12704   emulate sh
12705   NULLCMD=:
12706   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12707   # is contrary to our usage.  Disable this feature.
12708   alias -g '${1+"$@"}'='"$@"'
12709 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12710   set -o posix
12711 fi
12712 DUALCASE=1; export DUALCASE # for MKS sh
12713
12714 # Support unset when possible.
12715 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12716   as_unset=unset
12717 else
12718   as_unset=false
12719 fi
12720
12721
12722 # Work around bugs in pre-3.0 UWIN ksh.
12723 $as_unset ENV MAIL MAILPATH
12724 PS1='$ '
12725 PS2='> '
12726 PS4='+ '
12727
12728 # NLS nuisances.
12729 for as_var in \
12730   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12731   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12732   LC_TELEPHONE LC_TIME
12733 do
12734   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12735     eval $as_var=C; export $as_var
12736   else
12737     $as_unset $as_var
12738   fi
12739 done
12740
12741 # Required to use basename.
12742 if expr a : '\(a\)' >/dev/null 2>&1; then
12743   as_expr=expr
12744 else
12745   as_expr=false
12746 fi
12747
12748 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12749   as_basename=basename
12750 else
12751   as_basename=false
12752 fi
12753
12754
12755 # Name of the executable.
12756 as_me=`$as_basename "$0" ||
12757 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12758          X"$0" : 'X\(//\)$' \| \
12759          X"$0" : 'X\(/\)$' \| \
12760          .     : '\(.\)' 2>/dev/null ||
12761 echo X/"$0" |
12762     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12763           /^X\/\(\/\/\)$/{ s//\1/; q; }
12764           /^X\/\(\/\).*/{ s//\1/; q; }
12765           s/.*/./; q'`
12766
12767
12768 # PATH needs CR, and LINENO needs CR and PATH.
12769 # Avoid depending upon Character Ranges.
12770 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12771 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12772 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12773 as_cr_digits='0123456789'
12774 as_cr_alnum=$as_cr_Letters$as_cr_digits
12775
12776 # The user is always right.
12777 if test "${PATH_SEPARATOR+set}" != set; then
12778   echo "#! /bin/sh" >conf$$.sh
12779   echo  "exit 0"   >>conf$$.sh
12780   chmod +x conf$$.sh
12781   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12782     PATH_SEPARATOR=';'
12783   else
12784     PATH_SEPARATOR=:
12785   fi
12786   rm -f conf$$.sh
12787 fi
12788
12789
12790   as_lineno_1=$LINENO
12791   as_lineno_2=$LINENO
12792   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12793   test "x$as_lineno_1" != "x$as_lineno_2" &&
12794   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12795   # Find who we are.  Look in the path if we contain no path at all
12796   # relative or not.
12797   case $0 in
12798     *[\\/]* ) as_myself=$0 ;;
12799     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12800 for as_dir in $PATH
12801 do
12802   IFS=$as_save_IFS
12803   test -z "$as_dir" && as_dir=.
12804   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12805 done
12806
12807        ;;
12808   esac
12809   # We did not find ourselves, most probably we were run as `sh COMMAND'
12810   # in which case we are not to be found in the path.
12811   if test "x$as_myself" = x; then
12812     as_myself=$0
12813   fi
12814   if test ! -f "$as_myself"; then
12815     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12816 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12817    { (exit 1); exit 1; }; }
12818   fi
12819   case $CONFIG_SHELL in
12820   '')
12821     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12822 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12823 do
12824   IFS=$as_save_IFS
12825   test -z "$as_dir" && as_dir=.
12826   for as_base in sh bash ksh sh5; do
12827          case $as_dir in
12828          /*)
12829            if ("$as_dir/$as_base" -c '
12830   as_lineno_1=$LINENO
12831   as_lineno_2=$LINENO
12832   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12833   test "x$as_lineno_1" != "x$as_lineno_2" &&
12834   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12835              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12836              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12837              CONFIG_SHELL=$as_dir/$as_base
12838              export CONFIG_SHELL
12839              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12840            fi;;
12841          esac
12842        done
12843 done
12844 ;;
12845   esac
12846
12847   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12848   # uniformly replaced by the line number.  The first 'sed' inserts a
12849   # line-number line before each line; the second 'sed' does the real
12850   # work.  The second script uses 'N' to pair each line-number line
12851   # with the numbered line, and appends trailing '-' during
12852   # substitution so that $LINENO is not a special case at line end.
12853   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12854   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12855   sed '=' <$as_myself |
12856     sed '
12857       N
12858       s,$,-,
12859       : loop
12860       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12861       t loop
12862       s,-$,,
12863       s,^['$as_cr_digits']*\n,,
12864     ' >$as_me.lineno &&
12865   chmod +x $as_me.lineno ||
12866     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12867 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12868    { (exit 1); exit 1; }; }
12869
12870   # Don't try to exec as it changes $[0], causing all sort of problems
12871   # (the dirname of $[0] is not the place where we might find the
12872   # original and so on.  Autoconf is especially sensible to this).
12873   . ./$as_me.lineno
12874   # Exit status is that of the last command.
12875   exit
12876 }
12877
12878
12879 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12880   *c*,-n*) ECHO_N= ECHO_C='
12881 ' ECHO_T='      ' ;;
12882   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12883   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12884 esac
12885
12886 if expr a : '\(a\)' >/dev/null 2>&1; then
12887   as_expr=expr
12888 else
12889   as_expr=false
12890 fi
12891
12892 rm -f conf$$ conf$$.exe conf$$.file
12893 echo >conf$$.file
12894 if ln -s conf$$.file conf$$ 2>/dev/null; then
12895   # We could just check for DJGPP; but this test a) works b) is more generic
12896   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12897   if test -f conf$$.exe; then
12898     # Don't use ln at all; we don't have any links
12899     as_ln_s='cp -p'
12900   else
12901     as_ln_s='ln -s'
12902   fi
12903 elif ln conf$$.file conf$$ 2>/dev/null; then
12904   as_ln_s=ln
12905 else
12906   as_ln_s='cp -p'
12907 fi
12908 rm -f conf$$ conf$$.exe conf$$.file
12909
12910 if mkdir -p . 2>/dev/null; then
12911   as_mkdir_p=:
12912 else
12913   test -d ./-p && rmdir ./-p
12914   as_mkdir_p=false
12915 fi
12916
12917 as_executable_p="test -f"
12918
12919 # Sed expression to map a string onto a valid CPP name.
12920 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12921
12922 # Sed expression to map a string onto a valid variable name.
12923 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12924
12925
12926 # IFS
12927 # We need space, tab and new line, in precisely that order.
12928 as_nl='
12929 '
12930 IFS="   $as_nl"
12931
12932 # CDPATH.
12933 $as_unset CDPATH
12934
12935 exec 6>&1
12936
12937 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12938 # report actual input values of CONFIG_FILES etc. instead of their
12939 # values after options handling.  Logging --version etc. is OK.
12940 exec 5>>config.log
12941 {
12942   echo
12943   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12944 ## Running $as_me. ##
12945 _ASBOX
12946 } >&5
12947 cat >&5 <<_CSEOF
12948
12949 This file was extended by $as_me, which was
12950 generated by GNU Autoconf 2.59.  Invocation command line was
12951
12952   CONFIG_FILES    = $CONFIG_FILES
12953   CONFIG_HEADERS  = $CONFIG_HEADERS
12954   CONFIG_LINKS    = $CONFIG_LINKS
12955   CONFIG_COMMANDS = $CONFIG_COMMANDS
12956   $ $0 $@
12957
12958 _CSEOF
12959 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12960 echo >&5
12961 _ACEOF
12962
12963 # Files that config.status was made for.
12964 if test -n "$ac_config_files"; then
12965   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12966 fi
12967
12968 if test -n "$ac_config_headers"; then
12969   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12970 fi
12971
12972 if test -n "$ac_config_links"; then
12973   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12974 fi
12975
12976 if test -n "$ac_config_commands"; then
12977   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12978 fi
12979
12980 cat >>$CONFIG_STATUS <<\_ACEOF
12981
12982 ac_cs_usage="\
12983 \`$as_me' instantiates files from templates according to the
12984 current configuration.
12985
12986 Usage: $0 [OPTIONS] [FILE]...
12987
12988   -h, --help       print this help, then exit
12989   -V, --version    print version number, then exit
12990   -q, --quiet      do not print progress messages
12991   -d, --debug      don't remove temporary files
12992       --recheck    update $as_me by reconfiguring in the same conditions
12993   --file=FILE[:TEMPLATE]
12994                    instantiate the configuration file FILE
12995
12996 Configuration files:
12997 $config_files
12998
12999 Report bugs to <bug-autoconf@gnu.org>."
13000 _ACEOF
13001
13002 cat >>$CONFIG_STATUS <<_ACEOF
13003 ac_cs_version="\\
13004 config.status
13005 configured by $0, generated by GNU Autoconf 2.59,
13006   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
13007
13008 Copyright (C) 2003 Free Software Foundation, Inc.
13009 This config.status script is free software; the Free Software Foundation
13010 gives unlimited permission to copy, distribute and modify it."
13011 srcdir=$srcdir
13012 INSTALL="$INSTALL"
13013 _ACEOF
13014
13015 cat >>$CONFIG_STATUS <<\_ACEOF
13016 # If no file are specified by the user, then we need to provide default
13017 # value.  By we need to know if files were specified by the user.
13018 ac_need_defaults=:
13019 while test $# != 0
13020 do
13021   case $1 in
13022   --*=*)
13023     ac_option=`expr "x$1" : 'x\([^=]*\)='`
13024     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
13025     ac_shift=:
13026     ;;
13027   -*)
13028     ac_option=$1
13029     ac_optarg=$2
13030     ac_shift=shift
13031     ;;
13032   *) # This is not an option, so the user has probably given explicit
13033      # arguments.
13034      ac_option=$1
13035      ac_need_defaults=false;;
13036   esac
13037
13038   case $ac_option in
13039   # Handling of the options.
13040 _ACEOF
13041 cat >>$CONFIG_STATUS <<\_ACEOF
13042   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
13043     ac_cs_recheck=: ;;
13044   --version | --vers* | -V )
13045     echo "$ac_cs_version"; exit 0 ;;
13046   --he | --h)
13047     # Conflict between --help and --header
13048     { { echo "$as_me:$LINENO: error: ambiguous option: $1
13049 Try \`$0 --help' for more information." >&5
13050 echo "$as_me: error: ambiguous option: $1
13051 Try \`$0 --help' for more information." >&2;}
13052    { (exit 1); exit 1; }; };;
13053   --help | --hel | -h )
13054     echo "$ac_cs_usage"; exit 0 ;;
13055   --debug | --d* | -d )
13056     debug=: ;;
13057   --file | --fil | --fi | --f )
13058     $ac_shift
13059     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
13060     ac_need_defaults=false;;
13061   --header | --heade | --head | --hea )
13062     $ac_shift
13063     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
13064     ac_need_defaults=false;;
13065   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
13066   | -silent | --silent | --silen | --sile | --sil | --si | --s)
13067     ac_cs_silent=: ;;
13068
13069   # This is an error.
13070   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
13071 Try \`$0 --help' for more information." >&5
13072 echo "$as_me: error: unrecognized option: $1
13073 Try \`$0 --help' for more information." >&2;}
13074    { (exit 1); exit 1; }; } ;;
13075
13076   *) ac_config_targets="$ac_config_targets $1" ;;
13077
13078   esac
13079   shift
13080 done
13081
13082 ac_configure_extra_args=
13083
13084 if $ac_cs_silent; then
13085   exec 6>/dev/null
13086   ac_configure_extra_args="$ac_configure_extra_args --silent"
13087 fi
13088
13089 _ACEOF
13090 cat >>$CONFIG_STATUS <<_ACEOF
13091 if \$ac_cs_recheck; then
13092   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
13093   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
13094 fi
13095
13096 _ACEOF
13097
13098
13099
13100
13101
13102 cat >>$CONFIG_STATUS <<\_ACEOF
13103 for ac_config_target in $ac_config_targets
13104 do
13105   case "$ac_config_target" in
13106   # Handling of arguments.
13107   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
13108   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
13109 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
13110    { (exit 1); exit 1; }; };;
13111   esac
13112 done
13113
13114 # If the user did not use the arguments to specify the items to instantiate,
13115 # then the envvar interface is used.  Set only those that are not.
13116 # We use the long form for the default assignment because of an extremely
13117 # bizarre bug on SunOS 4.1.3.
13118 if $ac_need_defaults; then
13119   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
13120 fi
13121
13122 # Have a temporary directory for convenience.  Make it in the build tree
13123 # simply because there is no reason to put it here, and in addition,
13124 # creating and moving files from /tmp can sometimes cause problems.
13125 # Create a temporary directory, and hook for its removal unless debugging.
13126 $debug ||
13127 {
13128   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
13129   trap '{ (exit 1); exit 1; }' 1 2 13 15
13130 }
13131
13132 # Create a (secure) tmp directory for tmp files.
13133
13134 {
13135   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
13136   test -n "$tmp" && test -d "$tmp"
13137 }  ||
13138 {
13139   tmp=./confstat$$-$RANDOM
13140   (umask 077 && mkdir $tmp)
13141 } ||
13142 {
13143    echo "$me: cannot create a temporary directory in ." >&2
13144    { (exit 1); exit 1; }
13145 }
13146
13147 _ACEOF
13148
13149 cat >>$CONFIG_STATUS <<_ACEOF
13150
13151 #
13152 # CONFIG_FILES section.
13153 #
13154
13155 # No need to generate the scripts if there are no CONFIG_FILES.
13156 # This happens for instance when ./config.status config.h
13157 if test -n "\$CONFIG_FILES"; then
13158   # Protect against being on the right side of a sed subst in config.status.
13159   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
13160    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
13161 s,@SHELL@,$SHELL,;t t
13162 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
13163 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
13164 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
13165 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
13166 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
13167 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
13168 s,@exec_prefix@,$exec_prefix,;t t
13169 s,@prefix@,$prefix,;t t
13170 s,@program_transform_name@,$program_transform_name,;t t
13171 s,@bindir@,$bindir,;t t
13172 s,@sbindir@,$sbindir,;t t
13173 s,@libexecdir@,$libexecdir,;t t
13174 s,@datadir@,$datadir,;t t
13175 s,@sysconfdir@,$sysconfdir,;t t
13176 s,@sharedstatedir@,$sharedstatedir,;t t
13177 s,@localstatedir@,$localstatedir,;t t
13178 s,@libdir@,$libdir,;t t
13179 s,@includedir@,$includedir,;t t
13180 s,@oldincludedir@,$oldincludedir,;t t
13181 s,@infodir@,$infodir,;t t
13182 s,@mandir@,$mandir,;t t
13183 s,@build_alias@,$build_alias,;t t
13184 s,@host_alias@,$host_alias,;t t
13185 s,@target_alias@,$target_alias,;t t
13186 s,@DEFS@,$DEFS,;t t
13187 s,@ECHO_C@,$ECHO_C,;t t
13188 s,@ECHO_N@,$ECHO_N,;t t
13189 s,@ECHO_T@,$ECHO_T,;t t
13190 s,@LIBS@,$LIBS,;t t
13191 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
13192 s,@build@,$build,;t t
13193 s,@build_cpu@,$build_cpu,;t t
13194 s,@build_vendor@,$build_vendor,;t t
13195 s,@build_os@,$build_os,;t t
13196 s,@build_noncanonical@,$build_noncanonical,;t t
13197 s,@host_noncanonical@,$host_noncanonical,;t t
13198 s,@target_noncanonical@,$target_noncanonical,;t t
13199 s,@host@,$host,;t t
13200 s,@host_cpu@,$host_cpu,;t t
13201 s,@host_vendor@,$host_vendor,;t t
13202 s,@host_os@,$host_os,;t t
13203 s,@target@,$target,;t t
13204 s,@target_cpu@,$target_cpu,;t t
13205 s,@target_vendor@,$target_vendor,;t t
13206 s,@target_os@,$target_os,;t t
13207 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
13208 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
13209 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
13210 s,@LN@,$LN,;t t
13211 s,@LN_S@,$LN_S,;t t
13212 s,@build_libsubdir@,$build_libsubdir,;t t
13213 s,@build_subdir@,$build_subdir,;t t
13214 s,@host_subdir@,$host_subdir,;t t
13215 s,@target_subdir@,$target_subdir,;t t
13216 s,@CC@,$CC,;t t
13217 s,@CFLAGS@,$CFLAGS,;t t
13218 s,@LDFLAGS@,$LDFLAGS,;t t
13219 s,@CPPFLAGS@,$CPPFLAGS,;t t
13220 s,@ac_ct_CC@,$ac_ct_CC,;t t
13221 s,@EXEEXT@,$EXEEXT,;t t
13222 s,@OBJEXT@,$OBJEXT,;t t
13223 s,@CXX@,$CXX,;t t
13224 s,@CXXFLAGS@,$CXXFLAGS,;t t
13225 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
13226 s,@GNATBIND@,$GNATBIND,;t t
13227 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
13228 s,@GNATMAKE@,$GNATMAKE,;t t
13229 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
13230 s,@do_compare@,$do_compare,;t t
13231 s,@gmplibs@,$gmplibs,;t t
13232 s,@gmpinc@,$gmpinc,;t t
13233 s,@ppllibs@,$ppllibs,;t t
13234 s,@pplinc@,$pplinc,;t t
13235 s,@clooglibs@,$clooglibs,;t t
13236 s,@clooginc@,$clooginc,;t t
13237 s,@stage1_languages@,$stage1_languages,;t t
13238 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
13239 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
13240 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
13241 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
13242 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
13243 s,@GCC_SHLIB_SUBDIR@,$GCC_SHLIB_SUBDIR,;t t
13244 s,@tooldir@,$tooldir,;t t
13245 s,@build_tooldir@,$build_tooldir,;t t
13246 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
13247 s,@GDB_TK@,$GDB_TK,;t t
13248 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
13249 s,@build_configargs@,$build_configargs,;t t
13250 s,@build_configdirs@,$build_configdirs,;t t
13251 s,@host_configargs@,$host_configargs,;t t
13252 s,@configdirs@,$configdirs,;t t
13253 s,@target_configargs@,$target_configargs,;t t
13254 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
13255 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
13256 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
13257 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
13258 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
13259 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
13260 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
13261 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
13262 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
13263 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
13264 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
13265 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
13266 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
13267 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
13268 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
13269 s,@config_shell@,$config_shell,;t t
13270 s,@YACC@,$YACC,;t t
13271 s,@BISON@,$BISON,;t t
13272 s,@M4@,$M4,;t t
13273 s,@LEX@,$LEX,;t t
13274 s,@FLEX@,$FLEX,;t t
13275 s,@MAKEINFO@,$MAKEINFO,;t t
13276 s,@EXPECT@,$EXPECT,;t t
13277 s,@RUNTEST@,$RUNTEST,;t t
13278 s,@AR@,$AR,;t t
13279 s,@AS@,$AS,;t t
13280 s,@DLLTOOL@,$DLLTOOL,;t t
13281 s,@LD@,$LD,;t t
13282 s,@LIPO@,$LIPO,;t t
13283 s,@NM@,$NM,;t t
13284 s,@RANLIB@,$RANLIB,;t t
13285 s,@STRIP@,$STRIP,;t t
13286 s,@WINDRES@,$WINDRES,;t t
13287 s,@WINDMC@,$WINDMC,;t t
13288 s,@OBJCOPY@,$OBJCOPY,;t t
13289 s,@OBJDUMP@,$OBJDUMP,;t t
13290 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
13291 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
13292 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
13293 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
13294 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
13295 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13296 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13297 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13298 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13299 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13300 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13301 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13302 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13303 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13304 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13305 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13306 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13307 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13308 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13309 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13310 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13311 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13312 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13313 s,@MAINT@,$MAINT,;t t
13314 s,@stage1_cflags@,$stage1_cflags,;t t
13315 s,@stage1_checking@,$stage1_checking,;t t
13316 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13317 s,@datarootdir@,$datarootdir,;t t
13318 s,@docdir@,$docdir,;t t
13319 s,@pdfdir@,$pdfdir,;t t
13320 s,@htmldir@,$htmldir,;t t
13321 s,@LIBOBJS@,$LIBOBJS,;t t
13322 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13323 /@serialization_dependencies@/r $serialization_dependencies
13324 s,@serialization_dependencies@,,;t t
13325 /@host_makefile_frag@/r $host_makefile_frag
13326 s,@host_makefile_frag@,,;t t
13327 /@target_makefile_frag@/r $target_makefile_frag
13328 s,@target_makefile_frag@,,;t t
13329 /@alphaieee_frag@/r $alphaieee_frag
13330 s,@alphaieee_frag@,,;t t
13331 /@ospace_frag@/r $ospace_frag
13332 s,@ospace_frag@,,;t t
13333 CEOF
13334
13335 _ACEOF
13336
13337   cat >>$CONFIG_STATUS <<\_ACEOF
13338   # Split the substitutions into bite-sized pieces for seds with
13339   # small command number limits, like on Digital OSF/1 and HP-UX.
13340   ac_max_sed_lines=48
13341   ac_sed_frag=1 # Number of current file.
13342   ac_beg=1 # First line for current file.
13343   ac_end=$ac_max_sed_lines # Line after last line for current file.
13344   ac_more_lines=:
13345   ac_sed_cmds=
13346   while $ac_more_lines; do
13347     if test $ac_beg -gt 1; then
13348       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13349     else
13350       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13351     fi
13352     if test ! -s $tmp/subs.frag; then
13353       ac_more_lines=false
13354     else
13355       # The purpose of the label and of the branching condition is to
13356       # speed up the sed processing (if there are no `@' at all, there
13357       # is no need to browse any of the substitutions).
13358       # These are the two extra sed commands mentioned above.
13359       (echo ':t
13360   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13361       if test -z "$ac_sed_cmds"; then
13362         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13363       else
13364         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13365       fi
13366       ac_sed_frag=`expr $ac_sed_frag + 1`
13367       ac_beg=$ac_end
13368       ac_end=`expr $ac_end + $ac_max_sed_lines`
13369     fi
13370   done
13371   if test -z "$ac_sed_cmds"; then
13372     ac_sed_cmds=cat
13373   fi
13374 fi # test -n "$CONFIG_FILES"
13375
13376 _ACEOF
13377 cat >>$CONFIG_STATUS <<\_ACEOF
13378 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13379   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13380   case $ac_file in
13381   - | *:- | *:-:* ) # input from stdin
13382         cat >$tmp/stdin
13383         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13384         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13385   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13386         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13387   * )   ac_file_in=$ac_file.in ;;
13388   esac
13389
13390   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13391   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13392 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13393          X"$ac_file" : 'X\(//\)[^/]' \| \
13394          X"$ac_file" : 'X\(//\)$' \| \
13395          X"$ac_file" : 'X\(/\)' \| \
13396          .     : '\(.\)' 2>/dev/null ||
13397 echo X"$ac_file" |
13398     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13399           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13400           /^X\(\/\/\)$/{ s//\1/; q; }
13401           /^X\(\/\).*/{ s//\1/; q; }
13402           s/.*/./; q'`
13403   { if $as_mkdir_p; then
13404     mkdir -p "$ac_dir"
13405   else
13406     as_dir="$ac_dir"
13407     as_dirs=
13408     while test ! -d "$as_dir"; do
13409       as_dirs="$as_dir $as_dirs"
13410       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13411 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13412          X"$as_dir" : 'X\(//\)[^/]' \| \
13413          X"$as_dir" : 'X\(//\)$' \| \
13414          X"$as_dir" : 'X\(/\)' \| \
13415          .     : '\(.\)' 2>/dev/null ||
13416 echo X"$as_dir" |
13417     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13418           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13419           /^X\(\/\/\)$/{ s//\1/; q; }
13420           /^X\(\/\).*/{ s//\1/; q; }
13421           s/.*/./; q'`
13422     done
13423     test ! -n "$as_dirs" || mkdir $as_dirs
13424   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13425 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13426    { (exit 1); exit 1; }; }; }
13427
13428   ac_builddir=.
13429
13430 if test "$ac_dir" != .; then
13431   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13432   # A "../" for each directory in $ac_dir_suffix.
13433   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13434 else
13435   ac_dir_suffix= ac_top_builddir=
13436 fi
13437
13438 case $srcdir in
13439   .)  # No --srcdir option.  We are building in place.
13440     ac_srcdir=.
13441     if test -z "$ac_top_builddir"; then
13442        ac_top_srcdir=.
13443     else
13444        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13445     fi ;;
13446   [\\/]* | ?:[\\/]* )  # Absolute path.
13447     ac_srcdir=$srcdir$ac_dir_suffix;
13448     ac_top_srcdir=$srcdir ;;
13449   *) # Relative path.
13450     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13451     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13452 esac
13453
13454 # Do not use `cd foo && pwd` to compute absolute paths, because
13455 # the directories may not exist.
13456 case `pwd` in
13457 .) ac_abs_builddir="$ac_dir";;
13458 *)
13459   case "$ac_dir" in
13460   .) ac_abs_builddir=`pwd`;;
13461   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13462   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13463   esac;;
13464 esac
13465 case $ac_abs_builddir in
13466 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13467 *)
13468   case ${ac_top_builddir}. in
13469   .) ac_abs_top_builddir=$ac_abs_builddir;;
13470   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13471   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13472   esac;;
13473 esac
13474 case $ac_abs_builddir in
13475 .) ac_abs_srcdir=$ac_srcdir;;
13476 *)
13477   case $ac_srcdir in
13478   .) ac_abs_srcdir=$ac_abs_builddir;;
13479   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13480   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13481   esac;;
13482 esac
13483 case $ac_abs_builddir in
13484 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13485 *)
13486   case $ac_top_srcdir in
13487   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13488   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13489   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13490   esac;;
13491 esac
13492
13493
13494   case $INSTALL in
13495   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13496   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13497   esac
13498
13499   if test x"$ac_file" != x-; then
13500     { echo "$as_me:$LINENO: creating $ac_file" >&5
13501 echo "$as_me: creating $ac_file" >&6;}
13502     rm -f "$ac_file"
13503   fi
13504   # Let's still pretend it is `configure' which instantiates (i.e., don't
13505   # use $as_me), people would be surprised to read:
13506   #    /* config.h.  Generated by config.status.  */
13507   if test x"$ac_file" = x-; then
13508     configure_input=
13509   else
13510     configure_input="$ac_file.  "
13511   fi
13512   configure_input=$configure_input"Generated from `echo $ac_file_in |
13513                                      sed 's,.*/,,'` by configure."
13514
13515   # First look for the input files in the build tree, otherwise in the
13516   # src tree.
13517   ac_file_inputs=`IFS=:
13518     for f in $ac_file_in; do
13519       case $f in
13520       -) echo $tmp/stdin ;;
13521       [\\/$]*)
13522          # Absolute (can't be DOS-style, as IFS=:)
13523          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13524 echo "$as_me: error: cannot find input file: $f" >&2;}
13525    { (exit 1); exit 1; }; }
13526          echo "$f";;
13527       *) # Relative
13528          if test -f "$f"; then
13529            # Build tree
13530            echo "$f"
13531          elif test -f "$srcdir/$f"; then
13532            # Source tree
13533            echo "$srcdir/$f"
13534          else
13535            # /dev/null tree
13536            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13537 echo "$as_me: error: cannot find input file: $f" >&2;}
13538    { (exit 1); exit 1; }; }
13539          fi;;
13540       esac
13541     done` || { (exit 1); exit 1; }
13542 _ACEOF
13543 cat >>$CONFIG_STATUS <<_ACEOF
13544   sed "$ac_vpsub
13545 $extrasub
13546 _ACEOF
13547 cat >>$CONFIG_STATUS <<\_ACEOF
13548 :t
13549 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13550 s,@configure_input@,$configure_input,;t t
13551 s,@srcdir@,$ac_srcdir,;t t
13552 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13553 s,@top_srcdir@,$ac_top_srcdir,;t t
13554 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13555 s,@builddir@,$ac_builddir,;t t
13556 s,@abs_builddir@,$ac_abs_builddir,;t t
13557 s,@top_builddir@,$ac_top_builddir,;t t
13558 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13559 s,@INSTALL@,$ac_INSTALL,;t t
13560 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13561   rm -f $tmp/stdin
13562   if test x"$ac_file" != x-; then
13563     mv $tmp/out $ac_file
13564   else
13565     cat $tmp/out
13566     rm -f $tmp/out
13567   fi
13568
13569 done
13570 _ACEOF
13571
13572 cat >>$CONFIG_STATUS <<\_ACEOF
13573
13574 { (exit 0); exit 0; }
13575 _ACEOF
13576 chmod +x $CONFIG_STATUS
13577 ac_clean_files=$ac_clean_files_save
13578
13579
13580 # configure is writing to config.log, and then calls config.status.
13581 # config.status does its own redirection, appending to config.log.
13582 # Unfortunately, on DOS this fails, as config.log is still kept open
13583 # by configure, so config.status won't be able to write to it; its
13584 # output is simply discarded.  So we exec the FD to /dev/null,
13585 # effectively closing config.log, so it can be properly (re)opened and
13586 # appended to by config.status.  When coming back to configure, we
13587 # need to make the FD available again.
13588 if test "$no_create" != yes; then
13589   ac_cs_success=:
13590   ac_config_status_args=
13591   test "$silent" = yes &&
13592     ac_config_status_args="$ac_config_status_args --quiet"
13593   exec 5>/dev/null
13594   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13595   exec 5>>config.log
13596   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13597   # would make configure fail if this is the last instruction.
13598   $ac_cs_success || { (exit 1); exit 1; }
13599 fi
13600