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