configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S TOPLEVEL_CONFIGURE_ARGUMENTS build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs CC_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CFLAGS_FOR_BUILD CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277
 278 # Initialize some variables set by options.
 279 ac_init_help=
 280 ac_init_version=false
 281 # The variables have the same names as the options, with
 282 # dashes changed to underlines.
 283 cache_file=/dev/null
 284 exec_prefix=NONE
 285 no_create=
 286 no_recursion=
 287 prefix=NONE
 288 program_prefix=NONE
 289 program_suffix=NONE
 290 program_transform_name=s,x,x,
 291 silent=
 292 site=
 293 srcdir=
 294 verbose=
 295 x_includes=NONE
 296 x_libraries=NONE
 297
 298 # Installation directory options.
 299 # These are left unexpanded so users can "make install exec_prefix=/foo"
 300 # and all the variables that are supposed to be based on exec_prefix
 301 # by default will actually change.
 302 # Use braces instead of parens because sh, perl, etc. also accept them.
 303 bindir='${exec_prefix}/bin'
 304 sbindir='${exec_prefix}/sbin'
 305 libexecdir='${exec_prefix}/libexec'
 306 datadir='${prefix}/share'
 307 sysconfdir='${prefix}/etc'
 308 sharedstatedir='${prefix}/com'
 309 localstatedir='${prefix}/var'
 310 libdir='${exec_prefix}/lib'
 311 includedir='${prefix}/include'
 312 oldincludedir='/usr/include'
 313 infodir='${prefix}/info'
 314 mandir='${prefix}/man'
 315
 316 ac_prev=
 317 for ac_option
 318 do
 319   # If the previous option needs an argument, assign it.
 320   if test -n "$ac_prev"; then
 321     eval "$ac_prev=\$ac_option"
 322     ac_prev=
 323     continue
 324   fi
 325
 326   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 327
 328   # Accept the important Cygnus configure options, so we can diagnose typos.
 329
 330   case $ac_option in
 331
 332   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 333     ac_prev=bindir ;;
 334   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 335     bindir=$ac_optarg ;;
 336
 337   -build | --build | --buil | --bui | --bu)
 338     ac_prev=build_alias ;;
 339   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 340     build_alias=$ac_optarg ;;
 341
 342   -cache-file | --cache-file | --cache-fil | --cache-fi \
 343   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 344     ac_prev=cache_file ;;
 345   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 346   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 347     cache_file=$ac_optarg ;;
 348
 349   --config-cache | -C)
 350     cache_file=config.cache ;;
 351
 352   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 353     ac_prev=datadir ;;
 354   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 355   | --da=*)
 356     datadir=$ac_optarg ;;
 357
 358   -disable-* | --disable-*)
 359     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 360     # Reject names that are not valid shell variable names.
 361     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 362       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 363    { (exit 1); exit 1; }; }
 364     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 365     eval "enable_$ac_feature=no" ;;
 366
 367   -enable-* | --enable-*)
 368     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 369     # Reject names that are not valid shell variable names.
 370     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 371       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 372    { (exit 1); exit 1; }; }
 373     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 374     case $ac_option in
 375       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 376       *) ac_optarg=yes ;;
 377     esac
 378     eval "enable_$ac_feature='$ac_optarg'" ;;
 379
 380   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 381   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 382   | --exec | --exe | --ex)
 383     ac_prev=exec_prefix ;;
 384   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 385   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 386   | --exec=* | --exe=* | --ex=*)
 387     exec_prefix=$ac_optarg ;;
 388
 389   -gas | --gas | --ga | --g)
 390     # Obsolete; use --with-gas.
 391     with_gas=yes ;;
 392
 393   -help | --help | --hel | --he | -h)
 394     ac_init_help=long ;;
 395   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 396     ac_init_help=recursive ;;
 397   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 398     ac_init_help=short ;;
 399
 400   -host | --host | --hos | --ho)
 401     ac_prev=host_alias ;;
 402   -host=* | --host=* | --hos=* | --ho=*)
 403     host_alias=$ac_optarg ;;
 404
 405   -includedir | --includedir | --includedi | --included | --include \
 406   | --includ | --inclu | --incl | --inc)
 407     ac_prev=includedir ;;
 408   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 409   | --includ=* | --inclu=* | --incl=* | --inc=*)
 410     includedir=$ac_optarg ;;
 411
 412   -infodir | --infodir | --infodi | --infod | --info | --inf)
 413     ac_prev=infodir ;;
 414   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 415     infodir=$ac_optarg ;;
 416
 417   -libdir | --libdir | --libdi | --libd)
 418     ac_prev=libdir ;;
 419   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 420     libdir=$ac_optarg ;;
 421
 422   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 423   | --libexe | --libex | --libe)
 424     ac_prev=libexecdir ;;
 425   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 426   | --libexe=* | --libex=* | --libe=*)
 427     libexecdir=$ac_optarg ;;
 428
 429   -localstatedir | --localstatedir | --localstatedi | --localstated \
 430   | --localstate | --localstat | --localsta | --localst \
 431   | --locals | --local | --loca | --loc | --lo)
 432     ac_prev=localstatedir ;;
 433   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 434   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 435   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 436     localstatedir=$ac_optarg ;;
 437
 438   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 439     ac_prev=mandir ;;
 440   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 441     mandir=$ac_optarg ;;
 442
 443   -nfp | --nfp | --nf)
 444     # Obsolete; use --without-fp.
 445     with_fp=no ;;
 446
 447   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 448   | --no-cr | --no-c | -n)
 449     no_create=yes ;;
 450
 451   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 452   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 453     no_recursion=yes ;;
 454
 455   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 456   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 457   | --oldin | --oldi | --old | --ol | --o)
 458     ac_prev=oldincludedir ;;
 459   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 460   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 461   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 462     oldincludedir=$ac_optarg ;;
 463
 464   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 465     ac_prev=prefix ;;
 466   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 467     prefix=$ac_optarg ;;
 468
 469   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 470   | --program-pre | --program-pr | --program-p)
 471     ac_prev=program_prefix ;;
 472   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 473   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 474     program_prefix=$ac_optarg ;;
 475
 476   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 477   | --program-suf | --program-su | --program-s)
 478     ac_prev=program_suffix ;;
 479   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 480   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 481     program_suffix=$ac_optarg ;;
 482
 483   -program-transform-name | --program-transform-name \
 484   | --program-transform-nam | --program-transform-na \
 485   | --program-transform-n | --program-transform- \
 486   | --program-transform | --program-transfor \
 487   | --program-transfo | --program-transf \
 488   | --program-trans | --program-tran \
 489   | --progr-tra | --program-tr | --program-t)
 490     ac_prev=program_transform_name ;;
 491   -program-transform-name=* | --program-transform-name=* \
 492   | --program-transform-nam=* | --program-transform-na=* \
 493   | --program-transform-n=* | --program-transform-=* \
 494   | --program-transform=* | --program-transfor=* \
 495   | --program-transfo=* | --program-transf=* \
 496   | --program-trans=* | --program-tran=* \
 497   | --progr-tra=* | --program-tr=* | --program-t=*)
 498     program_transform_name=$ac_optarg ;;
 499
 500   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 501   | -silent | --silent | --silen | --sile | --sil)
 502     silent=yes ;;
 503
 504   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 505     ac_prev=sbindir ;;
 506   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 507   | --sbi=* | --sb=*)
 508     sbindir=$ac_optarg ;;
 509
 510   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 511   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 512   | --sharedst | --shareds | --shared | --share | --shar \
 513   | --sha | --sh)
 514     ac_prev=sharedstatedir ;;
 515   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 516   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 517   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 518   | --sha=* | --sh=*)
 519     sharedstatedir=$ac_optarg ;;
 520
 521   -site | --site | --sit)
 522     ac_prev=site ;;
 523   -site=* | --site=* | --sit=*)
 524     site=$ac_optarg ;;
 525
 526   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 527     ac_prev=srcdir ;;
 528   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 529     srcdir=$ac_optarg ;;
 530
 531   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 532   | --syscon | --sysco | --sysc | --sys | --sy)
 533     ac_prev=sysconfdir ;;
 534   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 535   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 536     sysconfdir=$ac_optarg ;;
 537
 538   -target | --target | --targe | --targ | --tar | --ta | --t)
 539     ac_prev=target_alias ;;
 540   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 541     target_alias=$ac_optarg ;;
 542
 543   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 544     verbose=yes ;;
 545
 546   -version | --version | --versio | --versi | --vers | -V)
 547     ac_init_version=: ;;
 548
 549   -with-* | --with-*)
 550     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 551     # Reject names that are not valid shell variable names.
 552     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 553       { echo "$as_me: error: invalid package name: $ac_package" >&2
 554    { (exit 1); exit 1; }; }
 555     ac_package=`echo $ac_package| sed 's/-/_/g'`
 556     case $ac_option in
 557       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 558       *) ac_optarg=yes ;;
 559     esac
 560     eval "with_$ac_package='$ac_optarg'" ;;
 561
 562   -without-* | --without-*)
 563     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 564     # Reject names that are not valid shell variable names.
 565     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 566       { echo "$as_me: error: invalid package name: $ac_package" >&2
 567    { (exit 1); exit 1; }; }
 568     ac_package=`echo $ac_package | sed 's/-/_/g'`
 569     eval "with_$ac_package=no" ;;
 570
 571   --x)
 572     # Obsolete; use --with-x.
 573     with_x=yes ;;
 574
 575   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 576   | --x-incl | --x-inc | --x-in | --x-i)
 577     ac_prev=x_includes ;;
 578   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 579   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 580     x_includes=$ac_optarg ;;
 581
 582   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 583   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 584     ac_prev=x_libraries ;;
 585   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 586   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 587     x_libraries=$ac_optarg ;;
 588
 589   -*) { echo "$as_me: error: unrecognized option: $ac_option
 590 Try \`$0 --help' for more information." >&2
 591    { (exit 1); exit 1; }; }
 592     ;;
 593
 594   *=*)
 595     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 596     # Reject names that are not valid shell variable names.
 597     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 598       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 599    { (exit 1); exit 1; }; }
 600     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 601     eval "$ac_envvar='$ac_optarg'"
 602     export $ac_envvar ;;
 603
 604   *)
 605     # FIXME: should be removed in autoconf 3.0.
 606     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 607     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 608       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 609     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 610     ;;
 611
 612   esac
 613 done
 614
 615 if test -n "$ac_prev"; then
 616   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 617   { echo "$as_me: error: missing argument to $ac_option" >&2
 618    { (exit 1); exit 1; }; }
 619 fi
 620
 621 # Be sure to have absolute paths.
 622 for ac_var in exec_prefix prefix
 623 do
 624   eval ac_val=$`echo $ac_var`
 625   case $ac_val in
 626     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 627     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 628    { (exit 1); exit 1; }; };;
 629   esac
 630 done
 631
 632 # Be sure to have absolute paths.
 633 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 634               localstatedir libdir includedir oldincludedir infodir mandir
 635 do
 636   eval ac_val=$`echo $ac_var`
 637   case $ac_val in
 638     [\\/$]* | ?:[\\/]* ) ;;
 639     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 640    { (exit 1); exit 1; }; };;
 641   esac
 642 done
 643
 644 # There might be people who depend on the old broken behavior: `$host'
 645 # used to hold the argument of --host etc.
 646 # FIXME: To remove some day.
 647 build=$build_alias
 648 host=$host_alias
 649 target=$target_alias
 650
 651 # FIXME: To remove some day.
 652 if test "x$host_alias" != x; then
 653   if test "x$build_alias" = x; then
 654     cross_compiling=maybe
 655     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 656     If a cross compiler is detected then cross compile mode will be used." >&2
 657   elif test "x$build_alias" != "x$host_alias"; then
 658     cross_compiling=yes
 659   fi
 660 fi
 661
 662 ac_tool_prefix=
 663 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 664
 665 test "$silent" = yes && exec 6>/dev/null
 666
 667
 668 # Find the source files, if location was not specified.
 669 if test -z "$srcdir"; then
 670   ac_srcdir_defaulted=yes
 671   # Try the directory containing this script, then its parent.
 672   ac_confdir=`(dirname "$0") 2>/dev/null ||
 673 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 674          X"$0" : 'X\(//\)[^/]' \| \
 675          X"$0" : 'X\(//\)$' \| \
 676          X"$0" : 'X\(/\)' \| \
 677          .     : '\(.\)' 2>/dev/null ||
 678 echo X"$0" |
 679     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 680           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 681           /^X\(\/\/\)$/{ s//\1/; q; }
 682           /^X\(\/\).*/{ s//\1/; q; }
 683           s/.*/./; q'`
 684   srcdir=$ac_confdir
 685   if test ! -r $srcdir/$ac_unique_file; then
 686     srcdir=..
 687   fi
 688 else
 689   ac_srcdir_defaulted=no
 690 fi
 691 if test ! -r $srcdir/$ac_unique_file; then
 692   if test "$ac_srcdir_defaulted" = yes; then
 693     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 694    { (exit 1); exit 1; }; }
 695   else
 696     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 697    { (exit 1); exit 1; }; }
 698   fi
 699 fi
 700 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 701   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 702    { (exit 1); exit 1; }; }
 703 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 704 ac_env_build_alias_set=${build_alias+set}
 705 ac_env_build_alias_value=$build_alias
 706 ac_cv_env_build_alias_set=${build_alias+set}
 707 ac_cv_env_build_alias_value=$build_alias
 708 ac_env_host_alias_set=${host_alias+set}
 709 ac_env_host_alias_value=$host_alias
 710 ac_cv_env_host_alias_set=${host_alias+set}
 711 ac_cv_env_host_alias_value=$host_alias
 712 ac_env_target_alias_set=${target_alias+set}
 713 ac_env_target_alias_value=$target_alias
 714 ac_cv_env_target_alias_set=${target_alias+set}
 715 ac_cv_env_target_alias_value=$target_alias
 716 ac_env_CC_set=${CC+set}
 717 ac_env_CC_value=$CC
 718 ac_cv_env_CC_set=${CC+set}
 719 ac_cv_env_CC_value=$CC
 720 ac_env_CFLAGS_set=${CFLAGS+set}
 721 ac_env_CFLAGS_value=$CFLAGS
 722 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 723 ac_cv_env_CFLAGS_value=$CFLAGS
 724 ac_env_LDFLAGS_set=${LDFLAGS+set}
 725 ac_env_LDFLAGS_value=$LDFLAGS
 726 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 727 ac_cv_env_LDFLAGS_value=$LDFLAGS
 728 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 729 ac_env_CPPFLAGS_value=$CPPFLAGS
 730 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 731 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 732 ac_env_CXX_set=${CXX+set}
 733 ac_env_CXX_value=$CXX
 734 ac_cv_env_CXX_set=${CXX+set}
 735 ac_cv_env_CXX_value=$CXX
 736 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 737 ac_env_CXXFLAGS_value=$CXXFLAGS
 738 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 739 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 740 ac_env_AR_set=${AR+set}
 741 ac_env_AR_value=$AR
 742 ac_cv_env_AR_set=${AR+set}
 743 ac_cv_env_AR_value=$AR
 744 ac_env_AS_set=${AS+set}
 745 ac_env_AS_value=$AS
 746 ac_cv_env_AS_set=${AS+set}
 747 ac_cv_env_AS_value=$AS
 748 ac_env_DLLTOOL_set=${DLLTOOL+set}
 749 ac_env_DLLTOOL_value=$DLLTOOL
 750 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 751 ac_cv_env_DLLTOOL_value=$DLLTOOL
 752 ac_env_LD_set=${LD+set}
 753 ac_env_LD_value=$LD
 754 ac_cv_env_LD_set=${LD+set}
 755 ac_cv_env_LD_value=$LD
 756 ac_env_LIPO_set=${LIPO+set}
 757 ac_env_LIPO_value=$LIPO
 758 ac_cv_env_LIPO_set=${LIPO+set}
 759 ac_cv_env_LIPO_value=$LIPO
 760 ac_env_NM_set=${NM+set}
 761 ac_env_NM_value=$NM
 762 ac_cv_env_NM_set=${NM+set}
 763 ac_cv_env_NM_value=$NM
 764 ac_env_RANLIB_set=${RANLIB+set}
 765 ac_env_RANLIB_value=$RANLIB
 766 ac_cv_env_RANLIB_set=${RANLIB+set}
 767 ac_cv_env_RANLIB_value=$RANLIB
 768 ac_env_STRIP_set=${STRIP+set}
 769 ac_env_STRIP_value=$STRIP
 770 ac_cv_env_STRIP_set=${STRIP+set}
 771 ac_cv_env_STRIP_value=$STRIP
 772 ac_env_WINDRES_set=${WINDRES+set}
 773 ac_env_WINDRES_value=$WINDRES
 774 ac_cv_env_WINDRES_set=${WINDRES+set}
 775 ac_cv_env_WINDRES_value=$WINDRES
 776 ac_env_WINDMC_set=${WINDMC+set}
 777 ac_env_WINDMC_value=$WINDMC
 778 ac_cv_env_WINDMC_set=${WINDMC+set}
 779 ac_cv_env_WINDMC_value=$WINDMC
 780 ac_env_OBJCOPY_set=${OBJCOPY+set}
 781 ac_env_OBJCOPY_value=$OBJCOPY
 782 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 783 ac_cv_env_OBJCOPY_value=$OBJCOPY
 784 ac_env_OBJDUMP_set=${OBJDUMP+set}
 785 ac_env_OBJDUMP_value=$OBJDUMP
 786 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 787 ac_cv_env_OBJDUMP_value=$OBJDUMP
 788 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 789 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 790 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 791 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 792 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 793 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 794 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 795 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 796 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 797 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 798 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 799 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 800 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 801 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 802 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 803 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 804 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 805 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 806 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 807 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 808 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 809 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 810 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 811 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 812 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 813 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 814 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 815 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 816 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 817 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 818 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 819 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 820 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 821 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 822 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 823 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 824 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 825 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 826 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 827 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 828 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 829 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 830 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 831 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 832 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 833 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 834 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 835 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 836 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 837 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 838 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 839 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 840 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 841 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 842 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 843 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 844 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 845 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 846 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 847 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 848 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 849 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 850 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 851 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 852
 853 #
 854 # Report the --help message.
 855 #
 856 if test "$ac_init_help" = "long"; then
 857   # Omit some internal or obsolete options to make the list less imposing.
 858   # This message is too long to be a string in the A/UX 3.1 sh.
 859   cat <<_ACEOF
 860 \`configure' configures this package to adapt to many kinds of systems.
 861
 862 Usage: $0 [OPTION]... [VAR=VALUE]...
 863
 864 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 865 VAR=VALUE.  See below for descriptions of some of the useful variables.
 866
 867 Defaults for the options are specified in brackets.
 868
 869 Configuration:
 870   -h, --help              display this help and exit
 871       --help=short        display options specific to this package
 872       --help=recursive    display the short help of all the included packages
 873   -V, --version           display version information and exit
 874   -q, --quiet, --silent   do not print \`checking...' messages
 875       --cache-file=FILE   cache test results in FILE [disabled]
 876   -C, --config-cache      alias for \`--cache-file=config.cache'
 877   -n, --no-create         do not create output files
 878       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 879
 880 _ACEOF
 881
 882   cat <<_ACEOF
 883 Installation directories:
 884   --prefix=PREFIX         install architecture-independent files in PREFIX
 885                           [$ac_default_prefix]
 886   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 887                           [PREFIX]
 888
 889 By default, \`make install' will install all the files in
 890 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 891 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 892 for instance \`--prefix=\$HOME'.
 893
 894 For better control, use the options below.
 895
 896 Fine tuning of the installation directories:
 897   --bindir=DIR           user executables [EPREFIX/bin]
 898   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 899   --libexecdir=DIR       program executables [EPREFIX/libexec]
 900   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 901   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 902   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 903   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 904   --libdir=DIR           object code libraries [EPREFIX/lib]
 905   --includedir=DIR       C header files [PREFIX/include]
 906   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 907   --infodir=DIR          info documentation [PREFIX/info]
 908   --mandir=DIR           man documentation [PREFIX/man]
 909 _ACEOF
 910
 911   cat <<\_ACEOF
 912
 913 Program names:
 914   --program-prefix=PREFIX            prepend PREFIX to installed program names
 915   --program-suffix=SUFFIX            append SUFFIX to installed program names
 916   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 917
 918 System types:
 919   --build=BUILD     configure for building on BUILD [guessed]
 920   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 921   --target=TARGET   configure for building compilers for TARGET [HOST]
 922 _ACEOF
 923 fi
 924
 925 if test -n "$ac_init_help"; then
 926
 927   cat <<\_ACEOF
 928
 929 Optional Features:
 930   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 931   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 932   --enable-libada         build libada directory
 933   --enable-libssp         build libssp directory
 934   --enable-stage1-languages[=all]   choose additional languages to build during
 935                           stage1.  Mostly useful for compiler development.
 936   --enable-objc-gc        enable use of Boehm's garbage collector with the
 937                           GNU Objective-C runtime
 938   --enable-bootstrap      enable bootstrapping [yes if native build]
 939   --enable-serial-[{host,target,build}-]configure
 940                           force sequential configuration of
 941                           sub-packages for the host, target or build
 942                           machine, or all sub-packages
 943   --enable-maintainer-mode enable make rules and dependencies not useful
 944                           (and sometimes confusing) to the casual installer
 945   --enable-stage1-checking[=all]   choose additional checking for stage1
 946                           of the compiler
 947   --enable-werror         enable -Werror in bootstrap stage2 and later
 948
 949 Optional Packages:
 950   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 951   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 952   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 953   --with-mpfr-dir=PATH    this option has been REMOVED
 954   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 955                           Equivalent to --with-mpfr-include=PATH/include
 956                           plus --with-mpfr-lib=PATH/lib
 957   --with-mpfr-include=PATH
 958                           specify directory for installed MPFR include files
 959   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 960   --with-gmp-dir=PATH     this option has been REMOVED
 961   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 962                           Equivalent to --with-gmp-include=PATH/include
 963                           plus --with-gmp-lib=PATH/lib
 964   --with-gmp-include=PATH specify directory for installed GMP include files
 965   --with-gmp-lib=PATH     specify directory for the installed GMP library
 966   --with-build-sysroot=SYSROOT
 967                           use sysroot as the system root during the build
 968   --with-debug-prefix-map='A=B C=D ...'
 969                              map A to B, C to D ... in debug information
 970   --with-build-time-tools=PATH
 971                           use given path to find target tools during the build
 972   --with-datarootdir      use datarootdir as the data root directory.
 973   --with-docdir           install documentation in this directory.
 974   --with-pdfdir           install pdf in this directory.
 975   --with-htmldir          install html in this directory.
 976
 977 Some influential environment variables:
 978   CC          C compiler command
 979   CFLAGS      C compiler flags
 980   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 981               nonstandard directory <lib dir>
 982   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 983               headers in a nonstandard directory <include dir>
 984   CXX         C++ compiler command
 985   CXXFLAGS    C++ compiler flags
 986   AR          AR for the host
 987   AS          AS for the host
 988   DLLTOOL     DLLTOOL for the host
 989   LD          LD for the host
 990   LIPO        LIPO for the host
 991   NM          NM for the host
 992   RANLIB      RANLIB for the host
 993   STRIP       STRIP for the host
 994   WINDRES     WINDRES for the host
 995   WINDMC      WINDMC for the host
 996   OBJCOPY     OBJCOPY for the host
 997   OBJDUMP     OBJDUMP for the host
 998   CC_FOR_TARGET
 999               CC for the target
1000   CXX_FOR_TARGET
1001               CXX for the target
1002   GCC_FOR_TARGET
1003               GCC for the target
1004   GCJ_FOR_TARGET
1005               GCJ for the target
1006   GFORTRAN_FOR_TARGET
1007               GFORTRAN for the target
1008   AR_FOR_TARGET
1009               AR for the target
1010   AS_FOR_TARGET
1011               AS for the target
1012   DLLTOOL_FOR_TARGET
1013               DLLTOOL for the target
1014   LD_FOR_TARGET
1015               LD for the target
1016   LIPO_FOR_TARGET
1017               LIPO for the target
1018   NM_FOR_TARGET
1019               NM for the target
1020   OBJDUMP_FOR_TARGET
1021               OBJDUMP for the target
1022   RANLIB_FOR_TARGET
1023               RANLIB for the target
1024   STRIP_FOR_TARGET
1025               STRIP for the target
1026   WINDRES_FOR_TARGET
1027               WINDRES for the target
1028   WINDMC_FOR_TARGET
1029               WINDMC for the target
1030
1031 Use these variables to override the choices made by `configure' or to help
1032 it to find libraries and programs with nonstandard names/locations.
1033
1034 _ACEOF
1035 fi
1036
1037 if test "$ac_init_help" = "recursive"; then
1038   # If there are subdirs, report their specific --help.
1039   ac_popdir=`pwd`
1040   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1041     test -d $ac_dir || continue
1042     ac_builddir=.
1043
1044 if test "$ac_dir" != .; then
1045   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1046   # A "../" for each directory in $ac_dir_suffix.
1047   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1048 else
1049   ac_dir_suffix= ac_top_builddir=
1050 fi
1051
1052 case $srcdir in
1053   .)  # No --srcdir option.  We are building in place.
1054     ac_srcdir=.
1055     if test -z "$ac_top_builddir"; then
1056        ac_top_srcdir=.
1057     else
1058        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1059     fi ;;
1060   [\\/]* | ?:[\\/]* )  # Absolute path.
1061     ac_srcdir=$srcdir$ac_dir_suffix;
1062     ac_top_srcdir=$srcdir ;;
1063   *) # Relative path.
1064     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1065     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1066 esac
1067
1068 # Do not use `cd foo && pwd` to compute absolute paths, because
1069 # the directories may not exist.
1070 case `pwd` in
1071 .) ac_abs_builddir="$ac_dir";;
1072 *)
1073   case "$ac_dir" in
1074   .) ac_abs_builddir=`pwd`;;
1075   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1076   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1077   esac;;
1078 esac
1079 case $ac_abs_builddir in
1080 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1081 *)
1082   case ${ac_top_builddir}. in
1083   .) ac_abs_top_builddir=$ac_abs_builddir;;
1084   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1085   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1086   esac;;
1087 esac
1088 case $ac_abs_builddir in
1089 .) ac_abs_srcdir=$ac_srcdir;;
1090 *)
1091   case $ac_srcdir in
1092   .) ac_abs_srcdir=$ac_abs_builddir;;
1093   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1094   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1095   esac;;
1096 esac
1097 case $ac_abs_builddir in
1098 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1099 *)
1100   case $ac_top_srcdir in
1101   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1102   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1103   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1104   esac;;
1105 esac
1106
1107     cd $ac_dir
1108     # Check for guested configure; otherwise get Cygnus style configure.
1109     if test -f $ac_srcdir/configure.gnu; then
1110       echo
1111       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1112     elif test -f $ac_srcdir/configure; then
1113       echo
1114       $SHELL $ac_srcdir/configure  --help=recursive
1115     elif test -f $ac_srcdir/configure.ac ||
1116            test -f $ac_srcdir/configure.in; then
1117       echo
1118       $ac_configure --help
1119     else
1120       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1121     fi
1122     cd $ac_popdir
1123   done
1124 fi
1125
1126 test -n "$ac_init_help" && exit 0
1127 if $ac_init_version; then
1128   cat <<\_ACEOF
1129
1130 Copyright (C) 2003 Free Software Foundation, Inc.
1131 This configure script is free software; the Free Software Foundation
1132 gives unlimited permission to copy, distribute and modify it.
1133 _ACEOF
1134   exit 0
1135 fi
1136 exec 5>config.log
1137 cat >&5 <<_ACEOF
1138 This file contains any messages produced by compilers while
1139 running configure, to aid debugging if configure makes a mistake.
1140
1141 It was created by $as_me, which was
1142 generated by GNU Autoconf 2.59.  Invocation command line was
1143
1144   $ $0 $@
1145
1146 _ACEOF
1147 {
1148 cat <<_ASUNAME
1149 ## --------- ##
1150 ## Platform. ##
1151 ## --------- ##
1152
1153 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1154 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1155 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1156 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1157 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1158
1159 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1160 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1161
1162 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1163 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1164 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1165 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1166 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1167 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1168 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1169
1170 _ASUNAME
1171
1172 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1173 for as_dir in $PATH
1174 do
1175   IFS=$as_save_IFS
1176   test -z "$as_dir" && as_dir=.
1177   echo "PATH: $as_dir"
1178 done
1179
1180 } >&5
1181
1182 cat >&5 <<_ACEOF
1183
1184
1185 ## ----------- ##
1186 ## Core tests. ##
1187 ## ----------- ##
1188
1189 _ACEOF
1190
1191
1192 # Keep a trace of the command line.
1193 # Strip out --no-create and --no-recursion so they do not pile up.
1194 # Strip out --silent because we don't want to record it for future runs.
1195 # Also quote any args containing shell meta-characters.
1196 # Make two passes to allow for proper duplicate-argument suppression.
1197 ac_configure_args=
1198 ac_configure_args0=
1199 ac_configure_args1=
1200 ac_sep=
1201 ac_must_keep_next=false
1202 for ac_pass in 1 2
1203 do
1204   for ac_arg
1205   do
1206     case $ac_arg in
1207     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1208     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1209     | -silent | --silent | --silen | --sile | --sil)
1210       continue ;;
1211     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1212       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1213     esac
1214     case $ac_pass in
1215     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1216     2)
1217       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1218       if test $ac_must_keep_next = true; then
1219         ac_must_keep_next=false # Got value, back to normal.
1220       else
1221         case $ac_arg in
1222           *=* | --config-cache | -C | -disable-* | --disable-* \
1223           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1224           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1225           | -with-* | --with-* | -without-* | --without-* | --x)
1226             case "$ac_configure_args0 " in
1227               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1228             esac
1229             ;;
1230           -* ) ac_must_keep_next=true ;;
1231         esac
1232       fi
1233       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1234       # Get rid of the leading space.
1235       ac_sep=" "
1236       ;;
1237     esac
1238   done
1239 done
1240 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1241 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1242
1243 # When interrupted or exit'd, cleanup temporary files, and complete
1244 # config.log.  We remove comments because anyway the quotes in there
1245 # would cause problems or look ugly.
1246 # WARNING: Be sure not to use single quotes in there, as some shells,
1247 # such as our DU 5.0 friend, will then `close' the trap.
1248 trap 'exit_status=$?
1249   # Save into config.log some information that might help in debugging.
1250   {
1251     echo
1252
1253     cat <<\_ASBOX
1254 ## ---------------- ##
1255 ## Cache variables. ##
1256 ## ---------------- ##
1257 _ASBOX
1258     echo
1259     # The following way of writing the cache mishandles newlines in values,
1260 {
1261   (set) 2>&1 |
1262     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1263     *ac_space=\ *)
1264       sed -n \
1265         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1266           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1267       ;;
1268     *)
1269       sed -n \
1270         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1271       ;;
1272     esac;
1273 }
1274     echo
1275
1276     cat <<\_ASBOX
1277 ## ----------------- ##
1278 ## Output variables. ##
1279 ## ----------------- ##
1280 _ASBOX
1281     echo
1282     for ac_var in $ac_subst_vars
1283     do
1284       eval ac_val=$`echo $ac_var`
1285       echo "$ac_var='"'"'$ac_val'"'"'"
1286     done | sort
1287     echo
1288
1289     if test -n "$ac_subst_files"; then
1290       cat <<\_ASBOX
1291 ## ------------- ##
1292 ## Output files. ##
1293 ## ------------- ##
1294 _ASBOX
1295       echo
1296       for ac_var in $ac_subst_files
1297       do
1298         eval ac_val=$`echo $ac_var`
1299         echo "$ac_var='"'"'$ac_val'"'"'"
1300       done | sort
1301       echo
1302     fi
1303
1304     if test -s confdefs.h; then
1305       cat <<\_ASBOX
1306 ## ----------- ##
1307 ## confdefs.h. ##
1308 ## ----------- ##
1309 _ASBOX
1310       echo
1311       sed "/^$/d" confdefs.h | sort
1312       echo
1313     fi
1314     test "$ac_signal" != 0 &&
1315       echo "$as_me: caught signal $ac_signal"
1316     echo "$as_me: exit $exit_status"
1317   } >&5
1318   rm -f core *.core &&
1319   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1320     exit $exit_status
1321      ' 0
1322 for ac_signal in 1 2 13 15; do
1323   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1324 done
1325 ac_signal=0
1326
1327 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1328 rm -rf conftest* confdefs.h
1329 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1330 echo >confdefs.h
1331
1332 # Predefined preprocessor variables.
1333
1334 cat >>confdefs.h <<_ACEOF
1335 #define PACKAGE_NAME "$PACKAGE_NAME"
1336 _ACEOF
1337
1338
1339 cat >>confdefs.h <<_ACEOF
1340 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1341 _ACEOF
1342
1343
1344 cat >>confdefs.h <<_ACEOF
1345 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1346 _ACEOF
1347
1348
1349 cat >>confdefs.h <<_ACEOF
1350 #define PACKAGE_STRING "$PACKAGE_STRING"
1351 _ACEOF
1352
1353
1354 cat >>confdefs.h <<_ACEOF
1355 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1356 _ACEOF
1357
1358
1359 # Let the site file select an alternate cache file if it wants to.
1360 # Prefer explicitly selected file to automatically selected ones.
1361 if test -z "$CONFIG_SITE"; then
1362   if test "x$prefix" != xNONE; then
1363     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1364   else
1365     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1366   fi
1367 fi
1368 for ac_site_file in $CONFIG_SITE; do
1369   if test -r "$ac_site_file"; then
1370     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1371 echo "$as_me: loading site script $ac_site_file" >&6;}
1372     sed 's/^/| /' "$ac_site_file" >&5
1373     . "$ac_site_file"
1374   fi
1375 done
1376
1377 if test -r "$cache_file"; then
1378   # Some versions of bash will fail to source /dev/null (special
1379   # files actually), so we avoid doing that.
1380   if test -f "$cache_file"; then
1381     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1382 echo "$as_me: loading cache $cache_file" >&6;}
1383     case $cache_file in
1384       [\\/]* | ?:[\\/]* ) . $cache_file;;
1385       *)                      . ./$cache_file;;
1386     esac
1387   fi
1388 else
1389   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1390 echo "$as_me: creating cache $cache_file" >&6;}
1391   >$cache_file
1392 fi
1393
1394 # Check that the precious variables saved in the cache have kept the same
1395 # value.
1396 ac_cache_corrupted=false
1397 for ac_var in `(set) 2>&1 |
1398                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1399   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1400   eval ac_new_set=\$ac_env_${ac_var}_set
1401   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1402   eval ac_new_val="\$ac_env_${ac_var}_value"
1403   case $ac_old_set,$ac_new_set in
1404     set,)
1405       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1406 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1407       ac_cache_corrupted=: ;;
1408     ,set)
1409       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1410 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1411       ac_cache_corrupted=: ;;
1412     ,);;
1413     *)
1414       if test "x$ac_old_val" != "x$ac_new_val"; then
1415         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1416 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1417         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1418 echo "$as_me:   former value:  $ac_old_val" >&2;}
1419         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1420 echo "$as_me:   current value: $ac_new_val" >&2;}
1421         ac_cache_corrupted=:
1422       fi;;
1423   esac
1424   # Pass precious variables to config.status.
1425   if test "$ac_new_set" = set; then
1426     case $ac_new_val in
1427     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1428       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1429     *) ac_arg=$ac_var=$ac_new_val ;;
1430     esac
1431     case " $ac_configure_args " in
1432       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1433       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1434     esac
1435   fi
1436 done
1437 if $ac_cache_corrupted; then
1438   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1439 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1440   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1441 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1442    { (exit 1); exit 1; }; }
1443 fi
1444
1445 ac_ext=c
1446 ac_cpp='$CPP $CPPFLAGS'
1447 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1448 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1449 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471 # Find the build, host, and target systems.
1472 ac_aux_dir=
1473 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1474   if test -f $ac_dir/install-sh; then
1475     ac_aux_dir=$ac_dir
1476     ac_install_sh="$ac_aux_dir/install-sh -c"
1477     break
1478   elif test -f $ac_dir/install.sh; then
1479     ac_aux_dir=$ac_dir
1480     ac_install_sh="$ac_aux_dir/install.sh -c"
1481     break
1482   elif test -f $ac_dir/shtool; then
1483     ac_aux_dir=$ac_dir
1484     ac_install_sh="$ac_aux_dir/shtool install -c"
1485     break
1486   fi
1487 done
1488 if test -z "$ac_aux_dir"; then
1489   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1490 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1491    { (exit 1); exit 1; }; }
1492 fi
1493 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1494 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1495 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1496
1497 # Make sure we can run config.sub.
1498 $ac_config_sub sun4 >/dev/null 2>&1 ||
1499   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1500 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1501    { (exit 1); exit 1; }; }
1502
1503 echo "$as_me:$LINENO: checking build system type" >&5
1504 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1505 if test "${ac_cv_build+set}" = set; then
1506   echo $ECHO_N "(cached) $ECHO_C" >&6
1507 else
1508   ac_cv_build_alias=$build_alias
1509 test -z "$ac_cv_build_alias" &&
1510   ac_cv_build_alias=`$ac_config_guess`
1511 test -z "$ac_cv_build_alias" &&
1512   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1513 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1514    { (exit 1); exit 1; }; }
1515 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1516   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1517 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1518    { (exit 1); exit 1; }; }
1519
1520 fi
1521 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1522 echo "${ECHO_T}$ac_cv_build" >&6
1523 build=$ac_cv_build
1524 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1525 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1526 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1527
1528
1529  case ${build_alias} in
1530   "") build_noncanonical=${build} ;;
1531   *) build_noncanonical=${build_alias} ;;
1532 esac
1533
1534
1535
1536  case ${host_alias} in
1537   "") host_noncanonical=${build_noncanonical} ;;
1538   *) host_noncanonical=${host_alias} ;;
1539 esac
1540
1541
1542
1543  case ${target_alias} in
1544   "") target_noncanonical=${host_noncanonical} ;;
1545   *) target_noncanonical=${target_alias} ;;
1546 esac
1547
1548
1549
1550
1551 test "$host_noncanonical" = "$target_noncanonical" &&
1552   test "$program_prefix$program_suffix$program_transform_name" = \
1553     NONENONEs,x,x, &&
1554   program_transform_name=s,y,y,
1555
1556 echo "$as_me:$LINENO: checking host system type" >&5
1557 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1558 if test "${ac_cv_host+set}" = set; then
1559   echo $ECHO_N "(cached) $ECHO_C" >&6
1560 else
1561   ac_cv_host_alias=$host_alias
1562 test -z "$ac_cv_host_alias" &&
1563   ac_cv_host_alias=$ac_cv_build_alias
1564 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1565   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1566 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1567    { (exit 1); exit 1; }; }
1568
1569 fi
1570 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1571 echo "${ECHO_T}$ac_cv_host" >&6
1572 host=$ac_cv_host
1573 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1574 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1575 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1576
1577
1578 echo "$as_me:$LINENO: checking target system type" >&5
1579 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1580 if test "${ac_cv_target+set}" = set; then
1581   echo $ECHO_N "(cached) $ECHO_C" >&6
1582 else
1583   ac_cv_target_alias=$target_alias
1584 test "x$ac_cv_target_alias" = "x" &&
1585   ac_cv_target_alias=$ac_cv_host_alias
1586 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1587   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1588 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1589    { (exit 1); exit 1; }; }
1590
1591 fi
1592 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1593 echo "${ECHO_T}$ac_cv_target" >&6
1594 target=$ac_cv_target
1595 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1596 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1597 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1598
1599
1600 # The aliases save the names the user supplied, while $host etc.
1601 # will get canonicalized.
1602 test -n "$target_alias" &&
1603   test "$program_prefix$program_suffix$program_transform_name" = \
1604     NONENONEs,x,x, &&
1605   program_prefix=${target_alias}-
1606 test "$program_prefix" != NONE &&
1607   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1608 # Use a double $ so make ignores it.
1609 test "$program_suffix" != NONE &&
1610   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1611 # Double any \ or $.  echo might interpret backslashes.
1612 # By default was `s,x,x', remove it if useless.
1613 cat <<\_ACEOF >conftest.sed
1614 s/[\\$]/&&/g;s/;s,x,x,$//
1615 _ACEOF
1616 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1617 rm conftest.sed
1618
1619
1620
1621 # Get 'install' or 'install-sh' and its variants.
1622 # Find a good install program.  We prefer a C program (faster),
1623 # so one script is as good as another.  But avoid the broken or
1624 # incompatible versions:
1625 # SysV /etc/install, /usr/sbin/install
1626 # SunOS /usr/etc/install
1627 # IRIX /sbin/install
1628 # AIX /bin/install
1629 # AmigaOS /C/install, which installs bootblocks on floppy discs
1630 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1631 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1632 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1633 # OS/2's system install, which has a completely different semantic
1634 # ./install, which can be erroneously created by make from ./install.sh.
1635 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1636 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1637 if test -z "$INSTALL"; then
1638 if test "${ac_cv_path_install+set}" = set; then
1639   echo $ECHO_N "(cached) $ECHO_C" >&6
1640 else
1641   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1642 for as_dir in $PATH
1643 do
1644   IFS=$as_save_IFS
1645   test -z "$as_dir" && as_dir=.
1646   # Account for people who put trailing slashes in PATH elements.
1647 case $as_dir/ in
1648   ./ | .// | /cC/* | \
1649   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1650   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1651   /usr/ucb/* ) ;;
1652   *)
1653     # OSF1 and SCO ODT 3.0 have their own names for install.
1654     # Don't use installbsd from OSF since it installs stuff as root
1655     # by default.
1656     for ac_prog in ginstall scoinst install; do
1657       for ac_exec_ext in '' $ac_executable_extensions; do
1658         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1659           if test $ac_prog = install &&
1660             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1661             # AIX install.  It has an incompatible calling convention.
1662             :
1663           elif test $ac_prog = install &&
1664             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1665             # program-specific install script used by HP pwplus--don't use.
1666             :
1667           else
1668             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1669             break 3
1670           fi
1671         fi
1672       done
1673     done
1674     ;;
1675 esac
1676 done
1677
1678
1679 fi
1680   if test "${ac_cv_path_install+set}" = set; then
1681     INSTALL=$ac_cv_path_install
1682   else
1683     # As a last resort, use the slow shell script.  We don't cache a
1684     # path for INSTALL within a source directory, because that will
1685     # break other packages using the cache if that directory is
1686     # removed, or if the path is relative.
1687     INSTALL=$ac_install_sh
1688   fi
1689 fi
1690 echo "$as_me:$LINENO: result: $INSTALL" >&5
1691 echo "${ECHO_T}$INSTALL" >&6
1692
1693 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1694 # It thinks the first close brace ends the variable substitution.
1695 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1696
1697 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1698
1699 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1700
1701 echo "$as_me:$LINENO: checking whether ln works" >&5
1702 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1703 if test "${acx_cv_prog_LN+set}" = set; then
1704   echo $ECHO_N "(cached) $ECHO_C" >&6
1705 else
1706   rm -f conftestdata_t
1707 echo >conftestdata_f
1708 if ln conftestdata_f conftestdata_t 2>/dev/null
1709 then
1710   acx_cv_prog_LN=ln
1711 else
1712   acx_cv_prog_LN=no
1713 fi
1714 rm -f conftestdata_f conftestdata_t
1715
1716 fi
1717 if test $acx_cv_prog_LN = no; then
1718   LN="cp"
1719   echo "$as_me:$LINENO: result: no, using $LN" >&5
1720 echo "${ECHO_T}no, using $LN" >&6
1721 else
1722   LN="$acx_cv_prog_LN"
1723   echo "$as_me:$LINENO: result: yes" >&5
1724 echo "${ECHO_T}yes" >&6
1725 fi
1726
1727 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1728 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1729 LN_S=$as_ln_s
1730 if test "$LN_S" = "ln -s"; then
1731   echo "$as_me:$LINENO: result: yes" >&5
1732 echo "${ECHO_T}yes" >&6
1733 else
1734   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1735 echo "${ECHO_T}no, using $LN_S" >&6
1736 fi
1737
1738
1739 ### we might need to use some other shell than /bin/sh for running subshells
1740 ### If we are on Windows, search for the shell.  This will permit people
1741 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1742 ### without also having to set CONFIG_SHELL.  This code will work when
1743 ### using bash, which sets OSTYPE.
1744 case "${OSTYPE}" in
1745 *win32*)
1746   if test x${CONFIG_SHELL} = x ; then
1747     if test ! -f /bin/sh ; then
1748       if test x${SHELL} != x && test -f ${SHELL} ; then
1749         CONFIG_SHELL=${SHELL}
1750         export CONFIG_SHELL
1751       else
1752         for prog in sh sh.exe bash bash.exe; do
1753           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1754           for dir in $PATH; do
1755             test -z "$dir" && dir=.
1756             if test -f $dir/$prog; then
1757               CONFIG_SHELL=$dir/$prog
1758               export CONFIG_SHELL
1759               break
1760             fi
1761           done
1762           IFS="$save_ifs"
1763           test -n "${CONFIG_SHELL}" && break
1764         done
1765       fi
1766     fi
1767   fi
1768   ;;
1769 esac
1770
1771 config_shell=${CONFIG_SHELL-/bin/sh}
1772
1773 progname=$0
1774 # if PWD already has a value, it is probably wrong.
1775 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1776
1777 # Export original configure arguments for use by sub-configures.
1778 # Quote arguments with shell meta charatcers.
1779 TOPLEVEL_CONFIGURE_ARGUMENTS=
1780 set -- "$progname" "$@"
1781 for ac_arg
1782 do
1783   case "$ac_arg" in
1784   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1785     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1786     # if the argument is of the form -foo=baz, quote the baz part only
1787     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1788   *) ;;
1789   esac
1790   # Add the quoted argument to the list.
1791   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1792 done
1793 if test "$silent" = yes; then
1794   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1795 fi
1796 # Remove the initial space we just introduced and, as these will be
1797 # expanded by make, quote '$'.
1798 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1799
1800
1801 moveifchange=${srcdir}/move-if-change
1802
1803 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1804
1805 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1806 # a relative path.
1807 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1808   INSTALL="${srcpwd}/install-sh -c"
1809 fi
1810
1811 # Set srcdir to "." if that's what it is.
1812 # This is important for multilib support.
1813 pwd=`${PWDCMD-pwd}`
1814 if test "${pwd}" = "${srcpwd}" ; then
1815   srcdir=.
1816 fi
1817
1818 topsrcdir=$srcpwd
1819
1820 extra_host_args=
1821
1822 ### To add a new directory to the tree, first choose whether it is a target
1823 ### or a host dependent tool.  Then put it into the appropriate list
1824 ### (library or tools, host or target), doing a dependency sort.
1825
1826 # Subdirs will be configured in the order listed in build_configdirs,
1827 # configdirs, or target_configdirs; see the serialization section below.
1828
1829 # Dependency sorting is only needed when *configuration* must be done in
1830 # a particular order.  In all cases a dependency should be specified in
1831 # the Makefile, whether or not it's implicitly specified here.
1832
1833 # Double entries in build_configdirs, configdirs, or target_configdirs may
1834 # cause circular dependencies and break everything horribly.
1835
1836 # these library is used by various programs built for the build
1837 # environment
1838 #
1839 build_libs="build-libiberty"
1840
1841 # these tools are built for the build environment
1842 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1843
1844 # these libraries are used by various programs built for the host environment
1845 #
1846 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1847
1848 # these tools are built for the host environment
1849 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1850 # know that we are building the simulator.
1851 # binutils, gas and ld appear in that order because it makes sense to run
1852 # "make check" in that particular order.
1853 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"
1854
1855 # libgcj represents the runtime libraries only used by gcj.
1856 libgcj="target-libffi \
1857         target-zlib \
1858         target-qthreads \
1859         target-libjava"
1860
1861 # these libraries are built for the target environment, and are built after
1862 # the host libraries and the host tools (which may be a cross compiler)
1863 #
1864 target_libraries="target-libgcc \
1865                 target-libiberty \
1866                 target-libgloss \
1867                 target-newlib \
1868                 target-libstdc++-v3 \
1869                 target-libmudflap \
1870                 target-libssp \
1871                 target-libgfortran \
1872                 target-boehm-gc \
1873                 ${libgcj} \
1874                 target-libobjc \
1875                 target-libada \
1876                 target-libgomp"
1877
1878 # these tools are built using the target libraries, and are intended to
1879 # run only in the target environment
1880 #
1881 # note: any program that *uses* libraries that are in the "target_libraries"
1882 # list belongs in this list.  those programs are also very likely
1883 # candidates for the "native_only" list which follows
1884 #
1885 target_tools="target-examples target-groff target-gperf target-rda"
1886
1887 ################################################################################
1888
1889 ## All tools belong in one of the four categories, and are assigned above
1890 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1891 ## is important because configure will choke if they ever get through.
1892 ## ${configdirs} is directories we build using the host tools.
1893 ## ${target_configdirs} is directories we build using the target tools.
1894 configdirs=`echo ${host_libs} ${host_tools}`
1895 target_configdirs=`echo ${target_libraries} ${target_tools}`
1896 build_configdirs=`echo ${build_libs} ${build_tools}`
1897
1898 ################################################################################
1899
1900 srcname="gnu development package"
1901
1902 # This gets set non-empty for some net releases of packages.
1903 appdirs=""
1904
1905 # Define is_cross_compiler to save on calls to 'test'.
1906 is_cross_compiler=
1907 if test x"${host}" = x"${target}" ; then
1908   is_cross_compiler=no
1909 else
1910   is_cross_compiler=yes
1911 fi
1912
1913 # Find the build and target subdir names.
1914
1915 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1916 # have matching libraries, they should use host libraries: Makefile.tpl
1917 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1918 # However, they still use the build modules, because the corresponding
1919 # host modules (e.g. bison) are only built for the host when bootstrap
1920 # finishes. So:
1921 # - build_subdir is where we find build modules, and never changes.
1922 # - build_libsubdir is where we find build libraries, and can be overridden.
1923
1924 # Prefix 'build-' so this never conflicts with target_subdir.
1925 build_subdir="build-${build_noncanonical}"
1926
1927 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1928 if test "${with_build_libsubdir+set}" = set; then
1929   withval="$with_build_libsubdir"
1930   build_libsubdir="$withval"
1931 else
1932   build_libsubdir="$build_subdir"
1933 fi;
1934 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1935 if ( test $srcdir = . && test -d gcc ) \
1936    || test -d $srcdir/../host-${host_noncanonical}; then
1937   host_subdir="host-${host_noncanonical}"
1938 else
1939   host_subdir=.
1940 fi
1941 # No prefix.
1942 target_subdir=${target_noncanonical}
1943
1944
1945 # Skipdirs are removed silently.
1946 skipdirs=
1947 # Noconfigdirs are removed loudly.
1948 noconfigdirs=""
1949
1950 use_gnu_ld=
1951 # Make sure we don't let GNU ld be added if we didn't want it.
1952 if test x$with_gnu_ld = xno ; then
1953   use_gnu_ld=no
1954   noconfigdirs="$noconfigdirs ld"
1955 fi
1956
1957 use_gnu_as=
1958 # Make sure we don't let GNU as be added if we didn't want it.
1959 if test x$with_gnu_as = xno ; then
1960   use_gnu_as=no
1961   noconfigdirs="$noconfigdirs gas"
1962 fi
1963
1964 # some tools are so dependent upon X11 that if we're not building with X,
1965 # it's not even worth trying to configure, much less build, that tool.
1966
1967 case ${with_x} in
1968   yes | "") ;; # the default value for this tree is that X11 is available
1969   no)
1970     skipdirs="${skipdirs} tk itcl libgui"
1971     # We won't be able to build gdbtk without X.
1972     enable_gdbtk=no
1973     ;;
1974   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1975 esac
1976
1977 # Some tools are only suitable for building in a "native" situation.
1978 # Remove these if host!=target.
1979 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"
1980
1981 # Similarly, some are only suitable for cross toolchains.
1982 # Remove these if host=target.
1983 cross_only="target-libgloss target-newlib target-opcodes"
1984
1985 case $is_cross_compiler in
1986   no) skipdirs="${skipdirs} ${cross_only}" ;;
1987   yes) skipdirs="${skipdirs} ${native_only}" ;;
1988 esac
1989
1990 # If both --with-headers and --with-libs are specified, default to
1991 # --without-newlib.
1992 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
1993    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
1994   if test x"${with_newlib}" = x ; then
1995     with_newlib=no
1996   fi
1997 fi
1998
1999 # Recognize --with-newlib/--without-newlib.
2000 case ${with_newlib} in
2001   no) skipdirs="${skipdirs} target-newlib" ;;
2002   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2003 esac
2004
2005 # Configure extra directories which are host specific
2006
2007 case "${host}" in
2008   *-cygwin*)
2009     configdirs="$configdirs libtermcap" ;;
2010 esac
2011
2012 # A target can indicate whether a language isn't supported for some reason.
2013 # Only spaces may be used in this macro; not newlines or tabs.
2014 unsupported_languages=
2015
2016 # Remove more programs from consideration, based on the host or
2017 # target this usually means that a port of the program doesn't
2018 # exist yet.
2019
2020 case "${host}" in
2021   hppa*64*-*-*)
2022     noconfigdirs="$noconfigdirs byacc"
2023     ;;
2024   i[3456789]86-*-vsta)
2025     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2026     ;;
2027   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2028     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2029     ;;
2030   x86_64-*-mingw*)
2031     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2032     ;;
2033   i[3456789]86-*-mingw32*)
2034     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2035     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2036     ;;
2037   i[3456789]86-*-beos*)
2038     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2039     ;;
2040   *-*-cygwin*)
2041     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2042     ;;
2043   *-*-netbsd*)
2044     noconfigdirs="$noconfigdirs rcs"
2045     ;;
2046   ppc*-*-pe)
2047     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2048     ;;
2049   powerpc-*-beos*)
2050     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2051     ;;
2052 esac
2053
2054
2055 # Check whether --enable-libada or --disable-libada was given.
2056 if test "${enable_libada+set}" = set; then
2057   enableval="$enable_libada"
2058   ENABLE_LIBADA=$enableval
2059 else
2060   ENABLE_LIBADA=yes
2061 fi;
2062 if test "${ENABLE_LIBADA}" != "yes" ; then
2063   noconfigdirs="$noconfigdirs gnattools"
2064 fi
2065
2066 # Check whether --enable-libssp or --disable-libssp was given.
2067 if test "${enable_libssp+set}" = set; then
2068   enableval="$enable_libssp"
2069   ENABLE_LIBSSP=$enableval
2070 else
2071   ENABLE_LIBSSP=yes
2072 fi;
2073
2074 # Save it here so that, even in case of --enable-libgcj, if the Java
2075 # front-end isn't enabled, we still get libgcj disabled.
2076 libgcj_saved=$libgcj
2077 case $enable_libgcj in
2078 yes)
2079   # If we reset it here, it won't get added to noconfigdirs in the
2080   # target-specific build rules, so it will be forcibly enabled
2081   # (unless the Java language itself isn't enabled).
2082   libgcj=
2083   ;;
2084 no)
2085   # Make sure we get it printed in the list of not supported target libs.
2086   noconfigdirs="$noconfigdirs ${libgcj}"
2087   ;;
2088 esac
2089
2090
2091 # Disable libmudflap on some systems.
2092 if test x$enable_libmudflap = x ; then
2093     case "${target}" in
2094     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2095         # Enable libmudflap by default in GNU and friends.
2096         ;;
2097     *-*-freebsd*)
2098         # Enable libmudflap by default in FreeBSD.
2099         ;;
2100     *)
2101         # Disable it by default everywhere else.
2102         noconfigdirs="$noconfigdirs target-libmudflap"
2103         ;;
2104     esac
2105 fi
2106
2107 # Disable libgomp on non POSIX hosted systems.
2108 if test x$enable_libgomp = x ; then
2109     # Enable libgomp by default on hosted POSIX systems.
2110     case "${target}" in
2111     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2112         ;;
2113     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2114         ;;
2115     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2116         ;;
2117     *-*-darwin* | *-*-aix*)
2118         ;;
2119     *)
2120         noconfigdirs="$noconfigdirs target-libgomp"
2121         ;;
2122     esac
2123 fi
2124
2125 # Default libgloss CPU subdirectory.
2126 libgloss_dir="$target_cpu"
2127
2128 case "${target}" in
2129   *-*-chorusos)
2130     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2131     ;;
2132   powerpc-*-darwin* | i[3456789]86-*-darwin*)
2133     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2134     noconfigdirs="$noconfigdirs sim target-rda"
2135     ;;
2136   *-*-darwin*)
2137     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2138     noconfigdirs="$noconfigdirs sim target-rda"
2139     noconfigdirs="$noconfigdirs ${libgcj}"
2140     ;;
2141   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2142     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2143     ;;
2144   *-*-freebsd*)
2145     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2146     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2147         && test -f /usr/local/include/gmp.h; then
2148       with_gmp=/usr/local
2149     fi
2150
2151     # Skip some stuff that's unsupported on some FreeBSD configurations.
2152     case "${target}" in
2153       i*86-*-*) ;;
2154       alpha*-*-*) ;;
2155       *)
2156         noconfigdirs="$noconfigdirs ${libgcj}"
2157         ;;
2158     esac
2159     ;;
2160   *-*-kaos*)
2161     # Remove unsupported stuff on all kaOS configurations.
2162     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2163     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2164     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2165     noconfigdirs="$noconfigdirs target-libgloss"
2166     ;;
2167   *-*-netbsd*)
2168     # Skip some stuff on all NetBSD configurations.
2169     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2170
2171     # Skip some stuff that's unsupported on some NetBSD configurations.
2172     case "${target}" in
2173       i*86-*-netbsdelf*) ;;
2174       arm*-*-netbsdelf*) ;;
2175       *)
2176         noconfigdirs="$noconfigdirs ${libgcj}"
2177         ;;
2178     esac
2179     ;;
2180   *-*-netware*)
2181     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2182     ;;
2183   *-*-rtems*)
2184     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2185     ;;
2186     # The tpf target doesn't support gdb yet.
2187   *-*-tpf*)
2188     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2189     ;;
2190   *-*-uclinux*)
2191     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2192     ;;
2193   *-*-vxworks*)
2194     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2195     ;;
2196   alpha*-dec-osf*)
2197     # ld works, but does not support shared libraries.
2198     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2199     # gas doesn't generate exception information.
2200     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2201     ;;
2202   alpha*-*-*vms*)
2203     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2204     ;;
2205   alpha*-*-linux*)
2206     # newlib is not 64 bit ready
2207     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2208     ;;
2209   alpha*-*-*)
2210     # newlib is not 64 bit ready
2211     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2212     ;;
2213   am33_2.0-*-linux*)
2214     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2215     ;;
2216   sh-*-linux*)
2217     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2218     ;;
2219   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2220     noconfigdirs="$noconfigdirs ${libgcj}"
2221     noconfigdirs="$noconfigdirs target-examples"
2222     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2223     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2224     noconfigdirs="$noconfigdirs expect dejagnu"
2225     # the C++ libraries don't build on top of CE's C libraries
2226     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2227     noconfigdirs="$noconfigdirs target-newlib"
2228     case "${host}" in
2229       *-*-cygwin*) ;; # keep gdb and readline
2230       *) noconfigdirs="$noconfigdirs gdb readline"
2231          ;;
2232     esac
2233     libgloss_dir=wince
2234     ;;
2235   arc-*-*)
2236     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2237     ;;
2238   arm-semi-aof )
2239     ;;
2240   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2241     noconfigdirs="$noconfigdirs ${libgcj}"
2242     libgloss_dir=arm
2243     ;;
2244   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2245     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2246     libgloss_dir=arm
2247     ;;
2248   arm*-*-linux-gnueabi)
2249     noconfigdirs="$noconfigdirs target-qthreads"
2250     noconfigdirs="$noconfigdirs target-libobjc"
2251     case ${with_newlib} in
2252       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2253     esac
2254     libgloss_dir=arm
2255     ;;
2256   arm*-*-symbianelf*)
2257     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2258     libgloss_dir=arm
2259     ;;
2260   arm-*-pe*)
2261     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2262     ;;
2263   thumb-*-coff)
2264     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2265     ;;
2266   thumb-*-elf)
2267     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2268     ;;
2269   thumb-*-pe)
2270     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2271     ;;
2272   arm-*-riscix*)
2273     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2274     ;;
2275   avr-*-*)
2276     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2277     ;;
2278   bfin-*-*)
2279     noconfigdirs="$noconfigdirs gdb"
2280     if test x${is_cross_compiler} != xno ; then
2281       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2282     fi
2283     ;;
2284   c4x-*-* | tic4x-*-*)
2285     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2286     ;;
2287   c54x*-*-* | tic54x-*-*)
2288     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2289     ;;
2290   cris-*-* | crisv32-*-*)
2291     unsupported_languages="$unsupported_languages java"
2292     case "${target}" in
2293       *-*-aout)
2294         unsupported_languages="$unsupported_languages fortran"
2295         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2296       *-*-elf)
2297         unsupported_languages="$unsupported_languages fortran"
2298         noconfigdirs="$noconfigdirs target-boehm-gc";;
2299       *-*-linux*)
2300         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2301       *)
2302         unsupported_languages="$unsupported_languages fortran"
2303         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2304     esac
2305     libgloss_dir=cris
2306     ;;
2307   crx-*-*)
2308     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2309     ;;
2310   d10v-*-*)
2311     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2312     ;;
2313   d30v-*-*)
2314     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2315     ;;
2316   ep9312-*-elf | ep9312-*-coff)
2317     libgloss_dir=arm
2318     ;;
2319   fr30-*-elf*)
2320     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2321     ;;
2322   frv-*-*)
2323     noconfigdirs="$noconfigdirs ${libgcj}"
2324     ;;
2325   h8300*-*-*)
2326     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2327     ;;
2328   h8500-*-*)
2329     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2330     ;;
2331   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2332     ;;
2333   hppa*64*-*-linux* | parisc*64*-*-linux*)
2334     # In this case, it's because the hppa64-linux target is for
2335     # the kernel only at this point and has no libc, and thus no
2336     # headers, crt*.o, etc., all of which are needed by these.
2337     noconfigdirs="$noconfigdirs target-zlib"
2338     ;;
2339   parisc*-*-linux* | hppa*-*-linux*)
2340     ;;
2341   hppa*-*-*elf* | \
2342   hppa*-*-lites* | \
2343   hppa*-*-openbsd* | \
2344   hppa*64*-*-*)
2345     noconfigdirs="$noconfigdirs ${libgcj}"
2346     ;;
2347   hppa*-hp-hpux11*)
2348     noconfigdirs="$noconfigdirs ld shellutils"
2349     ;;
2350   hppa*-*-pro*)
2351     libgloss_dir=pa
2352     ;;
2353   hppa*-*-*)
2354     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2355     # build on HP-UX 10.20.
2356     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2357     ;;
2358   i960-*-*)
2359     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2360     ;;
2361   ia64*-*-elf*)
2362     # No gdb support yet.
2363     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2364     ;;
2365   ia64*-**-hpux*)
2366     # No gdb or ld support yet.
2367     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2368     ;;
2369   i370-*-opened*)
2370     ;;
2371   i[3456789]86-*-coff | i[3456789]86-*-elf)
2372     noconfigdirs="$noconfigdirs ${libgcj}"
2373     libgloss_dir=i386
2374     ;;
2375   i[3456789]86-*-linux*)
2376     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2377     # not build java stuff by default.
2378     case "${target}" in
2379       *-*-*libc1*)
2380         noconfigdirs="$noconfigdirs ${libgcj}";;
2381     esac
2382
2383     # This section makes it possible to build newlib natively on linux.
2384     # If we are using a cross compiler then don't configure newlib.
2385     if test x${is_cross_compiler} != xno ; then
2386       noconfigdirs="$noconfigdirs target-newlib"
2387     fi
2388     noconfigdirs="$noconfigdirs target-libgloss"
2389     # If we are not using a cross compiler, do configure newlib.
2390     # Note however, that newlib will only be configured in this situation
2391     # if the --with-newlib option has been given, because otherwise
2392     # 'target-newlib' will appear in skipdirs.
2393     ;;
2394   i[3456789]86-*-mingw32*)
2395     target_configdirs="$target_configdirs target-winsup"
2396     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2397     ;;
2398   x86_64-*-mingw*)
2399     target_configdirs="$target_configdirs target-winsup"
2400     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2401     ;;
2402   *-*-cygwin*)
2403     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2404     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2405     # always build newlib if winsup directory is present.
2406     if test -d "$srcdir/winsup/cygwin"; then
2407       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2408     elif test -d "$srcdir/newlib"; then
2409       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2410     fi
2411     ;;
2412   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2413   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2414     ;;
2415   i[3456789]86-*-pe)
2416     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2417     ;;
2418   i[3456789]86-*-sco3.2v5*)
2419     # The linker does not yet know about weak symbols in COFF,
2420     # and is not configured to handle mixed ELF and COFF.
2421     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2422     ;;
2423   i[3456789]86-*-sco*)
2424     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2425     ;;
2426   i[3456789]86-*-solaris2*)
2427     noconfigdirs="$noconfigdirs target-libgloss"
2428     ;;
2429   i[3456789]86-*-sysv4*)
2430     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2431     ;;
2432   i[3456789]86-*-beos*)
2433     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2434     ;;
2435   i[3456789]86-*-rdos*)
2436     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2437     ;;
2438   m32r-*-*)
2439     noconfigdirs="$noconfigdirs ${libgcj}"
2440     ;;
2441   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2442     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2443     libgloss_dir=m68hc11
2444     ;;
2445   m68k-*-elf*)
2446     noconfigdirs="$noconfigdirs ${libgcj}"
2447     ;;
2448   m68k-*-coff*)
2449     noconfigdirs="$noconfigdirs ${libgcj}"
2450     ;;
2451   m68*-*-* | fido-*-*)
2452     libgloss_dir=m68k
2453     ;;
2454   mcore-*-pe*)
2455   # The EPOC C++ environment does not support exceptions or rtti,
2456   # and so building libstdc++-v3 tends not to always work.
2457     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2458     ;;
2459   mmix-*-*)
2460     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2461     unsupported_languages="$unsupported_languages fortran java"
2462     ;;
2463   mn10200-*-*)
2464     noconfigdirs="$noconfigdirs ${libgcj}"
2465     ;;
2466   mn10300-*-*)
2467     noconfigdirs="$noconfigdirs ${libgcj}"
2468     ;;
2469   mt-*-*)
2470     noconfigdirs="$noconfigdirs sim"
2471     ;;
2472   powerpc-*-aix*)
2473     # copied from rs6000-*-* entry
2474     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2475     ;;
2476   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2477     target_configdirs="$target_configdirs target-winsup"
2478     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2479     # always build newlib.
2480     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2481     ;;
2482     # This is temporary until we can link against shared libraries
2483   powerpcle-*-solaris*)
2484     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2485     libgloss_dir=rs6000
2486     ;;
2487   powerpc-*-beos*)
2488     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2489     ;;
2490   powerpc-*-eabi)
2491     noconfigdirs="$noconfigdirs ${libgcj}"
2492     libgloss_dir=rs6000
2493     ;;
2494   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2495     libgloss_dir=rs6000
2496     ;;
2497   rs6000-*-lynxos*)
2498     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2499     ;;
2500   rs6000-*-aix*)
2501     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2502     ;;
2503   rs6000-*-*)
2504     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2505     ;;
2506   m68k-apollo-*)
2507     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2508     ;;
2509   mips*-sde-elf*)
2510     skipdirs="$skipdirs target-libiberty"
2511     noconfigdirs="$noconfigdirs ${libgcj}"
2512     if test x$with_newlib = xyes; then
2513       noconfigdirs="$noconfigdirs gprof"
2514     fi
2515     libgloss_dir=mips
2516     ;;
2517   mips*-*-irix5*)
2518     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2519     ;;
2520   mips*-*-irix6*)
2521     # Linking libjava exceeds command-line length limits on at least
2522     # IRIX 6.2, but not on IRIX 6.5.
2523     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2524     # <oldham@codesourcery.com>
2525     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2526     ;;
2527   mips*-*-bsd*)
2528     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2529     ;;
2530   mips*-*-linux*)
2531     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2532     ;;
2533   mips*-*-*)
2534     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2535     libgloss_dir=mips
2536     ;;
2537   romp-*-*)
2538     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2539     ;;
2540   sh-*-* | sh64-*-*)
2541     case "${host}" in
2542       i[3456789]86-*-vsta) ;; # don't add gprof back in
2543       i[3456789]86-*-go32*) ;; # don't add gprof back in
2544       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2545       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2546     esac
2547     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2548     ;;
2549   sparclet-*-aout* | sparc86x-*-*)
2550     libgloss_dir=sparc
2551     ;;
2552   sparc-*-elf*)
2553     noconfigdirs="$noconfigdirs ${libgcj}"
2554     ;;
2555   sparc64-*-elf*)
2556     noconfigdirs="$noconfigdirs ${libgcj}"
2557     libgloss_dir=sparc
2558     ;;
2559   sparclite-*-*)
2560     noconfigdirs="$noconfigdirs ${libgcj}"
2561     libgloss_dir=sparc
2562     ;;
2563   sparc-*-sunos4*)
2564     noconfigdirs="$noconfigdirs ${libgcj}"
2565     if test x${is_cross_compiler} != xno ; then
2566            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2567     else
2568            use_gnu_ld=no
2569     fi
2570     ;;
2571   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2572     noconfigdirs="$noconfigdirs ${libgcj}"
2573     ;;
2574   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2575     ;;
2576   spu-*-*)
2577     skipdirs="target-libssp"
2578     ;;
2579   v810-*-*)
2580     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2581     ;;
2582   v850-*-*)
2583     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2584     ;;
2585   v850e-*-*)
2586     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2587     ;;
2588   v850ea-*-*)
2589     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2590     ;;
2591   vax-*-vms)
2592     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2593     ;;
2594   vax-*-*)
2595     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2596     ;;
2597   xtensa-*-*)
2598     noconfigdirs="$noconfigdirs ${libgcj}"
2599     ;;
2600   ip2k-*-*)
2601     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2602     ;;
2603   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2604     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2605     ;;
2606   *-*-lynxos*)
2607     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2608     ;;
2609   *-*-*)
2610     noconfigdirs="$noconfigdirs ${libgcj}"
2611     ;;
2612 esac
2613
2614 # If we aren't building newlib, then don't build libgloss, since libgloss
2615 # depends upon some newlib header files.
2616 case "${noconfigdirs}" in
2617   *target-libgloss*) ;;
2618   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2619 esac
2620
2621 # Work in distributions that contain no compiler tools, like Autoconf.
2622 tentative_cc=""
2623 host_makefile_frag=/dev/null
2624 if test -d ${srcdir}/config ; then
2625 case "${host}" in
2626   m68k-hp-hpux*)
2627     # Avoid "too much defining" errors from HPUX compiler.
2628     tentative_cc="cc -Wp,-H256000"
2629     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2630     # If it's HP/UX ar, this should be harmless.
2631     RANLIB="ar ts"
2632     ;;
2633   m68k-apollo-sysv*)
2634     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2635     ;;
2636   m68k-apollo-bsd*)
2637     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2638     # chokes on bfd, the compiler won't let you assign integers to enums, and
2639     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2640     # the apollo compiler" (the preferred version of GCC could be called cc,
2641     # or whatever), but I'm not sure leaving CC as cc is any better...
2642     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2643     # Used to have BISON=yacc.
2644     tentative_cc=gcc
2645     ;;
2646   m88k-dg-dgux*)
2647     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2648     ;;
2649   m88k-harris-cxux*)
2650     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2651     tentative_cc="cc -Xa"
2652     host_makefile_frag="config/mh-cxux"
2653     ;;
2654   m88k-motorola-sysv*)
2655     ;;
2656   mips*-dec-ultrix*)
2657     tentative_cc="cc -Wf,-XNg1000"
2658     host_makefile_frag="config/mh-decstation"
2659     ;;
2660   mips*-nec-sysv4*)
2661     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2662     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2663     host_makefile_frag="config/mh-necv4"
2664     ;;
2665   mips*-sgi-irix4*)
2666     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2667     # environment.  Also bump switch table size so that cp-parse will
2668     # compile.  Bump string length limit so linker builds.
2669     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2670     ;;
2671   mips*-*-sysv4*)
2672     host_makefile_frag="config/mh-sysv4"
2673     ;;
2674   mips*-*-sysv*)
2675     # This is for a MIPS running RISC/os 4.52C.
2676
2677     # This is needed for GDB, but needs to be in the top-level make because
2678     # if a library is compiled with the bsd headers and gets linked with the
2679     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2680     # a different size).
2681     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2682     # known except to select the sysv environment.  Could we use /proc instead?
2683     # These "sysv environments" and "bsd environments" often end up being a pain.
2684     #
2685     # This is not part of CFLAGS because perhaps not all C compilers have this
2686     # option.
2687     tentative_cc="cc -systype sysv"
2688     ;;
2689   i370-ibm-opened*)
2690     tentative_cc="c89"
2691     ;;
2692   i[3456789]86-*-sysv5*)
2693     host_makefile_frag="config/mh-sysv5"
2694     ;;
2695   i[3456789]86-*-dgux*)
2696     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2697     host_makefile_frag="config/mh-dgux386"
2698     ;;
2699   i[3456789]86-ncr-sysv4.3*)
2700     # The MetaWare compiler will generate a copyright message unless you
2701     # turn it off by adding the -Hnocopyr flag.
2702     tentative_cc="cc -Hnocopyr"
2703     ;;
2704   i[3456789]86-ncr-sysv4*)
2705     # for an NCR 3000 (i486/SVR4) system.
2706     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2707     # This compiler not only emits obnoxious copyright messages every time
2708     # you run it, but it chokes and dies on a whole bunch of GNU source
2709     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2710     tentative_cc="/usr/ccs/ATT/cc"
2711     host_makefile_frag="config/mh-ncr3000"
2712     ;;
2713   i[3456789]86-*-sco3.2v5*)
2714     ;;
2715   i[3456789]86-*-sco*)
2716     # The native C compiler botches some simple uses of const.  Unfortunately,
2717     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2718     tentative_cc="cc -Dconst="
2719     host_makefile_frag="config/mh-sco"
2720     ;;
2721   i[3456789]86-*-udk*)
2722     host_makefile_frag="config/mh-sysv5"
2723     ;;
2724   i[3456789]86-*-solaris2*)
2725     host_makefile_frag="config/mh-sysv4"
2726     ;;
2727   i[3456789]86-*-msdosdjgpp*)
2728     host_makefile_frag="config/mh-djgpp"
2729     ;;
2730   *-cygwin*)
2731     host_makefile_frag="config/mh-cygwin"
2732     ;;
2733   *-mingw32*)
2734     host_makefile_frag="config/mh-mingw"
2735     ;;
2736   *-mingw64*)
2737     host_makefile_frag="config/mh-mingw"
2738     ;;
2739   *-interix*)
2740     host_makefile_frag="config/mh-interix"
2741     ;;
2742   vax-*-ultrix2*)
2743     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2744     tentative_cc=gcc
2745     ;;
2746   *-*-solaris2*)
2747     host_makefile_frag="config/mh-solaris"
2748     ;;
2749   m68k-sun-sunos*)
2750     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2751     # without overflowing the jump tables (-J says to use a 32 bit table)
2752     tentative_cc="cc -J"
2753     ;;
2754   *-hp-hpux*)
2755     tentative_cc="cc -Wp,-H256000"
2756     ;;
2757   *-*-hiux*)
2758     tentative_cc="cc -Wp,-H256000"
2759     ;;
2760   rs6000-*-lynxos*)
2761     # /bin/cc is less than useful for our purposes.  Always use GCC
2762     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2763     host_makefile_frag="config/mh-lynxrs6k"
2764     ;;
2765   powerpc-*-darwin*)
2766     host_makefile_frag="config/mh-ppc-darwin"
2767     ;;
2768   powerpc-*-aix*)
2769     host_makefile_frag="config/mh-ppc-aix"
2770     ;;
2771   rs6000-*-aix*)
2772     host_makefile_frag="config/mh-ppc-aix"
2773     ;;
2774   *-*-lynxos*)
2775     # /bin/cc is less than useful for our purposes.  Always use GCC
2776     tentative_cc="/bin/gcc"
2777     ;;
2778   *-*-sysv4*)
2779     host_makefile_frag="config/mh-sysv4"
2780     ;;
2781   # This is placed last to prevent interfering with the cases above.
2782   i[3456789]86-*-*)
2783     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2784     host_makefile_frag="config/mh-x86omitfp"
2785     ;;
2786 esac
2787 fi
2788
2789 # If we aren't going to be using gcc, see if we can extract a definition
2790 # of CC from the fragment.
2791 # Actually, use the 'pre-extracted' version above.
2792 if test -z "${CC}" && test "${build}" = "${host}" ; then
2793   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2794   found=
2795   for dir in $PATH; do
2796     test -z "$dir" && dir=.
2797     if test -f $dir/gcc; then
2798       found=yes
2799       break
2800     fi
2801   done
2802   IFS="$save_ifs"
2803   if test -z "${found}" && test -n "${tentative_cc}" ; then
2804     CC=$tentative_cc
2805   fi
2806 fi
2807
2808 if test "${build}" != "${host}" ; then
2809   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2810 else
2811   CC_FOR_BUILD="\$(CC)"
2812 fi
2813
2814 ac_ext=c
2815 ac_cpp='$CPP $CPPFLAGS'
2816 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2817 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2818 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2819 if test -n "$ac_tool_prefix"; then
2820   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2821 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2822 echo "$as_me:$LINENO: checking for $ac_word" >&5
2823 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2824 if test "${ac_cv_prog_CC+set}" = set; then
2825   echo $ECHO_N "(cached) $ECHO_C" >&6
2826 else
2827   if test -n "$CC"; then
2828   ac_cv_prog_CC="$CC" # Let the user override the test.
2829 else
2830 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2831 for as_dir in $PATH
2832 do
2833   IFS=$as_save_IFS
2834   test -z "$as_dir" && as_dir=.
2835   for ac_exec_ext in '' $ac_executable_extensions; do
2836   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2837     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2838     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2839     break 2
2840   fi
2841 done
2842 done
2843
2844 fi
2845 fi
2846 CC=$ac_cv_prog_CC
2847 if test -n "$CC"; then
2848   echo "$as_me:$LINENO: result: $CC" >&5
2849 echo "${ECHO_T}$CC" >&6
2850 else
2851   echo "$as_me:$LINENO: result: no" >&5
2852 echo "${ECHO_T}no" >&6
2853 fi
2854
2855 fi
2856 if test -z "$ac_cv_prog_CC"; then
2857   ac_ct_CC=$CC
2858   # Extract the first word of "gcc", so it can be a program name with args.
2859 set dummy gcc; ac_word=$2
2860 echo "$as_me:$LINENO: checking for $ac_word" >&5
2861 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2862 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2863   echo $ECHO_N "(cached) $ECHO_C" >&6
2864 else
2865   if test -n "$ac_ct_CC"; then
2866   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2867 else
2868 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2869 for as_dir in $PATH
2870 do
2871   IFS=$as_save_IFS
2872   test -z "$as_dir" && as_dir=.
2873   for ac_exec_ext in '' $ac_executable_extensions; do
2874   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2875     ac_cv_prog_ac_ct_CC="gcc"
2876     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2877     break 2
2878   fi
2879 done
2880 done
2881
2882 fi
2883 fi
2884 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2885 if test -n "$ac_ct_CC"; then
2886   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2887 echo "${ECHO_T}$ac_ct_CC" >&6
2888 else
2889   echo "$as_me:$LINENO: result: no" >&5
2890 echo "${ECHO_T}no" >&6
2891 fi
2892
2893   CC=$ac_ct_CC
2894 else
2895   CC="$ac_cv_prog_CC"
2896 fi
2897
2898 if test -z "$CC"; then
2899   if test -n "$ac_tool_prefix"; then
2900   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2901 set dummy ${ac_tool_prefix}cc; ac_word=$2
2902 echo "$as_me:$LINENO: checking for $ac_word" >&5
2903 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2904 if test "${ac_cv_prog_CC+set}" = set; then
2905   echo $ECHO_N "(cached) $ECHO_C" >&6
2906 else
2907   if test -n "$CC"; then
2908   ac_cv_prog_CC="$CC" # Let the user override the test.
2909 else
2910 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2911 for as_dir in $PATH
2912 do
2913   IFS=$as_save_IFS
2914   test -z "$as_dir" && as_dir=.
2915   for ac_exec_ext in '' $ac_executable_extensions; do
2916   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2917     ac_cv_prog_CC="${ac_tool_prefix}cc"
2918     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2919     break 2
2920   fi
2921 done
2922 done
2923
2924 fi
2925 fi
2926 CC=$ac_cv_prog_CC
2927 if test -n "$CC"; then
2928   echo "$as_me:$LINENO: result: $CC" >&5
2929 echo "${ECHO_T}$CC" >&6
2930 else
2931   echo "$as_me:$LINENO: result: no" >&5
2932 echo "${ECHO_T}no" >&6
2933 fi
2934
2935 fi
2936 if test -z "$ac_cv_prog_CC"; then
2937   ac_ct_CC=$CC
2938   # Extract the first word of "cc", so it can be a program name with args.
2939 set dummy cc; ac_word=$2
2940 echo "$as_me:$LINENO: checking for $ac_word" >&5
2941 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2942 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2943   echo $ECHO_N "(cached) $ECHO_C" >&6
2944 else
2945   if test -n "$ac_ct_CC"; then
2946   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2947 else
2948 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2949 for as_dir in $PATH
2950 do
2951   IFS=$as_save_IFS
2952   test -z "$as_dir" && as_dir=.
2953   for ac_exec_ext in '' $ac_executable_extensions; do
2954   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2955     ac_cv_prog_ac_ct_CC="cc"
2956     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2957     break 2
2958   fi
2959 done
2960 done
2961
2962 fi
2963 fi
2964 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2965 if test -n "$ac_ct_CC"; then
2966   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2967 echo "${ECHO_T}$ac_ct_CC" >&6
2968 else
2969   echo "$as_me:$LINENO: result: no" >&5
2970 echo "${ECHO_T}no" >&6
2971 fi
2972
2973   CC=$ac_ct_CC
2974 else
2975   CC="$ac_cv_prog_CC"
2976 fi
2977
2978 fi
2979 if test -z "$CC"; then
2980   # Extract the first word of "cc", so it can be a program name with args.
2981 set dummy cc; ac_word=$2
2982 echo "$as_me:$LINENO: checking for $ac_word" >&5
2983 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2984 if test "${ac_cv_prog_CC+set}" = set; then
2985   echo $ECHO_N "(cached) $ECHO_C" >&6
2986 else
2987   if test -n "$CC"; then
2988   ac_cv_prog_CC="$CC" # Let the user override the test.
2989 else
2990   ac_prog_rejected=no
2991 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2992 for as_dir in $PATH
2993 do
2994   IFS=$as_save_IFS
2995   test -z "$as_dir" && as_dir=.
2996   for ac_exec_ext in '' $ac_executable_extensions; do
2997   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2998     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2999        ac_prog_rejected=yes
3000        continue
3001      fi
3002     ac_cv_prog_CC="cc"
3003     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3004     break 2
3005   fi
3006 done
3007 done
3008
3009 if test $ac_prog_rejected = yes; then
3010   # We found a bogon in the path, so make sure we never use it.
3011   set dummy $ac_cv_prog_CC
3012   shift
3013   if test $# != 0; then
3014     # We chose a different compiler from the bogus one.
3015     # However, it has the same basename, so the bogon will be chosen
3016     # first if we set CC to just the basename; use the full file name.
3017     shift
3018     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3019   fi
3020 fi
3021 fi
3022 fi
3023 CC=$ac_cv_prog_CC
3024 if test -n "$CC"; then
3025   echo "$as_me:$LINENO: result: $CC" >&5
3026 echo "${ECHO_T}$CC" >&6
3027 else
3028   echo "$as_me:$LINENO: result: no" >&5
3029 echo "${ECHO_T}no" >&6
3030 fi
3031
3032 fi
3033 if test -z "$CC"; then
3034   if test -n "$ac_tool_prefix"; then
3035   for ac_prog in cl
3036   do
3037     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3038 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3039 echo "$as_me:$LINENO: checking for $ac_word" >&5
3040 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3041 if test "${ac_cv_prog_CC+set}" = set; then
3042   echo $ECHO_N "(cached) $ECHO_C" >&6
3043 else
3044   if test -n "$CC"; then
3045   ac_cv_prog_CC="$CC" # Let the user override the test.
3046 else
3047 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3048 for as_dir in $PATH
3049 do
3050   IFS=$as_save_IFS
3051   test -z "$as_dir" && as_dir=.
3052   for ac_exec_ext in '' $ac_executable_extensions; do
3053   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3054     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3055     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3056     break 2
3057   fi
3058 done
3059 done
3060
3061 fi
3062 fi
3063 CC=$ac_cv_prog_CC
3064 if test -n "$CC"; then
3065   echo "$as_me:$LINENO: result: $CC" >&5
3066 echo "${ECHO_T}$CC" >&6
3067 else
3068   echo "$as_me:$LINENO: result: no" >&5
3069 echo "${ECHO_T}no" >&6
3070 fi
3071
3072     test -n "$CC" && break
3073   done
3074 fi
3075 if test -z "$CC"; then
3076   ac_ct_CC=$CC
3077   for ac_prog in cl
3078 do
3079   # Extract the first word of "$ac_prog", so it can be a program name with args.
3080 set dummy $ac_prog; ac_word=$2
3081 echo "$as_me:$LINENO: checking for $ac_word" >&5
3082 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3083 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3084   echo $ECHO_N "(cached) $ECHO_C" >&6
3085 else
3086   if test -n "$ac_ct_CC"; then
3087   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3088 else
3089 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3090 for as_dir in $PATH
3091 do
3092   IFS=$as_save_IFS
3093   test -z "$as_dir" && as_dir=.
3094   for ac_exec_ext in '' $ac_executable_extensions; do
3095   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3096     ac_cv_prog_ac_ct_CC="$ac_prog"
3097     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3098     break 2
3099   fi
3100 done
3101 done
3102
3103 fi
3104 fi
3105 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3106 if test -n "$ac_ct_CC"; then
3107   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3108 echo "${ECHO_T}$ac_ct_CC" >&6
3109 else
3110   echo "$as_me:$LINENO: result: no" >&5
3111 echo "${ECHO_T}no" >&6
3112 fi
3113
3114   test -n "$ac_ct_CC" && break
3115 done
3116
3117   CC=$ac_ct_CC
3118 fi
3119
3120 fi
3121
3122
3123 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3124 See \`config.log' for more details." >&5
3125 echo "$as_me: error: no acceptable C compiler found in \$PATH
3126 See \`config.log' for more details." >&2;}
3127    { (exit 1); exit 1; }; }
3128
3129 # Provide some information about the compiler.
3130 echo "$as_me:$LINENO:" \
3131      "checking for C compiler version" >&5
3132 ac_compiler=`set X $ac_compile; echo $2`
3133 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3134   (eval $ac_compiler --version </dev/null >&5) 2>&5
3135   ac_status=$?
3136   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3137   (exit $ac_status); }
3138 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3139   (eval $ac_compiler -v </dev/null >&5) 2>&5
3140   ac_status=$?
3141   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3142   (exit $ac_status); }
3143 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3144   (eval $ac_compiler -V </dev/null >&5) 2>&5
3145   ac_status=$?
3146   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3147   (exit $ac_status); }
3148
3149 cat >conftest.$ac_ext <<_ACEOF
3150 /* confdefs.h.  */
3151 _ACEOF
3152 cat confdefs.h >>conftest.$ac_ext
3153 cat >>conftest.$ac_ext <<_ACEOF
3154 /* end confdefs.h.  */
3155
3156 int
3157 main ()
3158 {
3159
3160   ;
3161   return 0;
3162 }
3163 _ACEOF
3164 ac_clean_files_save=$ac_clean_files
3165 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3166 # Try to create an executable without -o first, disregard a.out.
3167 # It will help us diagnose broken compilers, and finding out an intuition
3168 # of exeext.
3169 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3170 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3171 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3172 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3173   (eval $ac_link_default) 2>&5
3174   ac_status=$?
3175   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3176   (exit $ac_status); }; then
3177   # Find the output, starting from the most likely.  This scheme is
3178 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3179 # resort.
3180
3181 # Be careful to initialize this variable, since it used to be cached.
3182 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3183 ac_cv_exeext=
3184 # b.out is created by i960 compilers.
3185 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3186 do
3187   test -f "$ac_file" || continue
3188   case $ac_file in
3189     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3190         ;;
3191     conftest.$ac_ext )
3192         # This is the source file.
3193         ;;
3194     [ab].out )
3195         # We found the default executable, but exeext='' is most
3196         # certainly right.
3197         break;;
3198     *.* )
3199         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3200         # FIXME: I believe we export ac_cv_exeext for Libtool,
3201         # but it would be cool to find out if it's true.  Does anybody
3202         # maintain Libtool? --akim.
3203         export ac_cv_exeext
3204         break;;
3205     * )
3206         break;;
3207   esac
3208 done
3209 else
3210   echo "$as_me: failed program was:" >&5
3211 sed 's/^/| /' conftest.$ac_ext >&5
3212
3213 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3214 See \`config.log' for more details." >&5
3215 echo "$as_me: error: C compiler cannot create executables
3216 See \`config.log' for more details." >&2;}
3217    { (exit 77); exit 77; }; }
3218 fi
3219
3220 ac_exeext=$ac_cv_exeext
3221 echo "$as_me:$LINENO: result: $ac_file" >&5
3222 echo "${ECHO_T}$ac_file" >&6
3223
3224 # Check the compiler produces executables we can run.  If not, either
3225 # the compiler is broken, or we cross compile.
3226 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3227 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3228 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3229 # If not cross compiling, check that we can run a simple program.
3230 if test "$cross_compiling" != yes; then
3231   if { ac_try='./$ac_file'
3232   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3233   (eval $ac_try) 2>&5
3234   ac_status=$?
3235   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3236   (exit $ac_status); }; }; then
3237     cross_compiling=no
3238   else
3239     if test "$cross_compiling" = maybe; then
3240         cross_compiling=yes
3241     else
3242         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3243 If you meant to cross compile, use \`--host'.
3244 See \`config.log' for more details." >&5
3245 echo "$as_me: error: cannot run C compiled programs.
3246 If you meant to cross compile, use \`--host'.
3247 See \`config.log' for more details." >&2;}
3248    { (exit 1); exit 1; }; }
3249     fi
3250   fi
3251 fi
3252 echo "$as_me:$LINENO: result: yes" >&5
3253 echo "${ECHO_T}yes" >&6
3254
3255 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3256 ac_clean_files=$ac_clean_files_save
3257 # Check the compiler produces executables we can run.  If not, either
3258 # the compiler is broken, or we cross compile.
3259 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3260 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3261 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3262 echo "${ECHO_T}$cross_compiling" >&6
3263
3264 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3265 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3266 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3267   (eval $ac_link) 2>&5
3268   ac_status=$?
3269   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3270   (exit $ac_status); }; then
3271   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3272 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3273 # work properly (i.e., refer to `conftest.exe'), while it won't with
3274 # `rm'.
3275 for ac_file in conftest.exe conftest conftest.*; do
3276   test -f "$ac_file" || continue
3277   case $ac_file in
3278     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3279     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3280           export ac_cv_exeext
3281           break;;
3282     * ) break;;
3283   esac
3284 done
3285 else
3286   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3287 See \`config.log' for more details." >&5
3288 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3289 See \`config.log' for more details." >&2;}
3290    { (exit 1); exit 1; }; }
3291 fi
3292
3293 rm -f conftest$ac_cv_exeext
3294 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3295 echo "${ECHO_T}$ac_cv_exeext" >&6
3296
3297 rm -f conftest.$ac_ext
3298 EXEEXT=$ac_cv_exeext
3299 ac_exeext=$EXEEXT
3300 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3301 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3302 if test "${ac_cv_objext+set}" = set; then
3303   echo $ECHO_N "(cached) $ECHO_C" >&6
3304 else
3305   cat >conftest.$ac_ext <<_ACEOF
3306 /* confdefs.h.  */
3307 _ACEOF
3308 cat confdefs.h >>conftest.$ac_ext
3309 cat >>conftest.$ac_ext <<_ACEOF
3310 /* end confdefs.h.  */
3311
3312 int
3313 main ()
3314 {
3315
3316   ;
3317   return 0;
3318 }
3319 _ACEOF
3320 rm -f conftest.o conftest.obj
3321 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3322   (eval $ac_compile) 2>&5
3323   ac_status=$?
3324   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3325   (exit $ac_status); }; then
3326   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3327   case $ac_file in
3328     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3329     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3330        break;;
3331   esac
3332 done
3333 else
3334   echo "$as_me: failed program was:" >&5
3335 sed 's/^/| /' conftest.$ac_ext >&5
3336
3337 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3338 See \`config.log' for more details." >&5
3339 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3340 See \`config.log' for more details." >&2;}
3341    { (exit 1); exit 1; }; }
3342 fi
3343
3344 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3345 fi
3346 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3347 echo "${ECHO_T}$ac_cv_objext" >&6
3348 OBJEXT=$ac_cv_objext
3349 ac_objext=$OBJEXT
3350 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3351 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3352 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3353   echo $ECHO_N "(cached) $ECHO_C" >&6
3354 else
3355   cat >conftest.$ac_ext <<_ACEOF
3356 /* confdefs.h.  */
3357 _ACEOF
3358 cat confdefs.h >>conftest.$ac_ext
3359 cat >>conftest.$ac_ext <<_ACEOF
3360 /* end confdefs.h.  */
3361
3362 int
3363 main ()
3364 {
3365 #ifndef __GNUC__
3366        choke me
3367 #endif
3368
3369   ;
3370   return 0;
3371 }
3372 _ACEOF
3373 rm -f conftest.$ac_objext
3374 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3375   (eval $ac_compile) 2>conftest.er1
3376   ac_status=$?
3377   grep -v '^ *+' conftest.er1 >conftest.err
3378   rm -f conftest.er1
3379   cat conftest.err >&5
3380   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3381   (exit $ac_status); } &&
3382          { ac_try='test -z "$ac_c_werror_flag"
3383                          || test ! -s conftest.err'
3384   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3385   (eval $ac_try) 2>&5
3386   ac_status=$?
3387   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3388   (exit $ac_status); }; } &&
3389          { ac_try='test -s conftest.$ac_objext'
3390   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3391   (eval $ac_try) 2>&5
3392   ac_status=$?
3393   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3394   (exit $ac_status); }; }; then
3395   ac_compiler_gnu=yes
3396 else
3397   echo "$as_me: failed program was:" >&5
3398 sed 's/^/| /' conftest.$ac_ext >&5
3399
3400 ac_compiler_gnu=no
3401 fi
3402 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3403 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3404
3405 fi
3406 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3407 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3408 GCC=`test $ac_compiler_gnu = yes && echo yes`
3409 ac_test_CFLAGS=${CFLAGS+set}
3410 ac_save_CFLAGS=$CFLAGS
3411 CFLAGS="-g"
3412 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3413 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3414 if test "${ac_cv_prog_cc_g+set}" = set; then
3415   echo $ECHO_N "(cached) $ECHO_C" >&6
3416 else
3417   cat >conftest.$ac_ext <<_ACEOF
3418 /* confdefs.h.  */
3419 _ACEOF
3420 cat confdefs.h >>conftest.$ac_ext
3421 cat >>conftest.$ac_ext <<_ACEOF
3422 /* end confdefs.h.  */
3423
3424 int
3425 main ()
3426 {
3427
3428   ;
3429   return 0;
3430 }
3431 _ACEOF
3432 rm -f conftest.$ac_objext
3433 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3434   (eval $ac_compile) 2>conftest.er1
3435   ac_status=$?
3436   grep -v '^ *+' conftest.er1 >conftest.err
3437   rm -f conftest.er1
3438   cat conftest.err >&5
3439   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3440   (exit $ac_status); } &&
3441          { ac_try='test -z "$ac_c_werror_flag"
3442                          || test ! -s conftest.err'
3443   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3444   (eval $ac_try) 2>&5
3445   ac_status=$?
3446   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3447   (exit $ac_status); }; } &&
3448          { ac_try='test -s conftest.$ac_objext'
3449   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3450   (eval $ac_try) 2>&5
3451   ac_status=$?
3452   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3453   (exit $ac_status); }; }; then
3454   ac_cv_prog_cc_g=yes
3455 else
3456   echo "$as_me: failed program was:" >&5
3457 sed 's/^/| /' conftest.$ac_ext >&5
3458
3459 ac_cv_prog_cc_g=no
3460 fi
3461 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3462 fi
3463 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3464 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3465 if test "$ac_test_CFLAGS" = set; then
3466   CFLAGS=$ac_save_CFLAGS
3467 elif test $ac_cv_prog_cc_g = yes; then
3468   if test "$GCC" = yes; then
3469     CFLAGS="-g -O2"
3470   else
3471     CFLAGS="-g"
3472   fi
3473 else
3474   if test "$GCC" = yes; then
3475     CFLAGS="-O2"
3476   else
3477     CFLAGS=
3478   fi
3479 fi
3480 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3481 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3482 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3483   echo $ECHO_N "(cached) $ECHO_C" >&6
3484 else
3485   ac_cv_prog_cc_stdc=no
3486 ac_save_CC=$CC
3487 cat >conftest.$ac_ext <<_ACEOF
3488 /* confdefs.h.  */
3489 _ACEOF
3490 cat confdefs.h >>conftest.$ac_ext
3491 cat >>conftest.$ac_ext <<_ACEOF
3492 /* end confdefs.h.  */
3493 #include <stdarg.h>
3494 #include <stdio.h>
3495 #include <sys/types.h>
3496 #include <sys/stat.h>
3497 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3498 struct buf { int x; };
3499 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3500 static char *e (p, i)
3501      char **p;
3502      int i;
3503 {
3504   return p[i];
3505 }
3506 static char *f (char * (*g) (char **, int), char **p, ...)
3507 {
3508   char *s;
3509   va_list v;
3510   va_start (v,p);
3511   s = g (p, va_arg (v,int));
3512   va_end (v);
3513   return s;
3514 }
3515
3516 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3517    function prototypes and stuff, but not '\xHH' hex character constants.
3518    These don't provoke an error unfortunately, instead are silently treated
3519    as 'x'.  The following induces an error, until -std1 is added to get
3520    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3521    array size at least.  It's necessary to write '\x00'==0 to get something
3522    that's true only with -std1.  */
3523 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3524
3525 int test (int i, double x);
3526 struct s1 {int (*f) (int a);};
3527 struct s2 {int (*f) (double a);};
3528 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3529 int argc;
3530 char **argv;
3531 int
3532 main ()
3533 {
3534 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3535   ;
3536   return 0;
3537 }
3538 _ACEOF
3539 # Don't try gcc -ansi; that turns off useful extensions and
3540 # breaks some systems' header files.
3541 # AIX                   -qlanglvl=ansi
3542 # Ultrix and OSF/1      -std1
3543 # HP-UX 10.20 and later -Ae
3544 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3545 # SVR4                  -Xc -D__EXTENSIONS__
3546 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3547 do
3548   CC="$ac_save_CC $ac_arg"
3549   rm -f conftest.$ac_objext
3550 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3551   (eval $ac_compile) 2>conftest.er1
3552   ac_status=$?
3553   grep -v '^ *+' conftest.er1 >conftest.err
3554   rm -f conftest.er1
3555   cat conftest.err >&5
3556   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3557   (exit $ac_status); } &&
3558          { ac_try='test -z "$ac_c_werror_flag"
3559                          || test ! -s conftest.err'
3560   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3561   (eval $ac_try) 2>&5
3562   ac_status=$?
3563   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3564   (exit $ac_status); }; } &&
3565          { ac_try='test -s conftest.$ac_objext'
3566   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3567   (eval $ac_try) 2>&5
3568   ac_status=$?
3569   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3570   (exit $ac_status); }; }; then
3571   ac_cv_prog_cc_stdc=$ac_arg
3572 break
3573 else
3574   echo "$as_me: failed program was:" >&5
3575 sed 's/^/| /' conftest.$ac_ext >&5
3576
3577 fi
3578 rm -f conftest.err conftest.$ac_objext
3579 done
3580 rm -f conftest.$ac_ext conftest.$ac_objext
3581 CC=$ac_save_CC
3582
3583 fi
3584
3585 case "x$ac_cv_prog_cc_stdc" in
3586   x|xno)
3587     echo "$as_me:$LINENO: result: none needed" >&5
3588 echo "${ECHO_T}none needed" >&6 ;;
3589   *)
3590     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3591 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3592     CC="$CC $ac_cv_prog_cc_stdc" ;;
3593 esac
3594
3595 # Some people use a C++ compiler to compile C.  Since we use `exit',
3596 # in C++ we need to declare it.  In case someone uses the same compiler
3597 # for both compiling C and C++ we need to have the C++ compiler decide
3598 # the declaration of exit, since it's the most demanding environment.
3599 cat >conftest.$ac_ext <<_ACEOF
3600 #ifndef __cplusplus
3601   choke me
3602 #endif
3603 _ACEOF
3604 rm -f conftest.$ac_objext
3605 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3606   (eval $ac_compile) 2>conftest.er1
3607   ac_status=$?
3608   grep -v '^ *+' conftest.er1 >conftest.err
3609   rm -f conftest.er1
3610   cat conftest.err >&5
3611   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3612   (exit $ac_status); } &&
3613          { ac_try='test -z "$ac_c_werror_flag"
3614                          || test ! -s conftest.err'
3615   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3616   (eval $ac_try) 2>&5
3617   ac_status=$?
3618   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3619   (exit $ac_status); }; } &&
3620          { ac_try='test -s conftest.$ac_objext'
3621   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3622   (eval $ac_try) 2>&5
3623   ac_status=$?
3624   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3625   (exit $ac_status); }; }; then
3626   for ac_declaration in \
3627    '' \
3628    'extern "C" void std::exit (int) throw (); using std::exit;' \
3629    'extern "C" void std::exit (int); using std::exit;' \
3630    'extern "C" void exit (int) throw ();' \
3631    'extern "C" void exit (int);' \
3632    'void exit (int);'
3633 do
3634   cat >conftest.$ac_ext <<_ACEOF
3635 /* confdefs.h.  */
3636 _ACEOF
3637 cat confdefs.h >>conftest.$ac_ext
3638 cat >>conftest.$ac_ext <<_ACEOF
3639 /* end confdefs.h.  */
3640 $ac_declaration
3641 #include <stdlib.h>
3642 int
3643 main ()
3644 {
3645 exit (42);
3646   ;
3647   return 0;
3648 }
3649 _ACEOF
3650 rm -f conftest.$ac_objext
3651 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3652   (eval $ac_compile) 2>conftest.er1
3653   ac_status=$?
3654   grep -v '^ *+' conftest.er1 >conftest.err
3655   rm -f conftest.er1
3656   cat conftest.err >&5
3657   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3658   (exit $ac_status); } &&
3659          { ac_try='test -z "$ac_c_werror_flag"
3660                          || test ! -s conftest.err'
3661   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3662   (eval $ac_try) 2>&5
3663   ac_status=$?
3664   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3665   (exit $ac_status); }; } &&
3666          { ac_try='test -s conftest.$ac_objext'
3667   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3668   (eval $ac_try) 2>&5
3669   ac_status=$?
3670   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3671   (exit $ac_status); }; }; then
3672   :
3673 else
3674   echo "$as_me: failed program was:" >&5
3675 sed 's/^/| /' conftest.$ac_ext >&5
3676
3677 continue
3678 fi
3679 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3680   cat >conftest.$ac_ext <<_ACEOF
3681 /* confdefs.h.  */
3682 _ACEOF
3683 cat confdefs.h >>conftest.$ac_ext
3684 cat >>conftest.$ac_ext <<_ACEOF
3685 /* end confdefs.h.  */
3686 $ac_declaration
3687 int
3688 main ()
3689 {
3690 exit (42);
3691   ;
3692   return 0;
3693 }
3694 _ACEOF
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   break
3718 else
3719   echo "$as_me: failed program was:" >&5
3720 sed 's/^/| /' conftest.$ac_ext >&5
3721
3722 fi
3723 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3724 done
3725 rm -f conftest*
3726 if test -n "$ac_declaration"; then
3727   echo '#ifdef __cplusplus' >>confdefs.h
3728   echo $ac_declaration      >>confdefs.h
3729   echo '#endif'             >>confdefs.h
3730 fi
3731
3732 else
3733   echo "$as_me: failed program was:" >&5
3734 sed 's/^/| /' conftest.$ac_ext >&5
3735
3736 fi
3737 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3738 ac_ext=c
3739 ac_cpp='$CPP $CPPFLAGS'
3740 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3741 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3742 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3743
3744 ac_ext=cc
3745 ac_cpp='$CXXCPP $CPPFLAGS'
3746 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3747 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3748 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3749 if test -n "$ac_tool_prefix"; then
3750   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3751   do
3752     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3753 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3754 echo "$as_me:$LINENO: checking for $ac_word" >&5
3755 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3756 if test "${ac_cv_prog_CXX+set}" = set; then
3757   echo $ECHO_N "(cached) $ECHO_C" >&6
3758 else
3759   if test -n "$CXX"; then
3760   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3761 else
3762 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3763 for as_dir in $PATH
3764 do
3765   IFS=$as_save_IFS
3766   test -z "$as_dir" && as_dir=.
3767   for ac_exec_ext in '' $ac_executable_extensions; do
3768   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3769     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3770     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3771     break 2
3772   fi
3773 done
3774 done
3775
3776 fi
3777 fi
3778 CXX=$ac_cv_prog_CXX
3779 if test -n "$CXX"; then
3780   echo "$as_me:$LINENO: result: $CXX" >&5
3781 echo "${ECHO_T}$CXX" >&6
3782 else
3783   echo "$as_me:$LINENO: result: no" >&5
3784 echo "${ECHO_T}no" >&6
3785 fi
3786
3787     test -n "$CXX" && break
3788   done
3789 fi
3790 if test -z "$CXX"; then
3791   ac_ct_CXX=$CXX
3792   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3793 do
3794   # Extract the first word of "$ac_prog", so it can be a program name with args.
3795 set dummy $ac_prog; ac_word=$2
3796 echo "$as_me:$LINENO: checking for $ac_word" >&5
3797 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3798 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3799   echo $ECHO_N "(cached) $ECHO_C" >&6
3800 else
3801   if test -n "$ac_ct_CXX"; then
3802   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3803 else
3804 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3805 for as_dir in $PATH
3806 do
3807   IFS=$as_save_IFS
3808   test -z "$as_dir" && as_dir=.
3809   for ac_exec_ext in '' $ac_executable_extensions; do
3810   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3811     ac_cv_prog_ac_ct_CXX="$ac_prog"
3812     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3813     break 2
3814   fi
3815 done
3816 done
3817
3818 fi
3819 fi
3820 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3821 if test -n "$ac_ct_CXX"; then
3822   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3823 echo "${ECHO_T}$ac_ct_CXX" >&6
3824 else
3825   echo "$as_me:$LINENO: result: no" >&5
3826 echo "${ECHO_T}no" >&6
3827 fi
3828
3829   test -n "$ac_ct_CXX" && break
3830 done
3831 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3832
3833   CXX=$ac_ct_CXX
3834 fi
3835
3836
3837 # Provide some information about the compiler.
3838 echo "$as_me:$LINENO:" \
3839      "checking for C++ compiler version" >&5
3840 ac_compiler=`set X $ac_compile; echo $2`
3841 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3842   (eval $ac_compiler --version </dev/null >&5) 2>&5
3843   ac_status=$?
3844   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3845   (exit $ac_status); }
3846 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3847   (eval $ac_compiler -v </dev/null >&5) 2>&5
3848   ac_status=$?
3849   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3850   (exit $ac_status); }
3851 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3852   (eval $ac_compiler -V </dev/null >&5) 2>&5
3853   ac_status=$?
3854   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3855   (exit $ac_status); }
3856
3857 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3858 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3859 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3860   echo $ECHO_N "(cached) $ECHO_C" >&6
3861 else
3862   cat >conftest.$ac_ext <<_ACEOF
3863 /* confdefs.h.  */
3864 _ACEOF
3865 cat confdefs.h >>conftest.$ac_ext
3866 cat >>conftest.$ac_ext <<_ACEOF
3867 /* end confdefs.h.  */
3868
3869 int
3870 main ()
3871 {
3872 #ifndef __GNUC__
3873        choke me
3874 #endif
3875
3876   ;
3877   return 0;
3878 }
3879 _ACEOF
3880 rm -f conftest.$ac_objext
3881 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3882   (eval $ac_compile) 2>conftest.er1
3883   ac_status=$?
3884   grep -v '^ *+' conftest.er1 >conftest.err
3885   rm -f conftest.er1
3886   cat conftest.err >&5
3887   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3888   (exit $ac_status); } &&
3889          { ac_try='test -z "$ac_cxx_werror_flag"
3890                          || test ! -s conftest.err'
3891   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3892   (eval $ac_try) 2>&5
3893   ac_status=$?
3894   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3895   (exit $ac_status); }; } &&
3896          { ac_try='test -s conftest.$ac_objext'
3897   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3898   (eval $ac_try) 2>&5
3899   ac_status=$?
3900   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3901   (exit $ac_status); }; }; then
3902   ac_compiler_gnu=yes
3903 else
3904   echo "$as_me: failed program was:" >&5
3905 sed 's/^/| /' conftest.$ac_ext >&5
3906
3907 ac_compiler_gnu=no
3908 fi
3909 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3910 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3911
3912 fi
3913 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3914 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3915 GXX=`test $ac_compiler_gnu = yes && echo yes`
3916 ac_test_CXXFLAGS=${CXXFLAGS+set}
3917 ac_save_CXXFLAGS=$CXXFLAGS
3918 CXXFLAGS="-g"
3919 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3920 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3921 if test "${ac_cv_prog_cxx_g+set}" = set; then
3922   echo $ECHO_N "(cached) $ECHO_C" >&6
3923 else
3924   cat >conftest.$ac_ext <<_ACEOF
3925 /* confdefs.h.  */
3926 _ACEOF
3927 cat confdefs.h >>conftest.$ac_ext
3928 cat >>conftest.$ac_ext <<_ACEOF
3929 /* end confdefs.h.  */
3930
3931 int
3932 main ()
3933 {
3934
3935   ;
3936   return 0;
3937 }
3938 _ACEOF
3939 rm -f conftest.$ac_objext
3940 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3941   (eval $ac_compile) 2>conftest.er1
3942   ac_status=$?
3943   grep -v '^ *+' conftest.er1 >conftest.err
3944   rm -f conftest.er1
3945   cat conftest.err >&5
3946   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3947   (exit $ac_status); } &&
3948          { ac_try='test -z "$ac_cxx_werror_flag"
3949                          || test ! -s conftest.err'
3950   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3951   (eval $ac_try) 2>&5
3952   ac_status=$?
3953   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3954   (exit $ac_status); }; } &&
3955          { ac_try='test -s conftest.$ac_objext'
3956   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3957   (eval $ac_try) 2>&5
3958   ac_status=$?
3959   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3960   (exit $ac_status); }; }; then
3961   ac_cv_prog_cxx_g=yes
3962 else
3963   echo "$as_me: failed program was:" >&5
3964 sed 's/^/| /' conftest.$ac_ext >&5
3965
3966 ac_cv_prog_cxx_g=no
3967 fi
3968 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3969 fi
3970 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3971 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
3972 if test "$ac_test_CXXFLAGS" = set; then
3973   CXXFLAGS=$ac_save_CXXFLAGS
3974 elif test $ac_cv_prog_cxx_g = yes; then
3975   if test "$GXX" = yes; then
3976     CXXFLAGS="-g -O2"
3977   else
3978     CXXFLAGS="-g"
3979   fi
3980 else
3981   if test "$GXX" = yes; then
3982     CXXFLAGS="-O2"
3983   else
3984     CXXFLAGS=
3985   fi
3986 fi
3987 for ac_declaration in \
3988    '' \
3989    'extern "C" void std::exit (int) throw (); using std::exit;' \
3990    'extern "C" void std::exit (int); using std::exit;' \
3991    'extern "C" void exit (int) throw ();' \
3992    'extern "C" void exit (int);' \
3993    'void exit (int);'
3994 do
3995   cat >conftest.$ac_ext <<_ACEOF
3996 /* confdefs.h.  */
3997 _ACEOF
3998 cat confdefs.h >>conftest.$ac_ext
3999 cat >>conftest.$ac_ext <<_ACEOF
4000 /* end confdefs.h.  */
4001 $ac_declaration
4002 #include <stdlib.h>
4003 int
4004 main ()
4005 {
4006 exit (42);
4007   ;
4008   return 0;
4009 }
4010 _ACEOF
4011 rm -f conftest.$ac_objext
4012 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4013   (eval $ac_compile) 2>conftest.er1
4014   ac_status=$?
4015   grep -v '^ *+' conftest.er1 >conftest.err
4016   rm -f conftest.er1
4017   cat conftest.err >&5
4018   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4019   (exit $ac_status); } &&
4020          { ac_try='test -z "$ac_cxx_werror_flag"
4021                          || test ! -s conftest.err'
4022   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4023   (eval $ac_try) 2>&5
4024   ac_status=$?
4025   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4026   (exit $ac_status); }; } &&
4027          { ac_try='test -s conftest.$ac_objext'
4028   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4029   (eval $ac_try) 2>&5
4030   ac_status=$?
4031   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4032   (exit $ac_status); }; }; then
4033   :
4034 else
4035   echo "$as_me: failed program was:" >&5
4036 sed 's/^/| /' conftest.$ac_ext >&5
4037
4038 continue
4039 fi
4040 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4041   cat >conftest.$ac_ext <<_ACEOF
4042 /* confdefs.h.  */
4043 _ACEOF
4044 cat confdefs.h >>conftest.$ac_ext
4045 cat >>conftest.$ac_ext <<_ACEOF
4046 /* end confdefs.h.  */
4047 $ac_declaration
4048 int
4049 main ()
4050 {
4051 exit (42);
4052   ;
4053   return 0;
4054 }
4055 _ACEOF
4056 rm -f conftest.$ac_objext
4057 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4058   (eval $ac_compile) 2>conftest.er1
4059   ac_status=$?
4060   grep -v '^ *+' conftest.er1 >conftest.err
4061   rm -f conftest.er1
4062   cat conftest.err >&5
4063   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4064   (exit $ac_status); } &&
4065          { ac_try='test -z "$ac_cxx_werror_flag"
4066                          || test ! -s conftest.err'
4067   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4068   (eval $ac_try) 2>&5
4069   ac_status=$?
4070   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4071   (exit $ac_status); }; } &&
4072          { ac_try='test -s conftest.$ac_objext'
4073   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4074   (eval $ac_try) 2>&5
4075   ac_status=$?
4076   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4077   (exit $ac_status); }; }; then
4078   break
4079 else
4080   echo "$as_me: failed program was:" >&5
4081 sed 's/^/| /' conftest.$ac_ext >&5
4082
4083 fi
4084 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4085 done
4086 rm -f conftest*
4087 if test -n "$ac_declaration"; then
4088   echo '#ifdef __cplusplus' >>confdefs.h
4089   echo $ac_declaration      >>confdefs.h
4090   echo '#endif'             >>confdefs.h
4091 fi
4092
4093 ac_ext=c
4094 ac_cpp='$CPP $CPPFLAGS'
4095 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4096 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4097 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4098
4099
4100 # We must set the default linker to the linker used by gcc for the correct
4101 # operation of libtool.  If LD is not defined and we are using gcc, try to
4102 # set the LD default to the ld used by gcc.
4103 if test -z "$LD"; then
4104   if test "$GCC" = yes; then
4105     case $build in
4106     *-*-mingw*)
4107       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4108     *)
4109       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4110     esac
4111     case $gcc_prog_ld in
4112     # Accept absolute paths.
4113     [\\/]* | [A-Za-z]:[\\/]*)
4114       LD="$gcc_prog_ld" ;;
4115     esac
4116   fi
4117 fi
4118
4119
4120
4121
4122 if test -n "$ac_tool_prefix"; then
4123   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4124 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4125 echo "$as_me:$LINENO: checking for $ac_word" >&5
4126 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4127 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4128   echo $ECHO_N "(cached) $ECHO_C" >&6
4129 else
4130   if test -n "$GNATBIND"; then
4131   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4132 else
4133 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4134 for as_dir in $PATH
4135 do
4136   IFS=$as_save_IFS
4137   test -z "$as_dir" && as_dir=.
4138   for ac_exec_ext in '' $ac_executable_extensions; do
4139   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4140     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4141     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4142     break 2
4143   fi
4144 done
4145 done
4146
4147 fi
4148 fi
4149 GNATBIND=$ac_cv_prog_GNATBIND
4150 if test -n "$GNATBIND"; then
4151   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4152 echo "${ECHO_T}$GNATBIND" >&6
4153 else
4154   echo "$as_me:$LINENO: result: no" >&5
4155 echo "${ECHO_T}no" >&6
4156 fi
4157
4158 fi
4159 if test -z "$ac_cv_prog_GNATBIND"; then
4160   ac_ct_GNATBIND=$GNATBIND
4161   # Extract the first word of "gnatbind", so it can be a program name with args.
4162 set dummy gnatbind; ac_word=$2
4163 echo "$as_me:$LINENO: checking for $ac_word" >&5
4164 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4165 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4166   echo $ECHO_N "(cached) $ECHO_C" >&6
4167 else
4168   if test -n "$ac_ct_GNATBIND"; then
4169   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4170 else
4171 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4172 for as_dir in $PATH
4173 do
4174   IFS=$as_save_IFS
4175   test -z "$as_dir" && as_dir=.
4176   for ac_exec_ext in '' $ac_executable_extensions; do
4177   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4178     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4179     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4180     break 2
4181   fi
4182 done
4183 done
4184
4185   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4186 fi
4187 fi
4188 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4189 if test -n "$ac_ct_GNATBIND"; then
4190   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4191 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4192 else
4193   echo "$as_me:$LINENO: result: no" >&5
4194 echo "${ECHO_T}no" >&6
4195 fi
4196
4197   GNATBIND=$ac_ct_GNATBIND
4198 else
4199   GNATBIND="$ac_cv_prog_GNATBIND"
4200 fi
4201
4202 if test -n "$ac_tool_prefix"; then
4203   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4204 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4205 echo "$as_me:$LINENO: checking for $ac_word" >&5
4206 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4207 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4208   echo $ECHO_N "(cached) $ECHO_C" >&6
4209 else
4210   if test -n "$GNATMAKE"; then
4211   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4212 else
4213 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4214 for as_dir in $PATH
4215 do
4216   IFS=$as_save_IFS
4217   test -z "$as_dir" && as_dir=.
4218   for ac_exec_ext in '' $ac_executable_extensions; do
4219   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4220     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4221     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4222     break 2
4223   fi
4224 done
4225 done
4226
4227 fi
4228 fi
4229 GNATMAKE=$ac_cv_prog_GNATMAKE
4230 if test -n "$GNATMAKE"; then
4231   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4232 echo "${ECHO_T}$GNATMAKE" >&6
4233 else
4234   echo "$as_me:$LINENO: result: no" >&5
4235 echo "${ECHO_T}no" >&6
4236 fi
4237
4238 fi
4239 if test -z "$ac_cv_prog_GNATMAKE"; then
4240   ac_ct_GNATMAKE=$GNATMAKE
4241   # Extract the first word of "gnatmake", so it can be a program name with args.
4242 set dummy gnatmake; ac_word=$2
4243 echo "$as_me:$LINENO: checking for $ac_word" >&5
4244 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4245 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4246   echo $ECHO_N "(cached) $ECHO_C" >&6
4247 else
4248   if test -n "$ac_ct_GNATMAKE"; then
4249   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4250 else
4251 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4252 for as_dir in $PATH
4253 do
4254   IFS=$as_save_IFS
4255   test -z "$as_dir" && as_dir=.
4256   for ac_exec_ext in '' $ac_executable_extensions; do
4257   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4258     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4259     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4260     break 2
4261   fi
4262 done
4263 done
4264
4265   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4266 fi
4267 fi
4268 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4269 if test -n "$ac_ct_GNATMAKE"; then
4270   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4271 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4272 else
4273   echo "$as_me:$LINENO: result: no" >&5
4274 echo "${ECHO_T}no" >&6
4275 fi
4276
4277   GNATMAKE=$ac_ct_GNATMAKE
4278 else
4279   GNATMAKE="$ac_cv_prog_GNATMAKE"
4280 fi
4281
4282 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4283 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4284 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4285   echo $ECHO_N "(cached) $ECHO_C" >&6
4286 else
4287   cat >conftest.adb <<EOF
4288 procedure conftest is begin null; end conftest;
4289 EOF
4290 acx_cv_cc_gcc_supports_ada=no
4291 # There is a bug in old released versions of GCC which causes the
4292 # driver to exit successfully when the appropriate language module
4293 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4294 # Therefore we must check for the error message as well as an
4295 # unsuccessful exit.
4296 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4297 # given a .adb file, but produce no object file.  So we must check
4298 # if an object file was really produced to guard against this.
4299 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4300 if test x"$errors" = x && test -f conftest.$ac_objext; then
4301   acx_cv_cc_gcc_supports_ada=yes
4302 fi
4303 rm -f conftest.*
4304 fi
4305 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4306 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4307
4308 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4309   have_gnat=yes
4310 else
4311   have_gnat=no
4312 fi
4313
4314 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4315 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4316 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4317   echo $ECHO_N "(cached) $ECHO_C" >&6
4318 else
4319    echo abfoo >t1
4320   echo cdfoo >t2
4321   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4322   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4323     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4324       :
4325     else
4326       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4327     fi
4328   fi
4329   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4330     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4331       :
4332     else
4333       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4334     fi
4335   fi
4336   rm t1 t2
4337
4338 fi
4339 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4340 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4341 do_compare="$gcc_cv_prog_cmp_skip"
4342
4343
4344
4345 # Check for GMP and MPFR
4346 gmplibs="-lmpfr -lgmp"
4347 gmpinc=
4348 have_gmp=no
4349
4350 # Specify a location for mpfr
4351 # check for this first so it ends up on the link line before gmp.
4352
4353 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4354 if test "${with_mpfr_dir+set}" = set; then
4355   withval="$with_mpfr_dir"
4356   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4357 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4358 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4359 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4360    { (exit 1); exit 1; }; }
4361 fi;
4362
4363
4364 # Check whether --with-mpfr or --without-mpfr was given.
4365 if test "${with_mpfr+set}" = set; then
4366   withval="$with_mpfr"
4367
4368 fi;
4369
4370 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4371 if test "${with_mpfr_include+set}" = set; then
4372   withval="$with_mpfr_include"
4373
4374 fi;
4375
4376 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4377 if test "${with_mpfr_lib+set}" = set; then
4378   withval="$with_mpfr_lib"
4379
4380 fi;
4381
4382 if test "x$with_mpfr" != x; then
4383   gmplibs="-L$with_mpfr/lib $gmplibs"
4384   gmpinc="-I$with_mpfr/include"
4385 fi
4386 if test "x$with_mpfr_include" != x; then
4387   gmpinc="-I$with_mpfr_include"
4388 fi
4389 if test "x$with_mpfr_lib" != x; then
4390   gmplibs="-L$with_mpfr_lib $gmplibs"
4391 fi
4392 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4393   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4394   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4395   # Do not test the mpfr version.  Assume that it is sufficient, since
4396   # it is in the source tree, and the library has not been built yet
4397   # but it would be included on the link line in the version check below
4398   # hence making the test fail.
4399   have_gmp=yes
4400 fi
4401
4402 # Specify a location for gmp
4403
4404 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4405 if test "${with_gmp_dir+set}" = set; then
4406   withval="$with_gmp_dir"
4407   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4408 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4409 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4410 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4411    { (exit 1); exit 1; }; }
4412 fi;
4413
4414
4415 # Check whether --with-gmp or --without-gmp was given.
4416 if test "${with_gmp+set}" = set; then
4417   withval="$with_gmp"
4418
4419 fi;
4420
4421 # Check whether --with-gmp_include or --without-gmp_include was given.
4422 if test "${with_gmp_include+set}" = set; then
4423   withval="$with_gmp_include"
4424
4425 fi;
4426
4427 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4428 if test "${with_gmp_lib+set}" = set; then
4429   withval="$with_gmp_lib"
4430
4431 fi;
4432
4433
4434 if test "x$with_gmp" != x; then
4435   gmplibs="-L$with_gmp/lib $gmplibs"
4436   gmpinc="-I$with_gmp/include $gmpinc"
4437 fi
4438 if test "x$with_gmp_include" != x; then
4439   gmpinc="-I$with_gmp_include $gmpinc"
4440 fi
4441 if test "x$with_gmp_lib" != x; then
4442   gmplibs="-L$with_gmp_lib $gmplibs"
4443 fi
4444 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4445   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4446   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4447   # Do not test the gmp version.  Assume that it is sufficient, since
4448   # it is in the source tree, and the library has not been built yet
4449   # but it would be included on the link line in the version check below
4450   # hence making the test fail.
4451   have_gmp=yes
4452 fi
4453
4454 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4455   have_gmp=yes
4456   saved_CFLAGS="$CFLAGS"
4457   CFLAGS="$CFLAGS $gmpinc"
4458   # Check GMP actually works
4459   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4460 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4461
4462 cat >conftest.$ac_ext <<_ACEOF
4463 /* confdefs.h.  */
4464 _ACEOF
4465 cat confdefs.h >>conftest.$ac_ext
4466 cat >>conftest.$ac_ext <<_ACEOF
4467 /* end confdefs.h.  */
4468 #include "gmp.h"
4469 int
4470 main ()
4471 {
4472
4473   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4474   choke me
4475   #endif
4476
4477   ;
4478   return 0;
4479 }
4480 _ACEOF
4481 rm -f conftest.$ac_objext
4482 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4483   (eval $ac_compile) 2>conftest.er1
4484   ac_status=$?
4485   grep -v '^ *+' conftest.er1 >conftest.err
4486   rm -f conftest.er1
4487   cat conftest.err >&5
4488   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4489   (exit $ac_status); } &&
4490          { ac_try='test -z "$ac_c_werror_flag"
4491                          || test ! -s conftest.err'
4492   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4493   (eval $ac_try) 2>&5
4494   ac_status=$?
4495   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4496   (exit $ac_status); }; } &&
4497          { ac_try='test -s conftest.$ac_objext'
4498   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4499   (eval $ac_try) 2>&5
4500   ac_status=$?
4501   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4502   (exit $ac_status); }; }; then
4503   echo "$as_me:$LINENO: result: yes" >&5
4504 echo "${ECHO_T}yes" >&6
4505 else
4506   echo "$as_me: failed program was:" >&5
4507 sed 's/^/| /' conftest.$ac_ext >&5
4508
4509 echo "$as_me:$LINENO: result: no" >&5
4510 echo "${ECHO_T}no" >&6; have_gmp=no
4511 fi
4512 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4513
4514   if test x"$have_gmp" = xyes; then
4515     saved_LIBS="$LIBS"
4516     LIBS="$LIBS $gmplibs"
4517         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4518 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4519     cat >conftest.$ac_ext <<_ACEOF
4520 /* confdefs.h.  */
4521 _ACEOF
4522 cat confdefs.h >>conftest.$ac_ext
4523 cat >>conftest.$ac_ext <<_ACEOF
4524 /* end confdefs.h.  */
4525 #include <gmp.h>
4526     #include <mpfr.h>
4527 int
4528 main ()
4529 {
4530
4531     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,0)
4532     choke me
4533     #endif
4534     mpfr_t n;
4535     mpfr_t x;
4536     int t;
4537     mpfr_init (n);
4538     mpfr_init (x);
4539     mpfr_atan2 (n, n, x, GMP_RNDN);
4540     mpfr_erfc (n, x, GMP_RNDN);
4541     mpfr_subnormalize (x, t, GMP_RNDN);
4542
4543   ;
4544   return 0;
4545 }
4546 _ACEOF
4547 rm -f conftest.$ac_objext conftest$ac_exeext
4548 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4549   (eval $ac_link) 2>conftest.er1
4550   ac_status=$?
4551   grep -v '^ *+' conftest.er1 >conftest.err
4552   rm -f conftest.er1
4553   cat conftest.err >&5
4554   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4555   (exit $ac_status); } &&
4556          { ac_try='test -z "$ac_c_werror_flag"
4557                          || test ! -s conftest.err'
4558   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4559   (eval $ac_try) 2>&5
4560   ac_status=$?
4561   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4562   (exit $ac_status); }; } &&
4563          { ac_try='test -s conftest$ac_exeext'
4564   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4565   (eval $ac_try) 2>&5
4566   ac_status=$?
4567   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4568   (exit $ac_status); }; }; then
4569   cat >conftest.$ac_ext <<_ACEOF
4570 /* confdefs.h.  */
4571 _ACEOF
4572 cat confdefs.h >>conftest.$ac_ext
4573 cat >>conftest.$ac_ext <<_ACEOF
4574 /* end confdefs.h.  */
4575 #include <gmp.h>
4576     #include <mpfr.h>
4577 int
4578 main ()
4579 {
4580
4581     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4582     choke me
4583     #endif
4584     mpfr_t n; mpfr_init(n);
4585
4586   ;
4587   return 0;
4588 }
4589 _ACEOF
4590 rm -f conftest.$ac_objext conftest$ac_exeext
4591 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4592   (eval $ac_link) 2>conftest.er1
4593   ac_status=$?
4594   grep -v '^ *+' conftest.er1 >conftest.err
4595   rm -f conftest.er1
4596   cat conftest.err >&5
4597   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4598   (exit $ac_status); } &&
4599          { ac_try='test -z "$ac_c_werror_flag"
4600                          || test ! -s conftest.err'
4601   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4602   (eval $ac_try) 2>&5
4603   ac_status=$?
4604   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4605   (exit $ac_status); }; } &&
4606          { ac_try='test -s conftest$ac_exeext'
4607   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4608   (eval $ac_try) 2>&5
4609   ac_status=$?
4610   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4611   (exit $ac_status); }; }; then
4612   echo "$as_me:$LINENO: result: yes" >&5
4613 echo "${ECHO_T}yes" >&6
4614 else
4615   echo "$as_me: failed program was:" >&5
4616 sed 's/^/| /' conftest.$ac_ext >&5
4617
4618 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4619 echo "${ECHO_T}buggy but acceptable" >&6
4620 fi
4621 rm -f conftest.err conftest.$ac_objext \
4622       conftest$ac_exeext conftest.$ac_ext
4623 else
4624   echo "$as_me: failed program was:" >&5
4625 sed 's/^/| /' conftest.$ac_ext >&5
4626
4627 echo "$as_me:$LINENO: result: no" >&5
4628 echo "${ECHO_T}no" >&6; have_gmp=no
4629 fi
4630 rm -f conftest.err conftest.$ac_objext \
4631       conftest$ac_exeext conftest.$ac_ext
4632       LIBS="$saved_LIBS"
4633   fi
4634   CFLAGS="$saved_CFLAGS"
4635
4636   if test x$have_gmp != xyes; then
4637     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4638 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4639 Copies of these libraries' source code can be found at their respective
4640 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4641 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4642 If you obtained GMP and/or MPFR from a vendor distribution package, make
4643 sure that you have installed both the libraries and the header files.
4644 They may be located in separate packages." >&5
4645 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4646 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4647 Copies of these libraries' source code can be found at their respective
4648 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4649 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4650 If you obtained GMP and/or MPFR from a vendor distribution package, make
4651 sure that you have installed both the libraries and the header files.
4652 They may be located in separate packages." >&2;}
4653    { (exit 1); exit 1; }; }
4654   fi
4655 fi
4656
4657 # Flags needed for both GMP and/or MPFR
4658
4659
4660
4661 # By default, C is the only stage 1 language.
4662 stage1_languages=,c,
4663
4664 # Figure out what language subdirectories are present.
4665 # Look if the user specified --enable-languages="..."; if not, use
4666 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4667 # go away some day.
4668 # NB:  embedded tabs in this IF block -- do not untabify
4669 if test -d ${srcdir}/gcc; then
4670   if test x"${enable_languages+set}" != xset; then
4671     if test x"${LANGUAGES+set}" = xset; then
4672       enable_languages="${LANGUAGES}"
4673         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4674     else
4675       enable_languages=all
4676     fi
4677   else
4678     if test x"${enable_languages}" = x ||
4679        test x"${enable_languages}" = xyes;
4680        then
4681       echo configure.in: --enable-languages needs at least one language argument 1>&2
4682       exit 1
4683     fi
4684   fi
4685   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4686
4687   # 'f95' is the old name for the 'fortran' language. We issue a warning
4688   # and make the substitution.
4689   case ,${enable_languages}, in
4690     *,f95,*)
4691       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4692       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4693       ;;
4694   esac
4695
4696   # First scan to see if an enabled language requires some other language.
4697   # We assume that a given config-lang.in will list all the language
4698   # front ends it requires, even if some are required indirectly.
4699   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4700     case ${lang_frag} in
4701       ..) ;;
4702       # The odd quoting in the next line works around
4703       # an apparent bug in bash 1.12 on linux.
4704       ${srcdir}/gcc/[*]/config-lang.in) ;;
4705       *)
4706         # From the config-lang.in, get $language, $lang_requires
4707         language=
4708         lang_requires=
4709         . ${lang_frag}
4710         for other in ${lang_requires} ; do
4711           case ,${enable_languages}, in
4712             *,$other,*) ;;
4713             *,all,*) ;;
4714             *,$language,*)
4715               echo " \`$other' language required by \`$language'; enabling" 1>&2
4716               enable_languages="${enable_languages},${other}"
4717               ;;
4718           esac
4719         done
4720         ;;
4721     esac
4722   done
4723
4724   new_enable_languages=,c,
4725   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4726   potential_languages=,c,
4727
4728   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4729     case ${lang_frag} in
4730       ..) ;;
4731       # The odd quoting in the next line works around
4732       # an apparent bug in bash 1.12 on linux.
4733       ${srcdir}/gcc/[*]/config-lang.in) ;;
4734       *)
4735         # From the config-lang.in, get $language, $target_libs,
4736         # $lang_dirs, $boot_language, and $build_by_default
4737         language=
4738         target_libs=
4739         lang_dirs=
4740         subdir_requires=
4741         boot_language=no
4742         build_by_default=yes
4743         . ${lang_frag}
4744         if test x${language} = x; then
4745           echo "${lang_frag} doesn't set \$language." 1>&2
4746           exit 1
4747         fi
4748
4749         case ,${enable_languages}, in
4750           *,${language},*)
4751             # Language was explicitly selected; include it.
4752             add_this_lang=yes
4753             ;;
4754           *,all,*)
4755             # 'all' was selected, select it if it is a default language
4756             add_this_lang=${build_by_default}
4757             ;;
4758           *)
4759             add_this_lang=no
4760             ;;
4761         esac
4762
4763         # Disable languages that need other directories if these aren't available.
4764         for i in $subdir_requires; do
4765           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4766           case ,${enable_languages}, in
4767             *,${language},*)
4768               # Specifically requested language; tell them.
4769               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4770 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4771    { (exit 1); exit 1; }; }
4772               ;;
4773             *)
4774               # Silently disable.
4775               add_this_lang=unsupported
4776               ;;
4777           esac
4778         done
4779
4780         # Disable Ada if no preexisting GNAT is available.
4781         case ,${enable_languages},:${language}:${have_gnat} in
4782           *,${language},*:ada:no)
4783             # Specifically requested language; tell them.
4784             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4785 echo "$as_me: error: GNAT is required to build $language" >&2;}
4786    { (exit 1); exit 1; }; }
4787             ;;
4788           *:ada:no)
4789             # Silently disable.
4790             add_this_lang=unsupported
4791             ;;
4792         esac
4793
4794         # Disable a language that is unsupported by the target.
4795         case " $unsupported_languages " in
4796           *" $language "*)
4797             add_this_lang=unsupported
4798             ;;
4799         esac
4800
4801         case $add_this_lang in
4802           unsupported)
4803             # Remove language-dependent dirs.
4804             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4805             ;;
4806           no)
4807             # Remove language-dependent dirs; still show language as supported.
4808             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4809             potential_languages="${potential_languages}${language},"
4810             ;;
4811           yes)
4812             new_enable_languages="${new_enable_languages}${language},"
4813             potential_languages="${potential_languages}${language},"
4814             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4815             case ${boot_language} in
4816               yes)
4817                 # Add to (comma-separated) list of stage 1 languages.
4818                 stage1_languages="${stage1_languages}${language},"
4819                 ;;
4820             esac
4821             ;;
4822         esac
4823         ;;
4824     esac
4825   done
4826
4827   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4828 if test "${enable_stage1_languages+set}" = set; then
4829   enableval="$enable_stage1_languages"
4830   case ,${enable_stage1_languages}, in
4831     ,no,|,,)
4832       # Set it to something that will have no effect in the loop below
4833       enable_stage1_languages=c ;;
4834     ,yes,)
4835       enable_stage1_languages=`echo $new_enable_languages | \
4836         sed -e "s/^,//" -e "s/,$//" ` ;;
4837     *,all,*)
4838       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4839         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4840   esac
4841
4842   # Add "good" languages from enable_stage1_languages to stage1_languages,
4843   # while "bad" languages go in missing_languages.  Leave no duplicates.
4844   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4845     case $potential_languages in
4846       *,$i,*)
4847         case $stage1_languages in
4848           *,$i,*) ;;
4849           *) stage1_languages="$stage1_languages$i," ;;
4850         esac ;;
4851       *)
4852         case $missing_languages in
4853           *,$i,*) ;;
4854           *) missing_languages="$missing_languages$i," ;;
4855         esac ;;
4856      esac
4857   done
4858 fi;
4859
4860   # Remove leading/trailing commas that were added for simplicity
4861   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4862   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4863   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4864   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4865
4866   if test "x$missing_languages" != x; then
4867     { { echo "$as_me:$LINENO: error:
4868 The following requested languages could not be built: ${missing_languages}
4869 Supported languages are: ${potential_languages}" >&5
4870 echo "$as_me: error:
4871 The following requested languages could not be built: ${missing_languages}
4872 Supported languages are: ${potential_languages}" >&2;}
4873    { (exit 1); exit 1; }; }
4874   fi
4875   if test "x$new_enable_languages" != "x$enable_languages"; then
4876     echo The following languages will be built: ${new_enable_languages}
4877     enable_languages="$new_enable_languages"
4878   fi
4879
4880
4881   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4882 fi
4883
4884 # Handle --disable-<component> generically.
4885 for dir in $configdirs $build_configdirs $target_configdirs ; do
4886   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4887   if eval test x\${enable_${dirname}} "=" xno ; then
4888     noconfigdirs="$noconfigdirs $dir"
4889   fi
4890 done
4891
4892 # Check for Boehm's garbage collector
4893 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4894 if test "${enable_objc_gc+set}" = set; then
4895   enableval="$enable_objc_gc"
4896   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4897   *,objc,*:*:yes:*target-boehm-gc*)
4898     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4899 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4900    { (exit 1); exit 1; }; }
4901     ;;
4902 esac
4903 fi;
4904
4905 # Make sure we only build Boehm's garbage collector if required.
4906 case ,${enable_languages},:${enable_objc_gc} in
4907   *,objc,*:yes)
4908     # Keep target-boehm-gc if requested for Objective-C.
4909     ;;
4910   *)
4911     # Otherwise remove target-boehm-gc depending on target-libjava.
4912     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4913       noconfigdirs="$noconfigdirs target-boehm-gc"
4914     fi
4915     ;;
4916 esac
4917
4918 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4919 # $build_configdirs and $target_configdirs.
4920 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4921
4922 notsupp=""
4923 for dir in . $skipdirs $noconfigdirs ; do
4924   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4925   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4926     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4927     if test -r $srcdir/$dirname/configure ; then
4928       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4929         true
4930       else
4931         notsupp="$notsupp $dir"
4932       fi
4933     fi
4934   fi
4935   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4936     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4937     if test -r $srcdir/$dirname/configure ; then
4938       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4939         true
4940       else
4941         notsupp="$notsupp $dir"
4942       fi
4943     fi
4944   fi
4945   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4946     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4947     if test -r $srcdir/$dirname/configure ; then
4948       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4949         true
4950       else
4951         notsupp="$notsupp $dir"
4952       fi
4953     fi
4954   fi
4955 done
4956
4957 # Sometimes the tools are distributed with libiberty but with no other
4958 # libraries.  In that case, we don't want to build target-libiberty.
4959 # Don't let libgcc imply libiberty either.
4960 if test -n "${target_configdirs}" ; then
4961   libgcc=
4962   others=
4963   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
4964     if test "$i" = "libgcc"; then
4965       libgcc=target-libgcc
4966     elif test "$i" != "libiberty" ; then
4967       if test -r $srcdir/$i/configure ; then
4968         others=yes;
4969         break;
4970       fi
4971     fi
4972   done
4973   if test -z "${others}" ; then
4974     target_configdirs=$libgcc
4975   fi
4976 fi
4977
4978 # Quietly strip out all directories which aren't configurable in this tree.
4979 # This relies on all configurable subdirectories being autoconfiscated, which
4980 # is now the case.
4981 build_configdirs_all="$build_configdirs"
4982 build_configdirs=
4983 for i in ${build_configdirs_all} ; do
4984   j=`echo $i | sed -e s/build-//g`
4985   if test -f ${srcdir}/$j/configure ; then
4986     build_configdirs="${build_configdirs} $i"
4987   fi
4988 done
4989
4990 configdirs_all="$configdirs"
4991 configdirs=
4992 for i in ${configdirs_all} ; do
4993   if test -f ${srcdir}/$i/configure ; then
4994     configdirs="${configdirs} $i"
4995   fi
4996 done
4997
4998 target_configdirs_all="$target_configdirs"
4999 target_configdirs=
5000 for i in ${target_configdirs_all} ; do
5001   j=`echo $i | sed -e s/target-//g`
5002   if test -f ${srcdir}/$j/configure ; then
5003     target_configdirs="${target_configdirs} $i"
5004   fi
5005 done
5006
5007 # Produce a warning message for the subdirs we can't configure.
5008 # This isn't especially interesting in the Cygnus tree, but in the individual
5009 # FSF releases, it's important to let people know when their machine isn't
5010 # supported by the one or two programs in a package.
5011
5012 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5013   # If $appdirs is non-empty, at least one of those directories must still
5014   # be configured, or we error out.  (E.g., if the gas release supports a
5015   # specified target in some subdirs but not the gas subdir, we shouldn't
5016   # pretend that all is well.)
5017   if test -n "$appdirs" ; then
5018     for dir in $appdirs ; do
5019       if test -r $dir/Makefile.in ; then
5020         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5021           appdirs=""
5022           break
5023         fi
5024         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5025           appdirs=""
5026           break
5027         fi
5028       fi
5029     done
5030     if test -n "$appdirs" ; then
5031       echo "*** This configuration is not supported by this package." 1>&2
5032       exit 1
5033     fi
5034   fi
5035   # Okay, some application will build, or we don't care to check.  Still
5036   # notify of subdirs not getting built.
5037   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5038   echo "    ${notsupp}" 1>&2
5039   echo "    (Any other directories should still work fine.)" 1>&2
5040 fi
5041
5042 case "$host" in
5043   *msdosdjgpp*)
5044     enable_gdbtk=no ;;
5045 esac
5046
5047 # To find our prefix, in gcc_cv_tool_prefix.
5048
5049 # The user is always right.
5050 if test "${PATH_SEPARATOR+set}" != set; then
5051   echo "#! /bin/sh" >conf$$.sh
5052   echo  "exit 0"   >>conf$$.sh
5053   chmod +x conf$$.sh
5054   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5055     PATH_SEPARATOR=';'
5056   else
5057     PATH_SEPARATOR=:
5058   fi
5059   rm -f conf$$.sh
5060 fi
5061
5062
5063
5064 if test "x$exec_prefix" = xNONE; then
5065         if test "x$prefix" = xNONE; then
5066                 gcc_cv_tool_prefix=$ac_default_prefix
5067         else
5068                 gcc_cv_tool_prefix=$prefix
5069         fi
5070 else
5071         gcc_cv_tool_prefix=$exec_prefix
5072 fi
5073
5074 # If there is no compiler in the tree, use the PATH only.  In any
5075 # case, if there is no compiler in the tree nobody should use
5076 # AS_FOR_TARGET and LD_FOR_TARGET.
5077 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5078     gcc_version=`cat $srcdir/gcc/BASE-VER`
5079     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5080     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5081     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5082     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5083     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5084     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5085 else
5086     gcc_cv_tool_dirs=
5087 fi
5088
5089 if test x$build = x$target && test -n "$md_exec_prefix"; then
5090         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5091 fi
5092
5093
5094
5095 copy_dirs=
5096
5097
5098 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5099 if test "${with_build_sysroot+set}" = set; then
5100   withval="$with_build_sysroot"
5101   if test x"$withval" != x ; then
5102      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5103    fi
5104 else
5105   SYSROOT_CFLAGS_FOR_TARGET=
5106 fi;
5107
5108
5109
5110 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5111 if test "${with_debug_prefix_map+set}" = set; then
5112   withval="$with_debug_prefix_map"
5113   if test x"$withval" != x; then
5114      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5115      for debug_map in $withval; do
5116        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5117      done
5118    fi
5119 else
5120   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5121 fi;
5122
5123
5124 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5125 # the named directory are copied to $(tooldir)/sys-include.
5126 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5127   if test x${is_cross_compiler} = xno ; then
5128     echo 1>&2 '***' --with-headers is only supported when cross compiling
5129     exit 1
5130   fi
5131   if test x"${with_headers}" != xyes ; then
5132     x=${gcc_cv_tool_prefix}
5133     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5134   fi
5135 fi
5136
5137 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5138 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5139 # are permitted.
5140 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5141   if test x${is_cross_compiler} = xno ; then
5142     echo 1>&2 '***' --with-libs is only supported when cross compiling
5143     exit 1
5144   fi
5145   if test x"${with_libs}" != xyes ; then
5146     # Copy the libraries in reverse order, so that files in the first named
5147     # library override files in subsequent libraries.
5148     x=${gcc_cv_tool_prefix}
5149     for l in ${with_libs}; do
5150       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5151     done
5152   fi
5153 fi
5154
5155 # Set with_gnu_as and with_gnu_ld as appropriate.
5156 #
5157 # This is done by determining whether or not the appropriate directory
5158 # is available, and by checking whether or not specific configurations
5159 # have requested that this magic not happen.
5160 #
5161 # The command line options always override the explicit settings in
5162 # configure.in, and the settings in configure.in override this magic.
5163 #
5164 # If the default for a toolchain is to use GNU as and ld, and you don't
5165 # want to do that, then you should use the --without-gnu-as and
5166 # --without-gnu-ld options for the configure script.
5167
5168 if test x${use_gnu_as} = x &&
5169    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5170   with_gnu_as=yes
5171   extra_host_args="$extra_host_args --with-gnu-as"
5172 fi
5173
5174 if test x${use_gnu_ld} = x &&
5175    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5176   with_gnu_ld=yes
5177   extra_host_args="$extra_host_args --with-gnu-ld"
5178 fi
5179
5180 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5181 # can detect this case.
5182
5183 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5184   with_newlib=yes
5185   extra_host_args="$extra_host_args --with-newlib"
5186 fi
5187
5188 # Handle ${copy_dirs}
5189 set fnord ${copy_dirs}
5190 shift
5191 while test $# != 0 ; do
5192   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5193     :
5194   else
5195     echo Copying $1 to $2
5196
5197     # Use the install script to create the directory and all required
5198     # parent directories.
5199     if test -d $2 ; then
5200       :
5201     else
5202       echo >config.temp
5203       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5204     fi
5205
5206     # Copy the directory, assuming we have tar.
5207     # FIXME: Should we use B in the second tar?  Not all systems support it.
5208     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5209
5210     # It is the responsibility of the user to correctly adjust all
5211     # symlinks.  If somebody can figure out how to handle them correctly
5212     # here, feel free to add the code.
5213
5214     echo $1 > $2/COPIED
5215   fi
5216   shift; shift
5217 done
5218
5219 # Determine a target-dependent exec_prefix that the installed
5220 # gcc will search in.  Keep this list sorted by triplet, with
5221 # the *-*-osname triplets last.
5222 md_exec_prefix=
5223 case "${target}" in
5224   alpha*-*-*vms*)
5225     md_exec_prefix=/gnu/lib/gcc-lib
5226     ;;
5227   i[34567]86-pc-msdosdjgpp*)
5228     md_exec_prefix=/dev/env/DJDIR/bin
5229     ;;
5230   i[34567]86-*-sco3.2v5*)
5231     if test $with_gnu_as = yes; then
5232       md_exec_prefix=/usr/gnu/bin
5233     else
5234       md_exec_prefix=/usr/ccs/bin/elf
5235     fi
5236     ;;
5237
5238   mn10300-*-* | \
5239   powerpc-*-chorusos* | \
5240   powerpc*-*-eabi* | \
5241   powerpc*-*-sysv* | \
5242   powerpc*-*-kaos* | \
5243   s390x-ibm-tpf*)
5244     md_exec_prefix=/usr/ccs/bin
5245     ;;
5246   sparc64-*-elf*)
5247     ;;
5248   v850*-*-*)
5249     md_exec_prefix=/usr/ccs/bin
5250     ;;
5251   xtensa-*-elf*)
5252     ;;
5253
5254   *-*-beos* | \
5255   *-*-elf* | \
5256   *-*-hpux* | \
5257   *-*-netware* | \
5258   *-*-nto-qnx* | \
5259   *-*-rtems* | \
5260   *-*-solaris2* | \
5261   *-*-sysv[45]* | \
5262   *-*-vxworks* | \
5263   *-wrs-windiss)
5264     md_exec_prefix=/usr/ccs/bin
5265     ;;
5266 esac
5267
5268 extra_arflags_for_target=
5269 extra_nmflags_for_target=
5270 extra_ranlibflags_for_target=
5271 target_makefile_frag=/dev/null
5272 case "${target}" in
5273   mep*-*-*)
5274     target_makefile_frag="config/mt-mep"
5275     ;;
5276   spu-*-*)
5277     target_makefile_frag="config/mt-spu"
5278     ;;
5279   mips*-sde-elf*)
5280     target_makefile_frag="config/mt-sde"
5281     ;;
5282   mipsisa*-*-elfoabi*)
5283     target_makefile_frag="config/mt-mips-elfoabi"
5284     ;;
5285   *-*-netware*)
5286     target_makefile_frag="config/mt-netware"
5287     ;;
5288   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5289     target_makefile_frag="config/mt-gnu"
5290     ;;
5291   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5292     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5293     # commands to handle both 32-bit and 64-bit objects.  These flags are
5294     # harmless if we're using GNU nm or ar.
5295     extra_arflags_for_target=" -X32_64"
5296     extra_nmflags_for_target=" -B -X32_64"
5297     ;;
5298   *-*-darwin*)
5299     # ranlib from Darwin requires the -c flag to look at common symbols.
5300     extra_ranlibflags_for_target=" -c"
5301     ;;
5302   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5303     target_makefile_frag="config/mt-wince"
5304     ;;
5305 esac
5306
5307 alphaieee_frag=/dev/null
5308 case $target in
5309   alpha*-*-*)
5310     # This just makes sure to use the -mieee option to build target libs.
5311     # This should probably be set individually by each library.
5312     alphaieee_frag="config/mt-alphaieee"
5313     ;;
5314 esac
5315
5316 # If --enable-target-optspace always use -Os instead of -O2 to build
5317 # the target libraries, similarly if it is not specified, use -Os
5318 # on selected platforms.
5319 ospace_frag=/dev/null
5320 case "${enable_target_optspace}:${target}" in
5321   yes:*)
5322     ospace_frag="config/mt-ospace"
5323     ;;
5324   :d30v-*)
5325     ospace_frag="config/mt-d30v"
5326     ;;
5327   :m32r-* | :d10v-* | :fr30-*)
5328     ospace_frag="config/mt-ospace"
5329     ;;
5330   no:* | :*)
5331     ;;
5332   *)
5333     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5334     ;;
5335 esac
5336
5337 # Default to using --with-stabs for certain targets.
5338 if test x${with_stabs} = x ; then
5339   case "${target}" in
5340   mips*-*-irix[56]*)
5341     ;;
5342   mips*-*-* | alpha*-*-osf*)
5343     with_stabs=yes;
5344     extra_host_args="${extra_host_args} --with-stabs"
5345     ;;
5346   esac
5347 fi
5348
5349 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5350 # them automatically.
5351 case "${host}" in
5352   hppa*64*-*-hpux11*)
5353     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5354     ;;
5355 esac
5356
5357 # Some systems (e.g., one of the i386-aix systems the gas testers are
5358 # using) don't handle "\$" correctly, so don't use it here.
5359 tooldir='${exec_prefix}'/${target_noncanonical}
5360 build_tooldir=${tooldir}
5361
5362 # Create a .gdbinit file which runs the one in srcdir
5363 # and tells GDB to look there for source files.
5364
5365 if test -r ${srcdir}/.gdbinit ; then
5366   case ${srcdir} in
5367     .) ;;
5368     *) cat > ./.gdbinit <<EOF
5369 # ${NO_EDIT}
5370 dir ${srcdir}
5371 dir .
5372 source ${srcdir}/.gdbinit
5373 EOF
5374     ;;
5375   esac
5376 fi
5377
5378 # Make sure that the compiler is able to generate an executable.  If it
5379 # can't, we are probably in trouble.  We don't care whether we can run the
5380 # executable--we might be using a cross compiler--we only care whether it
5381 # can be created.  At this point the main configure script has set CC.
5382 we_are_ok=no
5383 echo "int main () { return 0; }" > conftest.c
5384 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5385 if test $? = 0 ; then
5386   if test -s conftest || test -s conftest.exe ; then
5387     we_are_ok=yes
5388   fi
5389 fi
5390 case $we_are_ok in
5391   no)
5392     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5393     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5394     rm -f conftest*
5395     exit 1
5396     ;;
5397 esac
5398 rm -f conftest*
5399
5400 # The Solaris /usr/ucb/cc compiler does not appear to work.
5401 case "${host}" in
5402   sparc-sun-solaris2*)
5403       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5404       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5405           could_use=
5406           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5407           if test -d /opt/cygnus/bin ; then
5408               if test "$could_use" = "" ; then
5409                   could_use="/opt/cygnus/bin"
5410               else
5411                   could_use="$could_use or /opt/cygnus/bin"
5412               fi
5413           fi
5414         if test "$could_use" = "" ; then
5415             echo "Warning: compilation may fail because you're using"
5416             echo "/usr/ucb/cc.  You should change your PATH or CC "
5417             echo "variable and rerun configure."
5418         else
5419             echo "Warning: compilation may fail because you're using"
5420             echo "/usr/ucb/cc, when you should use the C compiler from"
5421             echo "$could_use.  You should change your"
5422             echo "PATH or CC variable and rerun configure."
5423         fi
5424       fi
5425   ;;
5426 esac
5427
5428 case "${host}" in
5429   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5430   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5431   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5432 esac
5433
5434 # Record target_configdirs and the configure arguments for target and
5435 # build configuration in Makefile.
5436 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5437 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5438
5439 # Determine whether gdb needs tk/tcl or not.
5440 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5441 # and in that case we want gdb to be built without tk.  Ugh!
5442 # In fact I believe gdb is the *only* package directly dependent on tk,
5443 # so we should be able to put the 'maybe's in unconditionally and
5444 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5445 # 100% sure that that's safe though.
5446
5447 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5448 case "$enable_gdbtk" in
5449   no)
5450     GDB_TK="" ;;
5451   yes)
5452     GDB_TK="${gdb_tk}" ;;
5453   *)
5454     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5455     # distro.  Eventually someone will fix this and move Insight, nee
5456     # gdbtk to a separate directory.
5457     if test -d ${srcdir}/gdb/gdbtk ; then
5458       GDB_TK="${gdb_tk}"
5459     else
5460       GDB_TK=""
5461     fi
5462     ;;
5463 esac
5464 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5465 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5466
5467 # Strip out unwanted targets.
5468
5469 # While at that, we remove Makefiles if we were started for recursive
5470 # configuration, so that the top-level Makefile reconfigures them,
5471 # like we used to do when configure itself was recursive.
5472
5473 # Loop over modules.  $extrasub must be used with care, limiting as
5474 # much as possible the usage of range addresses.  That's because autoconf
5475 # splits the sed script to overcome limits in the number of commands,
5476 # and relying on carefully-timed sed passes may turn out to be very hard
5477 # to maintain later.  In this particular case, you just have to be careful
5478 # not to nest @if/@endif pairs, because configure will not warn you at all.
5479
5480 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5481 if test "${enable_bootstrap+set}" = set; then
5482   enableval="$enable_bootstrap"
5483
5484 else
5485   enable_bootstrap=default
5486 fi;
5487
5488 # Issue errors and warnings for invalid/strange bootstrap combinations.
5489 case "$configdirs" in
5490   *gcc*) have_compiler=yes ;;
5491   *) have_compiler=no ;;
5492 esac
5493
5494 case "$have_compiler:$host:$target:$enable_bootstrap" in
5495   *:*:*:no) ;;
5496
5497   # Default behavior.  Enable bootstrap if we have a compiler
5498   # and we are in a native configuration.
5499   yes:$build:$build:default)
5500     enable_bootstrap=yes ;;
5501
5502   *:*:*:default)
5503     enable_bootstrap=no ;;
5504
5505   # We have a compiler and we are in a native configuration, bootstrap is ok
5506   yes:$build:$build:yes)
5507     ;;
5508
5509   # Other configurations, but we have a compiler.  Assume the user knows
5510   # what he's doing.
5511   yes:*:*:yes)
5512     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5513 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5514     ;;
5515
5516   # No compiler: if they passed --enable-bootstrap explicitly, fail
5517   no:*:*:yes)
5518     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5519 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5520    { (exit 1); exit 1; }; } ;;
5521
5522   # Fail if wrong command line
5523   *)
5524     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5525 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5526    { (exit 1); exit 1; }; }
5527     ;;
5528 esac
5529
5530 # Adjust the toplevel makefile according to whether bootstrap was selected.
5531 case "$enable_bootstrap" in
5532   yes)
5533     bootstrap_suffix=bootstrap ;;
5534   no)
5535     bootstrap_suffix=no-bootstrap ;;
5536 esac
5537
5538 for module in ${build_configdirs} ; do
5539   if test -z "${no_recursion}" \
5540      && test -f ${build_subdir}/${module}/Makefile; then
5541     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5542     rm -f ${build_subdir}/${module}/Makefile
5543   fi
5544   extrasub="$extrasub
5545 /^@if build-$module\$/d
5546 /^@endif build-$module\$/d
5547 /^@if build-$module-$bootstrap_suffix\$/d
5548 /^@endif build-$module-$bootstrap_suffix\$/d"
5549 done
5550 for module in ${configdirs} ; do
5551   if test -z "${no_recursion}"; then
5552     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5553       if test -f ${file}; then
5554         echo 1>&2 "*** removing ${file} to force reconfigure"
5555         rm -f ${file}
5556       fi
5557     done
5558   fi
5559   extrasub="$extrasub
5560 /^@if $module\$/d
5561 /^@endif $module\$/d
5562 /^@if $module-$bootstrap_suffix\$/d
5563 /^@endif $module-$bootstrap_suffix\$/d"
5564 done
5565 for module in ${target_configdirs} ; do
5566   if test -z "${no_recursion}" \
5567      && test -f ${target_subdir}/${module}/Makefile; then
5568     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5569     rm -f ${target_subdir}/${module}/Makefile
5570   fi
5571   extrasub="$extrasub
5572 /^@if target-$module\$/d
5573 /^@endif target-$module\$/d
5574 /^@if target-$module-$bootstrap_suffix\$/d
5575 /^@endif target-$module-$bootstrap_suffix\$/d"
5576 done
5577
5578 extrasub="$extrasub
5579 /^@if /,/^@endif /d"
5580
5581 # Create the serialization dependencies.  This uses a temporary file.
5582
5583 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5584 if test "${enable_serial_configure+set}" = set; then
5585   enableval="$enable_serial_configure"
5586
5587 fi;
5588
5589 case ${enable_serial_configure} in
5590   yes)
5591     enable_serial_build_configure=yes
5592     enable_serial_host_configure=yes
5593     enable_serial_target_configure=yes
5594     ;;
5595 esac
5596
5597 # These force 'configure's to be done one at a time, to avoid problems
5598 # with contention over a shared config.cache.
5599 rm -f serdep.tmp
5600 echo '# serdep.tmp' > serdep.tmp
5601 olditem=
5602 test "x${enable_serial_build_configure}" = xyes &&
5603 for item in ${build_configdirs} ; do
5604   case ${olditem} in
5605     "") ;;
5606     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5607   esac
5608   olditem=${item}
5609 done
5610 olditem=
5611 test "x${enable_serial_host_configure}" = xyes &&
5612 for item in ${configdirs} ; do
5613   case ${olditem} in
5614     "") ;;
5615     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5616   esac
5617   olditem=${item}
5618 done
5619 olditem=
5620 test "x${enable_serial_target_configure}" = xyes &&
5621 for item in ${target_configdirs} ; do
5622   case ${olditem} in
5623     "") ;;
5624     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5625   esac
5626   olditem=${item}
5627 done
5628 serialization_dependencies=serdep.tmp
5629
5630
5631 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5632 # target, nonopt, and variable assignments.  These are the ones we
5633 # might not want to pass down to subconfigures.  Also strip
5634 # program-prefix, program-suffix, and program-transform-name, so that
5635 # we can pass down a consistent program-transform-name.
5636 baseargs=
5637 keep_next=no
5638 skip_next=no
5639 eval "set -- $ac_configure_args"
5640 for ac_arg
5641 do
5642   if test X"$skip_next" = X"yes"; then
5643     skip_next=no
5644     continue
5645   fi
5646   if test X"$keep_next" = X"yes"; then
5647     case $ac_arg in
5648       *\'*)
5649         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5650     esac
5651     baseargs="$baseargs '$ac_arg'"
5652     keep_next=no
5653     continue
5654   fi
5655
5656   # Handle separated arguments.  Based on the logic generated by
5657   # autoconf 2.59.
5658   case $ac_arg in
5659     *=* | --config-cache | -C | -disable-* | --disable-* \
5660       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5661       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5662       | -with-* | --with-* | -without-* | --without-* | --x)
5663       separate_arg=no
5664       ;;
5665     -*)
5666       separate_arg=yes
5667       ;;
5668     *)
5669       separate_arg=no
5670       ;;
5671   esac
5672
5673   case "$ac_arg" in
5674     --no*)
5675       continue
5676       ;;
5677     --c* | \
5678     --sr* | \
5679     --ho* | \
5680     --bu* | \
5681     --t* | \
5682     --program-* | \
5683     -cache_file* | \
5684     -srcdir* | \
5685     -host* | \
5686     -build* | \
5687     -target* | \
5688     -program-prefix* | \
5689     -program-suffix* | \
5690     -program-transform-name* )
5691       skip_next=$separate_arg
5692       continue
5693       ;;
5694     -*)
5695       # An option.  Add it.
5696       case $ac_arg in
5697         *\'*)
5698           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5699       esac
5700       baseargs="$baseargs '$ac_arg'"
5701       keep_next=$separate_arg
5702       ;;
5703     *)
5704       # Either a variable assignment, or a nonopt (triplet).  Don't
5705       # pass it down; let the Makefile handle this.
5706       continue
5707       ;;
5708   esac
5709 done
5710 # Remove the initial space we just introduced and, as these will be
5711 # expanded by make, quote '$'.
5712 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5713
5714 # Add in --program-transform-name, after --program-prefix and
5715 # --program-suffix have been applied to it.  Autoconf has already
5716 # doubled dollar signs and backslashes in program_transform_name; we want
5717 # the backslashes un-doubled, and then the entire thing wrapped in single
5718 # quotes, because this will be expanded first by make and then by the shell.
5719 # Also, because we want to override the logic in subdir configure scripts to
5720 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5721 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5722 ${program_transform_name}
5723 EOF_SED
5724 gcc_transform_name=`cat conftestsed.out`
5725 rm -f conftestsed.out
5726 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5727 if test "$silent" = yes; then
5728   baseargs="$baseargs --silent"
5729 fi
5730
5731 # For the build-side libraries, we just need to pretend we're native,
5732 # and not use the same cache file.  Multilibs are neither needed nor
5733 # desired.
5734 build_configargs="--cache-file=../config.cache ${baseargs}"
5735
5736 # For host modules, accept cache file option, or specification as blank.
5737 case "${cache_file}" in
5738 "") # empty
5739   cache_file_option="" ;;
5740 /* | [A-Za-z]:[\\/]* ) # absolute path
5741   cache_file_option="--cache-file=${cache_file}" ;;
5742 *) # relative path
5743   cache_file_option="--cache-file=../${cache_file}" ;;
5744 esac
5745
5746 # Host dirs don't like to share a cache file either, horribly enough.
5747 # This seems to be due to autoconf 2.5x stupidity.
5748 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5749
5750 target_configargs=${baseargs}
5751
5752 # Passing a --with-cross-host argument lets the target libraries know
5753 # whether they are being built with a cross-compiler or being built
5754 # native.  However, it would be better to use other mechanisms to make the
5755 # sorts of decisions they want to make on this basis.  Please consider
5756 # this option to be deprecated.  FIXME.
5757 if test x${is_cross_compiler} = xyes ; then
5758   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5759 fi
5760
5761 # Default to --enable-multilib.
5762 if test x${enable_multilib} = x ; then
5763   target_configargs="--enable-multilib ${target_configargs}"
5764 fi
5765
5766 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5767 # changed from the earlier setting of with_newlib.
5768 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5769   target_configargs="--with-newlib ${target_configargs}"
5770 fi
5771
5772 # Different target subdirs use different values of certain variables
5773 # (notably CXX).  Worse, multilibs use *lots* of different values.
5774 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5775 # it doesn't automatically accept command-line overrides of them.
5776 # This means it's not safe for target subdirs to share a cache file,
5777 # which is disgusting, but there you have it.  Hopefully this can be
5778 # fixed in future.  It's still worthwhile to use a cache file for each
5779 # directory.  I think.
5780
5781 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5782 # We need to pass --target, as newer autoconf's requires consistency
5783 # for target_alias and gcc doesn't manage it consistently.
5784 target_configargs="--cache-file=./config.cache ${target_configargs}"
5785
5786 FLAGS_FOR_TARGET=
5787 case " $target_configdirs " in
5788  *" newlib "*)
5789   case " $target_configargs " in
5790   *" --with-newlib "*)
5791    case "$target" in
5792    *-cygwin*)
5793      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' ;;
5794    esac
5795
5796    # If we're not building GCC, don't discard standard headers.
5797    if test -d ${srcdir}/gcc; then
5798      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5799
5800      if test "${build}" != "${host}"; then
5801        # On Canadian crosses, CC_FOR_TARGET will have already been set
5802        # by `configure', so we won't have an opportunity to add -Bgcc/
5803        # to it.  This is right: we don't want to search that directory
5804        # for binaries, but we want the header files in there, so add
5805        # them explicitly.
5806        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5807
5808        # Someone might think of using the pre-installed headers on
5809        # Canadian crosses, in case the installed compiler is not fully
5810        # compatible with the compiler being built.  In this case, it
5811        # would be better to flag an error than risking having
5812        # incompatible object files being constructed.  We can't
5813        # guarantee that an error will be flagged, but let's hope the
5814        # compiler will do it, when presented with incompatible header
5815        # files.
5816      fi
5817    fi
5818
5819    case "${target}-${is_cross_compiler}" in
5820    i[3456789]86-*-linux*-no)
5821       # Here host == target, so we don't need to build gcc,
5822       # so we don't want to discard standard headers.
5823       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5824       ;;
5825    *)
5826       # If we're building newlib, use its generic headers last, but search
5827       # for any libc-related directories first (so make it the last -B
5828       # switch).
5829       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5830
5831       # If we're building libgloss, find the startup file, simulator library
5832       # and linker script.
5833       case " $target_configdirs " in
5834         *" libgloss "*)
5835         # Look for startup file, simulator library and maybe linker script.
5836         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
5837         # Look for libnosys.a in case the target needs it.
5838         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5839         # Most targets have the linker script in the source directory.
5840         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
5841         ;;
5842       esac
5843       ;;
5844    esac
5845    ;;
5846   esac
5847   ;;
5848 esac
5849 case "$target" in
5850 *-mingw*)
5851   # Can't be handled as Cygwin above since Mingw does not use newlib.
5852   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' ;;
5853 esac
5854
5855 # Allow the user to override the flags for
5856 # our build compiler if desired.
5857 CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5858
5859 # On Canadian crosses, we'll be searching the right directories for
5860 # the previously-installed cross compiler, so don't bother to add
5861 # flags for directories within the install tree of the compiler
5862 # being built; programs in there won't even run.
5863 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5864   # Search for pre-installed headers if nothing else fits.
5865   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5866 fi
5867
5868 if test "x${use_gnu_ld}" = x &&
5869    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5870   # Arrange for us to find uninstalled linker scripts.
5871   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5872 fi
5873
5874 # Search for other target-specific linker scripts and such.
5875 case "${target}" in
5876   mep*)
5877     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5878     ;;
5879 esac
5880
5881 # Makefile fragments.
5882 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5883 do
5884   eval fragval=\$$frag
5885   if test $fragval != /dev/null; then
5886     eval $frag=${srcdir}/$fragval
5887   fi
5888 done
5889
5890
5891
5892
5893
5894 # Miscellanea: directories, flags, etc.
5895
5896
5897
5898
5899
5900
5901
5902 # Build module lists & subconfigure args.
5903
5904
5905
5906 # Host module lists & subconfigure args.
5907
5908
5909
5910 # Target module lists & subconfigure args.
5911
5912
5913
5914 # Build tools.
5915
5916
5917
5918 # Generate default definitions for YACC, M4, LEX and other programs that run
5919 # on the build machine.  These are used if the Makefile can't locate these
5920 # programs in objdir.
5921 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5922
5923 for ac_prog in 'bison -y' byacc yacc
5924 do
5925   # Extract the first word of "$ac_prog", so it can be a program name with args.
5926 set dummy $ac_prog; ac_word=$2
5927 echo "$as_me:$LINENO: checking for $ac_word" >&5
5928 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5929 if test "${ac_cv_prog_YACC+set}" = set; then
5930   echo $ECHO_N "(cached) $ECHO_C" >&6
5931 else
5932   if test -n "$YACC"; then
5933   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5934 else
5935 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5936 for as_dir in $PATH
5937 do
5938   IFS=$as_save_IFS
5939   test -z "$as_dir" && as_dir=.
5940   for ac_exec_ext in '' $ac_executable_extensions; do
5941   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5942     ac_cv_prog_YACC="$ac_prog"
5943     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5944     break 2
5945   fi
5946 done
5947 done
5948
5949 fi
5950 fi
5951 YACC=$ac_cv_prog_YACC
5952 if test -n "$YACC"; then
5953   echo "$as_me:$LINENO: result: $YACC" >&5
5954 echo "${ECHO_T}$YACC" >&6
5955 else
5956   echo "$as_me:$LINENO: result: no" >&5
5957 echo "${ECHO_T}no" >&6
5958 fi
5959
5960   test -n "$YACC" && break
5961 done
5962 test -n "$YACC" || YACC="$MISSING bison -y"
5963
5964 case " $build_configdirs " in
5965   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
5966   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
5967 esac
5968
5969 for ac_prog in bison
5970 do
5971   # Extract the first word of "$ac_prog", so it can be a program name with args.
5972 set dummy $ac_prog; ac_word=$2
5973 echo "$as_me:$LINENO: checking for $ac_word" >&5
5974 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5975 if test "${ac_cv_prog_BISON+set}" = set; then
5976   echo $ECHO_N "(cached) $ECHO_C" >&6
5977 else
5978   if test -n "$BISON"; then
5979   ac_cv_prog_BISON="$BISON" # Let the user override the test.
5980 else
5981 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5982 for as_dir in $PATH
5983 do
5984   IFS=$as_save_IFS
5985   test -z "$as_dir" && as_dir=.
5986   for ac_exec_ext in '' $ac_executable_extensions; do
5987   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5988     ac_cv_prog_BISON="$ac_prog"
5989     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5990     break 2
5991   fi
5992 done
5993 done
5994
5995 fi
5996 fi
5997 BISON=$ac_cv_prog_BISON
5998 if test -n "$BISON"; then
5999   echo "$as_me:$LINENO: result: $BISON" >&5
6000 echo "${ECHO_T}$BISON" >&6
6001 else
6002   echo "$as_me:$LINENO: result: no" >&5
6003 echo "${ECHO_T}no" >&6
6004 fi
6005
6006   test -n "$BISON" && break
6007 done
6008 test -n "$BISON" || BISON="$MISSING bison"
6009
6010 case " $build_configdirs " in
6011   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6012 esac
6013
6014 for ac_prog in gm4 gnum4 m4
6015 do
6016   # Extract the first word of "$ac_prog", so it can be a program name with args.
6017 set dummy $ac_prog; ac_word=$2
6018 echo "$as_me:$LINENO: checking for $ac_word" >&5
6019 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6020 if test "${ac_cv_prog_M4+set}" = set; then
6021   echo $ECHO_N "(cached) $ECHO_C" >&6
6022 else
6023   if test -n "$M4"; then
6024   ac_cv_prog_M4="$M4" # Let the user override the test.
6025 else
6026 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6027 for as_dir in $PATH
6028 do
6029   IFS=$as_save_IFS
6030   test -z "$as_dir" && as_dir=.
6031   for ac_exec_ext in '' $ac_executable_extensions; do
6032   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6033     ac_cv_prog_M4="$ac_prog"
6034     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6035     break 2
6036   fi
6037 done
6038 done
6039
6040 fi
6041 fi
6042 M4=$ac_cv_prog_M4
6043 if test -n "$M4"; then
6044   echo "$as_me:$LINENO: result: $M4" >&5
6045 echo "${ECHO_T}$M4" >&6
6046 else
6047   echo "$as_me:$LINENO: result: no" >&5
6048 echo "${ECHO_T}no" >&6
6049 fi
6050
6051   test -n "$M4" && break
6052 done
6053 test -n "$M4" || M4="$MISSING m4"
6054
6055 case " $build_configdirs " in
6056   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6057 esac
6058
6059 for ac_prog in flex lex
6060 do
6061   # Extract the first word of "$ac_prog", so it can be a program name with args.
6062 set dummy $ac_prog; ac_word=$2
6063 echo "$as_me:$LINENO: checking for $ac_word" >&5
6064 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6065 if test "${ac_cv_prog_LEX+set}" = set; then
6066   echo $ECHO_N "(cached) $ECHO_C" >&6
6067 else
6068   if test -n "$LEX"; then
6069   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6070 else
6071 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6072 for as_dir in $PATH
6073 do
6074   IFS=$as_save_IFS
6075   test -z "$as_dir" && as_dir=.
6076   for ac_exec_ext in '' $ac_executable_extensions; do
6077   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6078     ac_cv_prog_LEX="$ac_prog"
6079     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6080     break 2
6081   fi
6082 done
6083 done
6084
6085 fi
6086 fi
6087 LEX=$ac_cv_prog_LEX
6088 if test -n "$LEX"; then
6089   echo "$as_me:$LINENO: result: $LEX" >&5
6090 echo "${ECHO_T}$LEX" >&6
6091 else
6092   echo "$as_me:$LINENO: result: no" >&5
6093 echo "${ECHO_T}no" >&6
6094 fi
6095
6096   test -n "$LEX" && break
6097 done
6098 test -n "$LEX" || LEX="$MISSING flex"
6099
6100 case " $build_configdirs " in
6101   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6102   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6103 esac
6104
6105 for ac_prog in flex
6106 do
6107   # Extract the first word of "$ac_prog", so it can be a program name with args.
6108 set dummy $ac_prog; ac_word=$2
6109 echo "$as_me:$LINENO: checking for $ac_word" >&5
6110 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6111 if test "${ac_cv_prog_FLEX+set}" = set; then
6112   echo $ECHO_N "(cached) $ECHO_C" >&6
6113 else
6114   if test -n "$FLEX"; then
6115   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6116 else
6117 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6118 for as_dir in $PATH
6119 do
6120   IFS=$as_save_IFS
6121   test -z "$as_dir" && as_dir=.
6122   for ac_exec_ext in '' $ac_executable_extensions; do
6123   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6124     ac_cv_prog_FLEX="$ac_prog"
6125     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6126     break 2
6127   fi
6128 done
6129 done
6130
6131 fi
6132 fi
6133 FLEX=$ac_cv_prog_FLEX
6134 if test -n "$FLEX"; then
6135   echo "$as_me:$LINENO: result: $FLEX" >&5
6136 echo "${ECHO_T}$FLEX" >&6
6137 else
6138   echo "$as_me:$LINENO: result: no" >&5
6139 echo "${ECHO_T}no" >&6
6140 fi
6141
6142   test -n "$FLEX" && break
6143 done
6144 test -n "$FLEX" || FLEX="$MISSING flex"
6145
6146 case " $build_configdirs " in
6147   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6148 esac
6149
6150 for ac_prog in makeinfo
6151 do
6152   # Extract the first word of "$ac_prog", so it can be a program name with args.
6153 set dummy $ac_prog; ac_word=$2
6154 echo "$as_me:$LINENO: checking for $ac_word" >&5
6155 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6156 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6157   echo $ECHO_N "(cached) $ECHO_C" >&6
6158 else
6159   if test -n "$MAKEINFO"; then
6160   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6161 else
6162 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6163 for as_dir in $PATH
6164 do
6165   IFS=$as_save_IFS
6166   test -z "$as_dir" && as_dir=.
6167   for ac_exec_ext in '' $ac_executable_extensions; do
6168   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6169     ac_cv_prog_MAKEINFO="$ac_prog"
6170     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6171     break 2
6172   fi
6173 done
6174 done
6175
6176 fi
6177 fi
6178 MAKEINFO=$ac_cv_prog_MAKEINFO
6179 if test -n "$MAKEINFO"; then
6180   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6181 echo "${ECHO_T}$MAKEINFO" >&6
6182 else
6183   echo "$as_me:$LINENO: result: no" >&5
6184 echo "${ECHO_T}no" >&6
6185 fi
6186
6187   test -n "$MAKEINFO" && break
6188 done
6189 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6190
6191 case " $build_configdirs " in
6192   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6193   *)
6194
6195     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6196     # higher, else we use the "missing" dummy.
6197     if ${MAKEINFO} --version \
6198        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6199       :
6200     else
6201       MAKEINFO="$MISSING makeinfo"
6202     fi
6203     ;;
6204
6205 esac
6206
6207 # FIXME: expect and dejagnu may become build tools?
6208
6209 for ac_prog in expect
6210 do
6211   # Extract the first word of "$ac_prog", so it can be a program name with args.
6212 set dummy $ac_prog; ac_word=$2
6213 echo "$as_me:$LINENO: checking for $ac_word" >&5
6214 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6215 if test "${ac_cv_prog_EXPECT+set}" = set; then
6216   echo $ECHO_N "(cached) $ECHO_C" >&6
6217 else
6218   if test -n "$EXPECT"; then
6219   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6220 else
6221 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6222 for as_dir in $PATH
6223 do
6224   IFS=$as_save_IFS
6225   test -z "$as_dir" && as_dir=.
6226   for ac_exec_ext in '' $ac_executable_extensions; do
6227   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6228     ac_cv_prog_EXPECT="$ac_prog"
6229     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6230     break 2
6231   fi
6232 done
6233 done
6234
6235 fi
6236 fi
6237 EXPECT=$ac_cv_prog_EXPECT
6238 if test -n "$EXPECT"; then
6239   echo "$as_me:$LINENO: result: $EXPECT" >&5
6240 echo "${ECHO_T}$EXPECT" >&6
6241 else
6242   echo "$as_me:$LINENO: result: no" >&5
6243 echo "${ECHO_T}no" >&6
6244 fi
6245
6246   test -n "$EXPECT" && break
6247 done
6248 test -n "$EXPECT" || EXPECT="expect"
6249
6250 case " $configdirs " in
6251   *" expect "*)
6252     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6253     ;;
6254 esac
6255
6256 for ac_prog in runtest
6257 do
6258   # Extract the first word of "$ac_prog", so it can be a program name with args.
6259 set dummy $ac_prog; ac_word=$2
6260 echo "$as_me:$LINENO: checking for $ac_word" >&5
6261 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6262 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6263   echo $ECHO_N "(cached) $ECHO_C" >&6
6264 else
6265   if test -n "$RUNTEST"; then
6266   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6267 else
6268 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6269 for as_dir in $PATH
6270 do
6271   IFS=$as_save_IFS
6272   test -z "$as_dir" && as_dir=.
6273   for ac_exec_ext in '' $ac_executable_extensions; do
6274   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6275     ac_cv_prog_RUNTEST="$ac_prog"
6276     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6277     break 2
6278   fi
6279 done
6280 done
6281
6282 fi
6283 fi
6284 RUNTEST=$ac_cv_prog_RUNTEST
6285 if test -n "$RUNTEST"; then
6286   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6287 echo "${ECHO_T}$RUNTEST" >&6
6288 else
6289   echo "$as_me:$LINENO: result: no" >&5
6290 echo "${ECHO_T}no" >&6
6291 fi
6292
6293   test -n "$RUNTEST" && break
6294 done
6295 test -n "$RUNTEST" || RUNTEST="runtest"
6296
6297 case " $configdirs " in
6298   *" dejagnu "*)
6299     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6300     ;;
6301 esac
6302
6303
6304 # Host tools.
6305 ncn_tool_prefix=
6306 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6307 ncn_target_tool_prefix=
6308 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6309
6310
6311
6312 if test -n "$AR"; then
6313   ac_cv_prog_AR=$AR
6314 elif test -n "$ac_cv_prog_AR"; then
6315   AR=$ac_cv_prog_AR
6316 fi
6317
6318 if test -n "$ac_cv_prog_AR"; then
6319   for ncn_progname in ar; do
6320     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6321 set dummy ${ncn_progname}; ac_word=$2
6322 echo "$as_me:$LINENO: checking for $ac_word" >&5
6323 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6324 if test "${ac_cv_prog_AR+set}" = set; then
6325   echo $ECHO_N "(cached) $ECHO_C" >&6
6326 else
6327   if test -n "$AR"; then
6328   ac_cv_prog_AR="$AR" # Let the user override the test.
6329 else
6330 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6331 for as_dir in $PATH
6332 do
6333   IFS=$as_save_IFS
6334   test -z "$as_dir" && as_dir=.
6335   for ac_exec_ext in '' $ac_executable_extensions; do
6336   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6337     ac_cv_prog_AR="${ncn_progname}"
6338     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6339     break 2
6340   fi
6341 done
6342 done
6343
6344 fi
6345 fi
6346 AR=$ac_cv_prog_AR
6347 if test -n "$AR"; then
6348   echo "$as_me:$LINENO: result: $AR" >&5
6349 echo "${ECHO_T}$AR" >&6
6350 else
6351   echo "$as_me:$LINENO: result: no" >&5
6352 echo "${ECHO_T}no" >&6
6353 fi
6354
6355   done
6356 fi
6357
6358 for ncn_progname in ar; do
6359   if test -n "$ncn_tool_prefix"; then
6360     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6361 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6362 echo "$as_me:$LINENO: checking for $ac_word" >&5
6363 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6364 if test "${ac_cv_prog_AR+set}" = set; then
6365   echo $ECHO_N "(cached) $ECHO_C" >&6
6366 else
6367   if test -n "$AR"; then
6368   ac_cv_prog_AR="$AR" # Let the user override the test.
6369 else
6370 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6371 for as_dir in $PATH
6372 do
6373   IFS=$as_save_IFS
6374   test -z "$as_dir" && as_dir=.
6375   for ac_exec_ext in '' $ac_executable_extensions; do
6376   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6377     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6378     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6379     break 2
6380   fi
6381 done
6382 done
6383
6384 fi
6385 fi
6386 AR=$ac_cv_prog_AR
6387 if test -n "$AR"; then
6388   echo "$as_me:$LINENO: result: $AR" >&5
6389 echo "${ECHO_T}$AR" >&6
6390 else
6391   echo "$as_me:$LINENO: result: no" >&5
6392 echo "${ECHO_T}no" >&6
6393 fi
6394
6395   fi
6396   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6397     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6398 set dummy ${ncn_progname}; ac_word=$2
6399 echo "$as_me:$LINENO: checking for $ac_word" >&5
6400 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6401 if test "${ac_cv_prog_AR+set}" = set; then
6402   echo $ECHO_N "(cached) $ECHO_C" >&6
6403 else
6404   if test -n "$AR"; then
6405   ac_cv_prog_AR="$AR" # Let the user override the test.
6406 else
6407 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6408 for as_dir in $PATH
6409 do
6410   IFS=$as_save_IFS
6411   test -z "$as_dir" && as_dir=.
6412   for ac_exec_ext in '' $ac_executable_extensions; do
6413   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6414     ac_cv_prog_AR="${ncn_progname}"
6415     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6416     break 2
6417   fi
6418 done
6419 done
6420
6421 fi
6422 fi
6423 AR=$ac_cv_prog_AR
6424 if test -n "$AR"; then
6425   echo "$as_me:$LINENO: result: $AR" >&5
6426 echo "${ECHO_T}$AR" >&6
6427 else
6428   echo "$as_me:$LINENO: result: no" >&5
6429 echo "${ECHO_T}no" >&6
6430 fi
6431
6432   fi
6433   test -n "$ac_cv_prog_AR" && break
6434 done
6435
6436 if test -z "$ac_cv_prog_AR" ; then
6437   set dummy ar
6438   if test $build = $host ; then
6439     AR="$2"
6440   else
6441     AR="${ncn_tool_prefix}$2"
6442   fi
6443 fi
6444
6445
6446
6447 if test -n "$AS"; then
6448   ac_cv_prog_AS=$AS
6449 elif test -n "$ac_cv_prog_AS"; then
6450   AS=$ac_cv_prog_AS
6451 fi
6452
6453 if test -n "$ac_cv_prog_AS"; then
6454   for ncn_progname in as; do
6455     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6456 set dummy ${ncn_progname}; ac_word=$2
6457 echo "$as_me:$LINENO: checking for $ac_word" >&5
6458 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6459 if test "${ac_cv_prog_AS+set}" = set; then
6460   echo $ECHO_N "(cached) $ECHO_C" >&6
6461 else
6462   if test -n "$AS"; then
6463   ac_cv_prog_AS="$AS" # Let the user override the test.
6464 else
6465 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6466 for as_dir in $PATH
6467 do
6468   IFS=$as_save_IFS
6469   test -z "$as_dir" && as_dir=.
6470   for ac_exec_ext in '' $ac_executable_extensions; do
6471   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6472     ac_cv_prog_AS="${ncn_progname}"
6473     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6474     break 2
6475   fi
6476 done
6477 done
6478
6479 fi
6480 fi
6481 AS=$ac_cv_prog_AS
6482 if test -n "$AS"; then
6483   echo "$as_me:$LINENO: result: $AS" >&5
6484 echo "${ECHO_T}$AS" >&6
6485 else
6486   echo "$as_me:$LINENO: result: no" >&5
6487 echo "${ECHO_T}no" >&6
6488 fi
6489
6490   done
6491 fi
6492
6493 for ncn_progname in as; do
6494   if test -n "$ncn_tool_prefix"; then
6495     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6496 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6497 echo "$as_me:$LINENO: checking for $ac_word" >&5
6498 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6499 if test "${ac_cv_prog_AS+set}" = set; then
6500   echo $ECHO_N "(cached) $ECHO_C" >&6
6501 else
6502   if test -n "$AS"; then
6503   ac_cv_prog_AS="$AS" # Let the user override the test.
6504 else
6505 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6506 for as_dir in $PATH
6507 do
6508   IFS=$as_save_IFS
6509   test -z "$as_dir" && as_dir=.
6510   for ac_exec_ext in '' $ac_executable_extensions; do
6511   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6512     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6513     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6514     break 2
6515   fi
6516 done
6517 done
6518
6519 fi
6520 fi
6521 AS=$ac_cv_prog_AS
6522 if test -n "$AS"; then
6523   echo "$as_me:$LINENO: result: $AS" >&5
6524 echo "${ECHO_T}$AS" >&6
6525 else
6526   echo "$as_me:$LINENO: result: no" >&5
6527 echo "${ECHO_T}no" >&6
6528 fi
6529
6530   fi
6531   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6532     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6533 set dummy ${ncn_progname}; ac_word=$2
6534 echo "$as_me:$LINENO: checking for $ac_word" >&5
6535 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6536 if test "${ac_cv_prog_AS+set}" = set; then
6537   echo $ECHO_N "(cached) $ECHO_C" >&6
6538 else
6539   if test -n "$AS"; then
6540   ac_cv_prog_AS="$AS" # Let the user override the test.
6541 else
6542 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6543 for as_dir in $PATH
6544 do
6545   IFS=$as_save_IFS
6546   test -z "$as_dir" && as_dir=.
6547   for ac_exec_ext in '' $ac_executable_extensions; do
6548   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6549     ac_cv_prog_AS="${ncn_progname}"
6550     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6551     break 2
6552   fi
6553 done
6554 done
6555
6556 fi
6557 fi
6558 AS=$ac_cv_prog_AS
6559 if test -n "$AS"; then
6560   echo "$as_me:$LINENO: result: $AS" >&5
6561 echo "${ECHO_T}$AS" >&6
6562 else
6563   echo "$as_me:$LINENO: result: no" >&5
6564 echo "${ECHO_T}no" >&6
6565 fi
6566
6567   fi
6568   test -n "$ac_cv_prog_AS" && break
6569 done
6570
6571 if test -z "$ac_cv_prog_AS" ; then
6572   set dummy as
6573   if test $build = $host ; then
6574     AS="$2"
6575   else
6576     AS="${ncn_tool_prefix}$2"
6577   fi
6578 fi
6579
6580
6581
6582 if test -n "$DLLTOOL"; then
6583   ac_cv_prog_DLLTOOL=$DLLTOOL
6584 elif test -n "$ac_cv_prog_DLLTOOL"; then
6585   DLLTOOL=$ac_cv_prog_DLLTOOL
6586 fi
6587
6588 if test -n "$ac_cv_prog_DLLTOOL"; then
6589   for ncn_progname in dlltool; do
6590     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6591 set dummy ${ncn_progname}; ac_word=$2
6592 echo "$as_me:$LINENO: checking for $ac_word" >&5
6593 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6594 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6595   echo $ECHO_N "(cached) $ECHO_C" >&6
6596 else
6597   if test -n "$DLLTOOL"; then
6598   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6599 else
6600 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6601 for as_dir in $PATH
6602 do
6603   IFS=$as_save_IFS
6604   test -z "$as_dir" && as_dir=.
6605   for ac_exec_ext in '' $ac_executable_extensions; do
6606   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6607     ac_cv_prog_DLLTOOL="${ncn_progname}"
6608     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6609     break 2
6610   fi
6611 done
6612 done
6613
6614 fi
6615 fi
6616 DLLTOOL=$ac_cv_prog_DLLTOOL
6617 if test -n "$DLLTOOL"; then
6618   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6619 echo "${ECHO_T}$DLLTOOL" >&6
6620 else
6621   echo "$as_me:$LINENO: result: no" >&5
6622 echo "${ECHO_T}no" >&6
6623 fi
6624
6625   done
6626 fi
6627
6628 for ncn_progname in dlltool; do
6629   if test -n "$ncn_tool_prefix"; then
6630     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6631 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6632 echo "$as_me:$LINENO: checking for $ac_word" >&5
6633 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6634 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6635   echo $ECHO_N "(cached) $ECHO_C" >&6
6636 else
6637   if test -n "$DLLTOOL"; then
6638   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6639 else
6640 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6641 for as_dir in $PATH
6642 do
6643   IFS=$as_save_IFS
6644   test -z "$as_dir" && as_dir=.
6645   for ac_exec_ext in '' $ac_executable_extensions; do
6646   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6647     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6648     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6649     break 2
6650   fi
6651 done
6652 done
6653
6654 fi
6655 fi
6656 DLLTOOL=$ac_cv_prog_DLLTOOL
6657 if test -n "$DLLTOOL"; then
6658   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6659 echo "${ECHO_T}$DLLTOOL" >&6
6660 else
6661   echo "$as_me:$LINENO: result: no" >&5
6662 echo "${ECHO_T}no" >&6
6663 fi
6664
6665   fi
6666   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6667     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6668 set dummy ${ncn_progname}; ac_word=$2
6669 echo "$as_me:$LINENO: checking for $ac_word" >&5
6670 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6671 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6672   echo $ECHO_N "(cached) $ECHO_C" >&6
6673 else
6674   if test -n "$DLLTOOL"; then
6675   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6676 else
6677 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6678 for as_dir in $PATH
6679 do
6680   IFS=$as_save_IFS
6681   test -z "$as_dir" && as_dir=.
6682   for ac_exec_ext in '' $ac_executable_extensions; do
6683   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6684     ac_cv_prog_DLLTOOL="${ncn_progname}"
6685     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6686     break 2
6687   fi
6688 done
6689 done
6690
6691 fi
6692 fi
6693 DLLTOOL=$ac_cv_prog_DLLTOOL
6694 if test -n "$DLLTOOL"; then
6695   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6696 echo "${ECHO_T}$DLLTOOL" >&6
6697 else
6698   echo "$as_me:$LINENO: result: no" >&5
6699 echo "${ECHO_T}no" >&6
6700 fi
6701
6702   fi
6703   test -n "$ac_cv_prog_DLLTOOL" && break
6704 done
6705
6706 if test -z "$ac_cv_prog_DLLTOOL" ; then
6707   set dummy dlltool
6708   if test $build = $host ; then
6709     DLLTOOL="$2"
6710   else
6711     DLLTOOL="${ncn_tool_prefix}$2"
6712   fi
6713 fi
6714
6715
6716
6717 if test -n "$LD"; then
6718   ac_cv_prog_LD=$LD
6719 elif test -n "$ac_cv_prog_LD"; then
6720   LD=$ac_cv_prog_LD
6721 fi
6722
6723 if test -n "$ac_cv_prog_LD"; then
6724   for ncn_progname in ld; do
6725     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6726 set dummy ${ncn_progname}; ac_word=$2
6727 echo "$as_me:$LINENO: checking for $ac_word" >&5
6728 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6729 if test "${ac_cv_prog_LD+set}" = set; then
6730   echo $ECHO_N "(cached) $ECHO_C" >&6
6731 else
6732   if test -n "$LD"; then
6733   ac_cv_prog_LD="$LD" # Let the user override the test.
6734 else
6735 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6736 for as_dir in $PATH
6737 do
6738   IFS=$as_save_IFS
6739   test -z "$as_dir" && as_dir=.
6740   for ac_exec_ext in '' $ac_executable_extensions; do
6741   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6742     ac_cv_prog_LD="${ncn_progname}"
6743     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6744     break 2
6745   fi
6746 done
6747 done
6748
6749 fi
6750 fi
6751 LD=$ac_cv_prog_LD
6752 if test -n "$LD"; then
6753   echo "$as_me:$LINENO: result: $LD" >&5
6754 echo "${ECHO_T}$LD" >&6
6755 else
6756   echo "$as_me:$LINENO: result: no" >&5
6757 echo "${ECHO_T}no" >&6
6758 fi
6759
6760   done
6761 fi
6762
6763 for ncn_progname in ld; do
6764   if test -n "$ncn_tool_prefix"; then
6765     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6766 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6767 echo "$as_me:$LINENO: checking for $ac_word" >&5
6768 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6769 if test "${ac_cv_prog_LD+set}" = set; then
6770   echo $ECHO_N "(cached) $ECHO_C" >&6
6771 else
6772   if test -n "$LD"; then
6773   ac_cv_prog_LD="$LD" # Let the user override the test.
6774 else
6775 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6776 for as_dir in $PATH
6777 do
6778   IFS=$as_save_IFS
6779   test -z "$as_dir" && as_dir=.
6780   for ac_exec_ext in '' $ac_executable_extensions; do
6781   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6782     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6783     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6784     break 2
6785   fi
6786 done
6787 done
6788
6789 fi
6790 fi
6791 LD=$ac_cv_prog_LD
6792 if test -n "$LD"; then
6793   echo "$as_me:$LINENO: result: $LD" >&5
6794 echo "${ECHO_T}$LD" >&6
6795 else
6796   echo "$as_me:$LINENO: result: no" >&5
6797 echo "${ECHO_T}no" >&6
6798 fi
6799
6800   fi
6801   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6802     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6803 set dummy ${ncn_progname}; ac_word=$2
6804 echo "$as_me:$LINENO: checking for $ac_word" >&5
6805 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6806 if test "${ac_cv_prog_LD+set}" = set; then
6807   echo $ECHO_N "(cached) $ECHO_C" >&6
6808 else
6809   if test -n "$LD"; then
6810   ac_cv_prog_LD="$LD" # Let the user override the test.
6811 else
6812 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6813 for as_dir in $PATH
6814 do
6815   IFS=$as_save_IFS
6816   test -z "$as_dir" && as_dir=.
6817   for ac_exec_ext in '' $ac_executable_extensions; do
6818   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6819     ac_cv_prog_LD="${ncn_progname}"
6820     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6821     break 2
6822   fi
6823 done
6824 done
6825
6826 fi
6827 fi
6828 LD=$ac_cv_prog_LD
6829 if test -n "$LD"; then
6830   echo "$as_me:$LINENO: result: $LD" >&5
6831 echo "${ECHO_T}$LD" >&6
6832 else
6833   echo "$as_me:$LINENO: result: no" >&5
6834 echo "${ECHO_T}no" >&6
6835 fi
6836
6837   fi
6838   test -n "$ac_cv_prog_LD" && break
6839 done
6840
6841 if test -z "$ac_cv_prog_LD" ; then
6842   set dummy ld
6843   if test $build = $host ; then
6844     LD="$2"
6845   else
6846     LD="${ncn_tool_prefix}$2"
6847   fi
6848 fi
6849
6850
6851
6852 if test -n "$LIPO"; then
6853   ac_cv_prog_LIPO=$LIPO
6854 elif test -n "$ac_cv_prog_LIPO"; then
6855   LIPO=$ac_cv_prog_LIPO
6856 fi
6857
6858 if test -n "$ac_cv_prog_LIPO"; then
6859   for ncn_progname in lipo; do
6860     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6861 set dummy ${ncn_progname}; ac_word=$2
6862 echo "$as_me:$LINENO: checking for $ac_word" >&5
6863 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6864 if test "${ac_cv_prog_LIPO+set}" = set; then
6865   echo $ECHO_N "(cached) $ECHO_C" >&6
6866 else
6867   if test -n "$LIPO"; then
6868   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6869 else
6870 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6871 for as_dir in $PATH
6872 do
6873   IFS=$as_save_IFS
6874   test -z "$as_dir" && as_dir=.
6875   for ac_exec_ext in '' $ac_executable_extensions; do
6876   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6877     ac_cv_prog_LIPO="${ncn_progname}"
6878     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6879     break 2
6880   fi
6881 done
6882 done
6883
6884 fi
6885 fi
6886 LIPO=$ac_cv_prog_LIPO
6887 if test -n "$LIPO"; then
6888   echo "$as_me:$LINENO: result: $LIPO" >&5
6889 echo "${ECHO_T}$LIPO" >&6
6890 else
6891   echo "$as_me:$LINENO: result: no" >&5
6892 echo "${ECHO_T}no" >&6
6893 fi
6894
6895   done
6896 fi
6897
6898 for ncn_progname in lipo; do
6899   if test -n "$ncn_tool_prefix"; then
6900     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6901 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6902 echo "$as_me:$LINENO: checking for $ac_word" >&5
6903 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6904 if test "${ac_cv_prog_LIPO+set}" = set; then
6905   echo $ECHO_N "(cached) $ECHO_C" >&6
6906 else
6907   if test -n "$LIPO"; then
6908   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6909 else
6910 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6911 for as_dir in $PATH
6912 do
6913   IFS=$as_save_IFS
6914   test -z "$as_dir" && as_dir=.
6915   for ac_exec_ext in '' $ac_executable_extensions; do
6916   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6917     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6918     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6919     break 2
6920   fi
6921 done
6922 done
6923
6924 fi
6925 fi
6926 LIPO=$ac_cv_prog_LIPO
6927 if test -n "$LIPO"; then
6928   echo "$as_me:$LINENO: result: $LIPO" >&5
6929 echo "${ECHO_T}$LIPO" >&6
6930 else
6931   echo "$as_me:$LINENO: result: no" >&5
6932 echo "${ECHO_T}no" >&6
6933 fi
6934
6935   fi
6936   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6937     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6938 set dummy ${ncn_progname}; ac_word=$2
6939 echo "$as_me:$LINENO: checking for $ac_word" >&5
6940 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6941 if test "${ac_cv_prog_LIPO+set}" = set; then
6942   echo $ECHO_N "(cached) $ECHO_C" >&6
6943 else
6944   if test -n "$LIPO"; then
6945   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6946 else
6947 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6948 for as_dir in $PATH
6949 do
6950   IFS=$as_save_IFS
6951   test -z "$as_dir" && as_dir=.
6952   for ac_exec_ext in '' $ac_executable_extensions; do
6953   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6954     ac_cv_prog_LIPO="${ncn_progname}"
6955     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6956     break 2
6957   fi
6958 done
6959 done
6960
6961 fi
6962 fi
6963 LIPO=$ac_cv_prog_LIPO
6964 if test -n "$LIPO"; then
6965   echo "$as_me:$LINENO: result: $LIPO" >&5
6966 echo "${ECHO_T}$LIPO" >&6
6967 else
6968   echo "$as_me:$LINENO: result: no" >&5
6969 echo "${ECHO_T}no" >&6
6970 fi
6971
6972   fi
6973   test -n "$ac_cv_prog_LIPO" && break
6974 done
6975
6976 if test -z "$ac_cv_prog_LIPO" ; then
6977   set dummy lipo
6978   if test $build = $host ; then
6979     LIPO="$2"
6980   else
6981     LIPO="${ncn_tool_prefix}$2"
6982   fi
6983 fi
6984
6985
6986
6987 if test -n "$NM"; then
6988   ac_cv_prog_NM=$NM
6989 elif test -n "$ac_cv_prog_NM"; then
6990   NM=$ac_cv_prog_NM
6991 fi
6992
6993 if test -n "$ac_cv_prog_NM"; then
6994   for ncn_progname in nm; do
6995     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6996 set dummy ${ncn_progname}; ac_word=$2
6997 echo "$as_me:$LINENO: checking for $ac_word" >&5
6998 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6999 if test "${ac_cv_prog_NM+set}" = set; then
7000   echo $ECHO_N "(cached) $ECHO_C" >&6
7001 else
7002   if test -n "$NM"; then
7003   ac_cv_prog_NM="$NM" # Let the user override the test.
7004 else
7005 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7006 for as_dir in $PATH
7007 do
7008   IFS=$as_save_IFS
7009   test -z "$as_dir" && as_dir=.
7010   for ac_exec_ext in '' $ac_executable_extensions; do
7011   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7012     ac_cv_prog_NM="${ncn_progname}"
7013     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7014     break 2
7015   fi
7016 done
7017 done
7018
7019 fi
7020 fi
7021 NM=$ac_cv_prog_NM
7022 if test -n "$NM"; then
7023   echo "$as_me:$LINENO: result: $NM" >&5
7024 echo "${ECHO_T}$NM" >&6
7025 else
7026   echo "$as_me:$LINENO: result: no" >&5
7027 echo "${ECHO_T}no" >&6
7028 fi
7029
7030   done
7031 fi
7032
7033 for ncn_progname in nm; do
7034   if test -n "$ncn_tool_prefix"; then
7035     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7036 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7037 echo "$as_me:$LINENO: checking for $ac_word" >&5
7038 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7039 if test "${ac_cv_prog_NM+set}" = set; then
7040   echo $ECHO_N "(cached) $ECHO_C" >&6
7041 else
7042   if test -n "$NM"; then
7043   ac_cv_prog_NM="$NM" # Let the user override the test.
7044 else
7045 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7046 for as_dir in $PATH
7047 do
7048   IFS=$as_save_IFS
7049   test -z "$as_dir" && as_dir=.
7050   for ac_exec_ext in '' $ac_executable_extensions; do
7051   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7052     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7053     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7054     break 2
7055   fi
7056 done
7057 done
7058
7059 fi
7060 fi
7061 NM=$ac_cv_prog_NM
7062 if test -n "$NM"; then
7063   echo "$as_me:$LINENO: result: $NM" >&5
7064 echo "${ECHO_T}$NM" >&6
7065 else
7066   echo "$as_me:$LINENO: result: no" >&5
7067 echo "${ECHO_T}no" >&6
7068 fi
7069
7070   fi
7071   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7072     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7073 set dummy ${ncn_progname}; ac_word=$2
7074 echo "$as_me:$LINENO: checking for $ac_word" >&5
7075 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7076 if test "${ac_cv_prog_NM+set}" = set; then
7077   echo $ECHO_N "(cached) $ECHO_C" >&6
7078 else
7079   if test -n "$NM"; then
7080   ac_cv_prog_NM="$NM" # Let the user override the test.
7081 else
7082 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7083 for as_dir in $PATH
7084 do
7085   IFS=$as_save_IFS
7086   test -z "$as_dir" && as_dir=.
7087   for ac_exec_ext in '' $ac_executable_extensions; do
7088   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7089     ac_cv_prog_NM="${ncn_progname}"
7090     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7091     break 2
7092   fi
7093 done
7094 done
7095
7096 fi
7097 fi
7098 NM=$ac_cv_prog_NM
7099 if test -n "$NM"; then
7100   echo "$as_me:$LINENO: result: $NM" >&5
7101 echo "${ECHO_T}$NM" >&6
7102 else
7103   echo "$as_me:$LINENO: result: no" >&5
7104 echo "${ECHO_T}no" >&6
7105 fi
7106
7107   fi
7108   test -n "$ac_cv_prog_NM" && break
7109 done
7110
7111 if test -z "$ac_cv_prog_NM" ; then
7112   set dummy nm
7113   if test $build = $host ; then
7114     NM="$2"
7115   else
7116     NM="${ncn_tool_prefix}$2"
7117   fi
7118 fi
7119
7120
7121
7122 if test -n "$RANLIB"; then
7123   ac_cv_prog_RANLIB=$RANLIB
7124 elif test -n "$ac_cv_prog_RANLIB"; then
7125   RANLIB=$ac_cv_prog_RANLIB
7126 fi
7127
7128 if test -n "$ac_cv_prog_RANLIB"; then
7129   for ncn_progname in ranlib; do
7130     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7131 set dummy ${ncn_progname}; ac_word=$2
7132 echo "$as_me:$LINENO: checking for $ac_word" >&5
7133 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7134 if test "${ac_cv_prog_RANLIB+set}" = set; then
7135   echo $ECHO_N "(cached) $ECHO_C" >&6
7136 else
7137   if test -n "$RANLIB"; then
7138   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7139 else
7140 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7141 for as_dir in $PATH
7142 do
7143   IFS=$as_save_IFS
7144   test -z "$as_dir" && as_dir=.
7145   for ac_exec_ext in '' $ac_executable_extensions; do
7146   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7147     ac_cv_prog_RANLIB="${ncn_progname}"
7148     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7149     break 2
7150   fi
7151 done
7152 done
7153
7154 fi
7155 fi
7156 RANLIB=$ac_cv_prog_RANLIB
7157 if test -n "$RANLIB"; then
7158   echo "$as_me:$LINENO: result: $RANLIB" >&5
7159 echo "${ECHO_T}$RANLIB" >&6
7160 else
7161   echo "$as_me:$LINENO: result: no" >&5
7162 echo "${ECHO_T}no" >&6
7163 fi
7164
7165   done
7166 fi
7167
7168 for ncn_progname in ranlib; do
7169   if test -n "$ncn_tool_prefix"; then
7170     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7171 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7172 echo "$as_me:$LINENO: checking for $ac_word" >&5
7173 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7174 if test "${ac_cv_prog_RANLIB+set}" = set; then
7175   echo $ECHO_N "(cached) $ECHO_C" >&6
7176 else
7177   if test -n "$RANLIB"; then
7178   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7179 else
7180 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7181 for as_dir in $PATH
7182 do
7183   IFS=$as_save_IFS
7184   test -z "$as_dir" && as_dir=.
7185   for ac_exec_ext in '' $ac_executable_extensions; do
7186   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7187     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7188     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7189     break 2
7190   fi
7191 done
7192 done
7193
7194 fi
7195 fi
7196 RANLIB=$ac_cv_prog_RANLIB
7197 if test -n "$RANLIB"; then
7198   echo "$as_me:$LINENO: result: $RANLIB" >&5
7199 echo "${ECHO_T}$RANLIB" >&6
7200 else
7201   echo "$as_me:$LINENO: result: no" >&5
7202 echo "${ECHO_T}no" >&6
7203 fi
7204
7205   fi
7206   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7207     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7208 set dummy ${ncn_progname}; ac_word=$2
7209 echo "$as_me:$LINENO: checking for $ac_word" >&5
7210 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7211 if test "${ac_cv_prog_RANLIB+set}" = set; then
7212   echo $ECHO_N "(cached) $ECHO_C" >&6
7213 else
7214   if test -n "$RANLIB"; then
7215   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7216 else
7217 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7218 for as_dir in $PATH
7219 do
7220   IFS=$as_save_IFS
7221   test -z "$as_dir" && as_dir=.
7222   for ac_exec_ext in '' $ac_executable_extensions; do
7223   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7224     ac_cv_prog_RANLIB="${ncn_progname}"
7225     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7226     break 2
7227   fi
7228 done
7229 done
7230
7231 fi
7232 fi
7233 RANLIB=$ac_cv_prog_RANLIB
7234 if test -n "$RANLIB"; then
7235   echo "$as_me:$LINENO: result: $RANLIB" >&5
7236 echo "${ECHO_T}$RANLIB" >&6
7237 else
7238   echo "$as_me:$LINENO: result: no" >&5
7239 echo "${ECHO_T}no" >&6
7240 fi
7241
7242   fi
7243   test -n "$ac_cv_prog_RANLIB" && break
7244 done
7245
7246 if test -z "$ac_cv_prog_RANLIB" ; then
7247   RANLIB=":"
7248 fi
7249
7250
7251
7252 if test -n "$STRIP"; then
7253   ac_cv_prog_STRIP=$STRIP
7254 elif test -n "$ac_cv_prog_STRIP"; then
7255   STRIP=$ac_cv_prog_STRIP
7256 fi
7257
7258 if test -n "$ac_cv_prog_STRIP"; then
7259   for ncn_progname in strip; do
7260     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7261 set dummy ${ncn_progname}; ac_word=$2
7262 echo "$as_me:$LINENO: checking for $ac_word" >&5
7263 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7264 if test "${ac_cv_prog_STRIP+set}" = set; then
7265   echo $ECHO_N "(cached) $ECHO_C" >&6
7266 else
7267   if test -n "$STRIP"; then
7268   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7269 else
7270 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7271 for as_dir in $PATH
7272 do
7273   IFS=$as_save_IFS
7274   test -z "$as_dir" && as_dir=.
7275   for ac_exec_ext in '' $ac_executable_extensions; do
7276   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7277     ac_cv_prog_STRIP="${ncn_progname}"
7278     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7279     break 2
7280   fi
7281 done
7282 done
7283
7284 fi
7285 fi
7286 STRIP=$ac_cv_prog_STRIP
7287 if test -n "$STRIP"; then
7288   echo "$as_me:$LINENO: result: $STRIP" >&5
7289 echo "${ECHO_T}$STRIP" >&6
7290 else
7291   echo "$as_me:$LINENO: result: no" >&5
7292 echo "${ECHO_T}no" >&6
7293 fi
7294
7295   done
7296 fi
7297
7298 for ncn_progname in strip; do
7299   if test -n "$ncn_tool_prefix"; then
7300     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7301 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7302 echo "$as_me:$LINENO: checking for $ac_word" >&5
7303 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7304 if test "${ac_cv_prog_STRIP+set}" = set; then
7305   echo $ECHO_N "(cached) $ECHO_C" >&6
7306 else
7307   if test -n "$STRIP"; then
7308   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7309 else
7310 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7311 for as_dir in $PATH
7312 do
7313   IFS=$as_save_IFS
7314   test -z "$as_dir" && as_dir=.
7315   for ac_exec_ext in '' $ac_executable_extensions; do
7316   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7317     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7318     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7319     break 2
7320   fi
7321 done
7322 done
7323
7324 fi
7325 fi
7326 STRIP=$ac_cv_prog_STRIP
7327 if test -n "$STRIP"; then
7328   echo "$as_me:$LINENO: result: $STRIP" >&5
7329 echo "${ECHO_T}$STRIP" >&6
7330 else
7331   echo "$as_me:$LINENO: result: no" >&5
7332 echo "${ECHO_T}no" >&6
7333 fi
7334
7335   fi
7336   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7337     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7338 set dummy ${ncn_progname}; ac_word=$2
7339 echo "$as_me:$LINENO: checking for $ac_word" >&5
7340 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7341 if test "${ac_cv_prog_STRIP+set}" = set; then
7342   echo $ECHO_N "(cached) $ECHO_C" >&6
7343 else
7344   if test -n "$STRIP"; then
7345   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7346 else
7347 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7348 for as_dir in $PATH
7349 do
7350   IFS=$as_save_IFS
7351   test -z "$as_dir" && as_dir=.
7352   for ac_exec_ext in '' $ac_executable_extensions; do
7353   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7354     ac_cv_prog_STRIP="${ncn_progname}"
7355     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7356     break 2
7357   fi
7358 done
7359 done
7360
7361 fi
7362 fi
7363 STRIP=$ac_cv_prog_STRIP
7364 if test -n "$STRIP"; then
7365   echo "$as_me:$LINENO: result: $STRIP" >&5
7366 echo "${ECHO_T}$STRIP" >&6
7367 else
7368   echo "$as_me:$LINENO: result: no" >&5
7369 echo "${ECHO_T}no" >&6
7370 fi
7371
7372   fi
7373   test -n "$ac_cv_prog_STRIP" && break
7374 done
7375
7376 if test -z "$ac_cv_prog_STRIP" ; then
7377   STRIP=":"
7378 fi
7379
7380
7381
7382 if test -n "$WINDRES"; then
7383   ac_cv_prog_WINDRES=$WINDRES
7384 elif test -n "$ac_cv_prog_WINDRES"; then
7385   WINDRES=$ac_cv_prog_WINDRES
7386 fi
7387
7388 if test -n "$ac_cv_prog_WINDRES"; then
7389   for ncn_progname in windres; do
7390     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7391 set dummy ${ncn_progname}; ac_word=$2
7392 echo "$as_me:$LINENO: checking for $ac_word" >&5
7393 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7394 if test "${ac_cv_prog_WINDRES+set}" = set; then
7395   echo $ECHO_N "(cached) $ECHO_C" >&6
7396 else
7397   if test -n "$WINDRES"; then
7398   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7399 else
7400 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7401 for as_dir in $PATH
7402 do
7403   IFS=$as_save_IFS
7404   test -z "$as_dir" && as_dir=.
7405   for ac_exec_ext in '' $ac_executable_extensions; do
7406   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7407     ac_cv_prog_WINDRES="${ncn_progname}"
7408     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7409     break 2
7410   fi
7411 done
7412 done
7413
7414 fi
7415 fi
7416 WINDRES=$ac_cv_prog_WINDRES
7417 if test -n "$WINDRES"; then
7418   echo "$as_me:$LINENO: result: $WINDRES" >&5
7419 echo "${ECHO_T}$WINDRES" >&6
7420 else
7421   echo "$as_me:$LINENO: result: no" >&5
7422 echo "${ECHO_T}no" >&6
7423 fi
7424
7425   done
7426 fi
7427
7428 for ncn_progname in windres; do
7429   if test -n "$ncn_tool_prefix"; then
7430     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7431 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7432 echo "$as_me:$LINENO: checking for $ac_word" >&5
7433 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7434 if test "${ac_cv_prog_WINDRES+set}" = set; then
7435   echo $ECHO_N "(cached) $ECHO_C" >&6
7436 else
7437   if test -n "$WINDRES"; then
7438   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7439 else
7440 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7441 for as_dir in $PATH
7442 do
7443   IFS=$as_save_IFS
7444   test -z "$as_dir" && as_dir=.
7445   for ac_exec_ext in '' $ac_executable_extensions; do
7446   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7447     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7448     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7449     break 2
7450   fi
7451 done
7452 done
7453
7454 fi
7455 fi
7456 WINDRES=$ac_cv_prog_WINDRES
7457 if test -n "$WINDRES"; then
7458   echo "$as_me:$LINENO: result: $WINDRES" >&5
7459 echo "${ECHO_T}$WINDRES" >&6
7460 else
7461   echo "$as_me:$LINENO: result: no" >&5
7462 echo "${ECHO_T}no" >&6
7463 fi
7464
7465   fi
7466   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7467     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7468 set dummy ${ncn_progname}; ac_word=$2
7469 echo "$as_me:$LINENO: checking for $ac_word" >&5
7470 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7471 if test "${ac_cv_prog_WINDRES+set}" = set; then
7472   echo $ECHO_N "(cached) $ECHO_C" >&6
7473 else
7474   if test -n "$WINDRES"; then
7475   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7476 else
7477 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7478 for as_dir in $PATH
7479 do
7480   IFS=$as_save_IFS
7481   test -z "$as_dir" && as_dir=.
7482   for ac_exec_ext in '' $ac_executable_extensions; do
7483   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7484     ac_cv_prog_WINDRES="${ncn_progname}"
7485     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7486     break 2
7487   fi
7488 done
7489 done
7490
7491 fi
7492 fi
7493 WINDRES=$ac_cv_prog_WINDRES
7494 if test -n "$WINDRES"; then
7495   echo "$as_me:$LINENO: result: $WINDRES" >&5
7496 echo "${ECHO_T}$WINDRES" >&6
7497 else
7498   echo "$as_me:$LINENO: result: no" >&5
7499 echo "${ECHO_T}no" >&6
7500 fi
7501
7502   fi
7503   test -n "$ac_cv_prog_WINDRES" && break
7504 done
7505
7506 if test -z "$ac_cv_prog_WINDRES" ; then
7507   set dummy windres
7508   if test $build = $host ; then
7509     WINDRES="$2"
7510   else
7511     WINDRES="${ncn_tool_prefix}$2"
7512   fi
7513 fi
7514
7515
7516
7517 if test -n "$WINDMC"; then
7518   ac_cv_prog_WINDMC=$WINDMC
7519 elif test -n "$ac_cv_prog_WINDMC"; then
7520   WINDMC=$ac_cv_prog_WINDMC
7521 fi
7522
7523 if test -n "$ac_cv_prog_WINDMC"; then
7524   for ncn_progname in windmc; do
7525     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7526 set dummy ${ncn_progname}; ac_word=$2
7527 echo "$as_me:$LINENO: checking for $ac_word" >&5
7528 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7529 if test "${ac_cv_prog_WINDMC+set}" = set; then
7530   echo $ECHO_N "(cached) $ECHO_C" >&6
7531 else
7532   if test -n "$WINDMC"; then
7533   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7534 else
7535 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7536 for as_dir in $PATH
7537 do
7538   IFS=$as_save_IFS
7539   test -z "$as_dir" && as_dir=.
7540   for ac_exec_ext in '' $ac_executable_extensions; do
7541   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7542     ac_cv_prog_WINDMC="${ncn_progname}"
7543     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7544     break 2
7545   fi
7546 done
7547 done
7548
7549 fi
7550 fi
7551 WINDMC=$ac_cv_prog_WINDMC
7552 if test -n "$WINDMC"; then
7553   echo "$as_me:$LINENO: result: $WINDMC" >&5
7554 echo "${ECHO_T}$WINDMC" >&6
7555 else
7556   echo "$as_me:$LINENO: result: no" >&5
7557 echo "${ECHO_T}no" >&6
7558 fi
7559
7560   done
7561 fi
7562
7563 for ncn_progname in windmc; do
7564   if test -n "$ncn_tool_prefix"; then
7565     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7566 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7567 echo "$as_me:$LINENO: checking for $ac_word" >&5
7568 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7569 if test "${ac_cv_prog_WINDMC+set}" = set; then
7570   echo $ECHO_N "(cached) $ECHO_C" >&6
7571 else
7572   if test -n "$WINDMC"; then
7573   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7574 else
7575 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7576 for as_dir in $PATH
7577 do
7578   IFS=$as_save_IFS
7579   test -z "$as_dir" && as_dir=.
7580   for ac_exec_ext in '' $ac_executable_extensions; do
7581   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7582     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7583     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7584     break 2
7585   fi
7586 done
7587 done
7588
7589 fi
7590 fi
7591 WINDMC=$ac_cv_prog_WINDMC
7592 if test -n "$WINDMC"; then
7593   echo "$as_me:$LINENO: result: $WINDMC" >&5
7594 echo "${ECHO_T}$WINDMC" >&6
7595 else
7596   echo "$as_me:$LINENO: result: no" >&5
7597 echo "${ECHO_T}no" >&6
7598 fi
7599
7600   fi
7601   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7602     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7603 set dummy ${ncn_progname}; ac_word=$2
7604 echo "$as_me:$LINENO: checking for $ac_word" >&5
7605 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7606 if test "${ac_cv_prog_WINDMC+set}" = set; then
7607   echo $ECHO_N "(cached) $ECHO_C" >&6
7608 else
7609   if test -n "$WINDMC"; then
7610   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7611 else
7612 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7613 for as_dir in $PATH
7614 do
7615   IFS=$as_save_IFS
7616   test -z "$as_dir" && as_dir=.
7617   for ac_exec_ext in '' $ac_executable_extensions; do
7618   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7619     ac_cv_prog_WINDMC="${ncn_progname}"
7620     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7621     break 2
7622   fi
7623 done
7624 done
7625
7626 fi
7627 fi
7628 WINDMC=$ac_cv_prog_WINDMC
7629 if test -n "$WINDMC"; then
7630   echo "$as_me:$LINENO: result: $WINDMC" >&5
7631 echo "${ECHO_T}$WINDMC" >&6
7632 else
7633   echo "$as_me:$LINENO: result: no" >&5
7634 echo "${ECHO_T}no" >&6
7635 fi
7636
7637   fi
7638   test -n "$ac_cv_prog_WINDMC" && break
7639 done
7640
7641 if test -z "$ac_cv_prog_WINDMC" ; then
7642   set dummy windmc
7643   if test $build = $host ; then
7644     WINDMC="$2"
7645   else
7646     WINDMC="${ncn_tool_prefix}$2"
7647   fi
7648 fi
7649
7650
7651
7652 if test -n "$OBJCOPY"; then
7653   ac_cv_prog_OBJCOPY=$OBJCOPY
7654 elif test -n "$ac_cv_prog_OBJCOPY"; then
7655   OBJCOPY=$ac_cv_prog_OBJCOPY
7656 fi
7657
7658 if test -n "$ac_cv_prog_OBJCOPY"; then
7659   for ncn_progname in objcopy; do
7660     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7661 set dummy ${ncn_progname}; ac_word=$2
7662 echo "$as_me:$LINENO: checking for $ac_word" >&5
7663 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7664 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7665   echo $ECHO_N "(cached) $ECHO_C" >&6
7666 else
7667   if test -n "$OBJCOPY"; then
7668   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7669 else
7670 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7671 for as_dir in $PATH
7672 do
7673   IFS=$as_save_IFS
7674   test -z "$as_dir" && as_dir=.
7675   for ac_exec_ext in '' $ac_executable_extensions; do
7676   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7677     ac_cv_prog_OBJCOPY="${ncn_progname}"
7678     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7679     break 2
7680   fi
7681 done
7682 done
7683
7684 fi
7685 fi
7686 OBJCOPY=$ac_cv_prog_OBJCOPY
7687 if test -n "$OBJCOPY"; then
7688   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7689 echo "${ECHO_T}$OBJCOPY" >&6
7690 else
7691   echo "$as_me:$LINENO: result: no" >&5
7692 echo "${ECHO_T}no" >&6
7693 fi
7694
7695   done
7696 fi
7697
7698 for ncn_progname in objcopy; do
7699   if test -n "$ncn_tool_prefix"; then
7700     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7701 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7702 echo "$as_me:$LINENO: checking for $ac_word" >&5
7703 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7704 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7705   echo $ECHO_N "(cached) $ECHO_C" >&6
7706 else
7707   if test -n "$OBJCOPY"; then
7708   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7709 else
7710 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7711 for as_dir in $PATH
7712 do
7713   IFS=$as_save_IFS
7714   test -z "$as_dir" && as_dir=.
7715   for ac_exec_ext in '' $ac_executable_extensions; do
7716   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7717     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7718     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7719     break 2
7720   fi
7721 done
7722 done
7723
7724 fi
7725 fi
7726 OBJCOPY=$ac_cv_prog_OBJCOPY
7727 if test -n "$OBJCOPY"; then
7728   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7729 echo "${ECHO_T}$OBJCOPY" >&6
7730 else
7731   echo "$as_me:$LINENO: result: no" >&5
7732 echo "${ECHO_T}no" >&6
7733 fi
7734
7735   fi
7736   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7737     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7738 set dummy ${ncn_progname}; ac_word=$2
7739 echo "$as_me:$LINENO: checking for $ac_word" >&5
7740 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7741 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7742   echo $ECHO_N "(cached) $ECHO_C" >&6
7743 else
7744   if test -n "$OBJCOPY"; then
7745   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7746 else
7747 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7748 for as_dir in $PATH
7749 do
7750   IFS=$as_save_IFS
7751   test -z "$as_dir" && as_dir=.
7752   for ac_exec_ext in '' $ac_executable_extensions; do
7753   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7754     ac_cv_prog_OBJCOPY="${ncn_progname}"
7755     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7756     break 2
7757   fi
7758 done
7759 done
7760
7761 fi
7762 fi
7763 OBJCOPY=$ac_cv_prog_OBJCOPY
7764 if test -n "$OBJCOPY"; then
7765   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7766 echo "${ECHO_T}$OBJCOPY" >&6
7767 else
7768   echo "$as_me:$LINENO: result: no" >&5
7769 echo "${ECHO_T}no" >&6
7770 fi
7771
7772   fi
7773   test -n "$ac_cv_prog_OBJCOPY" && break
7774 done
7775
7776 if test -z "$ac_cv_prog_OBJCOPY" ; then
7777   set dummy objcopy
7778   if test $build = $host ; then
7779     OBJCOPY="$2"
7780   else
7781     OBJCOPY="${ncn_tool_prefix}$2"
7782   fi
7783 fi
7784
7785
7786
7787 if test -n "$OBJDUMP"; then
7788   ac_cv_prog_OBJDUMP=$OBJDUMP
7789 elif test -n "$ac_cv_prog_OBJDUMP"; then
7790   OBJDUMP=$ac_cv_prog_OBJDUMP
7791 fi
7792
7793 if test -n "$ac_cv_prog_OBJDUMP"; then
7794   for ncn_progname in objdump; do
7795     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7796 set dummy ${ncn_progname}; ac_word=$2
7797 echo "$as_me:$LINENO: checking for $ac_word" >&5
7798 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7799 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7800   echo $ECHO_N "(cached) $ECHO_C" >&6
7801 else
7802   if test -n "$OBJDUMP"; then
7803   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7804 else
7805 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7806 for as_dir in $PATH
7807 do
7808   IFS=$as_save_IFS
7809   test -z "$as_dir" && as_dir=.
7810   for ac_exec_ext in '' $ac_executable_extensions; do
7811   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7812     ac_cv_prog_OBJDUMP="${ncn_progname}"
7813     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7814     break 2
7815   fi
7816 done
7817 done
7818
7819 fi
7820 fi
7821 OBJDUMP=$ac_cv_prog_OBJDUMP
7822 if test -n "$OBJDUMP"; then
7823   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7824 echo "${ECHO_T}$OBJDUMP" >&6
7825 else
7826   echo "$as_me:$LINENO: result: no" >&5
7827 echo "${ECHO_T}no" >&6
7828 fi
7829
7830   done
7831 fi
7832
7833 for ncn_progname in objdump; do
7834   if test -n "$ncn_tool_prefix"; then
7835     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7836 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7837 echo "$as_me:$LINENO: checking for $ac_word" >&5
7838 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7839 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7840   echo $ECHO_N "(cached) $ECHO_C" >&6
7841 else
7842   if test -n "$OBJDUMP"; then
7843   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7844 else
7845 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7846 for as_dir in $PATH
7847 do
7848   IFS=$as_save_IFS
7849   test -z "$as_dir" && as_dir=.
7850   for ac_exec_ext in '' $ac_executable_extensions; do
7851   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7852     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7853     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7854     break 2
7855   fi
7856 done
7857 done
7858
7859 fi
7860 fi
7861 OBJDUMP=$ac_cv_prog_OBJDUMP
7862 if test -n "$OBJDUMP"; then
7863   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7864 echo "${ECHO_T}$OBJDUMP" >&6
7865 else
7866   echo "$as_me:$LINENO: result: no" >&5
7867 echo "${ECHO_T}no" >&6
7868 fi
7869
7870   fi
7871   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7872     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7873 set dummy ${ncn_progname}; ac_word=$2
7874 echo "$as_me:$LINENO: checking for $ac_word" >&5
7875 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7876 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7877   echo $ECHO_N "(cached) $ECHO_C" >&6
7878 else
7879   if test -n "$OBJDUMP"; then
7880   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7881 else
7882 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7883 for as_dir in $PATH
7884 do
7885   IFS=$as_save_IFS
7886   test -z "$as_dir" && as_dir=.
7887   for ac_exec_ext in '' $ac_executable_extensions; do
7888   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7889     ac_cv_prog_OBJDUMP="${ncn_progname}"
7890     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7891     break 2
7892   fi
7893 done
7894 done
7895
7896 fi
7897 fi
7898 OBJDUMP=$ac_cv_prog_OBJDUMP
7899 if test -n "$OBJDUMP"; then
7900   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7901 echo "${ECHO_T}$OBJDUMP" >&6
7902 else
7903   echo "$as_me:$LINENO: result: no" >&5
7904 echo "${ECHO_T}no" >&6
7905 fi
7906
7907   fi
7908   test -n "$ac_cv_prog_OBJDUMP" && break
7909 done
7910
7911 if test -z "$ac_cv_prog_OBJDUMP" ; then
7912   set dummy objdump
7913   if test $build = $host ; then
7914     OBJDUMP="$2"
7915   else
7916     OBJDUMP="${ncn_tool_prefix}$2"
7917   fi
7918 fi
7919
7920
7921
7922
7923
7924
7925
7926 # Target tools.
7927
7928 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7929 if test "${with_build_time_tools+set}" = set; then
7930   withval="$with_build_time_tools"
7931   case x"$withval" in
7932      x/*) ;;
7933      *)
7934        with_build_time_tools=
7935        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7936 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7937        ;;
7938    esac
7939 else
7940   with_build_time_tools=
7941 fi;
7942
7943
7944
7945 if test -n "$CC_FOR_TARGET"; then
7946   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7947 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7948   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7949 fi
7950
7951 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7952   for ncn_progname in cc gcc; do
7953     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7954 set dummy ${ncn_progname}; ac_word=$2
7955 echo "$as_me:$LINENO: checking for $ac_word" >&5
7956 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7957 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7958   echo $ECHO_N "(cached) $ECHO_C" >&6
7959 else
7960   if test -n "$CC_FOR_TARGET"; then
7961   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7962 else
7963 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7964 for as_dir in $PATH
7965 do
7966   IFS=$as_save_IFS
7967   test -z "$as_dir" && as_dir=.
7968   for ac_exec_ext in '' $ac_executable_extensions; do
7969   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7970     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7971     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7972     break 2
7973   fi
7974 done
7975 done
7976
7977 fi
7978 fi
7979 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7980 if test -n "$CC_FOR_TARGET"; then
7981   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7982 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7983 else
7984   echo "$as_me:$LINENO: result: no" >&5
7985 echo "${ECHO_T}no" >&6
7986 fi
7987
7988   done
7989 fi
7990
7991 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
7992   for ncn_progname in cc gcc; do
7993     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7994 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7995     if test -x $with_build_time_tools/${ncn_progname}; then
7996       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7997       echo "$as_me:$LINENO: result: yes" >&5
7998 echo "${ECHO_T}yes" >&6
7999       break
8000     else
8001       echo "$as_me:$LINENO: result: no" >&5
8002 echo "${ECHO_T}no" >&6
8003     fi
8004   done
8005 fi
8006
8007 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8008   for ncn_progname in cc gcc; do
8009     if test -n "$ncn_target_tool_prefix"; then
8010       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8011 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8012 echo "$as_me:$LINENO: checking for $ac_word" >&5
8013 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8014 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8015   echo $ECHO_N "(cached) $ECHO_C" >&6
8016 else
8017   if test -n "$CC_FOR_TARGET"; then
8018   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8019 else
8020 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8021 for as_dir in $PATH
8022 do
8023   IFS=$as_save_IFS
8024   test -z "$as_dir" && as_dir=.
8025   for ac_exec_ext in '' $ac_executable_extensions; do
8026   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8027     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8028     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8029     break 2
8030   fi
8031 done
8032 done
8033
8034 fi
8035 fi
8036 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8037 if test -n "$CC_FOR_TARGET"; then
8038   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8039 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8040 else
8041   echo "$as_me:$LINENO: result: no" >&5
8042 echo "${ECHO_T}no" >&6
8043 fi
8044
8045     fi
8046     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8047       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8048 set dummy ${ncn_progname}; ac_word=$2
8049 echo "$as_me:$LINENO: checking for $ac_word" >&5
8050 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8051 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8052   echo $ECHO_N "(cached) $ECHO_C" >&6
8053 else
8054   if test -n "$CC_FOR_TARGET"; then
8055   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8056 else
8057 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8058 for as_dir in $PATH
8059 do
8060   IFS=$as_save_IFS
8061   test -z "$as_dir" && as_dir=.
8062   for ac_exec_ext in '' $ac_executable_extensions; do
8063   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8064     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8065     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8066     break 2
8067   fi
8068 done
8069 done
8070
8071 fi
8072 fi
8073 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8074 if test -n "$CC_FOR_TARGET"; then
8075   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8076 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8077 else
8078   echo "$as_me:$LINENO: result: no" >&5
8079 echo "${ECHO_T}no" >&6
8080 fi
8081
8082     fi
8083     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8084   done
8085 fi
8086
8087 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8088   set dummy cc gcc
8089   if test $build = $target ; then
8090     CC_FOR_TARGET="$2"
8091   else
8092     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8093   fi
8094 else
8095   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8096 fi
8097
8098
8099
8100 if test -n "$CXX_FOR_TARGET"; then
8101   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8102 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8103   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8104 fi
8105
8106 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8107   for ncn_progname in c++ g++ cxx gxx; do
8108     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8109 set dummy ${ncn_progname}; ac_word=$2
8110 echo "$as_me:$LINENO: checking for $ac_word" >&5
8111 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8112 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8113   echo $ECHO_N "(cached) $ECHO_C" >&6
8114 else
8115   if test -n "$CXX_FOR_TARGET"; then
8116   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8117 else
8118 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8119 for as_dir in $PATH
8120 do
8121   IFS=$as_save_IFS
8122   test -z "$as_dir" && as_dir=.
8123   for ac_exec_ext in '' $ac_executable_extensions; do
8124   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8125     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8126     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8127     break 2
8128   fi
8129 done
8130 done
8131
8132 fi
8133 fi
8134 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8135 if test -n "$CXX_FOR_TARGET"; then
8136   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8137 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8138 else
8139   echo "$as_me:$LINENO: result: no" >&5
8140 echo "${ECHO_T}no" >&6
8141 fi
8142
8143   done
8144 fi
8145
8146 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8147   for ncn_progname in c++ g++ cxx gxx; do
8148     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8149 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8150     if test -x $with_build_time_tools/${ncn_progname}; then
8151       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8152       echo "$as_me:$LINENO: result: yes" >&5
8153 echo "${ECHO_T}yes" >&6
8154       break
8155     else
8156       echo "$as_me:$LINENO: result: no" >&5
8157 echo "${ECHO_T}no" >&6
8158     fi
8159   done
8160 fi
8161
8162 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8163   for ncn_progname in c++ g++ cxx gxx; do
8164     if test -n "$ncn_target_tool_prefix"; then
8165       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8166 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8167 echo "$as_me:$LINENO: checking for $ac_word" >&5
8168 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8169 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8170   echo $ECHO_N "(cached) $ECHO_C" >&6
8171 else
8172   if test -n "$CXX_FOR_TARGET"; then
8173   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8174 else
8175 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8176 for as_dir in $PATH
8177 do
8178   IFS=$as_save_IFS
8179   test -z "$as_dir" && as_dir=.
8180   for ac_exec_ext in '' $ac_executable_extensions; do
8181   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8182     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8183     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8184     break 2
8185   fi
8186 done
8187 done
8188
8189 fi
8190 fi
8191 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8192 if test -n "$CXX_FOR_TARGET"; then
8193   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8194 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8195 else
8196   echo "$as_me:$LINENO: result: no" >&5
8197 echo "${ECHO_T}no" >&6
8198 fi
8199
8200     fi
8201     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8202       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8203 set dummy ${ncn_progname}; ac_word=$2
8204 echo "$as_me:$LINENO: checking for $ac_word" >&5
8205 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8206 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8207   echo $ECHO_N "(cached) $ECHO_C" >&6
8208 else
8209   if test -n "$CXX_FOR_TARGET"; then
8210   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8211 else
8212 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8213 for as_dir in $PATH
8214 do
8215   IFS=$as_save_IFS
8216   test -z "$as_dir" && as_dir=.
8217   for ac_exec_ext in '' $ac_executable_extensions; do
8218   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8219     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8220     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8221     break 2
8222   fi
8223 done
8224 done
8225
8226 fi
8227 fi
8228 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8229 if test -n "$CXX_FOR_TARGET"; then
8230   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8231 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8232 else
8233   echo "$as_me:$LINENO: result: no" >&5
8234 echo "${ECHO_T}no" >&6
8235 fi
8236
8237     fi
8238     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8239   done
8240 fi
8241
8242 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8243   set dummy c++ g++ cxx gxx
8244   if test $build = $target ; then
8245     CXX_FOR_TARGET="$2"
8246   else
8247     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8248   fi
8249 else
8250   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8251 fi
8252
8253
8254
8255 if test -n "$GCC_FOR_TARGET"; then
8256   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8257 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8258   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8259 fi
8260
8261 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8262   for ncn_progname in gcc; do
8263     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8264 set dummy ${ncn_progname}; ac_word=$2
8265 echo "$as_me:$LINENO: checking for $ac_word" >&5
8266 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8267 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8268   echo $ECHO_N "(cached) $ECHO_C" >&6
8269 else
8270   if test -n "$GCC_FOR_TARGET"; then
8271   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8272 else
8273 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8274 for as_dir in $PATH
8275 do
8276   IFS=$as_save_IFS
8277   test -z "$as_dir" && as_dir=.
8278   for ac_exec_ext in '' $ac_executable_extensions; do
8279   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8280     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8281     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8282     break 2
8283   fi
8284 done
8285 done
8286
8287 fi
8288 fi
8289 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8290 if test -n "$GCC_FOR_TARGET"; then
8291   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8292 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8293 else
8294   echo "$as_me:$LINENO: result: no" >&5
8295 echo "${ECHO_T}no" >&6
8296 fi
8297
8298   done
8299 fi
8300
8301 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8302   for ncn_progname in gcc; do
8303     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8304 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8305     if test -x $with_build_time_tools/${ncn_progname}; then
8306       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8307       echo "$as_me:$LINENO: result: yes" >&5
8308 echo "${ECHO_T}yes" >&6
8309       break
8310     else
8311       echo "$as_me:$LINENO: result: no" >&5
8312 echo "${ECHO_T}no" >&6
8313     fi
8314   done
8315 fi
8316
8317 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8318   for ncn_progname in gcc; do
8319     if test -n "$ncn_target_tool_prefix"; then
8320       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8321 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8322 echo "$as_me:$LINENO: checking for $ac_word" >&5
8323 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8324 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8325   echo $ECHO_N "(cached) $ECHO_C" >&6
8326 else
8327   if test -n "$GCC_FOR_TARGET"; then
8328   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8329 else
8330 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8331 for as_dir in $PATH
8332 do
8333   IFS=$as_save_IFS
8334   test -z "$as_dir" && as_dir=.
8335   for ac_exec_ext in '' $ac_executable_extensions; do
8336   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8337     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8338     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8339     break 2
8340   fi
8341 done
8342 done
8343
8344 fi
8345 fi
8346 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8347 if test -n "$GCC_FOR_TARGET"; then
8348   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8349 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8350 else
8351   echo "$as_me:$LINENO: result: no" >&5
8352 echo "${ECHO_T}no" >&6
8353 fi
8354
8355     fi
8356     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8357       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8358 set dummy ${ncn_progname}; ac_word=$2
8359 echo "$as_me:$LINENO: checking for $ac_word" >&5
8360 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8361 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8362   echo $ECHO_N "(cached) $ECHO_C" >&6
8363 else
8364   if test -n "$GCC_FOR_TARGET"; then
8365   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8366 else
8367 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8368 for as_dir in $PATH
8369 do
8370   IFS=$as_save_IFS
8371   test -z "$as_dir" && as_dir=.
8372   for ac_exec_ext in '' $ac_executable_extensions; do
8373   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8374     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8375     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8376     break 2
8377   fi
8378 done
8379 done
8380
8381 fi
8382 fi
8383 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8384 if test -n "$GCC_FOR_TARGET"; then
8385   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8386 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8387 else
8388   echo "$as_me:$LINENO: result: no" >&5
8389 echo "${ECHO_T}no" >&6
8390 fi
8391
8392     fi
8393     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8394   done
8395 fi
8396
8397 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8398   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8399 else
8400   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8401 fi
8402
8403
8404
8405 if test -n "$GCJ_FOR_TARGET"; then
8406   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8407 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8408   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8409 fi
8410
8411 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8412   for ncn_progname in gcj; do
8413     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8414 set dummy ${ncn_progname}; ac_word=$2
8415 echo "$as_me:$LINENO: checking for $ac_word" >&5
8416 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8417 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8418   echo $ECHO_N "(cached) $ECHO_C" >&6
8419 else
8420   if test -n "$GCJ_FOR_TARGET"; then
8421   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8422 else
8423 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8424 for as_dir in $PATH
8425 do
8426   IFS=$as_save_IFS
8427   test -z "$as_dir" && as_dir=.
8428   for ac_exec_ext in '' $ac_executable_extensions; do
8429   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8430     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8431     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8432     break 2
8433   fi
8434 done
8435 done
8436
8437 fi
8438 fi
8439 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8440 if test -n "$GCJ_FOR_TARGET"; then
8441   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8442 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8443 else
8444   echo "$as_me:$LINENO: result: no" >&5
8445 echo "${ECHO_T}no" >&6
8446 fi
8447
8448   done
8449 fi
8450
8451 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8452   for ncn_progname in gcj; do
8453     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8454 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8455     if test -x $with_build_time_tools/${ncn_progname}; then
8456       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8457       echo "$as_me:$LINENO: result: yes" >&5
8458 echo "${ECHO_T}yes" >&6
8459       break
8460     else
8461       echo "$as_me:$LINENO: result: no" >&5
8462 echo "${ECHO_T}no" >&6
8463     fi
8464   done
8465 fi
8466
8467 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8468   for ncn_progname in gcj; do
8469     if test -n "$ncn_target_tool_prefix"; then
8470       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8471 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8472 echo "$as_me:$LINENO: checking for $ac_word" >&5
8473 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8474 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8475   echo $ECHO_N "(cached) $ECHO_C" >&6
8476 else
8477   if test -n "$GCJ_FOR_TARGET"; then
8478   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8479 else
8480 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8481 for as_dir in $PATH
8482 do
8483   IFS=$as_save_IFS
8484   test -z "$as_dir" && as_dir=.
8485   for ac_exec_ext in '' $ac_executable_extensions; do
8486   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8487     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8488     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8489     break 2
8490   fi
8491 done
8492 done
8493
8494 fi
8495 fi
8496 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8497 if test -n "$GCJ_FOR_TARGET"; then
8498   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8499 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8500 else
8501   echo "$as_me:$LINENO: result: no" >&5
8502 echo "${ECHO_T}no" >&6
8503 fi
8504
8505     fi
8506     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8507       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8508 set dummy ${ncn_progname}; ac_word=$2
8509 echo "$as_me:$LINENO: checking for $ac_word" >&5
8510 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8511 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8512   echo $ECHO_N "(cached) $ECHO_C" >&6
8513 else
8514   if test -n "$GCJ_FOR_TARGET"; then
8515   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8516 else
8517 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8518 for as_dir in $PATH
8519 do
8520   IFS=$as_save_IFS
8521   test -z "$as_dir" && as_dir=.
8522   for ac_exec_ext in '' $ac_executable_extensions; do
8523   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8524     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8525     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8526     break 2
8527   fi
8528 done
8529 done
8530
8531 fi
8532 fi
8533 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8534 if test -n "$GCJ_FOR_TARGET"; then
8535   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8536 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8537 else
8538   echo "$as_me:$LINENO: result: no" >&5
8539 echo "${ECHO_T}no" >&6
8540 fi
8541
8542     fi
8543     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8544   done
8545 fi
8546
8547 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8548   set dummy gcj
8549   if test $build = $target ; then
8550     GCJ_FOR_TARGET="$2"
8551   else
8552     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8553   fi
8554 else
8555   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8556 fi
8557
8558
8559
8560 if test -n "$GFORTRAN_FOR_TARGET"; then
8561   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8562 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8563   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8564 fi
8565
8566 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8567   for ncn_progname in gfortran; do
8568     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8569 set dummy ${ncn_progname}; ac_word=$2
8570 echo "$as_me:$LINENO: checking for $ac_word" >&5
8571 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8572 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8573   echo $ECHO_N "(cached) $ECHO_C" >&6
8574 else
8575   if test -n "$GFORTRAN_FOR_TARGET"; then
8576   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8577 else
8578 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8579 for as_dir in $PATH
8580 do
8581   IFS=$as_save_IFS
8582   test -z "$as_dir" && as_dir=.
8583   for ac_exec_ext in '' $ac_executable_extensions; do
8584   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8585     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8586     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8587     break 2
8588   fi
8589 done
8590 done
8591
8592 fi
8593 fi
8594 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8595 if test -n "$GFORTRAN_FOR_TARGET"; then
8596   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8597 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8598 else
8599   echo "$as_me:$LINENO: result: no" >&5
8600 echo "${ECHO_T}no" >&6
8601 fi
8602
8603   done
8604 fi
8605
8606 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8607   for ncn_progname in gfortran; do
8608     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8609 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8610     if test -x $with_build_time_tools/${ncn_progname}; then
8611       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8612       echo "$as_me:$LINENO: result: yes" >&5
8613 echo "${ECHO_T}yes" >&6
8614       break
8615     else
8616       echo "$as_me:$LINENO: result: no" >&5
8617 echo "${ECHO_T}no" >&6
8618     fi
8619   done
8620 fi
8621
8622 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8623   for ncn_progname in gfortran; do
8624     if test -n "$ncn_target_tool_prefix"; then
8625       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8626 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8627 echo "$as_me:$LINENO: checking for $ac_word" >&5
8628 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8629 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8630   echo $ECHO_N "(cached) $ECHO_C" >&6
8631 else
8632   if test -n "$GFORTRAN_FOR_TARGET"; then
8633   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8634 else
8635 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8636 for as_dir in $PATH
8637 do
8638   IFS=$as_save_IFS
8639   test -z "$as_dir" && as_dir=.
8640   for ac_exec_ext in '' $ac_executable_extensions; do
8641   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8642     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8643     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8644     break 2
8645   fi
8646 done
8647 done
8648
8649 fi
8650 fi
8651 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8652 if test -n "$GFORTRAN_FOR_TARGET"; then
8653   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8654 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8655 else
8656   echo "$as_me:$LINENO: result: no" >&5
8657 echo "${ECHO_T}no" >&6
8658 fi
8659
8660     fi
8661     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8662       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8663 set dummy ${ncn_progname}; ac_word=$2
8664 echo "$as_me:$LINENO: checking for $ac_word" >&5
8665 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8666 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8667   echo $ECHO_N "(cached) $ECHO_C" >&6
8668 else
8669   if test -n "$GFORTRAN_FOR_TARGET"; then
8670   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8671 else
8672 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8673 for as_dir in $PATH
8674 do
8675   IFS=$as_save_IFS
8676   test -z "$as_dir" && as_dir=.
8677   for ac_exec_ext in '' $ac_executable_extensions; do
8678   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8679     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8680     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8681     break 2
8682   fi
8683 done
8684 done
8685
8686 fi
8687 fi
8688 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8689 if test -n "$GFORTRAN_FOR_TARGET"; then
8690   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8691 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8692 else
8693   echo "$as_me:$LINENO: result: no" >&5
8694 echo "${ECHO_T}no" >&6
8695 fi
8696
8697     fi
8698     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8699   done
8700 fi
8701
8702 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8703   set dummy gfortran
8704   if test $build = $target ; then
8705     GFORTRAN_FOR_TARGET="$2"
8706   else
8707     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8708   fi
8709 else
8710   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8711 fi
8712
8713
8714
8715 cat > conftest.c << \EOF
8716 #ifdef __GNUC__
8717   gcc_yay;
8718 #endif
8719 EOF
8720 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8721   have_gcc_for_target=yes
8722 else
8723   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8724   have_gcc_for_target=no
8725 fi
8726 rm conftest.c
8727
8728
8729
8730
8731 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8732   if test -n "$with_build_time_tools"; then
8733     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8734 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8735     if test -x $with_build_time_tools/ar; then
8736       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8737       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8738       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8739 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8740     else
8741       echo "$as_me:$LINENO: result: no" >&5
8742 echo "${ECHO_T}no" >&6
8743     fi
8744   elif test $build != $host && test $have_gcc_for_target = yes; then
8745     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8746     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8747     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8748   fi
8749 fi
8750 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8751   # Extract the first word of "ar", so it can be a program name with args.
8752 set dummy ar; ac_word=$2
8753 echo "$as_me:$LINENO: checking for $ac_word" >&5
8754 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8755 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8756   echo $ECHO_N "(cached) $ECHO_C" >&6
8757 else
8758   case $AR_FOR_TARGET in
8759   [\\/]* | ?:[\\/]*)
8760   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8761   ;;
8762   *)
8763   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8764 for as_dir in $gcc_cv_tool_dirs
8765 do
8766   IFS=$as_save_IFS
8767   test -z "$as_dir" && as_dir=.
8768   for ac_exec_ext in '' $ac_executable_extensions; do
8769   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8770     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8771     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8772     break 2
8773   fi
8774 done
8775 done
8776
8777   ;;
8778 esac
8779 fi
8780 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8781
8782 if test -n "$AR_FOR_TARGET"; then
8783   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8784 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8785 else
8786   echo "$as_me:$LINENO: result: no" >&5
8787 echo "${ECHO_T}no" >&6
8788 fi
8789
8790 fi
8791 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8792
8793
8794 if test -n "$AR_FOR_TARGET"; then
8795   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8796 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8797   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8798 fi
8799
8800 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8801   for ncn_progname in ar; do
8802     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8803 set dummy ${ncn_progname}; ac_word=$2
8804 echo "$as_me:$LINENO: checking for $ac_word" >&5
8805 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8806 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8807   echo $ECHO_N "(cached) $ECHO_C" >&6
8808 else
8809   if test -n "$AR_FOR_TARGET"; then
8810   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8811 else
8812 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8813 for as_dir in $PATH
8814 do
8815   IFS=$as_save_IFS
8816   test -z "$as_dir" && as_dir=.
8817   for ac_exec_ext in '' $ac_executable_extensions; do
8818   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8819     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8820     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8821     break 2
8822   fi
8823 done
8824 done
8825
8826 fi
8827 fi
8828 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8829 if test -n "$AR_FOR_TARGET"; then
8830   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8831 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8832 else
8833   echo "$as_me:$LINENO: result: no" >&5
8834 echo "${ECHO_T}no" >&6
8835 fi
8836
8837   done
8838 fi
8839
8840 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8841   for ncn_progname in ar; do
8842     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8843 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8844     if test -x $with_build_time_tools/${ncn_progname}; then
8845       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8846       echo "$as_me:$LINENO: result: yes" >&5
8847 echo "${ECHO_T}yes" >&6
8848       break
8849     else
8850       echo "$as_me:$LINENO: result: no" >&5
8851 echo "${ECHO_T}no" >&6
8852     fi
8853   done
8854 fi
8855
8856 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8857   for ncn_progname in ar; do
8858     if test -n "$ncn_target_tool_prefix"; then
8859       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8860 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8861 echo "$as_me:$LINENO: checking for $ac_word" >&5
8862 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8863 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8864   echo $ECHO_N "(cached) $ECHO_C" >&6
8865 else
8866   if test -n "$AR_FOR_TARGET"; then
8867   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8868 else
8869 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8870 for as_dir in $PATH
8871 do
8872   IFS=$as_save_IFS
8873   test -z "$as_dir" && as_dir=.
8874   for ac_exec_ext in '' $ac_executable_extensions; do
8875   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8876     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8877     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8878     break 2
8879   fi
8880 done
8881 done
8882
8883 fi
8884 fi
8885 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8886 if test -n "$AR_FOR_TARGET"; then
8887   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8888 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8889 else
8890   echo "$as_me:$LINENO: result: no" >&5
8891 echo "${ECHO_T}no" >&6
8892 fi
8893
8894     fi
8895     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8896       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8897 set dummy ${ncn_progname}; ac_word=$2
8898 echo "$as_me:$LINENO: checking for $ac_word" >&5
8899 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8900 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8901   echo $ECHO_N "(cached) $ECHO_C" >&6
8902 else
8903   if test -n "$AR_FOR_TARGET"; then
8904   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8905 else
8906 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8907 for as_dir in $PATH
8908 do
8909   IFS=$as_save_IFS
8910   test -z "$as_dir" && as_dir=.
8911   for ac_exec_ext in '' $ac_executable_extensions; do
8912   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8913     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8914     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8915     break 2
8916   fi
8917 done
8918 done
8919
8920 fi
8921 fi
8922 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8923 if test -n "$AR_FOR_TARGET"; then
8924   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8925 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8926 else
8927   echo "$as_me:$LINENO: result: no" >&5
8928 echo "${ECHO_T}no" >&6
8929 fi
8930
8931     fi
8932     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8933   done
8934 fi
8935
8936 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8937   set dummy ar
8938   if test $build = $target ; then
8939     AR_FOR_TARGET="$2"
8940   else
8941     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8942   fi
8943 else
8944   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
8945 fi
8946
8947 else
8948   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8949 fi
8950
8951
8952
8953
8954 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8955   if test -n "$with_build_time_tools"; then
8956     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
8957 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
8958     if test -x $with_build_time_tools/as; then
8959       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
8960       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8961       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
8962 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
8963     else
8964       echo "$as_me:$LINENO: result: no" >&5
8965 echo "${ECHO_T}no" >&6
8966     fi
8967   elif test $build != $host && test $have_gcc_for_target = yes; then
8968     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
8969     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
8970     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8971   fi
8972 fi
8973 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8974   # Extract the first word of "as", so it can be a program name with args.
8975 set dummy as; ac_word=$2
8976 echo "$as_me:$LINENO: checking for $ac_word" >&5
8977 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8978 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
8979   echo $ECHO_N "(cached) $ECHO_C" >&6
8980 else
8981   case $AS_FOR_TARGET in
8982   [\\/]* | ?:[\\/]*)
8983   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
8984   ;;
8985   *)
8986   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8987 for as_dir in $gcc_cv_tool_dirs
8988 do
8989   IFS=$as_save_IFS
8990   test -z "$as_dir" && as_dir=.
8991   for ac_exec_ext in '' $ac_executable_extensions; do
8992   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8993     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8994     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8995     break 2
8996   fi
8997 done
8998 done
8999
9000   ;;
9001 esac
9002 fi
9003 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9004
9005 if test -n "$AS_FOR_TARGET"; then
9006   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9007 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9008 else
9009   echo "$as_me:$LINENO: result: no" >&5
9010 echo "${ECHO_T}no" >&6
9011 fi
9012
9013 fi
9014 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9015
9016
9017 if test -n "$AS_FOR_TARGET"; then
9018   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9019 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9020   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9021 fi
9022
9023 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9024   for ncn_progname in as; do
9025     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9026 set dummy ${ncn_progname}; ac_word=$2
9027 echo "$as_me:$LINENO: checking for $ac_word" >&5
9028 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9029 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9030   echo $ECHO_N "(cached) $ECHO_C" >&6
9031 else
9032   if test -n "$AS_FOR_TARGET"; then
9033   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9034 else
9035 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9036 for as_dir in $PATH
9037 do
9038   IFS=$as_save_IFS
9039   test -z "$as_dir" && as_dir=.
9040   for ac_exec_ext in '' $ac_executable_extensions; do
9041   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9042     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9043     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9044     break 2
9045   fi
9046 done
9047 done
9048
9049 fi
9050 fi
9051 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9052 if test -n "$AS_FOR_TARGET"; then
9053   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9054 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9055 else
9056   echo "$as_me:$LINENO: result: no" >&5
9057 echo "${ECHO_T}no" >&6
9058 fi
9059
9060   done
9061 fi
9062
9063 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9064   for ncn_progname in as; do
9065     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9066 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9067     if test -x $with_build_time_tools/${ncn_progname}; then
9068       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9069       echo "$as_me:$LINENO: result: yes" >&5
9070 echo "${ECHO_T}yes" >&6
9071       break
9072     else
9073       echo "$as_me:$LINENO: result: no" >&5
9074 echo "${ECHO_T}no" >&6
9075     fi
9076   done
9077 fi
9078
9079 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9080   for ncn_progname in as; do
9081     if test -n "$ncn_target_tool_prefix"; then
9082       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9083 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9084 echo "$as_me:$LINENO: checking for $ac_word" >&5
9085 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9086 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9087   echo $ECHO_N "(cached) $ECHO_C" >&6
9088 else
9089   if test -n "$AS_FOR_TARGET"; then
9090   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9091 else
9092 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9093 for as_dir in $PATH
9094 do
9095   IFS=$as_save_IFS
9096   test -z "$as_dir" && as_dir=.
9097   for ac_exec_ext in '' $ac_executable_extensions; do
9098   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9099     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9100     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9101     break 2
9102   fi
9103 done
9104 done
9105
9106 fi
9107 fi
9108 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9109 if test -n "$AS_FOR_TARGET"; then
9110   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9111 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9112 else
9113   echo "$as_me:$LINENO: result: no" >&5
9114 echo "${ECHO_T}no" >&6
9115 fi
9116
9117     fi
9118     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9119       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9120 set dummy ${ncn_progname}; ac_word=$2
9121 echo "$as_me:$LINENO: checking for $ac_word" >&5
9122 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9123 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9124   echo $ECHO_N "(cached) $ECHO_C" >&6
9125 else
9126   if test -n "$AS_FOR_TARGET"; then
9127   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9128 else
9129 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9130 for as_dir in $PATH
9131 do
9132   IFS=$as_save_IFS
9133   test -z "$as_dir" && as_dir=.
9134   for ac_exec_ext in '' $ac_executable_extensions; do
9135   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9136     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9137     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9138     break 2
9139   fi
9140 done
9141 done
9142
9143 fi
9144 fi
9145 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9146 if test -n "$AS_FOR_TARGET"; then
9147   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9148 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9149 else
9150   echo "$as_me:$LINENO: result: no" >&5
9151 echo "${ECHO_T}no" >&6
9152 fi
9153
9154     fi
9155     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9156   done
9157 fi
9158
9159 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9160   set dummy as
9161   if test $build = $target ; then
9162     AS_FOR_TARGET="$2"
9163   else
9164     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9165   fi
9166 else
9167   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9168 fi
9169
9170 else
9171   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9172 fi
9173
9174
9175
9176
9177 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9178   if test -n "$with_build_time_tools"; then
9179     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9180 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9181     if test -x $with_build_time_tools/dlltool; then
9182       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9183       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9184       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9185 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9186     else
9187       echo "$as_me:$LINENO: result: no" >&5
9188 echo "${ECHO_T}no" >&6
9189     fi
9190   elif test $build != $host && test $have_gcc_for_target = yes; then
9191     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9192     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9193     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9194   fi
9195 fi
9196 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9197   # Extract the first word of "dlltool", so it can be a program name with args.
9198 set dummy dlltool; ac_word=$2
9199 echo "$as_me:$LINENO: checking for $ac_word" >&5
9200 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9201 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9202   echo $ECHO_N "(cached) $ECHO_C" >&6
9203 else
9204   case $DLLTOOL_FOR_TARGET in
9205   [\\/]* | ?:[\\/]*)
9206   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9207   ;;
9208   *)
9209   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9210 for as_dir in $gcc_cv_tool_dirs
9211 do
9212   IFS=$as_save_IFS
9213   test -z "$as_dir" && as_dir=.
9214   for ac_exec_ext in '' $ac_executable_extensions; do
9215   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9216     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9217     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9218     break 2
9219   fi
9220 done
9221 done
9222
9223   ;;
9224 esac
9225 fi
9226 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9227
9228 if test -n "$DLLTOOL_FOR_TARGET"; then
9229   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9230 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9231 else
9232   echo "$as_me:$LINENO: result: no" >&5
9233 echo "${ECHO_T}no" >&6
9234 fi
9235
9236 fi
9237 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9238
9239
9240 if test -n "$DLLTOOL_FOR_TARGET"; then
9241   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9242 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9243   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9244 fi
9245
9246 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9247   for ncn_progname in dlltool; do
9248     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9249 set dummy ${ncn_progname}; ac_word=$2
9250 echo "$as_me:$LINENO: checking for $ac_word" >&5
9251 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9252 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9253   echo $ECHO_N "(cached) $ECHO_C" >&6
9254 else
9255   if test -n "$DLLTOOL_FOR_TARGET"; then
9256   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9257 else
9258 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9259 for as_dir in $PATH
9260 do
9261   IFS=$as_save_IFS
9262   test -z "$as_dir" && as_dir=.
9263   for ac_exec_ext in '' $ac_executable_extensions; do
9264   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9265     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9266     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9267     break 2
9268   fi
9269 done
9270 done
9271
9272 fi
9273 fi
9274 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9275 if test -n "$DLLTOOL_FOR_TARGET"; then
9276   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9277 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9278 else
9279   echo "$as_me:$LINENO: result: no" >&5
9280 echo "${ECHO_T}no" >&6
9281 fi
9282
9283   done
9284 fi
9285
9286 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9287   for ncn_progname in dlltool; do
9288     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9289 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9290     if test -x $with_build_time_tools/${ncn_progname}; then
9291       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9292       echo "$as_me:$LINENO: result: yes" >&5
9293 echo "${ECHO_T}yes" >&6
9294       break
9295     else
9296       echo "$as_me:$LINENO: result: no" >&5
9297 echo "${ECHO_T}no" >&6
9298     fi
9299   done
9300 fi
9301
9302 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9303   for ncn_progname in dlltool; do
9304     if test -n "$ncn_target_tool_prefix"; then
9305       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9306 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9307 echo "$as_me:$LINENO: checking for $ac_word" >&5
9308 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9309 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9310   echo $ECHO_N "(cached) $ECHO_C" >&6
9311 else
9312   if test -n "$DLLTOOL_FOR_TARGET"; then
9313   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9314 else
9315 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9316 for as_dir in $PATH
9317 do
9318   IFS=$as_save_IFS
9319   test -z "$as_dir" && as_dir=.
9320   for ac_exec_ext in '' $ac_executable_extensions; do
9321   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9322     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9323     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9324     break 2
9325   fi
9326 done
9327 done
9328
9329 fi
9330 fi
9331 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9332 if test -n "$DLLTOOL_FOR_TARGET"; then
9333   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9334 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9335 else
9336   echo "$as_me:$LINENO: result: no" >&5
9337 echo "${ECHO_T}no" >&6
9338 fi
9339
9340     fi
9341     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9342       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9343 set dummy ${ncn_progname}; ac_word=$2
9344 echo "$as_me:$LINENO: checking for $ac_word" >&5
9345 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9346 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9347   echo $ECHO_N "(cached) $ECHO_C" >&6
9348 else
9349   if test -n "$DLLTOOL_FOR_TARGET"; then
9350   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9351 else
9352 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9353 for as_dir in $PATH
9354 do
9355   IFS=$as_save_IFS
9356   test -z "$as_dir" && as_dir=.
9357   for ac_exec_ext in '' $ac_executable_extensions; do
9358   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9359     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9360     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9361     break 2
9362   fi
9363 done
9364 done
9365
9366 fi
9367 fi
9368 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9369 if test -n "$DLLTOOL_FOR_TARGET"; then
9370   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9371 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9372 else
9373   echo "$as_me:$LINENO: result: no" >&5
9374 echo "${ECHO_T}no" >&6
9375 fi
9376
9377     fi
9378     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9379   done
9380 fi
9381
9382 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9383   set dummy dlltool
9384   if test $build = $target ; then
9385     DLLTOOL_FOR_TARGET="$2"
9386   else
9387     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9388   fi
9389 else
9390   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9391 fi
9392
9393 else
9394   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9395 fi
9396
9397
9398
9399
9400 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9401   if test -n "$with_build_time_tools"; then
9402     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9403 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9404     if test -x $with_build_time_tools/ld; then
9405       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9406       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9407       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9408 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9409     else
9410       echo "$as_me:$LINENO: result: no" >&5
9411 echo "${ECHO_T}no" >&6
9412     fi
9413   elif test $build != $host && test $have_gcc_for_target = yes; then
9414     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9415     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9416     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9417   fi
9418 fi
9419 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9420   # Extract the first word of "ld", so it can be a program name with args.
9421 set dummy ld; ac_word=$2
9422 echo "$as_me:$LINENO: checking for $ac_word" >&5
9423 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9424 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9425   echo $ECHO_N "(cached) $ECHO_C" >&6
9426 else
9427   case $LD_FOR_TARGET in
9428   [\\/]* | ?:[\\/]*)
9429   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9430   ;;
9431   *)
9432   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9433 for as_dir in $gcc_cv_tool_dirs
9434 do
9435   IFS=$as_save_IFS
9436   test -z "$as_dir" && as_dir=.
9437   for ac_exec_ext in '' $ac_executable_extensions; do
9438   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9439     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9440     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9441     break 2
9442   fi
9443 done
9444 done
9445
9446   ;;
9447 esac
9448 fi
9449 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9450
9451 if test -n "$LD_FOR_TARGET"; then
9452   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9453 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9454 else
9455   echo "$as_me:$LINENO: result: no" >&5
9456 echo "${ECHO_T}no" >&6
9457 fi
9458
9459 fi
9460 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9461
9462
9463 if test -n "$LD_FOR_TARGET"; then
9464   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9465 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9466   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9467 fi
9468
9469 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9470   for ncn_progname in ld; do
9471     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9472 set dummy ${ncn_progname}; ac_word=$2
9473 echo "$as_me:$LINENO: checking for $ac_word" >&5
9474 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9475 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9476   echo $ECHO_N "(cached) $ECHO_C" >&6
9477 else
9478   if test -n "$LD_FOR_TARGET"; then
9479   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9480 else
9481 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9482 for as_dir in $PATH
9483 do
9484   IFS=$as_save_IFS
9485   test -z "$as_dir" && as_dir=.
9486   for ac_exec_ext in '' $ac_executable_extensions; do
9487   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9488     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9489     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9490     break 2
9491   fi
9492 done
9493 done
9494
9495 fi
9496 fi
9497 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9498 if test -n "$LD_FOR_TARGET"; then
9499   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9500 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9501 else
9502   echo "$as_me:$LINENO: result: no" >&5
9503 echo "${ECHO_T}no" >&6
9504 fi
9505
9506   done
9507 fi
9508
9509 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9510   for ncn_progname in ld; do
9511     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9512 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9513     if test -x $with_build_time_tools/${ncn_progname}; then
9514       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9515       echo "$as_me:$LINENO: result: yes" >&5
9516 echo "${ECHO_T}yes" >&6
9517       break
9518     else
9519       echo "$as_me:$LINENO: result: no" >&5
9520 echo "${ECHO_T}no" >&6
9521     fi
9522   done
9523 fi
9524
9525 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9526   for ncn_progname in ld; do
9527     if test -n "$ncn_target_tool_prefix"; then
9528       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9529 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9530 echo "$as_me:$LINENO: checking for $ac_word" >&5
9531 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9532 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9533   echo $ECHO_N "(cached) $ECHO_C" >&6
9534 else
9535   if test -n "$LD_FOR_TARGET"; then
9536   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9537 else
9538 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9539 for as_dir in $PATH
9540 do
9541   IFS=$as_save_IFS
9542   test -z "$as_dir" && as_dir=.
9543   for ac_exec_ext in '' $ac_executable_extensions; do
9544   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9545     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9546     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9547     break 2
9548   fi
9549 done
9550 done
9551
9552 fi
9553 fi
9554 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9555 if test -n "$LD_FOR_TARGET"; then
9556   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9557 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9558 else
9559   echo "$as_me:$LINENO: result: no" >&5
9560 echo "${ECHO_T}no" >&6
9561 fi
9562
9563     fi
9564     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9565       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9566 set dummy ${ncn_progname}; ac_word=$2
9567 echo "$as_me:$LINENO: checking for $ac_word" >&5
9568 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9569 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9570   echo $ECHO_N "(cached) $ECHO_C" >&6
9571 else
9572   if test -n "$LD_FOR_TARGET"; then
9573   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9574 else
9575 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9576 for as_dir in $PATH
9577 do
9578   IFS=$as_save_IFS
9579   test -z "$as_dir" && as_dir=.
9580   for ac_exec_ext in '' $ac_executable_extensions; do
9581   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9582     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9583     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9584     break 2
9585   fi
9586 done
9587 done
9588
9589 fi
9590 fi
9591 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9592 if test -n "$LD_FOR_TARGET"; then
9593   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9594 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9595 else
9596   echo "$as_me:$LINENO: result: no" >&5
9597 echo "${ECHO_T}no" >&6
9598 fi
9599
9600     fi
9601     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9602   done
9603 fi
9604
9605 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9606   set dummy ld
9607   if test $build = $target ; then
9608     LD_FOR_TARGET="$2"
9609   else
9610     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9611   fi
9612 else
9613   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9614 fi
9615
9616 else
9617   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9618 fi
9619
9620
9621
9622
9623 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9624   if test -n "$with_build_time_tools"; then
9625     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9626 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9627     if test -x $with_build_time_tools/lipo; then
9628       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9629       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9630       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9631 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9632     else
9633       echo "$as_me:$LINENO: result: no" >&5
9634 echo "${ECHO_T}no" >&6
9635     fi
9636   elif test $build != $host && test $have_gcc_for_target = yes; then
9637     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9638     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9639     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9640   fi
9641 fi
9642 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9643   # Extract the first word of "lipo", so it can be a program name with args.
9644 set dummy lipo; ac_word=$2
9645 echo "$as_me:$LINENO: checking for $ac_word" >&5
9646 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9647 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9648   echo $ECHO_N "(cached) $ECHO_C" >&6
9649 else
9650   case $LIPO_FOR_TARGET in
9651   [\\/]* | ?:[\\/]*)
9652   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9653   ;;
9654   *)
9655   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9656 for as_dir in $gcc_cv_tool_dirs
9657 do
9658   IFS=$as_save_IFS
9659   test -z "$as_dir" && as_dir=.
9660   for ac_exec_ext in '' $ac_executable_extensions; do
9661   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9662     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9663     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9664     break 2
9665   fi
9666 done
9667 done
9668
9669   ;;
9670 esac
9671 fi
9672 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9673
9674 if test -n "$LIPO_FOR_TARGET"; then
9675   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9676 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9677 else
9678   echo "$as_me:$LINENO: result: no" >&5
9679 echo "${ECHO_T}no" >&6
9680 fi
9681
9682 fi
9683 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9684
9685
9686 if test -n "$LIPO_FOR_TARGET"; then
9687   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9688 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9689   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9690 fi
9691
9692 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9693   for ncn_progname in lipo; do
9694     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9695 set dummy ${ncn_progname}; ac_word=$2
9696 echo "$as_me:$LINENO: checking for $ac_word" >&5
9697 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9698 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9699   echo $ECHO_N "(cached) $ECHO_C" >&6
9700 else
9701   if test -n "$LIPO_FOR_TARGET"; then
9702   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9703 else
9704 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9705 for as_dir in $PATH
9706 do
9707   IFS=$as_save_IFS
9708   test -z "$as_dir" && as_dir=.
9709   for ac_exec_ext in '' $ac_executable_extensions; do
9710   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9711     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9712     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9713     break 2
9714   fi
9715 done
9716 done
9717
9718 fi
9719 fi
9720 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9721 if test -n "$LIPO_FOR_TARGET"; then
9722   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9723 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9724 else
9725   echo "$as_me:$LINENO: result: no" >&5
9726 echo "${ECHO_T}no" >&6
9727 fi
9728
9729   done
9730 fi
9731
9732 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9733   for ncn_progname in lipo; do
9734     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9735 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9736     if test -x $with_build_time_tools/${ncn_progname}; then
9737       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9738       echo "$as_me:$LINENO: result: yes" >&5
9739 echo "${ECHO_T}yes" >&6
9740       break
9741     else
9742       echo "$as_me:$LINENO: result: no" >&5
9743 echo "${ECHO_T}no" >&6
9744     fi
9745   done
9746 fi
9747
9748 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9749   for ncn_progname in lipo; do
9750     if test -n "$ncn_target_tool_prefix"; then
9751       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9752 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9753 echo "$as_me:$LINENO: checking for $ac_word" >&5
9754 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9755 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9756   echo $ECHO_N "(cached) $ECHO_C" >&6
9757 else
9758   if test -n "$LIPO_FOR_TARGET"; then
9759   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9760 else
9761 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9762 for as_dir in $PATH
9763 do
9764   IFS=$as_save_IFS
9765   test -z "$as_dir" && as_dir=.
9766   for ac_exec_ext in '' $ac_executable_extensions; do
9767   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9768     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9769     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9770     break 2
9771   fi
9772 done
9773 done
9774
9775 fi
9776 fi
9777 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9778 if test -n "$LIPO_FOR_TARGET"; then
9779   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9780 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9781 else
9782   echo "$as_me:$LINENO: result: no" >&5
9783 echo "${ECHO_T}no" >&6
9784 fi
9785
9786     fi
9787     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9788       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9789 set dummy ${ncn_progname}; ac_word=$2
9790 echo "$as_me:$LINENO: checking for $ac_word" >&5
9791 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9792 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9793   echo $ECHO_N "(cached) $ECHO_C" >&6
9794 else
9795   if test -n "$LIPO_FOR_TARGET"; then
9796   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9797 else
9798 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9799 for as_dir in $PATH
9800 do
9801   IFS=$as_save_IFS
9802   test -z "$as_dir" && as_dir=.
9803   for ac_exec_ext in '' $ac_executable_extensions; do
9804   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9805     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9806     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9807     break 2
9808   fi
9809 done
9810 done
9811
9812 fi
9813 fi
9814 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9815 if test -n "$LIPO_FOR_TARGET"; then
9816   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9817 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9818 else
9819   echo "$as_me:$LINENO: result: no" >&5
9820 echo "${ECHO_T}no" >&6
9821 fi
9822
9823     fi
9824     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9825   done
9826 fi
9827
9828 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9829   set dummy lipo
9830   if test $build = $target ; then
9831     LIPO_FOR_TARGET="$2"
9832   else
9833     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9834   fi
9835 else
9836   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9837 fi
9838
9839 else
9840   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9841 fi
9842
9843
9844
9845
9846 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9847   if test -n "$with_build_time_tools"; then
9848     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9849 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9850     if test -x $with_build_time_tools/nm; then
9851       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9852       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9853       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9854 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9855     else
9856       echo "$as_me:$LINENO: result: no" >&5
9857 echo "${ECHO_T}no" >&6
9858     fi
9859   elif test $build != $host && test $have_gcc_for_target = yes; then
9860     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9861     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9862     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9863   fi
9864 fi
9865 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9866   # Extract the first word of "nm", so it can be a program name with args.
9867 set dummy nm; ac_word=$2
9868 echo "$as_me:$LINENO: checking for $ac_word" >&5
9869 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9870 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9871   echo $ECHO_N "(cached) $ECHO_C" >&6
9872 else
9873   case $NM_FOR_TARGET in
9874   [\\/]* | ?:[\\/]*)
9875   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9876   ;;
9877   *)
9878   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9879 for as_dir in $gcc_cv_tool_dirs
9880 do
9881   IFS=$as_save_IFS
9882   test -z "$as_dir" && as_dir=.
9883   for ac_exec_ext in '' $ac_executable_extensions; do
9884   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9885     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9886     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9887     break 2
9888   fi
9889 done
9890 done
9891
9892   ;;
9893 esac
9894 fi
9895 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9896
9897 if test -n "$NM_FOR_TARGET"; then
9898   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9899 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9900 else
9901   echo "$as_me:$LINENO: result: no" >&5
9902 echo "${ECHO_T}no" >&6
9903 fi
9904
9905 fi
9906 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9907
9908
9909 if test -n "$NM_FOR_TARGET"; then
9910   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9911 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9912   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9913 fi
9914
9915 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9916   for ncn_progname in nm; do
9917     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9918 set dummy ${ncn_progname}; ac_word=$2
9919 echo "$as_me:$LINENO: checking for $ac_word" >&5
9920 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9921 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9922   echo $ECHO_N "(cached) $ECHO_C" >&6
9923 else
9924   if test -n "$NM_FOR_TARGET"; then
9925   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9926 else
9927 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9928 for as_dir in $PATH
9929 do
9930   IFS=$as_save_IFS
9931   test -z "$as_dir" && as_dir=.
9932   for ac_exec_ext in '' $ac_executable_extensions; do
9933   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9934     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9935     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9936     break 2
9937   fi
9938 done
9939 done
9940
9941 fi
9942 fi
9943 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9944 if test -n "$NM_FOR_TARGET"; then
9945   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9946 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9947 else
9948   echo "$as_me:$LINENO: result: no" >&5
9949 echo "${ECHO_T}no" >&6
9950 fi
9951
9952   done
9953 fi
9954
9955 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
9956   for ncn_progname in nm; do
9957     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9958 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9959     if test -x $with_build_time_tools/${ncn_progname}; then
9960       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9961       echo "$as_me:$LINENO: result: yes" >&5
9962 echo "${ECHO_T}yes" >&6
9963       break
9964     else
9965       echo "$as_me:$LINENO: result: no" >&5
9966 echo "${ECHO_T}no" >&6
9967     fi
9968   done
9969 fi
9970
9971 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
9972   for ncn_progname in nm; do
9973     if test -n "$ncn_target_tool_prefix"; then
9974       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9975 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9976 echo "$as_me:$LINENO: checking for $ac_word" >&5
9977 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9978 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9979   echo $ECHO_N "(cached) $ECHO_C" >&6
9980 else
9981   if test -n "$NM_FOR_TARGET"; then
9982   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9983 else
9984 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9985 for as_dir in $PATH
9986 do
9987   IFS=$as_save_IFS
9988   test -z "$as_dir" && as_dir=.
9989   for ac_exec_ext in '' $ac_executable_extensions; do
9990   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9991     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9992     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9993     break 2
9994   fi
9995 done
9996 done
9997
9998 fi
9999 fi
10000 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10001 if test -n "$NM_FOR_TARGET"; then
10002   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10003 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10004 else
10005   echo "$as_me:$LINENO: result: no" >&5
10006 echo "${ECHO_T}no" >&6
10007 fi
10008
10009     fi
10010     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10011       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10012 set dummy ${ncn_progname}; ac_word=$2
10013 echo "$as_me:$LINENO: checking for $ac_word" >&5
10014 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10015 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10016   echo $ECHO_N "(cached) $ECHO_C" >&6
10017 else
10018   if test -n "$NM_FOR_TARGET"; then
10019   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10020 else
10021 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10022 for as_dir in $PATH
10023 do
10024   IFS=$as_save_IFS
10025   test -z "$as_dir" && as_dir=.
10026   for ac_exec_ext in '' $ac_executable_extensions; do
10027   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10028     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10029     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10030     break 2
10031   fi
10032 done
10033 done
10034
10035 fi
10036 fi
10037 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10038 if test -n "$NM_FOR_TARGET"; then
10039   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10040 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10041 else
10042   echo "$as_me:$LINENO: result: no" >&5
10043 echo "${ECHO_T}no" >&6
10044 fi
10045
10046     fi
10047     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10048   done
10049 fi
10050
10051 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10052   set dummy nm
10053   if test $build = $target ; then
10054     NM_FOR_TARGET="$2"
10055   else
10056     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10057   fi
10058 else
10059   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10060 fi
10061
10062 else
10063   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10064 fi
10065
10066
10067
10068
10069 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10070   if test -n "$with_build_time_tools"; then
10071     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10072 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10073     if test -x $with_build_time_tools/objdump; then
10074       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10075       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10076       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10077 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10078     else
10079       echo "$as_me:$LINENO: result: no" >&5
10080 echo "${ECHO_T}no" >&6
10081     fi
10082   elif test $build != $host && test $have_gcc_for_target = yes; then
10083     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10084     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10085     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10086   fi
10087 fi
10088 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10089   # Extract the first word of "objdump", so it can be a program name with args.
10090 set dummy objdump; ac_word=$2
10091 echo "$as_me:$LINENO: checking for $ac_word" >&5
10092 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10093 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10094   echo $ECHO_N "(cached) $ECHO_C" >&6
10095 else
10096   case $OBJDUMP_FOR_TARGET in
10097   [\\/]* | ?:[\\/]*)
10098   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10099   ;;
10100   *)
10101   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10102 for as_dir in $gcc_cv_tool_dirs
10103 do
10104   IFS=$as_save_IFS
10105   test -z "$as_dir" && as_dir=.
10106   for ac_exec_ext in '' $ac_executable_extensions; do
10107   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10108     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10109     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10110     break 2
10111   fi
10112 done
10113 done
10114
10115   ;;
10116 esac
10117 fi
10118 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10119
10120 if test -n "$OBJDUMP_FOR_TARGET"; then
10121   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10122 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10123 else
10124   echo "$as_me:$LINENO: result: no" >&5
10125 echo "${ECHO_T}no" >&6
10126 fi
10127
10128 fi
10129 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10130
10131
10132 if test -n "$OBJDUMP_FOR_TARGET"; then
10133   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10134 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10135   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10136 fi
10137
10138 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10139   for ncn_progname in objdump; do
10140     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10141 set dummy ${ncn_progname}; ac_word=$2
10142 echo "$as_me:$LINENO: checking for $ac_word" >&5
10143 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10144 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10145   echo $ECHO_N "(cached) $ECHO_C" >&6
10146 else
10147   if test -n "$OBJDUMP_FOR_TARGET"; then
10148   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10149 else
10150 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10151 for as_dir in $PATH
10152 do
10153   IFS=$as_save_IFS
10154   test -z "$as_dir" && as_dir=.
10155   for ac_exec_ext in '' $ac_executable_extensions; do
10156   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10157     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10158     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10159     break 2
10160   fi
10161 done
10162 done
10163
10164 fi
10165 fi
10166 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10167 if test -n "$OBJDUMP_FOR_TARGET"; then
10168   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10169 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10170 else
10171   echo "$as_me:$LINENO: result: no" >&5
10172 echo "${ECHO_T}no" >&6
10173 fi
10174
10175   done
10176 fi
10177
10178 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10179   for ncn_progname in objdump; do
10180     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10181 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10182     if test -x $with_build_time_tools/${ncn_progname}; then
10183       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10184       echo "$as_me:$LINENO: result: yes" >&5
10185 echo "${ECHO_T}yes" >&6
10186       break
10187     else
10188       echo "$as_me:$LINENO: result: no" >&5
10189 echo "${ECHO_T}no" >&6
10190     fi
10191   done
10192 fi
10193
10194 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10195   for ncn_progname in objdump; do
10196     if test -n "$ncn_target_tool_prefix"; then
10197       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10198 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10199 echo "$as_me:$LINENO: checking for $ac_word" >&5
10200 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10201 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10202   echo $ECHO_N "(cached) $ECHO_C" >&6
10203 else
10204   if test -n "$OBJDUMP_FOR_TARGET"; then
10205   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10206 else
10207 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10208 for as_dir in $PATH
10209 do
10210   IFS=$as_save_IFS
10211   test -z "$as_dir" && as_dir=.
10212   for ac_exec_ext in '' $ac_executable_extensions; do
10213   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10214     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10215     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10216     break 2
10217   fi
10218 done
10219 done
10220
10221 fi
10222 fi
10223 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10224 if test -n "$OBJDUMP_FOR_TARGET"; then
10225   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10226 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10227 else
10228   echo "$as_me:$LINENO: result: no" >&5
10229 echo "${ECHO_T}no" >&6
10230 fi
10231
10232     fi
10233     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10234       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10235 set dummy ${ncn_progname}; ac_word=$2
10236 echo "$as_me:$LINENO: checking for $ac_word" >&5
10237 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10238 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10239   echo $ECHO_N "(cached) $ECHO_C" >&6
10240 else
10241   if test -n "$OBJDUMP_FOR_TARGET"; then
10242   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10243 else
10244 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10245 for as_dir in $PATH
10246 do
10247   IFS=$as_save_IFS
10248   test -z "$as_dir" && as_dir=.
10249   for ac_exec_ext in '' $ac_executable_extensions; do
10250   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10251     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10252     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10253     break 2
10254   fi
10255 done
10256 done
10257
10258 fi
10259 fi
10260 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10261 if test -n "$OBJDUMP_FOR_TARGET"; then
10262   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10263 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10264 else
10265   echo "$as_me:$LINENO: result: no" >&5
10266 echo "${ECHO_T}no" >&6
10267 fi
10268
10269     fi
10270     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10271   done
10272 fi
10273
10274 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10275   set dummy objdump
10276   if test $build = $target ; then
10277     OBJDUMP_FOR_TARGET="$2"
10278   else
10279     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10280   fi
10281 else
10282   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10283 fi
10284
10285 else
10286   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10287 fi
10288
10289
10290
10291
10292 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10293   if test -n "$with_build_time_tools"; then
10294     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10295 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10296     if test -x $with_build_time_tools/ranlib; then
10297       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10298       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10299       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10300 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10301     else
10302       echo "$as_me:$LINENO: result: no" >&5
10303 echo "${ECHO_T}no" >&6
10304     fi
10305   elif test $build != $host && test $have_gcc_for_target = yes; then
10306     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10307     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10308     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10309   fi
10310 fi
10311 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10312   # Extract the first word of "ranlib", so it can be a program name with args.
10313 set dummy ranlib; ac_word=$2
10314 echo "$as_me:$LINENO: checking for $ac_word" >&5
10315 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10316 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10317   echo $ECHO_N "(cached) $ECHO_C" >&6
10318 else
10319   case $RANLIB_FOR_TARGET in
10320   [\\/]* | ?:[\\/]*)
10321   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10322   ;;
10323   *)
10324   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10325 for as_dir in $gcc_cv_tool_dirs
10326 do
10327   IFS=$as_save_IFS
10328   test -z "$as_dir" && as_dir=.
10329   for ac_exec_ext in '' $ac_executable_extensions; do
10330   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10331     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10332     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10333     break 2
10334   fi
10335 done
10336 done
10337
10338   ;;
10339 esac
10340 fi
10341 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10342
10343 if test -n "$RANLIB_FOR_TARGET"; then
10344   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10345 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10346 else
10347   echo "$as_me:$LINENO: result: no" >&5
10348 echo "${ECHO_T}no" >&6
10349 fi
10350
10351 fi
10352 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10353
10354
10355 if test -n "$RANLIB_FOR_TARGET"; then
10356   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10357 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10358   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10359 fi
10360
10361 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10362   for ncn_progname in ranlib; do
10363     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10364 set dummy ${ncn_progname}; ac_word=$2
10365 echo "$as_me:$LINENO: checking for $ac_word" >&5
10366 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10367 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10368   echo $ECHO_N "(cached) $ECHO_C" >&6
10369 else
10370   if test -n "$RANLIB_FOR_TARGET"; then
10371   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10372 else
10373 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10374 for as_dir in $PATH
10375 do
10376   IFS=$as_save_IFS
10377   test -z "$as_dir" && as_dir=.
10378   for ac_exec_ext in '' $ac_executable_extensions; do
10379   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10380     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10381     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10382     break 2
10383   fi
10384 done
10385 done
10386
10387 fi
10388 fi
10389 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10390 if test -n "$RANLIB_FOR_TARGET"; then
10391   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10392 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10393 else
10394   echo "$as_me:$LINENO: result: no" >&5
10395 echo "${ECHO_T}no" >&6
10396 fi
10397
10398   done
10399 fi
10400
10401 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10402   for ncn_progname in ranlib; do
10403     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10404 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10405     if test -x $with_build_time_tools/${ncn_progname}; then
10406       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10407       echo "$as_me:$LINENO: result: yes" >&5
10408 echo "${ECHO_T}yes" >&6
10409       break
10410     else
10411       echo "$as_me:$LINENO: result: no" >&5
10412 echo "${ECHO_T}no" >&6
10413     fi
10414   done
10415 fi
10416
10417 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10418   for ncn_progname in ranlib; do
10419     if test -n "$ncn_target_tool_prefix"; then
10420       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10421 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10422 echo "$as_me:$LINENO: checking for $ac_word" >&5
10423 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10424 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10425   echo $ECHO_N "(cached) $ECHO_C" >&6
10426 else
10427   if test -n "$RANLIB_FOR_TARGET"; then
10428   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10429 else
10430 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10431 for as_dir in $PATH
10432 do
10433   IFS=$as_save_IFS
10434   test -z "$as_dir" && as_dir=.
10435   for ac_exec_ext in '' $ac_executable_extensions; do
10436   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10437     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10438     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10439     break 2
10440   fi
10441 done
10442 done
10443
10444 fi
10445 fi
10446 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10447 if test -n "$RANLIB_FOR_TARGET"; then
10448   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10449 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10450 else
10451   echo "$as_me:$LINENO: result: no" >&5
10452 echo "${ECHO_T}no" >&6
10453 fi
10454
10455     fi
10456     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10457       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10458 set dummy ${ncn_progname}; ac_word=$2
10459 echo "$as_me:$LINENO: checking for $ac_word" >&5
10460 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10461 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10462   echo $ECHO_N "(cached) $ECHO_C" >&6
10463 else
10464   if test -n "$RANLIB_FOR_TARGET"; then
10465   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10466 else
10467 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10468 for as_dir in $PATH
10469 do
10470   IFS=$as_save_IFS
10471   test -z "$as_dir" && as_dir=.
10472   for ac_exec_ext in '' $ac_executable_extensions; do
10473   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10474     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10475     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10476     break 2
10477   fi
10478 done
10479 done
10480
10481 fi
10482 fi
10483 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10484 if test -n "$RANLIB_FOR_TARGET"; then
10485   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10486 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10487 else
10488   echo "$as_me:$LINENO: result: no" >&5
10489 echo "${ECHO_T}no" >&6
10490 fi
10491
10492     fi
10493     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10494   done
10495 fi
10496
10497 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10498   set dummy ranlib
10499   if test $build = $target ; then
10500     RANLIB_FOR_TARGET="$2"
10501   else
10502     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10503   fi
10504 else
10505   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10506 fi
10507
10508 else
10509   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10510 fi
10511
10512
10513
10514
10515 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10516   if test -n "$with_build_time_tools"; then
10517     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10518 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10519     if test -x $with_build_time_tools/strip; then
10520       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10521       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10522       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10523 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10524     else
10525       echo "$as_me:$LINENO: result: no" >&5
10526 echo "${ECHO_T}no" >&6
10527     fi
10528   elif test $build != $host && test $have_gcc_for_target = yes; then
10529     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10530     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10531     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10532   fi
10533 fi
10534 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10535   # Extract the first word of "strip", so it can be a program name with args.
10536 set dummy strip; ac_word=$2
10537 echo "$as_me:$LINENO: checking for $ac_word" >&5
10538 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10539 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10540   echo $ECHO_N "(cached) $ECHO_C" >&6
10541 else
10542   case $STRIP_FOR_TARGET in
10543   [\\/]* | ?:[\\/]*)
10544   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10545   ;;
10546   *)
10547   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10548 for as_dir in $gcc_cv_tool_dirs
10549 do
10550   IFS=$as_save_IFS
10551   test -z "$as_dir" && as_dir=.
10552   for ac_exec_ext in '' $ac_executable_extensions; do
10553   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10554     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10555     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10556     break 2
10557   fi
10558 done
10559 done
10560
10561   ;;
10562 esac
10563 fi
10564 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10565
10566 if test -n "$STRIP_FOR_TARGET"; then
10567   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10568 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10569 else
10570   echo "$as_me:$LINENO: result: no" >&5
10571 echo "${ECHO_T}no" >&6
10572 fi
10573
10574 fi
10575 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10576
10577
10578 if test -n "$STRIP_FOR_TARGET"; then
10579   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10580 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10581   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10582 fi
10583
10584 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10585   for ncn_progname in strip; do
10586     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10587 set dummy ${ncn_progname}; ac_word=$2
10588 echo "$as_me:$LINENO: checking for $ac_word" >&5
10589 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10590 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10591   echo $ECHO_N "(cached) $ECHO_C" >&6
10592 else
10593   if test -n "$STRIP_FOR_TARGET"; then
10594   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10595 else
10596 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10597 for as_dir in $PATH
10598 do
10599   IFS=$as_save_IFS
10600   test -z "$as_dir" && as_dir=.
10601   for ac_exec_ext in '' $ac_executable_extensions; do
10602   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10603     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10604     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10605     break 2
10606   fi
10607 done
10608 done
10609
10610 fi
10611 fi
10612 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10613 if test -n "$STRIP_FOR_TARGET"; then
10614   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10615 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10616 else
10617   echo "$as_me:$LINENO: result: no" >&5
10618 echo "${ECHO_T}no" >&6
10619 fi
10620
10621   done
10622 fi
10623
10624 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10625   for ncn_progname in strip; do
10626     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10627 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10628     if test -x $with_build_time_tools/${ncn_progname}; then
10629       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10630       echo "$as_me:$LINENO: result: yes" >&5
10631 echo "${ECHO_T}yes" >&6
10632       break
10633     else
10634       echo "$as_me:$LINENO: result: no" >&5
10635 echo "${ECHO_T}no" >&6
10636     fi
10637   done
10638 fi
10639
10640 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10641   for ncn_progname in strip; do
10642     if test -n "$ncn_target_tool_prefix"; then
10643       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10644 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10645 echo "$as_me:$LINENO: checking for $ac_word" >&5
10646 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10647 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10648   echo $ECHO_N "(cached) $ECHO_C" >&6
10649 else
10650   if test -n "$STRIP_FOR_TARGET"; then
10651   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10652 else
10653 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10654 for as_dir in $PATH
10655 do
10656   IFS=$as_save_IFS
10657   test -z "$as_dir" && as_dir=.
10658   for ac_exec_ext in '' $ac_executable_extensions; do
10659   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10660     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10661     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10662     break 2
10663   fi
10664 done
10665 done
10666
10667 fi
10668 fi
10669 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10670 if test -n "$STRIP_FOR_TARGET"; then
10671   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10672 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10673 else
10674   echo "$as_me:$LINENO: result: no" >&5
10675 echo "${ECHO_T}no" >&6
10676 fi
10677
10678     fi
10679     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10680       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10681 set dummy ${ncn_progname}; ac_word=$2
10682 echo "$as_me:$LINENO: checking for $ac_word" >&5
10683 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10684 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10685   echo $ECHO_N "(cached) $ECHO_C" >&6
10686 else
10687   if test -n "$STRIP_FOR_TARGET"; then
10688   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10689 else
10690 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10691 for as_dir in $PATH
10692 do
10693   IFS=$as_save_IFS
10694   test -z "$as_dir" && as_dir=.
10695   for ac_exec_ext in '' $ac_executable_extensions; do
10696   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10697     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10698     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10699     break 2
10700   fi
10701 done
10702 done
10703
10704 fi
10705 fi
10706 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10707 if test -n "$STRIP_FOR_TARGET"; then
10708   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10709 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10710 else
10711   echo "$as_me:$LINENO: result: no" >&5
10712 echo "${ECHO_T}no" >&6
10713 fi
10714
10715     fi
10716     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10717   done
10718 fi
10719
10720 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10721   set dummy strip
10722   if test $build = $target ; then
10723     STRIP_FOR_TARGET="$2"
10724   else
10725     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10726   fi
10727 else
10728   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10729 fi
10730
10731 else
10732   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10733 fi
10734
10735
10736
10737
10738 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10739   if test -n "$with_build_time_tools"; then
10740     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10741 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10742     if test -x $with_build_time_tools/windres; then
10743       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10744       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10745       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10746 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10747     else
10748       echo "$as_me:$LINENO: result: no" >&5
10749 echo "${ECHO_T}no" >&6
10750     fi
10751   elif test $build != $host && test $have_gcc_for_target = yes; then
10752     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10753     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10754     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10755   fi
10756 fi
10757 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10758   # Extract the first word of "windres", so it can be a program name with args.
10759 set dummy windres; ac_word=$2
10760 echo "$as_me:$LINENO: checking for $ac_word" >&5
10761 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10762 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10763   echo $ECHO_N "(cached) $ECHO_C" >&6
10764 else
10765   case $WINDRES_FOR_TARGET in
10766   [\\/]* | ?:[\\/]*)
10767   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10768   ;;
10769   *)
10770   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10771 for as_dir in $gcc_cv_tool_dirs
10772 do
10773   IFS=$as_save_IFS
10774   test -z "$as_dir" && as_dir=.
10775   for ac_exec_ext in '' $ac_executable_extensions; do
10776   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10777     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10778     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10779     break 2
10780   fi
10781 done
10782 done
10783
10784   ;;
10785 esac
10786 fi
10787 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10788
10789 if test -n "$WINDRES_FOR_TARGET"; then
10790   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10791 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10792 else
10793   echo "$as_me:$LINENO: result: no" >&5
10794 echo "${ECHO_T}no" >&6
10795 fi
10796
10797 fi
10798 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10799
10800
10801 if test -n "$WINDRES_FOR_TARGET"; then
10802   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10803 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10804   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10805 fi
10806
10807 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10808   for ncn_progname in windres; do
10809     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10810 set dummy ${ncn_progname}; ac_word=$2
10811 echo "$as_me:$LINENO: checking for $ac_word" >&5
10812 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10813 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10814   echo $ECHO_N "(cached) $ECHO_C" >&6
10815 else
10816   if test -n "$WINDRES_FOR_TARGET"; then
10817   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10818 else
10819 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10820 for as_dir in $PATH
10821 do
10822   IFS=$as_save_IFS
10823   test -z "$as_dir" && as_dir=.
10824   for ac_exec_ext in '' $ac_executable_extensions; do
10825   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10826     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10827     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10828     break 2
10829   fi
10830 done
10831 done
10832
10833 fi
10834 fi
10835 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10836 if test -n "$WINDRES_FOR_TARGET"; then
10837   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10838 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10839 else
10840   echo "$as_me:$LINENO: result: no" >&5
10841 echo "${ECHO_T}no" >&6
10842 fi
10843
10844   done
10845 fi
10846
10847 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10848   for ncn_progname in windres; do
10849     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10850 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10851     if test -x $with_build_time_tools/${ncn_progname}; then
10852       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10853       echo "$as_me:$LINENO: result: yes" >&5
10854 echo "${ECHO_T}yes" >&6
10855       break
10856     else
10857       echo "$as_me:$LINENO: result: no" >&5
10858 echo "${ECHO_T}no" >&6
10859     fi
10860   done
10861 fi
10862
10863 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10864   for ncn_progname in windres; do
10865     if test -n "$ncn_target_tool_prefix"; then
10866       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10867 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10868 echo "$as_me:$LINENO: checking for $ac_word" >&5
10869 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10870 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10871   echo $ECHO_N "(cached) $ECHO_C" >&6
10872 else
10873   if test -n "$WINDRES_FOR_TARGET"; then
10874   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10875 else
10876 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10877 for as_dir in $PATH
10878 do
10879   IFS=$as_save_IFS
10880   test -z "$as_dir" && as_dir=.
10881   for ac_exec_ext in '' $ac_executable_extensions; do
10882   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10883     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10884     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10885     break 2
10886   fi
10887 done
10888 done
10889
10890 fi
10891 fi
10892 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10893 if test -n "$WINDRES_FOR_TARGET"; then
10894   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10895 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10896 else
10897   echo "$as_me:$LINENO: result: no" >&5
10898 echo "${ECHO_T}no" >&6
10899 fi
10900
10901     fi
10902     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10903       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10904 set dummy ${ncn_progname}; ac_word=$2
10905 echo "$as_me:$LINENO: checking for $ac_word" >&5
10906 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10907 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10908   echo $ECHO_N "(cached) $ECHO_C" >&6
10909 else
10910   if test -n "$WINDRES_FOR_TARGET"; then
10911   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10912 else
10913 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10914 for as_dir in $PATH
10915 do
10916   IFS=$as_save_IFS
10917   test -z "$as_dir" && as_dir=.
10918   for ac_exec_ext in '' $ac_executable_extensions; do
10919   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10920     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10921     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10922     break 2
10923   fi
10924 done
10925 done
10926
10927 fi
10928 fi
10929 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10930 if test -n "$WINDRES_FOR_TARGET"; then
10931   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10932 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10933 else
10934   echo "$as_me:$LINENO: result: no" >&5
10935 echo "${ECHO_T}no" >&6
10936 fi
10937
10938     fi
10939     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10940   done
10941 fi
10942
10943 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10944   set dummy windres
10945   if test $build = $target ; then
10946     WINDRES_FOR_TARGET="$2"
10947   else
10948     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10949   fi
10950 else
10951   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
10952 fi
10953
10954 else
10955   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10956 fi
10957
10958
10959
10960
10961 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
10962   if test -n "$with_build_time_tools"; then
10963     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
10964 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
10965     if test -x $with_build_time_tools/windmc; then
10966       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
10967       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10968       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
10969 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
10970     else
10971       echo "$as_me:$LINENO: result: no" >&5
10972 echo "${ECHO_T}no" >&6
10973     fi
10974   elif test $build != $host && test $have_gcc_for_target = yes; then
10975     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
10976     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
10977     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10978   fi
10979 fi
10980 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10981   # Extract the first word of "windmc", so it can be a program name with args.
10982 set dummy windmc; ac_word=$2
10983 echo "$as_me:$LINENO: checking for $ac_word" >&5
10984 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10985 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
10986   echo $ECHO_N "(cached) $ECHO_C" >&6
10987 else
10988   case $WINDMC_FOR_TARGET in
10989   [\\/]* | ?:[\\/]*)
10990   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
10991   ;;
10992   *)
10993   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10994 for as_dir in $gcc_cv_tool_dirs
10995 do
10996   IFS=$as_save_IFS
10997   test -z "$as_dir" && as_dir=.
10998   for ac_exec_ext in '' $ac_executable_extensions; do
10999   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11000     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11001     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11002     break 2
11003   fi
11004 done
11005 done
11006
11007   ;;
11008 esac
11009 fi
11010 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11011
11012 if test -n "$WINDMC_FOR_TARGET"; then
11013   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11014 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11015 else
11016   echo "$as_me:$LINENO: result: no" >&5
11017 echo "${ECHO_T}no" >&6
11018 fi
11019
11020 fi
11021 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11022
11023
11024 if test -n "$WINDMC_FOR_TARGET"; then
11025   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11026 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11027   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11028 fi
11029
11030 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11031   for ncn_progname in windmc; do
11032     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11033 set dummy ${ncn_progname}; ac_word=$2
11034 echo "$as_me:$LINENO: checking for $ac_word" >&5
11035 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11036 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11037   echo $ECHO_N "(cached) $ECHO_C" >&6
11038 else
11039   if test -n "$WINDMC_FOR_TARGET"; then
11040   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11041 else
11042 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11043 for as_dir in $PATH
11044 do
11045   IFS=$as_save_IFS
11046   test -z "$as_dir" && as_dir=.
11047   for ac_exec_ext in '' $ac_executable_extensions; do
11048   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11049     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11050     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11051     break 2
11052   fi
11053 done
11054 done
11055
11056 fi
11057 fi
11058 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11059 if test -n "$WINDMC_FOR_TARGET"; then
11060   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11061 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11062 else
11063   echo "$as_me:$LINENO: result: no" >&5
11064 echo "${ECHO_T}no" >&6
11065 fi
11066
11067   done
11068 fi
11069
11070 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11071   for ncn_progname in windmc; do
11072     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11073 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11074     if test -x $with_build_time_tools/${ncn_progname}; then
11075       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11076       echo "$as_me:$LINENO: result: yes" >&5
11077 echo "${ECHO_T}yes" >&6
11078       break
11079     else
11080       echo "$as_me:$LINENO: result: no" >&5
11081 echo "${ECHO_T}no" >&6
11082     fi
11083   done
11084 fi
11085
11086 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11087   for ncn_progname in windmc; do
11088     if test -n "$ncn_target_tool_prefix"; then
11089       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11090 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11091 echo "$as_me:$LINENO: checking for $ac_word" >&5
11092 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11093 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11094   echo $ECHO_N "(cached) $ECHO_C" >&6
11095 else
11096   if test -n "$WINDMC_FOR_TARGET"; then
11097   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11098 else
11099 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11100 for as_dir in $PATH
11101 do
11102   IFS=$as_save_IFS
11103   test -z "$as_dir" && as_dir=.
11104   for ac_exec_ext in '' $ac_executable_extensions; do
11105   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11106     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11107     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11108     break 2
11109   fi
11110 done
11111 done
11112
11113 fi
11114 fi
11115 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11116 if test -n "$WINDMC_FOR_TARGET"; then
11117   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11118 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11119 else
11120   echo "$as_me:$LINENO: result: no" >&5
11121 echo "${ECHO_T}no" >&6
11122 fi
11123
11124     fi
11125     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11126       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11127 set dummy ${ncn_progname}; ac_word=$2
11128 echo "$as_me:$LINENO: checking for $ac_word" >&5
11129 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11130 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11131   echo $ECHO_N "(cached) $ECHO_C" >&6
11132 else
11133   if test -n "$WINDMC_FOR_TARGET"; then
11134   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11135 else
11136 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11137 for as_dir in $PATH
11138 do
11139   IFS=$as_save_IFS
11140   test -z "$as_dir" && as_dir=.
11141   for ac_exec_ext in '' $ac_executable_extensions; do
11142   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11143     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11144     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11145     break 2
11146   fi
11147 done
11148 done
11149
11150 fi
11151 fi
11152 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11153 if test -n "$WINDMC_FOR_TARGET"; then
11154   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11155 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11156 else
11157   echo "$as_me:$LINENO: result: no" >&5
11158 echo "${ECHO_T}no" >&6
11159 fi
11160
11161     fi
11162     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11163   done
11164 fi
11165
11166 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11167   set dummy windmc
11168   if test $build = $target ; then
11169     WINDMC_FOR_TARGET="$2"
11170   else
11171     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11172   fi
11173 else
11174   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11175 fi
11176
11177 else
11178   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11179 fi
11180
11181
11182 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11183
11184 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11185 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11186 if test "x${build}" != "x${host}" ; then
11187   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11188     # We already found the complete path
11189     ac_dir=`dirname $AR_FOR_TARGET`
11190     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11191 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11192   else
11193     # Canadian cross, just use what we found
11194     echo "$as_me:$LINENO: result: pre-installed" >&5
11195 echo "${ECHO_T}pre-installed" >&6
11196   fi
11197 else
11198   ok=yes
11199   case " ${configdirs} " in
11200     *" binutils "*) ;;
11201     *) ok=no ;;
11202   esac
11203
11204   if test $ok = yes; then
11205     # An in-tree tool is available and we can use it
11206     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11207     echo "$as_me:$LINENO: result: just compiled" >&5
11208 echo "${ECHO_T}just compiled" >&6
11209   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11210     # We already found the complete path
11211     ac_dir=`dirname $AR_FOR_TARGET`
11212     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11213 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11214   elif test "x$target" = "x$host"; then
11215     # We can use an host tool
11216     AR_FOR_TARGET='$(AR)'
11217     echo "$as_me:$LINENO: result: host tool" >&5
11218 echo "${ECHO_T}host tool" >&6
11219   else
11220     # We need a cross tool
11221     echo "$as_me:$LINENO: result: pre-installed" >&5
11222 echo "${ECHO_T}pre-installed" >&6
11223   fi
11224 fi
11225
11226 echo "$as_me:$LINENO: checking where to find the target as" >&5
11227 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11228 if test "x${build}" != "x${host}" ; then
11229   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11230     # We already found the complete path
11231     ac_dir=`dirname $AS_FOR_TARGET`
11232     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11233 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11234   else
11235     # Canadian cross, just use what we found
11236     echo "$as_me:$LINENO: result: pre-installed" >&5
11237 echo "${ECHO_T}pre-installed" >&6
11238   fi
11239 else
11240   ok=yes
11241   case " ${configdirs} " in
11242     *" gas "*) ;;
11243     *) ok=no ;;
11244   esac
11245
11246   if test $ok = yes; then
11247     # An in-tree tool is available and we can use it
11248     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11249     echo "$as_me:$LINENO: result: just compiled" >&5
11250 echo "${ECHO_T}just compiled" >&6
11251   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11252     # We already found the complete path
11253     ac_dir=`dirname $AS_FOR_TARGET`
11254     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11255 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11256   elif test "x$target" = "x$host"; then
11257     # We can use an host tool
11258     AS_FOR_TARGET='$(AS)'
11259     echo "$as_me:$LINENO: result: host tool" >&5
11260 echo "${ECHO_T}host tool" >&6
11261   else
11262     # We need a cross tool
11263     echo "$as_me:$LINENO: result: pre-installed" >&5
11264 echo "${ECHO_T}pre-installed" >&6
11265   fi
11266 fi
11267
11268 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11269 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11270 if test "x${build}" != "x${host}" ; then
11271   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11272     # We already found the complete path
11273     ac_dir=`dirname $CC_FOR_TARGET`
11274     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11275 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11276   else
11277     # Canadian cross, just use what we found
11278     echo "$as_me:$LINENO: result: pre-installed" >&5
11279 echo "${ECHO_T}pre-installed" >&6
11280   fi
11281 else
11282   ok=yes
11283   case " ${configdirs} " in
11284     *" gcc "*) ;;
11285     *) ok=no ;;
11286   esac
11287
11288   if test $ok = yes; then
11289     # An in-tree tool is available and we can use it
11290     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11291     echo "$as_me:$LINENO: result: just compiled" >&5
11292 echo "${ECHO_T}just compiled" >&6
11293   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11294     # We already found the complete path
11295     ac_dir=`dirname $CC_FOR_TARGET`
11296     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11297 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11298   elif test "x$target" = "x$host"; then
11299     # We can use an host tool
11300     CC_FOR_TARGET='$(CC)'
11301     echo "$as_me:$LINENO: result: host tool" >&5
11302 echo "${ECHO_T}host tool" >&6
11303   else
11304     # We need a cross tool
11305     echo "$as_me:$LINENO: result: pre-installed" >&5
11306 echo "${ECHO_T}pre-installed" >&6
11307   fi
11308 fi
11309
11310 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11311 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11312 if test "x${build}" != "x${host}" ; then
11313   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11314     # We already found the complete path
11315     ac_dir=`dirname $CXX_FOR_TARGET`
11316     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11317 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11318   else
11319     # Canadian cross, just use what we found
11320     echo "$as_me:$LINENO: result: pre-installed" >&5
11321 echo "${ECHO_T}pre-installed" >&6
11322   fi
11323 else
11324   ok=yes
11325   case " ${configdirs} " in
11326     *" gcc "*) ;;
11327     *) ok=no ;;
11328   esac
11329   case ,${enable_languages}, in
11330     *,c++,*) ;;
11331     *) ok=no ;;
11332   esac
11333   if test $ok = yes; then
11334     # An in-tree tool is available and we can use it
11335     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'
11336     echo "$as_me:$LINENO: result: just compiled" >&5
11337 echo "${ECHO_T}just compiled" >&6
11338   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11339     # We already found the complete path
11340     ac_dir=`dirname $CXX_FOR_TARGET`
11341     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11342 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11343   elif test "x$target" = "x$host"; then
11344     # We can use an host tool
11345     CXX_FOR_TARGET='$(CXX)'
11346     echo "$as_me:$LINENO: result: host tool" >&5
11347 echo "${ECHO_T}host tool" >&6
11348   else
11349     # We need a cross tool
11350     echo "$as_me:$LINENO: result: pre-installed" >&5
11351 echo "${ECHO_T}pre-installed" >&6
11352   fi
11353 fi
11354
11355 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11356 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11357 if test "x${build}" != "x${host}" ; then
11358   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11359     # We already found the complete path
11360     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11361     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11362 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11363   else
11364     # Canadian cross, just use what we found
11365     echo "$as_me:$LINENO: result: pre-installed" >&5
11366 echo "${ECHO_T}pre-installed" >&6
11367   fi
11368 else
11369   ok=yes
11370   case " ${configdirs} " in
11371     *" gcc "*) ;;
11372     *) ok=no ;;
11373   esac
11374   case ,${enable_languages}, in
11375     *,c++,*) ;;
11376     *) ok=no ;;
11377   esac
11378   if test $ok = yes; then
11379     # An in-tree tool is available and we can use it
11380     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'
11381     echo "$as_me:$LINENO: result: just compiled" >&5
11382 echo "${ECHO_T}just compiled" >&6
11383   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11384     # We already found the complete path
11385     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11386     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11387 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11388   elif test "x$target" = "x$host"; then
11389     # We can use an host tool
11390     RAW_CXX_FOR_TARGET='$(CXX)'
11391     echo "$as_me:$LINENO: result: host tool" >&5
11392 echo "${ECHO_T}host tool" >&6
11393   else
11394     # We need a cross tool
11395     echo "$as_me:$LINENO: result: pre-installed" >&5
11396 echo "${ECHO_T}pre-installed" >&6
11397   fi
11398 fi
11399
11400 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11401 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11402 if test "x${build}" != "x${host}" ; then
11403   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11404     # We already found the complete path
11405     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11406     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11407 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11408   else
11409     # Canadian cross, just use what we found
11410     echo "$as_me:$LINENO: result: pre-installed" >&5
11411 echo "${ECHO_T}pre-installed" >&6
11412   fi
11413 else
11414   ok=yes
11415   case " ${configdirs} " in
11416     *" binutils "*) ;;
11417     *) ok=no ;;
11418   esac
11419
11420   if test $ok = yes; then
11421     # An in-tree tool is available and we can use it
11422     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11423     echo "$as_me:$LINENO: result: just compiled" >&5
11424 echo "${ECHO_T}just compiled" >&6
11425   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11426     # We already found the complete path
11427     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11428     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11429 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11430   elif test "x$target" = "x$host"; then
11431     # We can use an host tool
11432     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11433     echo "$as_me:$LINENO: result: host tool" >&5
11434 echo "${ECHO_T}host tool" >&6
11435   else
11436     # We need a cross tool
11437     echo "$as_me:$LINENO: result: pre-installed" >&5
11438 echo "${ECHO_T}pre-installed" >&6
11439   fi
11440 fi
11441
11442 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11443 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11444 if test "x${build}" != "x${host}" ; then
11445   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11446     # We already found the complete path
11447     ac_dir=`dirname $GCC_FOR_TARGET`
11448     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11449 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11450   else
11451     # Canadian cross, just use what we found
11452     echo "$as_me:$LINENO: result: pre-installed" >&5
11453 echo "${ECHO_T}pre-installed" >&6
11454   fi
11455 else
11456   ok=yes
11457   case " ${configdirs} " in
11458     *" gcc "*) ;;
11459     *) ok=no ;;
11460   esac
11461
11462   if test $ok = yes; then
11463     # An in-tree tool is available and we can use it
11464     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11465     echo "$as_me:$LINENO: result: just compiled" >&5
11466 echo "${ECHO_T}just compiled" >&6
11467   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11468     # We already found the complete path
11469     ac_dir=`dirname $GCC_FOR_TARGET`
11470     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11471 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11472   elif test "x$target" = "x$host"; then
11473     # We can use an host tool
11474     GCC_FOR_TARGET='$()'
11475     echo "$as_me:$LINENO: result: host tool" >&5
11476 echo "${ECHO_T}host tool" >&6
11477   else
11478     # We need a cross tool
11479     echo "$as_me:$LINENO: result: pre-installed" >&5
11480 echo "${ECHO_T}pre-installed" >&6
11481   fi
11482 fi
11483
11484 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11485 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11486 if test "x${build}" != "x${host}" ; then
11487   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11488     # We already found the complete path
11489     ac_dir=`dirname $GCJ_FOR_TARGET`
11490     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11491 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11492   else
11493     # Canadian cross, just use what we found
11494     echo "$as_me:$LINENO: result: pre-installed" >&5
11495 echo "${ECHO_T}pre-installed" >&6
11496   fi
11497 else
11498   ok=yes
11499   case " ${configdirs} " in
11500     *" gcc "*) ;;
11501     *) ok=no ;;
11502   esac
11503   case ,${enable_languages}, in
11504     *,java,*) ;;
11505     *) ok=no ;;
11506   esac
11507   if test $ok = yes; then
11508     # An in-tree tool is available and we can use it
11509     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11510     echo "$as_me:$LINENO: result: just compiled" >&5
11511 echo "${ECHO_T}just compiled" >&6
11512   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11513     # We already found the complete path
11514     ac_dir=`dirname $GCJ_FOR_TARGET`
11515     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11516 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11517   elif test "x$target" = "x$host"; then
11518     # We can use an host tool
11519     GCJ_FOR_TARGET='$(GCJ)'
11520     echo "$as_me:$LINENO: result: host tool" >&5
11521 echo "${ECHO_T}host tool" >&6
11522   else
11523     # We need a cross tool
11524     echo "$as_me:$LINENO: result: pre-installed" >&5
11525 echo "${ECHO_T}pre-installed" >&6
11526   fi
11527 fi
11528
11529 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11530 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11531 if test "x${build}" != "x${host}" ; then
11532   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11533     # We already found the complete path
11534     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11535     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11536 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11537   else
11538     # Canadian cross, just use what we found
11539     echo "$as_me:$LINENO: result: pre-installed" >&5
11540 echo "${ECHO_T}pre-installed" >&6
11541   fi
11542 else
11543   ok=yes
11544   case " ${configdirs} " in
11545     *" gcc "*) ;;
11546     *) ok=no ;;
11547   esac
11548   case ,${enable_languages}, in
11549     *,fortran,*) ;;
11550     *) ok=no ;;
11551   esac
11552   if test $ok = yes; then
11553     # An in-tree tool is available and we can use it
11554     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11555     echo "$as_me:$LINENO: result: just compiled" >&5
11556 echo "${ECHO_T}just compiled" >&6
11557   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11558     # We already found the complete path
11559     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11560     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11561 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11562   elif test "x$target" = "x$host"; then
11563     # We can use an host tool
11564     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11565     echo "$as_me:$LINENO: result: host tool" >&5
11566 echo "${ECHO_T}host tool" >&6
11567   else
11568     # We need a cross tool
11569     echo "$as_me:$LINENO: result: pre-installed" >&5
11570 echo "${ECHO_T}pre-installed" >&6
11571   fi
11572 fi
11573
11574 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11575 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11576 if test "x${build}" != "x${host}" ; then
11577   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11578     # We already found the complete path
11579     ac_dir=`dirname $LD_FOR_TARGET`
11580     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11581 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11582   else
11583     # Canadian cross, just use what we found
11584     echo "$as_me:$LINENO: result: pre-installed" >&5
11585 echo "${ECHO_T}pre-installed" >&6
11586   fi
11587 else
11588   ok=yes
11589   case " ${configdirs} " in
11590     *" ld "*) ;;
11591     *) ok=no ;;
11592   esac
11593
11594   if test $ok = yes; then
11595     # An in-tree tool is available and we can use it
11596     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11597     echo "$as_me:$LINENO: result: just compiled" >&5
11598 echo "${ECHO_T}just compiled" >&6
11599   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11600     # We already found the complete path
11601     ac_dir=`dirname $LD_FOR_TARGET`
11602     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11603 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11604   elif test "x$target" = "x$host"; then
11605     # We can use an host tool
11606     LD_FOR_TARGET='$(LD)'
11607     echo "$as_me:$LINENO: result: host tool" >&5
11608 echo "${ECHO_T}host tool" >&6
11609   else
11610     # We need a cross tool
11611     echo "$as_me:$LINENO: result: pre-installed" >&5
11612 echo "${ECHO_T}pre-installed" >&6
11613   fi
11614 fi
11615
11616 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11617 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11618 if test "x${build}" != "x${host}" ; then
11619   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11620     # We already found the complete path
11621     ac_dir=`dirname $LIPO_FOR_TARGET`
11622     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11623 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11624   else
11625     # Canadian cross, just use what we found
11626     echo "$as_me:$LINENO: result: pre-installed" >&5
11627 echo "${ECHO_T}pre-installed" >&6
11628   fi
11629 else
11630   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11631     # We already found the complete path
11632     ac_dir=`dirname $LIPO_FOR_TARGET`
11633     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11634 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11635   elif test "x$target" = "x$host"; then
11636     # We can use an host tool
11637     LIPO_FOR_TARGET='$(LIPO)'
11638     echo "$as_me:$LINENO: result: host tool" >&5
11639 echo "${ECHO_T}host tool" >&6
11640   else
11641     # We need a cross tool
11642     echo "$as_me:$LINENO: result: pre-installed" >&5
11643 echo "${ECHO_T}pre-installed" >&6
11644   fi
11645 fi
11646
11647 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11648 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11649 if test "x${build}" != "x${host}" ; then
11650   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11651     # We already found the complete path
11652     ac_dir=`dirname $NM_FOR_TARGET`
11653     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11654 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11655   else
11656     # Canadian cross, just use what we found
11657     echo "$as_me:$LINENO: result: pre-installed" >&5
11658 echo "${ECHO_T}pre-installed" >&6
11659   fi
11660 else
11661   ok=yes
11662   case " ${configdirs} " in
11663     *" binutils "*) ;;
11664     *) ok=no ;;
11665   esac
11666
11667   if test $ok = yes; then
11668     # An in-tree tool is available and we can use it
11669     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11670     echo "$as_me:$LINENO: result: just compiled" >&5
11671 echo "${ECHO_T}just compiled" >&6
11672   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11673     # We already found the complete path
11674     ac_dir=`dirname $NM_FOR_TARGET`
11675     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11676 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11677   elif test "x$target" = "x$host"; then
11678     # We can use an host tool
11679     NM_FOR_TARGET='$(NM)'
11680     echo "$as_me:$LINENO: result: host tool" >&5
11681 echo "${ECHO_T}host tool" >&6
11682   else
11683     # We need a cross tool
11684     echo "$as_me:$LINENO: result: pre-installed" >&5
11685 echo "${ECHO_T}pre-installed" >&6
11686   fi
11687 fi
11688
11689 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11690 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11691 if test "x${build}" != "x${host}" ; then
11692   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11693     # We already found the complete path
11694     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11695     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11696 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11697   else
11698     # Canadian cross, just use what we found
11699     echo "$as_me:$LINENO: result: pre-installed" >&5
11700 echo "${ECHO_T}pre-installed" >&6
11701   fi
11702 else
11703   ok=yes
11704   case " ${configdirs} " in
11705     *" binutils "*) ;;
11706     *) ok=no ;;
11707   esac
11708
11709   if test $ok = yes; then
11710     # An in-tree tool is available and we can use it
11711     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11712     echo "$as_me:$LINENO: result: just compiled" >&5
11713 echo "${ECHO_T}just compiled" >&6
11714   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11715     # We already found the complete path
11716     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11717     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11718 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11719   elif test "x$target" = "x$host"; then
11720     # We can use an host tool
11721     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11722     echo "$as_me:$LINENO: result: host tool" >&5
11723 echo "${ECHO_T}host tool" >&6
11724   else
11725     # We need a cross tool
11726     echo "$as_me:$LINENO: result: pre-installed" >&5
11727 echo "${ECHO_T}pre-installed" >&6
11728   fi
11729 fi
11730
11731 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11732 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11733 if test "x${build}" != "x${host}" ; then
11734   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11735     # We already found the complete path
11736     ac_dir=`dirname $RANLIB_FOR_TARGET`
11737     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11738 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11739   else
11740     # Canadian cross, just use what we found
11741     echo "$as_me:$LINENO: result: pre-installed" >&5
11742 echo "${ECHO_T}pre-installed" >&6
11743   fi
11744 else
11745   ok=yes
11746   case " ${configdirs} " in
11747     *" binutils "*) ;;
11748     *) ok=no ;;
11749   esac
11750
11751   if test $ok = yes; then
11752     # An in-tree tool is available and we can use it
11753     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11754     echo "$as_me:$LINENO: result: just compiled" >&5
11755 echo "${ECHO_T}just compiled" >&6
11756   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11757     # We already found the complete path
11758     ac_dir=`dirname $RANLIB_FOR_TARGET`
11759     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11760 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11761   elif test "x$target" = "x$host"; then
11762     # We can use an host tool
11763     RANLIB_FOR_TARGET='$(RANLIB)'
11764     echo "$as_me:$LINENO: result: host tool" >&5
11765 echo "${ECHO_T}host tool" >&6
11766   else
11767     # We need a cross tool
11768     echo "$as_me:$LINENO: result: pre-installed" >&5
11769 echo "${ECHO_T}pre-installed" >&6
11770   fi
11771 fi
11772
11773 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11774 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11775 if test "x${build}" != "x${host}" ; then
11776   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11777     # We already found the complete path
11778     ac_dir=`dirname $STRIP_FOR_TARGET`
11779     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11780 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11781   else
11782     # Canadian cross, just use what we found
11783     echo "$as_me:$LINENO: result: pre-installed" >&5
11784 echo "${ECHO_T}pre-installed" >&6
11785   fi
11786 else
11787   ok=yes
11788   case " ${configdirs} " in
11789     *" binutils "*) ;;
11790     *) ok=no ;;
11791   esac
11792
11793   if test $ok = yes; then
11794     # An in-tree tool is available and we can use it
11795     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11796     echo "$as_me:$LINENO: result: just compiled" >&5
11797 echo "${ECHO_T}just compiled" >&6
11798   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11799     # We already found the complete path
11800     ac_dir=`dirname $STRIP_FOR_TARGET`
11801     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11802 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11803   elif test "x$target" = "x$host"; then
11804     # We can use an host tool
11805     STRIP_FOR_TARGET='$(STRIP)'
11806     echo "$as_me:$LINENO: result: host tool" >&5
11807 echo "${ECHO_T}host tool" >&6
11808   else
11809     # We need a cross tool
11810     echo "$as_me:$LINENO: result: pre-installed" >&5
11811 echo "${ECHO_T}pre-installed" >&6
11812   fi
11813 fi
11814
11815 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11816 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11817 if test "x${build}" != "x${host}" ; then
11818   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11819     # We already found the complete path
11820     ac_dir=`dirname $WINDRES_FOR_TARGET`
11821     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11822 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11823   else
11824     # Canadian cross, just use what we found
11825     echo "$as_me:$LINENO: result: pre-installed" >&5
11826 echo "${ECHO_T}pre-installed" >&6
11827   fi
11828 else
11829   ok=yes
11830   case " ${configdirs} " in
11831     *" binutils "*) ;;
11832     *) ok=no ;;
11833   esac
11834
11835   if test $ok = yes; then
11836     # An in-tree tool is available and we can use it
11837     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11838     echo "$as_me:$LINENO: result: just compiled" >&5
11839 echo "${ECHO_T}just compiled" >&6
11840   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11841     # We already found the complete path
11842     ac_dir=`dirname $WINDRES_FOR_TARGET`
11843     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11844 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11845   elif test "x$target" = "x$host"; then
11846     # We can use an host tool
11847     WINDRES_FOR_TARGET='$(WINDRES)'
11848     echo "$as_me:$LINENO: result: host tool" >&5
11849 echo "${ECHO_T}host tool" >&6
11850   else
11851     # We need a cross tool
11852     echo "$as_me:$LINENO: result: pre-installed" >&5
11853 echo "${ECHO_T}pre-installed" >&6
11854   fi
11855 fi
11856
11857 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
11858 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
11859 if test "x${build}" != "x${host}" ; then
11860   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11861     # We already found the complete path
11862     ac_dir=`dirname $WINDMC_FOR_TARGET`
11863     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11864 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11865   else
11866     # Canadian cross, just use what we found
11867     echo "$as_me:$LINENO: result: pre-installed" >&5
11868 echo "${ECHO_T}pre-installed" >&6
11869   fi
11870 else
11871   ok=yes
11872   case " ${configdirs} " in
11873     *" binutils "*) ;;
11874     *) ok=no ;;
11875   esac
11876
11877   if test $ok = yes; then
11878     # An in-tree tool is available and we can use it
11879     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
11880     echo "$as_me:$LINENO: result: just compiled" >&5
11881 echo "${ECHO_T}just compiled" >&6
11882   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11883     # We already found the complete path
11884     ac_dir=`dirname $WINDMC_FOR_TARGET`
11885     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11886 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11887   elif test "x$target" = "x$host"; then
11888     # We can use an host tool
11889     WINDMC_FOR_TARGET='$(WINDMC)'
11890     echo "$as_me:$LINENO: result: host tool" >&5
11891 echo "${ECHO_T}host tool" >&6
11892   else
11893     # We need a cross tool
11894     echo "$as_me:$LINENO: result: pre-installed" >&5
11895 echo "${ECHO_T}pre-installed" >&6
11896   fi
11897 fi
11898
11899
11900
11901
11902
11903 # Certain tools may need extra flags.
11904 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11905 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11906 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11907
11908 # When building target libraries, except in a Canadian cross, we use
11909 # the same toolchain as the compiler we just built.
11910 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11911 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11912 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11913 if test $host = $build; then
11914   case " $configdirs " in
11915     *" gcc "*)
11916       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11917       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11918       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11919       ;;
11920   esac
11921 fi
11922
11923
11924
11925
11926
11927 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11928 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11929 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11930 if test "${enable_maintainer_mode+set}" = set; then
11931   enableval="$enable_maintainer_mode"
11932   USE_MAINTAINER_MODE=$enableval
11933 else
11934   USE_MAINTAINER_MODE=no
11935 fi;
11936 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11937 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11938
11939
11940 if test "$USE_MAINTAINER_MODE" = yes; then
11941   MAINTAINER_MODE_TRUE=
11942   MAINTAINER_MODE_FALSE='#'
11943 else
11944   MAINTAINER_MODE_TRUE='#'
11945   MAINTAINER_MODE_FALSE=
11946 fi
11947 MAINT=$MAINTAINER_MODE_TRUE
11948
11949 # ---------------------
11950 # GCC bootstrap support
11951 # ---------------------
11952
11953 # Stage specific cflags for build.
11954 stage1_cflags="-g"
11955 case $build in
11956   vax-*-*)
11957     case ${GCC} in
11958       yes) stage1_cflags="-g -Wa,-J" ;;
11959       *) stage1_cflags="-g -J" ;;
11960     esac ;;
11961 esac
11962
11963 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
11964 if test "$GCC" = yes; then
11965   saved_CFLAGS="$CFLAGS"
11966
11967   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
11968   CFLAGS="$CFLAGS -fkeep-inline-functions"
11969   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
11970 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
11971   cat >conftest.$ac_ext <<_ACEOF
11972 /* confdefs.h.  */
11973 _ACEOF
11974 cat confdefs.h >>conftest.$ac_ext
11975 cat >>conftest.$ac_ext <<_ACEOF
11976 /* end confdefs.h.  */
11977
11978 #if (__GNUC__ < 3) \
11979     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
11980                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
11981 #error http://gcc.gnu.org/PR29382
11982 #endif
11983
11984 int
11985 main ()
11986 {
11987
11988   ;
11989   return 0;
11990 }
11991 _ACEOF
11992 rm -f conftest.$ac_objext
11993 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11994   (eval $ac_compile) 2>conftest.er1
11995   ac_status=$?
11996   grep -v '^ *+' conftest.er1 >conftest.err
11997   rm -f conftest.er1
11998   cat conftest.err >&5
11999   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12000   (exit $ac_status); } &&
12001          { ac_try='test -z "$ac_c_werror_flag"
12002                          || test ! -s conftest.err'
12003   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12004   (eval $ac_try) 2>&5
12005   ac_status=$?
12006   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12007   (exit $ac_status); }; } &&
12008          { ac_try='test -s conftest.$ac_objext'
12009   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12010   (eval $ac_try) 2>&5
12011   ac_status=$?
12012   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12013   (exit $ac_status); }; }; then
12014   echo "$as_me:$LINENO: result: yes" >&5
12015 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12016 else
12017   echo "$as_me: failed program was:" >&5
12018 sed 's/^/| /' conftest.$ac_ext >&5
12019
12020 echo "$as_me:$LINENO: result: no" >&5
12021 echo "${ECHO_T}no" >&6
12022 fi
12023 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12024
12025   CFLAGS="$saved_CFLAGS"
12026 fi
12027
12028
12029
12030 # Enable --enable-checking in stage1 of the compiler.
12031 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12032 if test "${enable_stage1_checking+set}" = set; then
12033   enableval="$enable_stage1_checking"
12034   stage1_checking=--enable-checking=${enable_stage1_checking}
12035 else
12036   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12037   stage1_checking=--enable-checking=yes,types
12038 else
12039   stage1_checking=--enable-checking=$enable_checking,types
12040 fi
12041 fi;
12042
12043
12044 # Enable -Werror in bootstrap stage2 and later.
12045 # Check whether --enable-werror or --disable-werror was given.
12046 if test "${enable_werror+set}" = set; then
12047   enableval="$enable_werror"
12048
12049 else
12050   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12051   enable_werror=yes
12052 else
12053   enable_werror=no
12054 fi
12055 fi;
12056 case ${enable_werror} in
12057   yes) stage2_werror_flag="--enable-werror-always" ;;
12058   *) stage2_werror_flag="" ;;
12059 esac
12060
12061
12062 # Flags needed to enable html installing and building
12063
12064 # Check whether --with-datarootdir or --without-datarootdir was given.
12065 if test "${with_datarootdir+set}" = set; then
12066   withval="$with_datarootdir"
12067   datarootdir="\${prefix}/${withval}"
12068 else
12069   datarootdir="\${prefix}/share"
12070 fi;
12071
12072
12073 # Check whether --with-docdir or --without-docdir was given.
12074 if test "${with_docdir+set}" = set; then
12075   withval="$with_docdir"
12076   docdir="\${prefix}/${withval}"
12077 else
12078   docdir="\${datarootdir}/doc"
12079 fi;
12080
12081
12082 # Check whether --with-pdfdir or --without-pdfdir was given.
12083 if test "${with_pdfdir+set}" = set; then
12084   withval="$with_pdfdir"
12085   pdfdir="\${prefix}/${withval}"
12086 else
12087   pdfdir="\${docdir}"
12088 fi;
12089
12090
12091 # Check whether --with-htmldir or --without-htmldir was given.
12092 if test "${with_htmldir+set}" = set; then
12093   withval="$with_htmldir"
12094   htmldir="\${prefix}/${withval}"
12095 else
12096   htmldir="\${docdir}"
12097 fi;
12098
12099
12100
12101
12102
12103
12104           ac_config_files="$ac_config_files Makefile"
12105 cat >confcache <<\_ACEOF
12106 # This file is a shell script that caches the results of configure
12107 # tests run on this system so they can be shared between configure
12108 # scripts and configure runs, see configure's option --config-cache.
12109 # It is not useful on other systems.  If it contains results you don't
12110 # want to keep, you may remove or edit it.
12111 #
12112 # config.status only pays attention to the cache file if you give it
12113 # the --recheck option to rerun configure.
12114 #
12115 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12116 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12117 # following values.
12118
12119 _ACEOF
12120
12121 # The following way of writing the cache mishandles newlines in values,
12122 # but we know of no workaround that is simple, portable, and efficient.
12123 # So, don't put newlines in cache variables' values.
12124 # Ultrix sh set writes to stderr and can't be redirected directly,
12125 # and sets the high bit in the cache file unless we assign to the vars.
12126 {
12127   (set) 2>&1 |
12128     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12129     *ac_space=\ *)
12130       # `set' does not quote correctly, so add quotes (double-quote
12131       # substitution turns \\\\ into \\, and sed turns \\ into \).
12132       sed -n \
12133         "s/'/'\\\\''/g;
12134           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12135       ;;
12136     *)
12137       # `set' quotes correctly as required by POSIX, so do not add quotes.
12138       sed -n \
12139         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12140       ;;
12141     esac;
12142 } |
12143   sed '
12144      t clear
12145      : clear
12146      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12147      t end
12148      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12149      : end' >>confcache
12150 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12151   if test -w $cache_file; then
12152     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12153     cat confcache >$cache_file
12154   else
12155     echo "not updating unwritable cache $cache_file"
12156   fi
12157 fi
12158 rm -f confcache
12159
12160 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12161 # Let make expand exec_prefix.
12162 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12163
12164 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12165 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12166 # trailing colons and then remove the whole line if VPATH becomes empty
12167 # (actually we leave an empty line to preserve line numbers).
12168 if test "x$srcdir" = x.; then
12169   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12170 s/:*\$(srcdir):*/:/;
12171 s/:*\${srcdir}:*/:/;
12172 s/:*@srcdir@:*/:/;
12173 s/^\([^=]*=[     ]*\):*/\1/;
12174 s/:*$//;
12175 s/^[^=]*=[       ]*$//;
12176 }'
12177 fi
12178
12179 # Transform confdefs.h into DEFS.
12180 # Protect against shell expansion while executing Makefile rules.
12181 # Protect against Makefile macro expansion.
12182 #
12183 # If the first sed substitution is executed (which looks for macros that
12184 # take arguments), then we branch to the quote section.  Otherwise,
12185 # look for a macro that doesn't take arguments.
12186 cat >confdef2opt.sed <<\_ACEOF
12187 t clear
12188 : clear
12189 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12190 t quote
12191 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12192 t quote
12193 d
12194 : quote
12195 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12196 s,\[,\\&,g
12197 s,\],\\&,g
12198 s,\$,$$,g
12199 p
12200 _ACEOF
12201 # We use echo to avoid assuming a particular line-breaking character.
12202 # The extra dot is to prevent the shell from consuming trailing
12203 # line-breaks from the sub-command output.  A line-break within
12204 # single-quotes doesn't work because, if this script is created in a
12205 # platform that uses two characters for line-breaks (e.g., DOS), tr
12206 # would break.
12207 ac_LF_and_DOT=`echo; echo .`
12208 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12209 rm -f confdef2opt.sed
12210
12211
12212 ac_libobjs=
12213 ac_ltlibobjs=
12214 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12215   # 1. Remove the extension, and $U if already installed.
12216   ac_i=`echo "$ac_i" |
12217          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12218   # 2. Add them.
12219   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12220   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12221 done
12222 LIBOBJS=$ac_libobjs
12223
12224 LTLIBOBJS=$ac_ltlibobjs
12225
12226
12227
12228 : ${CONFIG_STATUS=./config.status}
12229 ac_clean_files_save=$ac_clean_files
12230 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12231 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12232 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12233 cat >$CONFIG_STATUS <<_ACEOF
12234 #! $SHELL
12235 # Generated by $as_me.
12236 # Run this file to recreate the current configuration.
12237 # Compiler output produced by configure, useful for debugging
12238 # configure, is in config.log if it exists.
12239
12240 debug=false
12241 ac_cs_recheck=false
12242 ac_cs_silent=false
12243 SHELL=\${CONFIG_SHELL-$SHELL}
12244 _ACEOF
12245
12246 cat >>$CONFIG_STATUS <<\_ACEOF
12247 ## --------------------- ##
12248 ## M4sh Initialization.  ##
12249 ## --------------------- ##
12250
12251 # Be Bourne compatible
12252 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12253   emulate sh
12254   NULLCMD=:
12255   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12256   # is contrary to our usage.  Disable this feature.
12257   alias -g '${1+"$@"}'='"$@"'
12258 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12259   set -o posix
12260 fi
12261 DUALCASE=1; export DUALCASE # for MKS sh
12262
12263 # Support unset when possible.
12264 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12265   as_unset=unset
12266 else
12267   as_unset=false
12268 fi
12269
12270
12271 # Work around bugs in pre-3.0 UWIN ksh.
12272 $as_unset ENV MAIL MAILPATH
12273 PS1='$ '
12274 PS2='> '
12275 PS4='+ '
12276
12277 # NLS nuisances.
12278 for as_var in \
12279   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12280   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12281   LC_TELEPHONE LC_TIME
12282 do
12283   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12284     eval $as_var=C; export $as_var
12285   else
12286     $as_unset $as_var
12287   fi
12288 done
12289
12290 # Required to use basename.
12291 if expr a : '\(a\)' >/dev/null 2>&1; then
12292   as_expr=expr
12293 else
12294   as_expr=false
12295 fi
12296
12297 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12298   as_basename=basename
12299 else
12300   as_basename=false
12301 fi
12302
12303
12304 # Name of the executable.
12305 as_me=`$as_basename "$0" ||
12306 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12307          X"$0" : 'X\(//\)$' \| \
12308          X"$0" : 'X\(/\)$' \| \
12309          .     : '\(.\)' 2>/dev/null ||
12310 echo X/"$0" |
12311     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12312           /^X\/\(\/\/\)$/{ s//\1/; q; }
12313           /^X\/\(\/\).*/{ s//\1/; q; }
12314           s/.*/./; q'`
12315
12316
12317 # PATH needs CR, and LINENO needs CR and PATH.
12318 # Avoid depending upon Character Ranges.
12319 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12320 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12321 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12322 as_cr_digits='0123456789'
12323 as_cr_alnum=$as_cr_Letters$as_cr_digits
12324
12325 # The user is always right.
12326 if test "${PATH_SEPARATOR+set}" != set; then
12327   echo "#! /bin/sh" >conf$$.sh
12328   echo  "exit 0"   >>conf$$.sh
12329   chmod +x conf$$.sh
12330   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12331     PATH_SEPARATOR=';'
12332   else
12333     PATH_SEPARATOR=:
12334   fi
12335   rm -f conf$$.sh
12336 fi
12337
12338
12339   as_lineno_1=$LINENO
12340   as_lineno_2=$LINENO
12341   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12342   test "x$as_lineno_1" != "x$as_lineno_2" &&
12343   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12344   # Find who we are.  Look in the path if we contain no path at all
12345   # relative or not.
12346   case $0 in
12347     *[\\/]* ) as_myself=$0 ;;
12348     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12349 for as_dir in $PATH
12350 do
12351   IFS=$as_save_IFS
12352   test -z "$as_dir" && as_dir=.
12353   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12354 done
12355
12356        ;;
12357   esac
12358   # We did not find ourselves, most probably we were run as `sh COMMAND'
12359   # in which case we are not to be found in the path.
12360   if test "x$as_myself" = x; then
12361     as_myself=$0
12362   fi
12363   if test ! -f "$as_myself"; then
12364     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12365 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12366    { (exit 1); exit 1; }; }
12367   fi
12368   case $CONFIG_SHELL in
12369   '')
12370     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12371 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12372 do
12373   IFS=$as_save_IFS
12374   test -z "$as_dir" && as_dir=.
12375   for as_base in sh bash ksh sh5; do
12376          case $as_dir in
12377          /*)
12378            if ("$as_dir/$as_base" -c '
12379   as_lineno_1=$LINENO
12380   as_lineno_2=$LINENO
12381   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12382   test "x$as_lineno_1" != "x$as_lineno_2" &&
12383   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12384              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12385              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12386              CONFIG_SHELL=$as_dir/$as_base
12387              export CONFIG_SHELL
12388              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12389            fi;;
12390          esac
12391        done
12392 done
12393 ;;
12394   esac
12395
12396   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12397   # uniformly replaced by the line number.  The first 'sed' inserts a
12398   # line-number line before each line; the second 'sed' does the real
12399   # work.  The second script uses 'N' to pair each line-number line
12400   # with the numbered line, and appends trailing '-' during
12401   # substitution so that $LINENO is not a special case at line end.
12402   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12403   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12404   sed '=' <$as_myself |
12405     sed '
12406       N
12407       s,$,-,
12408       : loop
12409       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12410       t loop
12411       s,-$,,
12412       s,^['$as_cr_digits']*\n,,
12413     ' >$as_me.lineno &&
12414   chmod +x $as_me.lineno ||
12415     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12416 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12417    { (exit 1); exit 1; }; }
12418
12419   # Don't try to exec as it changes $[0], causing all sort of problems
12420   # (the dirname of $[0] is not the place where we might find the
12421   # original and so on.  Autoconf is especially sensible to this).
12422   . ./$as_me.lineno
12423   # Exit status is that of the last command.
12424   exit
12425 }
12426
12427
12428 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12429   *c*,-n*) ECHO_N= ECHO_C='
12430 ' ECHO_T='      ' ;;
12431   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12432   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12433 esac
12434
12435 if expr a : '\(a\)' >/dev/null 2>&1; then
12436   as_expr=expr
12437 else
12438   as_expr=false
12439 fi
12440
12441 rm -f conf$$ conf$$.exe conf$$.file
12442 echo >conf$$.file
12443 if ln -s conf$$.file conf$$ 2>/dev/null; then
12444   # We could just check for DJGPP; but this test a) works b) is more generic
12445   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12446   if test -f conf$$.exe; then
12447     # Don't use ln at all; we don't have any links
12448     as_ln_s='cp -p'
12449   else
12450     as_ln_s='ln -s'
12451   fi
12452 elif ln conf$$.file conf$$ 2>/dev/null; then
12453   as_ln_s=ln
12454 else
12455   as_ln_s='cp -p'
12456 fi
12457 rm -f conf$$ conf$$.exe conf$$.file
12458
12459 if mkdir -p . 2>/dev/null; then
12460   as_mkdir_p=:
12461 else
12462   test -d ./-p && rmdir ./-p
12463   as_mkdir_p=false
12464 fi
12465
12466 as_executable_p="test -f"
12467
12468 # Sed expression to map a string onto a valid CPP name.
12469 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12470
12471 # Sed expression to map a string onto a valid variable name.
12472 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12473
12474
12475 # IFS
12476 # We need space, tab and new line, in precisely that order.
12477 as_nl='
12478 '
12479 IFS="   $as_nl"
12480
12481 # CDPATH.
12482 $as_unset CDPATH
12483
12484 exec 6>&1
12485
12486 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12487 # report actual input values of CONFIG_FILES etc. instead of their
12488 # values after options handling.  Logging --version etc. is OK.
12489 exec 5>>config.log
12490 {
12491   echo
12492   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12493 ## Running $as_me. ##
12494 _ASBOX
12495 } >&5
12496 cat >&5 <<_CSEOF
12497
12498 This file was extended by $as_me, which was
12499 generated by GNU Autoconf 2.59.  Invocation command line was
12500
12501   CONFIG_FILES    = $CONFIG_FILES
12502   CONFIG_HEADERS  = $CONFIG_HEADERS
12503   CONFIG_LINKS    = $CONFIG_LINKS
12504   CONFIG_COMMANDS = $CONFIG_COMMANDS
12505   $ $0 $@
12506
12507 _CSEOF
12508 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12509 echo >&5
12510 _ACEOF
12511
12512 # Files that config.status was made for.
12513 if test -n "$ac_config_files"; then
12514   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12515 fi
12516
12517 if test -n "$ac_config_headers"; then
12518   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12519 fi
12520
12521 if test -n "$ac_config_links"; then
12522   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12523 fi
12524
12525 if test -n "$ac_config_commands"; then
12526   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12527 fi
12528
12529 cat >>$CONFIG_STATUS <<\_ACEOF
12530
12531 ac_cs_usage="\
12532 \`$as_me' instantiates files from templates according to the
12533 current configuration.
12534
12535 Usage: $0 [OPTIONS] [FILE]...
12536
12537   -h, --help       print this help, then exit
12538   -V, --version    print version number, then exit
12539   -q, --quiet      do not print progress messages
12540   -d, --debug      don't remove temporary files
12541       --recheck    update $as_me by reconfiguring in the same conditions
12542   --file=FILE[:TEMPLATE]
12543                    instantiate the configuration file FILE
12544
12545 Configuration files:
12546 $config_files
12547
12548 Report bugs to <bug-autoconf@gnu.org>."
12549 _ACEOF
12550
12551 cat >>$CONFIG_STATUS <<_ACEOF
12552 ac_cs_version="\\
12553 config.status
12554 configured by $0, generated by GNU Autoconf 2.59,
12555   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12556
12557 Copyright (C) 2003 Free Software Foundation, Inc.
12558 This config.status script is free software; the Free Software Foundation
12559 gives unlimited permission to copy, distribute and modify it."
12560 srcdir=$srcdir
12561 INSTALL="$INSTALL"
12562 _ACEOF
12563
12564 cat >>$CONFIG_STATUS <<\_ACEOF
12565 # If no file are specified by the user, then we need to provide default
12566 # value.  By we need to know if files were specified by the user.
12567 ac_need_defaults=:
12568 while test $# != 0
12569 do
12570   case $1 in
12571   --*=*)
12572     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12573     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12574     ac_shift=:
12575     ;;
12576   -*)
12577     ac_option=$1
12578     ac_optarg=$2
12579     ac_shift=shift
12580     ;;
12581   *) # This is not an option, so the user has probably given explicit
12582      # arguments.
12583      ac_option=$1
12584      ac_need_defaults=false;;
12585   esac
12586
12587   case $ac_option in
12588   # Handling of the options.
12589 _ACEOF
12590 cat >>$CONFIG_STATUS <<\_ACEOF
12591   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12592     ac_cs_recheck=: ;;
12593   --version | --vers* | -V )
12594     echo "$ac_cs_version"; exit 0 ;;
12595   --he | --h)
12596     # Conflict between --help and --header
12597     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12598 Try \`$0 --help' for more information." >&5
12599 echo "$as_me: error: ambiguous option: $1
12600 Try \`$0 --help' for more information." >&2;}
12601    { (exit 1); exit 1; }; };;
12602   --help | --hel | -h )
12603     echo "$ac_cs_usage"; exit 0 ;;
12604   --debug | --d* | -d )
12605     debug=: ;;
12606   --file | --fil | --fi | --f )
12607     $ac_shift
12608     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12609     ac_need_defaults=false;;
12610   --header | --heade | --head | --hea )
12611     $ac_shift
12612     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12613     ac_need_defaults=false;;
12614   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12615   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12616     ac_cs_silent=: ;;
12617
12618   # This is an error.
12619   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12620 Try \`$0 --help' for more information." >&5
12621 echo "$as_me: error: unrecognized option: $1
12622 Try \`$0 --help' for more information." >&2;}
12623    { (exit 1); exit 1; }; } ;;
12624
12625   *) ac_config_targets="$ac_config_targets $1" ;;
12626
12627   esac
12628   shift
12629 done
12630
12631 ac_configure_extra_args=
12632
12633 if $ac_cs_silent; then
12634   exec 6>/dev/null
12635   ac_configure_extra_args="$ac_configure_extra_args --silent"
12636 fi
12637
12638 _ACEOF
12639 cat >>$CONFIG_STATUS <<_ACEOF
12640 if \$ac_cs_recheck; then
12641   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12642   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12643 fi
12644
12645 _ACEOF
12646
12647
12648
12649
12650
12651 cat >>$CONFIG_STATUS <<\_ACEOF
12652 for ac_config_target in $ac_config_targets
12653 do
12654   case "$ac_config_target" in
12655   # Handling of arguments.
12656   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12657   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12658 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12659    { (exit 1); exit 1; }; };;
12660   esac
12661 done
12662
12663 # If the user did not use the arguments to specify the items to instantiate,
12664 # then the envvar interface is used.  Set only those that are not.
12665 # We use the long form for the default assignment because of an extremely
12666 # bizarre bug on SunOS 4.1.3.
12667 if $ac_need_defaults; then
12668   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12669 fi
12670
12671 # Have a temporary directory for convenience.  Make it in the build tree
12672 # simply because there is no reason to put it here, and in addition,
12673 # creating and moving files from /tmp can sometimes cause problems.
12674 # Create a temporary directory, and hook for its removal unless debugging.
12675 $debug ||
12676 {
12677   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12678   trap '{ (exit 1); exit 1; }' 1 2 13 15
12679 }
12680
12681 # Create a (secure) tmp directory for tmp files.
12682
12683 {
12684   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12685   test -n "$tmp" && test -d "$tmp"
12686 }  ||
12687 {
12688   tmp=./confstat$$-$RANDOM
12689   (umask 077 && mkdir $tmp)
12690 } ||
12691 {
12692    echo "$me: cannot create a temporary directory in ." >&2
12693    { (exit 1); exit 1; }
12694 }
12695
12696 _ACEOF
12697
12698 cat >>$CONFIG_STATUS <<_ACEOF
12699
12700 #
12701 # CONFIG_FILES section.
12702 #
12703
12704 # No need to generate the scripts if there are no CONFIG_FILES.
12705 # This happens for instance when ./config.status config.h
12706 if test -n "\$CONFIG_FILES"; then
12707   # Protect against being on the right side of a sed subst in config.status.
12708   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12709    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12710 s,@SHELL@,$SHELL,;t t
12711 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12712 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12713 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12714 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12715 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12716 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12717 s,@exec_prefix@,$exec_prefix,;t t
12718 s,@prefix@,$prefix,;t t
12719 s,@program_transform_name@,$program_transform_name,;t t
12720 s,@bindir@,$bindir,;t t
12721 s,@sbindir@,$sbindir,;t t
12722 s,@libexecdir@,$libexecdir,;t t
12723 s,@datadir@,$datadir,;t t
12724 s,@sysconfdir@,$sysconfdir,;t t
12725 s,@sharedstatedir@,$sharedstatedir,;t t
12726 s,@localstatedir@,$localstatedir,;t t
12727 s,@libdir@,$libdir,;t t
12728 s,@includedir@,$includedir,;t t
12729 s,@oldincludedir@,$oldincludedir,;t t
12730 s,@infodir@,$infodir,;t t
12731 s,@mandir@,$mandir,;t t
12732 s,@build_alias@,$build_alias,;t t
12733 s,@host_alias@,$host_alias,;t t
12734 s,@target_alias@,$target_alias,;t t
12735 s,@DEFS@,$DEFS,;t t
12736 s,@ECHO_C@,$ECHO_C,;t t
12737 s,@ECHO_N@,$ECHO_N,;t t
12738 s,@ECHO_T@,$ECHO_T,;t t
12739 s,@LIBS@,$LIBS,;t t
12740 s,@build@,$build,;t t
12741 s,@build_cpu@,$build_cpu,;t t
12742 s,@build_vendor@,$build_vendor,;t t
12743 s,@build_os@,$build_os,;t t
12744 s,@build_noncanonical@,$build_noncanonical,;t t
12745 s,@host_noncanonical@,$host_noncanonical,;t t
12746 s,@target_noncanonical@,$target_noncanonical,;t t
12747 s,@host@,$host,;t t
12748 s,@host_cpu@,$host_cpu,;t t
12749 s,@host_vendor@,$host_vendor,;t t
12750 s,@host_os@,$host_os,;t t
12751 s,@target@,$target,;t t
12752 s,@target_cpu@,$target_cpu,;t t
12753 s,@target_vendor@,$target_vendor,;t t
12754 s,@target_os@,$target_os,;t t
12755 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12756 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12757 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12758 s,@LN@,$LN,;t t
12759 s,@LN_S@,$LN_S,;t t
12760 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12761 s,@build_libsubdir@,$build_libsubdir,;t t
12762 s,@build_subdir@,$build_subdir,;t t
12763 s,@host_subdir@,$host_subdir,;t t
12764 s,@target_subdir@,$target_subdir,;t t
12765 s,@CC@,$CC,;t t
12766 s,@CFLAGS@,$CFLAGS,;t t
12767 s,@LDFLAGS@,$LDFLAGS,;t t
12768 s,@CPPFLAGS@,$CPPFLAGS,;t t
12769 s,@ac_ct_CC@,$ac_ct_CC,;t t
12770 s,@EXEEXT@,$EXEEXT,;t t
12771 s,@OBJEXT@,$OBJEXT,;t t
12772 s,@CXX@,$CXX,;t t
12773 s,@CXXFLAGS@,$CXXFLAGS,;t t
12774 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12775 s,@GNATBIND@,$GNATBIND,;t t
12776 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12777 s,@GNATMAKE@,$GNATMAKE,;t t
12778 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12779 s,@do_compare@,$do_compare,;t t
12780 s,@gmplibs@,$gmplibs,;t t
12781 s,@gmpinc@,$gmpinc,;t t
12782 s,@stage1_languages@,$stage1_languages,;t t
12783 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12784 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12785 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12786 s,@tooldir@,$tooldir,;t t
12787 s,@build_tooldir@,$build_tooldir,;t t
12788 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12789 s,@GDB_TK@,$GDB_TK,;t t
12790 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12791 s,@build_configargs@,$build_configargs,;t t
12792 s,@build_configdirs@,$build_configdirs,;t t
12793 s,@host_configargs@,$host_configargs,;t t
12794 s,@configdirs@,$configdirs,;t t
12795 s,@target_configargs@,$target_configargs,;t t
12796 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12797 s,@config_shell@,$config_shell,;t t
12798 s,@YACC@,$YACC,;t t
12799 s,@BISON@,$BISON,;t t
12800 s,@M4@,$M4,;t t
12801 s,@LEX@,$LEX,;t t
12802 s,@FLEX@,$FLEX,;t t
12803 s,@MAKEINFO@,$MAKEINFO,;t t
12804 s,@EXPECT@,$EXPECT,;t t
12805 s,@RUNTEST@,$RUNTEST,;t t
12806 s,@AR@,$AR,;t t
12807 s,@AS@,$AS,;t t
12808 s,@DLLTOOL@,$DLLTOOL,;t t
12809 s,@LD@,$LD,;t t
12810 s,@LIPO@,$LIPO,;t t
12811 s,@NM@,$NM,;t t
12812 s,@RANLIB@,$RANLIB,;t t
12813 s,@STRIP@,$STRIP,;t t
12814 s,@WINDRES@,$WINDRES,;t t
12815 s,@WINDMC@,$WINDMC,;t t
12816 s,@OBJCOPY@,$OBJCOPY,;t t
12817 s,@OBJDUMP@,$OBJDUMP,;t t
12818 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12819 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12820 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12821 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12822 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12823 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12824 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12825 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12826 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12827 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12828 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12829 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12830 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12831 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12832 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12833 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12834 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12835 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12836 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12837 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12838 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12839 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12840 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12841 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12842 s,@MAINT@,$MAINT,;t t
12843 s,@stage1_cflags@,$stage1_cflags,;t t
12844 s,@stage1_checking@,$stage1_checking,;t t
12845 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12846 s,@datarootdir@,$datarootdir,;t t
12847 s,@docdir@,$docdir,;t t
12848 s,@pdfdir@,$pdfdir,;t t
12849 s,@htmldir@,$htmldir,;t t
12850 s,@LIBOBJS@,$LIBOBJS,;t t
12851 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12852 /@serialization_dependencies@/r $serialization_dependencies
12853 s,@serialization_dependencies@,,;t t
12854 /@host_makefile_frag@/r $host_makefile_frag
12855 s,@host_makefile_frag@,,;t t
12856 /@target_makefile_frag@/r $target_makefile_frag
12857 s,@target_makefile_frag@,,;t t
12858 /@alphaieee_frag@/r $alphaieee_frag
12859 s,@alphaieee_frag@,,;t t
12860 /@ospace_frag@/r $ospace_frag
12861 s,@ospace_frag@,,;t t
12862 CEOF
12863
12864 _ACEOF
12865
12866   cat >>$CONFIG_STATUS <<\_ACEOF
12867   # Split the substitutions into bite-sized pieces for seds with
12868   # small command number limits, like on Digital OSF/1 and HP-UX.
12869   ac_max_sed_lines=48
12870   ac_sed_frag=1 # Number of current file.
12871   ac_beg=1 # First line for current file.
12872   ac_end=$ac_max_sed_lines # Line after last line for current file.
12873   ac_more_lines=:
12874   ac_sed_cmds=
12875   while $ac_more_lines; do
12876     if test $ac_beg -gt 1; then
12877       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12878     else
12879       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12880     fi
12881     if test ! -s $tmp/subs.frag; then
12882       ac_more_lines=false
12883     else
12884       # The purpose of the label and of the branching condition is to
12885       # speed up the sed processing (if there are no `@' at all, there
12886       # is no need to browse any of the substitutions).
12887       # These are the two extra sed commands mentioned above.
12888       (echo ':t
12889   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12890       if test -z "$ac_sed_cmds"; then
12891         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12892       else
12893         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12894       fi
12895       ac_sed_frag=`expr $ac_sed_frag + 1`
12896       ac_beg=$ac_end
12897       ac_end=`expr $ac_end + $ac_max_sed_lines`
12898     fi
12899   done
12900   if test -z "$ac_sed_cmds"; then
12901     ac_sed_cmds=cat
12902   fi
12903 fi # test -n "$CONFIG_FILES"
12904
12905 _ACEOF
12906 cat >>$CONFIG_STATUS <<\_ACEOF
12907 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12908   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12909   case $ac_file in
12910   - | *:- | *:-:* ) # input from stdin
12911         cat >$tmp/stdin
12912         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12913         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12914   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12915         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12916   * )   ac_file_in=$ac_file.in ;;
12917   esac
12918
12919   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12920   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12921 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12922          X"$ac_file" : 'X\(//\)[^/]' \| \
12923          X"$ac_file" : 'X\(//\)$' \| \
12924          X"$ac_file" : 'X\(/\)' \| \
12925          .     : '\(.\)' 2>/dev/null ||
12926 echo X"$ac_file" |
12927     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12928           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12929           /^X\(\/\/\)$/{ s//\1/; q; }
12930           /^X\(\/\).*/{ s//\1/; q; }
12931           s/.*/./; q'`
12932   { if $as_mkdir_p; then
12933     mkdir -p "$ac_dir"
12934   else
12935     as_dir="$ac_dir"
12936     as_dirs=
12937     while test ! -d "$as_dir"; do
12938       as_dirs="$as_dir $as_dirs"
12939       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12940 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12941          X"$as_dir" : 'X\(//\)[^/]' \| \
12942          X"$as_dir" : 'X\(//\)$' \| \
12943          X"$as_dir" : 'X\(/\)' \| \
12944          .     : '\(.\)' 2>/dev/null ||
12945 echo X"$as_dir" |
12946     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12947           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12948           /^X\(\/\/\)$/{ s//\1/; q; }
12949           /^X\(\/\).*/{ s//\1/; q; }
12950           s/.*/./; q'`
12951     done
12952     test ! -n "$as_dirs" || mkdir $as_dirs
12953   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
12954 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
12955    { (exit 1); exit 1; }; }; }
12956
12957   ac_builddir=.
12958
12959 if test "$ac_dir" != .; then
12960   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
12961   # A "../" for each directory in $ac_dir_suffix.
12962   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
12963 else
12964   ac_dir_suffix= ac_top_builddir=
12965 fi
12966
12967 case $srcdir in
12968   .)  # No --srcdir option.  We are building in place.
12969     ac_srcdir=.
12970     if test -z "$ac_top_builddir"; then
12971        ac_top_srcdir=.
12972     else
12973        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
12974     fi ;;
12975   [\\/]* | ?:[\\/]* )  # Absolute path.
12976     ac_srcdir=$srcdir$ac_dir_suffix;
12977     ac_top_srcdir=$srcdir ;;
12978   *) # Relative path.
12979     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
12980     ac_top_srcdir=$ac_top_builddir$srcdir ;;
12981 esac
12982
12983 # Do not use `cd foo && pwd` to compute absolute paths, because
12984 # the directories may not exist.
12985 case `pwd` in
12986 .) ac_abs_builddir="$ac_dir";;
12987 *)
12988   case "$ac_dir" in
12989   .) ac_abs_builddir=`pwd`;;
12990   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
12991   *) ac_abs_builddir=`pwd`/"$ac_dir";;
12992   esac;;
12993 esac
12994 case $ac_abs_builddir in
12995 .) ac_abs_top_builddir=${ac_top_builddir}.;;
12996 *)
12997   case ${ac_top_builddir}. in
12998   .) ac_abs_top_builddir=$ac_abs_builddir;;
12999   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13000   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13001   esac;;
13002 esac
13003 case $ac_abs_builddir in
13004 .) ac_abs_srcdir=$ac_srcdir;;
13005 *)
13006   case $ac_srcdir in
13007   .) ac_abs_srcdir=$ac_abs_builddir;;
13008   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13009   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13010   esac;;
13011 esac
13012 case $ac_abs_builddir in
13013 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13014 *)
13015   case $ac_top_srcdir in
13016   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13017   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13018   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13019   esac;;
13020 esac
13021
13022
13023   case $INSTALL in
13024   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13025   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13026   esac
13027
13028   if test x"$ac_file" != x-; then
13029     { echo "$as_me:$LINENO: creating $ac_file" >&5
13030 echo "$as_me: creating $ac_file" >&6;}
13031     rm -f "$ac_file"
13032   fi
13033   # Let's still pretend it is `configure' which instantiates (i.e., don't
13034   # use $as_me), people would be surprised to read:
13035   #    /* config.h.  Generated by config.status.  */
13036   if test x"$ac_file" = x-; then
13037     configure_input=
13038   else
13039     configure_input="$ac_file.  "
13040   fi
13041   configure_input=$configure_input"Generated from `echo $ac_file_in |
13042                                      sed 's,.*/,,'` by configure."
13043
13044   # First look for the input files in the build tree, otherwise in the
13045   # src tree.
13046   ac_file_inputs=`IFS=:
13047     for f in $ac_file_in; do
13048       case $f in
13049       -) echo $tmp/stdin ;;
13050       [\\/$]*)
13051          # Absolute (can't be DOS-style, as IFS=:)
13052          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13053 echo "$as_me: error: cannot find input file: $f" >&2;}
13054    { (exit 1); exit 1; }; }
13055          echo "$f";;
13056       *) # Relative
13057          if test -f "$f"; then
13058            # Build tree
13059            echo "$f"
13060          elif test -f "$srcdir/$f"; then
13061            # Source tree
13062            echo "$srcdir/$f"
13063          else
13064            # /dev/null tree
13065            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13066 echo "$as_me: error: cannot find input file: $f" >&2;}
13067    { (exit 1); exit 1; }; }
13068          fi;;
13069       esac
13070     done` || { (exit 1); exit 1; }
13071 _ACEOF
13072 cat >>$CONFIG_STATUS <<_ACEOF
13073   sed "$ac_vpsub
13074 $extrasub
13075 _ACEOF
13076 cat >>$CONFIG_STATUS <<\_ACEOF
13077 :t
13078 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13079 s,@configure_input@,$configure_input,;t t
13080 s,@srcdir@,$ac_srcdir,;t t
13081 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13082 s,@top_srcdir@,$ac_top_srcdir,;t t
13083 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13084 s,@builddir@,$ac_builddir,;t t
13085 s,@abs_builddir@,$ac_abs_builddir,;t t
13086 s,@top_builddir@,$ac_top_builddir,;t t
13087 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13088 s,@INSTALL@,$ac_INSTALL,;t t
13089 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13090   rm -f $tmp/stdin
13091   if test x"$ac_file" != x-; then
13092     mv $tmp/out $ac_file
13093   else
13094     cat $tmp/out
13095     rm -f $tmp/out
13096   fi
13097
13098 done
13099 _ACEOF
13100
13101 cat >>$CONFIG_STATUS <<\_ACEOF
13102
13103 { (exit 0); exit 0; }
13104 _ACEOF
13105 chmod +x $CONFIG_STATUS
13106 ac_clean_files=$ac_clean_files_save
13107
13108
13109 # configure is writing to config.log, and then calls config.status.
13110 # config.status does its own redirection, appending to config.log.
13111 # Unfortunately, on DOS this fails, as config.log is still kept open
13112 # by configure, so config.status won't be able to write to it; its
13113 # output is simply discarded.  So we exec the FD to /dev/null,
13114 # effectively closing config.log, so it can be properly (re)opened and
13115 # appended to by config.status.  When coming back to configure, we
13116 # need to make the FD available again.
13117 if test "$no_create" != yes; then
13118   ac_cs_success=:
13119   ac_config_status_args=
13120   test "$silent" = yes &&
13121     ac_config_status_args="$ac_config_status_args --quiet"
13122   exec 5>/dev/null
13123   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13124   exec 5>>config.log
13125   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13126   # would make configure fail if this is the last instruction.
13127   $ac_cs_success || { (exit 1); exit 1; }
13128 fi
13129