configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S TOPLEVEL_CONFIGURE_ARGUMENTS build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc stage1_languages SYSROOT_CFLAGS_FOR_TARGET RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs CC_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES 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-build-time-tools=PATH
 969                           use given path to find target tools during the build
 970   --with-datarootdir      use datarootdir as the data root directory.
 971   --with-docdir           install documentation in this directory.
 972   --with-pdfdir           install pdf in this directory.
 973   --with-htmldir          install html in this directory.
 974
 975 Some influential environment variables:
 976   CC          C compiler command
 977   CFLAGS      C compiler flags
 978   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 979               nonstandard directory <lib dir>
 980   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 981               headers in a nonstandard directory <include dir>
 982   CXX         C++ compiler command
 983   CXXFLAGS    C++ compiler flags
 984   AR          AR for the host
 985   AS          AS for the host
 986   DLLTOOL     DLLTOOL for the host
 987   LD          LD for the host
 988   LIPO        LIPO for the host
 989   NM          NM for the host
 990   RANLIB      RANLIB for the host
 991   STRIP       STRIP for the host
 992   WINDRES     WINDRES for the host
 993   WINDMC      WINDMC for the host
 994   OBJCOPY     OBJCOPY for the host
 995   OBJDUMP     OBJDUMP for the host
 996   CC_FOR_TARGET
 997               CC for the target
 998   CXX_FOR_TARGET
 999               CXX for the target
1000   GCC_FOR_TARGET
1001               GCC for the target
1002   GCJ_FOR_TARGET
1003               GCJ for the target
1004   GFORTRAN_FOR_TARGET
1005               GFORTRAN for the target
1006   AR_FOR_TARGET
1007               AR for the target
1008   AS_FOR_TARGET
1009               AS for the target
1010   DLLTOOL_FOR_TARGET
1011               DLLTOOL for the target
1012   LD_FOR_TARGET
1013               LD for the target
1014   LIPO_FOR_TARGET
1015               LIPO for the target
1016   NM_FOR_TARGET
1017               NM for the target
1018   OBJDUMP_FOR_TARGET
1019               OBJDUMP for the target
1020   RANLIB_FOR_TARGET
1021               RANLIB for the target
1022   STRIP_FOR_TARGET
1023               STRIP for the target
1024   WINDRES_FOR_TARGET
1025               WINDRES for the target
1026   WINDMC_FOR_TARGET
1027               WINDMC for the target
1028
1029 Use these variables to override the choices made by `configure' or to help
1030 it to find libraries and programs with nonstandard names/locations.
1031
1032 _ACEOF
1033 fi
1034
1035 if test "$ac_init_help" = "recursive"; then
1036   # If there are subdirs, report their specific --help.
1037   ac_popdir=`pwd`
1038   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1039     test -d $ac_dir || continue
1040     ac_builddir=.
1041
1042 if test "$ac_dir" != .; then
1043   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1044   # A "../" for each directory in $ac_dir_suffix.
1045   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1046 else
1047   ac_dir_suffix= ac_top_builddir=
1048 fi
1049
1050 case $srcdir in
1051   .)  # No --srcdir option.  We are building in place.
1052     ac_srcdir=.
1053     if test -z "$ac_top_builddir"; then
1054        ac_top_srcdir=.
1055     else
1056        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1057     fi ;;
1058   [\\/]* | ?:[\\/]* )  # Absolute path.
1059     ac_srcdir=$srcdir$ac_dir_suffix;
1060     ac_top_srcdir=$srcdir ;;
1061   *) # Relative path.
1062     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1063     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1064 esac
1065
1066 # Do not use `cd foo && pwd` to compute absolute paths, because
1067 # the directories may not exist.
1068 case `pwd` in
1069 .) ac_abs_builddir="$ac_dir";;
1070 *)
1071   case "$ac_dir" in
1072   .) ac_abs_builddir=`pwd`;;
1073   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1074   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1075   esac;;
1076 esac
1077 case $ac_abs_builddir in
1078 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1079 *)
1080   case ${ac_top_builddir}. in
1081   .) ac_abs_top_builddir=$ac_abs_builddir;;
1082   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1083   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1084   esac;;
1085 esac
1086 case $ac_abs_builddir in
1087 .) ac_abs_srcdir=$ac_srcdir;;
1088 *)
1089   case $ac_srcdir in
1090   .) ac_abs_srcdir=$ac_abs_builddir;;
1091   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1092   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1093   esac;;
1094 esac
1095 case $ac_abs_builddir in
1096 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1097 *)
1098   case $ac_top_srcdir in
1099   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1100   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1101   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1102   esac;;
1103 esac
1104
1105     cd $ac_dir
1106     # Check for guested configure; otherwise get Cygnus style configure.
1107     if test -f $ac_srcdir/configure.gnu; then
1108       echo
1109       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1110     elif test -f $ac_srcdir/configure; then
1111       echo
1112       $SHELL $ac_srcdir/configure  --help=recursive
1113     elif test -f $ac_srcdir/configure.ac ||
1114            test -f $ac_srcdir/configure.in; then
1115       echo
1116       $ac_configure --help
1117     else
1118       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1119     fi
1120     cd $ac_popdir
1121   done
1122 fi
1123
1124 test -n "$ac_init_help" && exit 0
1125 if $ac_init_version; then
1126   cat <<\_ACEOF
1127
1128 Copyright (C) 2003 Free Software Foundation, Inc.
1129 This configure script is free software; the Free Software Foundation
1130 gives unlimited permission to copy, distribute and modify it.
1131 _ACEOF
1132   exit 0
1133 fi
1134 exec 5>config.log
1135 cat >&5 <<_ACEOF
1136 This file contains any messages produced by compilers while
1137 running configure, to aid debugging if configure makes a mistake.
1138
1139 It was created by $as_me, which was
1140 generated by GNU Autoconf 2.59.  Invocation command line was
1141
1142   $ $0 $@
1143
1144 _ACEOF
1145 {
1146 cat <<_ASUNAME
1147 ## --------- ##
1148 ## Platform. ##
1149 ## --------- ##
1150
1151 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1152 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1153 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1154 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1155 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1156
1157 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1158 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1159
1160 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1161 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1162 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1163 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1164 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1165 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1166 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1167
1168 _ASUNAME
1169
1170 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1171 for as_dir in $PATH
1172 do
1173   IFS=$as_save_IFS
1174   test -z "$as_dir" && as_dir=.
1175   echo "PATH: $as_dir"
1176 done
1177
1178 } >&5
1179
1180 cat >&5 <<_ACEOF
1181
1182
1183 ## ----------- ##
1184 ## Core tests. ##
1185 ## ----------- ##
1186
1187 _ACEOF
1188
1189
1190 # Keep a trace of the command line.
1191 # Strip out --no-create and --no-recursion so they do not pile up.
1192 # Strip out --silent because we don't want to record it for future runs.
1193 # Also quote any args containing shell meta-characters.
1194 # Make two passes to allow for proper duplicate-argument suppression.
1195 ac_configure_args=
1196 ac_configure_args0=
1197 ac_configure_args1=
1198 ac_sep=
1199 ac_must_keep_next=false
1200 for ac_pass in 1 2
1201 do
1202   for ac_arg
1203   do
1204     case $ac_arg in
1205     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1206     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1207     | -silent | --silent | --silen | --sile | --sil)
1208       continue ;;
1209     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1210       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1211     esac
1212     case $ac_pass in
1213     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1214     2)
1215       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1216       if test $ac_must_keep_next = true; then
1217         ac_must_keep_next=false # Got value, back to normal.
1218       else
1219         case $ac_arg in
1220           *=* | --config-cache | -C | -disable-* | --disable-* \
1221           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1222           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1223           | -with-* | --with-* | -without-* | --without-* | --x)
1224             case "$ac_configure_args0 " in
1225               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1226             esac
1227             ;;
1228           -* ) ac_must_keep_next=true ;;
1229         esac
1230       fi
1231       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1232       # Get rid of the leading space.
1233       ac_sep=" "
1234       ;;
1235     esac
1236   done
1237 done
1238 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1239 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1240
1241 # When interrupted or exit'd, cleanup temporary files, and complete
1242 # config.log.  We remove comments because anyway the quotes in there
1243 # would cause problems or look ugly.
1244 # WARNING: Be sure not to use single quotes in there, as some shells,
1245 # such as our DU 5.0 friend, will then `close' the trap.
1246 trap 'exit_status=$?
1247   # Save into config.log some information that might help in debugging.
1248   {
1249     echo
1250
1251     cat <<\_ASBOX
1252 ## ---------------- ##
1253 ## Cache variables. ##
1254 ## ---------------- ##
1255 _ASBOX
1256     echo
1257     # The following way of writing the cache mishandles newlines in values,
1258 {
1259   (set) 2>&1 |
1260     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1261     *ac_space=\ *)
1262       sed -n \
1263         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1264           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1265       ;;
1266     *)
1267       sed -n \
1268         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1269       ;;
1270     esac;
1271 }
1272     echo
1273
1274     cat <<\_ASBOX
1275 ## ----------------- ##
1276 ## Output variables. ##
1277 ## ----------------- ##
1278 _ASBOX
1279     echo
1280     for ac_var in $ac_subst_vars
1281     do
1282       eval ac_val=$`echo $ac_var`
1283       echo "$ac_var='"'"'$ac_val'"'"'"
1284     done | sort
1285     echo
1286
1287     if test -n "$ac_subst_files"; then
1288       cat <<\_ASBOX
1289 ## ------------- ##
1290 ## Output files. ##
1291 ## ------------- ##
1292 _ASBOX
1293       echo
1294       for ac_var in $ac_subst_files
1295       do
1296         eval ac_val=$`echo $ac_var`
1297         echo "$ac_var='"'"'$ac_val'"'"'"
1298       done | sort
1299       echo
1300     fi
1301
1302     if test -s confdefs.h; then
1303       cat <<\_ASBOX
1304 ## ----------- ##
1305 ## confdefs.h. ##
1306 ## ----------- ##
1307 _ASBOX
1308       echo
1309       sed "/^$/d" confdefs.h | sort
1310       echo
1311     fi
1312     test "$ac_signal" != 0 &&
1313       echo "$as_me: caught signal $ac_signal"
1314     echo "$as_me: exit $exit_status"
1315   } >&5
1316   rm -f core *.core &&
1317   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1318     exit $exit_status
1319      ' 0
1320 for ac_signal in 1 2 13 15; do
1321   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1322 done
1323 ac_signal=0
1324
1325 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1326 rm -rf conftest* confdefs.h
1327 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1328 echo >confdefs.h
1329
1330 # Predefined preprocessor variables.
1331
1332 cat >>confdefs.h <<_ACEOF
1333 #define PACKAGE_NAME "$PACKAGE_NAME"
1334 _ACEOF
1335
1336
1337 cat >>confdefs.h <<_ACEOF
1338 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1339 _ACEOF
1340
1341
1342 cat >>confdefs.h <<_ACEOF
1343 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1344 _ACEOF
1345
1346
1347 cat >>confdefs.h <<_ACEOF
1348 #define PACKAGE_STRING "$PACKAGE_STRING"
1349 _ACEOF
1350
1351
1352 cat >>confdefs.h <<_ACEOF
1353 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1354 _ACEOF
1355
1356
1357 # Let the site file select an alternate cache file if it wants to.
1358 # Prefer explicitly selected file to automatically selected ones.
1359 if test -z "$CONFIG_SITE"; then
1360   if test "x$prefix" != xNONE; then
1361     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1362   else
1363     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1364   fi
1365 fi
1366 for ac_site_file in $CONFIG_SITE; do
1367   if test -r "$ac_site_file"; then
1368     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1369 echo "$as_me: loading site script $ac_site_file" >&6;}
1370     sed 's/^/| /' "$ac_site_file" >&5
1371     . "$ac_site_file"
1372   fi
1373 done
1374
1375 if test -r "$cache_file"; then
1376   # Some versions of bash will fail to source /dev/null (special
1377   # files actually), so we avoid doing that.
1378   if test -f "$cache_file"; then
1379     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1380 echo "$as_me: loading cache $cache_file" >&6;}
1381     case $cache_file in
1382       [\\/]* | ?:[\\/]* ) . $cache_file;;
1383       *)                      . ./$cache_file;;
1384     esac
1385   fi
1386 else
1387   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1388 echo "$as_me: creating cache $cache_file" >&6;}
1389   >$cache_file
1390 fi
1391
1392 # Check that the precious variables saved in the cache have kept the same
1393 # value.
1394 ac_cache_corrupted=false
1395 for ac_var in `(set) 2>&1 |
1396                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1397   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1398   eval ac_new_set=\$ac_env_${ac_var}_set
1399   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1400   eval ac_new_val="\$ac_env_${ac_var}_value"
1401   case $ac_old_set,$ac_new_set in
1402     set,)
1403       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1404 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1405       ac_cache_corrupted=: ;;
1406     ,set)
1407       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1408 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1409       ac_cache_corrupted=: ;;
1410     ,);;
1411     *)
1412       if test "x$ac_old_val" != "x$ac_new_val"; then
1413         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1414 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1415         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1416 echo "$as_me:   former value:  $ac_old_val" >&2;}
1417         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1418 echo "$as_me:   current value: $ac_new_val" >&2;}
1419         ac_cache_corrupted=:
1420       fi;;
1421   esac
1422   # Pass precious variables to config.status.
1423   if test "$ac_new_set" = set; then
1424     case $ac_new_val in
1425     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1426       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1427     *) ac_arg=$ac_var=$ac_new_val ;;
1428     esac
1429     case " $ac_configure_args " in
1430       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1431       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1432     esac
1433   fi
1434 done
1435 if $ac_cache_corrupted; then
1436   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1437 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1438   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1439 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1440    { (exit 1); exit 1; }; }
1441 fi
1442
1443 ac_ext=c
1444 ac_cpp='$CPP $CPPFLAGS'
1445 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1446 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1447 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469 # Find the build, host, and target systems.
1470 ac_aux_dir=
1471 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1472   if test -f $ac_dir/install-sh; then
1473     ac_aux_dir=$ac_dir
1474     ac_install_sh="$ac_aux_dir/install-sh -c"
1475     break
1476   elif test -f $ac_dir/install.sh; then
1477     ac_aux_dir=$ac_dir
1478     ac_install_sh="$ac_aux_dir/install.sh -c"
1479     break
1480   elif test -f $ac_dir/shtool; then
1481     ac_aux_dir=$ac_dir
1482     ac_install_sh="$ac_aux_dir/shtool install -c"
1483     break
1484   fi
1485 done
1486 if test -z "$ac_aux_dir"; then
1487   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1488 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1489    { (exit 1); exit 1; }; }
1490 fi
1491 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1492 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1493 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1494
1495 # Make sure we can run config.sub.
1496 $ac_config_sub sun4 >/dev/null 2>&1 ||
1497   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1498 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1499    { (exit 1); exit 1; }; }
1500
1501 echo "$as_me:$LINENO: checking build system type" >&5
1502 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1503 if test "${ac_cv_build+set}" = set; then
1504   echo $ECHO_N "(cached) $ECHO_C" >&6
1505 else
1506   ac_cv_build_alias=$build_alias
1507 test -z "$ac_cv_build_alias" &&
1508   ac_cv_build_alias=`$ac_config_guess`
1509 test -z "$ac_cv_build_alias" &&
1510   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1511 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1512    { (exit 1); exit 1; }; }
1513 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1514   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1515 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1516    { (exit 1); exit 1; }; }
1517
1518 fi
1519 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1520 echo "${ECHO_T}$ac_cv_build" >&6
1521 build=$ac_cv_build
1522 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1523 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1524 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1525
1526
1527  case ${build_alias} in
1528   "") build_noncanonical=${build} ;;
1529   *) build_noncanonical=${build_alias} ;;
1530 esac
1531
1532
1533
1534  case ${host_alias} in
1535   "") host_noncanonical=${build_noncanonical} ;;
1536   *) host_noncanonical=${host_alias} ;;
1537 esac
1538
1539
1540
1541  case ${target_alias} in
1542   "") target_noncanonical=${host_noncanonical} ;;
1543   *) target_noncanonical=${target_alias} ;;
1544 esac
1545
1546
1547
1548
1549 test "$host_noncanonical" = "$target_noncanonical" &&
1550   test "$program_prefix$program_suffix$program_transform_name" = \
1551     NONENONEs,x,x, &&
1552   program_transform_name=s,y,y,
1553
1554 echo "$as_me:$LINENO: checking host system type" >&5
1555 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1556 if test "${ac_cv_host+set}" = set; then
1557   echo $ECHO_N "(cached) $ECHO_C" >&6
1558 else
1559   ac_cv_host_alias=$host_alias
1560 test -z "$ac_cv_host_alias" &&
1561   ac_cv_host_alias=$ac_cv_build_alias
1562 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1563   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1564 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1565    { (exit 1); exit 1; }; }
1566
1567 fi
1568 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1569 echo "${ECHO_T}$ac_cv_host" >&6
1570 host=$ac_cv_host
1571 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1572 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1573 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1574
1575
1576 echo "$as_me:$LINENO: checking target system type" >&5
1577 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1578 if test "${ac_cv_target+set}" = set; then
1579   echo $ECHO_N "(cached) $ECHO_C" >&6
1580 else
1581   ac_cv_target_alias=$target_alias
1582 test "x$ac_cv_target_alias" = "x" &&
1583   ac_cv_target_alias=$ac_cv_host_alias
1584 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1585   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1586 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1587    { (exit 1); exit 1; }; }
1588
1589 fi
1590 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1591 echo "${ECHO_T}$ac_cv_target" >&6
1592 target=$ac_cv_target
1593 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1594 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1595 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1596
1597
1598 # The aliases save the names the user supplied, while $host etc.
1599 # will get canonicalized.
1600 test -n "$target_alias" &&
1601   test "$program_prefix$program_suffix$program_transform_name" = \
1602     NONENONEs,x,x, &&
1603   program_prefix=${target_alias}-
1604 test "$program_prefix" != NONE &&
1605   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1606 # Use a double $ so make ignores it.
1607 test "$program_suffix" != NONE &&
1608   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1609 # Double any \ or $.  echo might interpret backslashes.
1610 # By default was `s,x,x', remove it if useless.
1611 cat <<\_ACEOF >conftest.sed
1612 s/[\\$]/&&/g;s/;s,x,x,$//
1613 _ACEOF
1614 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1615 rm conftest.sed
1616
1617
1618
1619 # Get 'install' or 'install-sh' and its variants.
1620 # Find a good install program.  We prefer a C program (faster),
1621 # so one script is as good as another.  But avoid the broken or
1622 # incompatible versions:
1623 # SysV /etc/install, /usr/sbin/install
1624 # SunOS /usr/etc/install
1625 # IRIX /sbin/install
1626 # AIX /bin/install
1627 # AmigaOS /C/install, which installs bootblocks on floppy discs
1628 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1629 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1630 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1631 # OS/2's system install, which has a completely different semantic
1632 # ./install, which can be erroneously created by make from ./install.sh.
1633 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1634 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1635 if test -z "$INSTALL"; then
1636 if test "${ac_cv_path_install+set}" = set; then
1637   echo $ECHO_N "(cached) $ECHO_C" >&6
1638 else
1639   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1640 for as_dir in $PATH
1641 do
1642   IFS=$as_save_IFS
1643   test -z "$as_dir" && as_dir=.
1644   # Account for people who put trailing slashes in PATH elements.
1645 case $as_dir/ in
1646   ./ | .// | /cC/* | \
1647   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1648   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1649   /usr/ucb/* ) ;;
1650   *)
1651     # OSF1 and SCO ODT 3.0 have their own names for install.
1652     # Don't use installbsd from OSF since it installs stuff as root
1653     # by default.
1654     for ac_prog in ginstall scoinst install; do
1655       for ac_exec_ext in '' $ac_executable_extensions; do
1656         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1657           if test $ac_prog = install &&
1658             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1659             # AIX install.  It has an incompatible calling convention.
1660             :
1661           elif test $ac_prog = install &&
1662             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1663             # program-specific install script used by HP pwplus--don't use.
1664             :
1665           else
1666             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1667             break 3
1668           fi
1669         fi
1670       done
1671     done
1672     ;;
1673 esac
1674 done
1675
1676
1677 fi
1678   if test "${ac_cv_path_install+set}" = set; then
1679     INSTALL=$ac_cv_path_install
1680   else
1681     # As a last resort, use the slow shell script.  We don't cache a
1682     # path for INSTALL within a source directory, because that will
1683     # break other packages using the cache if that directory is
1684     # removed, or if the path is relative.
1685     INSTALL=$ac_install_sh
1686   fi
1687 fi
1688 echo "$as_me:$LINENO: result: $INSTALL" >&5
1689 echo "${ECHO_T}$INSTALL" >&6
1690
1691 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1692 # It thinks the first close brace ends the variable substitution.
1693 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1694
1695 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1696
1697 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1698
1699 echo "$as_me:$LINENO: checking whether ln works" >&5
1700 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1701 if test "${acx_cv_prog_LN+set}" = set; then
1702   echo $ECHO_N "(cached) $ECHO_C" >&6
1703 else
1704   rm -f conftestdata_t
1705 echo >conftestdata_f
1706 if ln conftestdata_f conftestdata_t 2>/dev/null
1707 then
1708   acx_cv_prog_LN=ln
1709 else
1710   acx_cv_prog_LN=no
1711 fi
1712 rm -f conftestdata_f conftestdata_t
1713
1714 fi
1715 if test $acx_cv_prog_LN = no; then
1716   LN="cp"
1717   echo "$as_me:$LINENO: result: no, using $LN" >&5
1718 echo "${ECHO_T}no, using $LN" >&6
1719 else
1720   LN="$acx_cv_prog_LN"
1721   echo "$as_me:$LINENO: result: yes" >&5
1722 echo "${ECHO_T}yes" >&6
1723 fi
1724
1725 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1726 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1727 LN_S=$as_ln_s
1728 if test "$LN_S" = "ln -s"; then
1729   echo "$as_me:$LINENO: result: yes" >&5
1730 echo "${ECHO_T}yes" >&6
1731 else
1732   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1733 echo "${ECHO_T}no, using $LN_S" >&6
1734 fi
1735
1736
1737 ### we might need to use some other shell than /bin/sh for running subshells
1738 ### If we are on Windows, search for the shell.  This will permit people
1739 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1740 ### without also having to set CONFIG_SHELL.  This code will work when
1741 ### using bash, which sets OSTYPE.
1742 case "${OSTYPE}" in
1743 *win32*)
1744   if test x${CONFIG_SHELL} = x ; then
1745     if test ! -f /bin/sh ; then
1746       if test x${SHELL} != x && test -f ${SHELL} ; then
1747         CONFIG_SHELL=${SHELL}
1748         export CONFIG_SHELL
1749       else
1750         for prog in sh sh.exe bash bash.exe; do
1751           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1752           for dir in $PATH; do
1753             test -z "$dir" && dir=.
1754             if test -f $dir/$prog; then
1755               CONFIG_SHELL=$dir/$prog
1756               export CONFIG_SHELL
1757               break
1758             fi
1759           done
1760           IFS="$save_ifs"
1761           test -n "${CONFIG_SHELL}" && break
1762         done
1763       fi
1764     fi
1765   fi
1766   ;;
1767 esac
1768
1769 config_shell=${CONFIG_SHELL-/bin/sh}
1770
1771 progname=$0
1772 # if PWD already has a value, it is probably wrong.
1773 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1774
1775 # Export original configure arguments for use by sub-configures.
1776 # Quote arguments with shell meta charatcers.
1777 TOPLEVEL_CONFIGURE_ARGUMENTS=
1778 set -- "$progname" "$@"
1779 for ac_arg
1780 do
1781   case "$ac_arg" in
1782   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1783     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1784     # if the argument is of the form -foo=baz, quote the baz part only
1785     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1786   *) ;;
1787   esac
1788   # Add the quoted argument to the list.
1789   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1790 done
1791 if test "$silent" = yes; then
1792   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1793 fi
1794 # Remove the initial space we just introduced and, as these will be
1795 # expanded by make, quote '$'.
1796 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1797
1798
1799 moveifchange=${srcdir}/move-if-change
1800
1801 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1802
1803 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1804 # a relative path.
1805 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1806   INSTALL="${srcpwd}/install-sh -c"
1807 fi
1808
1809 # Set srcdir to "." if that's what it is.
1810 # This is important for multilib support.
1811 pwd=`${PWDCMD-pwd}`
1812 if test "${pwd}" = "${srcpwd}" ; then
1813   srcdir=.
1814 fi
1815
1816 topsrcdir=$srcpwd
1817
1818 extra_host_args=
1819
1820 ### To add a new directory to the tree, first choose whether it is a target
1821 ### or a host dependent tool.  Then put it into the appropriate list
1822 ### (library or tools, host or target), doing a dependency sort.
1823
1824 # Subdirs will be configured in the order listed in build_configdirs,
1825 # configdirs, or target_configdirs; see the serialization section below.
1826
1827 # Dependency sorting is only needed when *configuration* must be done in
1828 # a particular order.  In all cases a dependency should be specified in
1829 # the Makefile, whether or not it's implicitly specified here.
1830
1831 # Double entries in build_configdirs, configdirs, or target_configdirs may
1832 # cause circular dependencies and break everything horribly.
1833
1834 # these library is used by various programs built for the build
1835 # environment
1836 #
1837 build_libs="build-libiberty"
1838
1839 # these tools are built for the build environment
1840 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1841
1842 # these libraries are used by various programs built for the host environment
1843 #
1844 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1845
1846 # these tools are built for the host environment
1847 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1848 # know that we are building the simulator.
1849 # binutils, gas and ld appear in that order because it makes sense to run
1850 # "make check" in that particular order.
1851 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"
1852
1853 # libgcj represents the runtime libraries only used by gcj.
1854 libgcj="target-libffi \
1855         target-zlib \
1856         target-qthreads \
1857         target-libjava"
1858
1859 # these libraries are built for the target environment, and are built after
1860 # the host libraries and the host tools (which may be a cross compiler)
1861 #
1862 target_libraries="target-libgcc \
1863                 target-libiberty \
1864                 target-libgloss \
1865                 target-newlib \
1866                 target-libstdc++-v3 \
1867                 target-libmudflap \
1868                 target-libssp \
1869                 target-libgfortran \
1870                 target-boehm-gc \
1871                 ${libgcj} \
1872                 target-libobjc \
1873                 target-libada \
1874                 target-libgomp"
1875
1876 # these tools are built using the target libraries, and are intended to
1877 # run only in the target environment
1878 #
1879 # note: any program that *uses* libraries that are in the "target_libraries"
1880 # list belongs in this list.  those programs are also very likely
1881 # candidates for the "native_only" list which follows
1882 #
1883 target_tools="target-examples target-groff target-gperf target-rda"
1884
1885 ################################################################################
1886
1887 ## All tools belong in one of the four categories, and are assigned above
1888 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1889 ## is important because configure will choke if they ever get through.
1890 ## ${configdirs} is directories we build using the host tools.
1891 ## ${target_configdirs} is directories we build using the target tools.
1892 configdirs=`echo ${host_libs} ${host_tools}`
1893 target_configdirs=`echo ${target_libraries} ${target_tools}`
1894 build_configdirs=`echo ${build_libs} ${build_tools}`
1895
1896 ################################################################################
1897
1898 srcname="gnu development package"
1899
1900 # This gets set non-empty for some net releases of packages.
1901 appdirs=""
1902
1903 # Define is_cross_compiler to save on calls to 'test'.
1904 is_cross_compiler=
1905 if test x"${host}" = x"${target}" ; then
1906   is_cross_compiler=no
1907 else
1908   is_cross_compiler=yes
1909 fi
1910
1911 # Find the build and target subdir names.
1912
1913 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1914 # have matching libraries, they should use host libraries: Makefile.tpl
1915 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1916 # However, they still use the build modules, because the corresponding
1917 # host modules (e.g. bison) are only built for the host when bootstrap
1918 # finishes. So:
1919 # - build_subdir is where we find build modules, and never changes.
1920 # - build_libsubdir is where we find build libraries, and can be overridden.
1921
1922 # Prefix 'build-' so this never conflicts with target_subdir.
1923 build_subdir="build-${build_noncanonical}"
1924
1925 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1926 if test "${with_build_libsubdir+set}" = set; then
1927   withval="$with_build_libsubdir"
1928   build_libsubdir="$withval"
1929 else
1930   build_libsubdir="$build_subdir"
1931 fi;
1932 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1933 if ( test $srcdir = . && test -d gcc ) \
1934    || test -d $srcdir/../host-${host_noncanonical}; then
1935   host_subdir="host-${host_noncanonical}"
1936 else
1937   host_subdir=.
1938 fi
1939 # No prefix.
1940 target_subdir=${target_noncanonical}
1941
1942
1943 # Skipdirs are removed silently.
1944 skipdirs=
1945 # Noconfigdirs are removed loudly.
1946 noconfigdirs=""
1947
1948 use_gnu_ld=
1949 # Make sure we don't let GNU ld be added if we didn't want it.
1950 if test x$with_gnu_ld = xno ; then
1951   use_gnu_ld=no
1952   noconfigdirs="$noconfigdirs ld"
1953 fi
1954
1955 use_gnu_as=
1956 # Make sure we don't let GNU as be added if we didn't want it.
1957 if test x$with_gnu_as = xno ; then
1958   use_gnu_as=no
1959   noconfigdirs="$noconfigdirs gas"
1960 fi
1961
1962 # some tools are so dependent upon X11 that if we're not building with X,
1963 # it's not even worth trying to configure, much less build, that tool.
1964
1965 case ${with_x} in
1966   yes | "") ;; # the default value for this tree is that X11 is available
1967   no)
1968     skipdirs="${skipdirs} tk itcl libgui"
1969     # We won't be able to build gdbtk without X.
1970     enable_gdbtk=no
1971     ;;
1972   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1973 esac
1974
1975 # Some tools are only suitable for building in a "native" situation.
1976 # Remove these if host!=target.
1977 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"
1978
1979 # Similarly, some are only suitable for cross toolchains.
1980 # Remove these if host=target.
1981 cross_only="target-libgloss target-newlib target-opcodes"
1982
1983 case $is_cross_compiler in
1984   no) skipdirs="${skipdirs} ${cross_only}" ;;
1985   yes) skipdirs="${skipdirs} ${native_only}" ;;
1986 esac
1987
1988 # If both --with-headers and --with-libs are specified, default to
1989 # --without-newlib.
1990 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
1991    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
1992   if test x"${with_newlib}" = x ; then
1993     with_newlib=no
1994   fi
1995 fi
1996
1997 # Recognize --with-newlib/--without-newlib.
1998 case ${with_newlib} in
1999   no) skipdirs="${skipdirs} target-newlib" ;;
2000   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2001 esac
2002
2003 # Configure extra directories which are host specific
2004
2005 case "${host}" in
2006   *-cygwin*)
2007     configdirs="$configdirs libtermcap" ;;
2008 esac
2009
2010 # A target can indicate whether a language isn't supported for some reason.
2011 # Only spaces may be used in this macro; not newlines or tabs.
2012 unsupported_languages=
2013
2014 # Remove more programs from consideration, based on the host or
2015 # target this usually means that a port of the program doesn't
2016 # exist yet.
2017
2018 case "${host}" in
2019   hppa*64*-*-*)
2020     noconfigdirs="$noconfigdirs byacc"
2021     ;;
2022   i[3456789]86-*-vsta)
2023     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2024     ;;
2025   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2026     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2027     ;;
2028   x86_64-*-mingw*)
2029     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2030     ;;
2031   i[3456789]86-*-mingw32*)
2032     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2033     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2034     ;;
2035   i[3456789]86-*-beos*)
2036     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2037     ;;
2038   *-*-cygwin*)
2039     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2040     ;;
2041   *-*-netbsd*)
2042     noconfigdirs="$noconfigdirs rcs"
2043     ;;
2044   ppc*-*-pe)
2045     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2046     ;;
2047   powerpc-*-beos*)
2048     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2049     ;;
2050 esac
2051
2052
2053 # Check whether --enable-libada or --disable-libada was given.
2054 if test "${enable_libada+set}" = set; then
2055   enableval="$enable_libada"
2056   ENABLE_LIBADA=$enableval
2057 else
2058   ENABLE_LIBADA=yes
2059 fi;
2060 if test "${ENABLE_LIBADA}" != "yes" ; then
2061   noconfigdirs="$noconfigdirs gnattools"
2062 fi
2063
2064 # Check whether --enable-libssp or --disable-libssp was given.
2065 if test "${enable_libssp+set}" = set; then
2066   enableval="$enable_libssp"
2067   ENABLE_LIBSSP=$enableval
2068 else
2069   ENABLE_LIBSSP=yes
2070 fi;
2071
2072 # Save it here so that, even in case of --enable-libgcj, if the Java
2073 # front-end isn't enabled, we still get libgcj disabled.
2074 libgcj_saved=$libgcj
2075 case $enable_libgcj in
2076 yes)
2077   # If we reset it here, it won't get added to noconfigdirs in the
2078   # target-specific build rules, so it will be forcibly enabled
2079   # (unless the Java language itself isn't enabled).
2080   libgcj=
2081   ;;
2082 no)
2083   # Make sure we get it printed in the list of not supported target libs.
2084   noconfigdirs="$noconfigdirs ${libgcj}"
2085   ;;
2086 esac
2087
2088
2089 # Disable libmudflap on some systems.
2090 if test x$enable_libmudflap = x ; then
2091     case "${target}" in
2092     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2093         # Enable libmudflap by default in GNU and friends.
2094         ;;
2095     *-*-freebsd*)
2096         # Enable libmudflap by default in FreeBSD.
2097         ;;
2098     *)
2099         # Disable it by default everywhere else.
2100         noconfigdirs="$noconfigdirs target-libmudflap"
2101         ;;
2102     esac
2103 fi
2104
2105 # Disable libgomp on non POSIX hosted systems.
2106 if test x$enable_libgomp = x ; then
2107     # Enable libgomp by default on hosted POSIX systems.
2108     case "${target}" in
2109     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2110         ;;
2111     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2112         ;;
2113     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2114         ;;
2115     *-*-darwin* | *-*-aix*)
2116         ;;
2117     *)
2118         noconfigdirs="$noconfigdirs target-libgomp"
2119         ;;
2120     esac
2121 fi
2122
2123
2124 case "${target}" in
2125   *-*-chorusos)
2126     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2127     ;;
2128   powerpc-*-darwin* | i[3456789]86-*-darwin*)
2129     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2130     noconfigdirs="$noconfigdirs sim target-rda"
2131     ;;
2132   *-*-darwin*)
2133     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2134     noconfigdirs="$noconfigdirs sim target-rda"
2135     noconfigdirs="$noconfigdirs ${libgcj}"
2136     ;;
2137   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2138     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2139     ;;
2140   *-*-freebsd*)
2141     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2142     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2143         && test -f /usr/local/include/gmp.h; then
2144       with_gmp=/usr/local
2145     fi
2146
2147     # Skip some stuff that's unsupported on some FreeBSD configurations.
2148     case "${target}" in
2149       i*86-*-*) ;;
2150       alpha*-*-*) ;;
2151       *)
2152         noconfigdirs="$noconfigdirs ${libgcj}"
2153         ;;
2154     esac
2155     ;;
2156   *-*-kaos*)
2157     # Remove unsupported stuff on all kaOS configurations.
2158     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2159     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2160     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2161     noconfigdirs="$noconfigdirs target-libgloss"
2162     ;;
2163   *-*-netbsd*)
2164     # Skip some stuff on all NetBSD configurations.
2165     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2166
2167     # Skip some stuff that's unsupported on some NetBSD configurations.
2168     case "${target}" in
2169       i*86-*-netbsdelf*) ;;
2170       arm*-*-netbsdelf*) ;;
2171       *)
2172         noconfigdirs="$noconfigdirs ${libgcj}"
2173         ;;
2174     esac
2175     ;;
2176   *-*-netware*)
2177     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2178     ;;
2179   *-*-rtems*)
2180     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2181     ;;
2182     # The tpf target doesn't support gdb yet.
2183   *-*-tpf*)
2184     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2185     ;;
2186   *-*-uclinux*)
2187     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2188     ;;
2189   *-*-vxworks*)
2190     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2191     ;;
2192   alpha*-dec-osf*)
2193     # ld works, but does not support shared libraries.
2194     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2195     # gas doesn't generate exception information.
2196     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2197     ;;
2198   alpha*-*-*vms*)
2199     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2200     ;;
2201   alpha*-*-linux*)
2202     # newlib is not 64 bit ready
2203     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2204     ;;
2205   alpha*-*-*)
2206     # newlib is not 64 bit ready
2207     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2208     ;;
2209   am33_2.0-*-linux*)
2210     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2211     ;;
2212   sh-*-linux*)
2213     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2214     ;;
2215   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2216     noconfigdirs="$noconfigdirs ${libgcj}"
2217     noconfigdirs="$noconfigdirs target-examples"
2218     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2219     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2220     noconfigdirs="$noconfigdirs expect dejagnu"
2221     # the C++ libraries don't build on top of CE's C libraries
2222     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2223     noconfigdirs="$noconfigdirs target-newlib"
2224     case "${host}" in
2225       *-*-cygwin*) ;; # keep gdb and readline
2226       *) noconfigdirs="$noconfigdirs gdb readline"
2227          ;;
2228     esac
2229     ;;
2230   arc-*-*)
2231     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2232     ;;
2233   arm-semi-aof )
2234     ;;
2235   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2236     noconfigdirs="$noconfigdirs ${libgcj}"
2237     ;;
2238   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2239     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2240     ;;
2241   arm*-*-linux-gnueabi)
2242     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2243     noconfigdirs="$noconfigdirs target-libjava target-libobjc"
2244     case ${with_newlib} in
2245       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2246     esac
2247     ;;
2248   arm*-*-symbianelf*)
2249     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2250     ;;
2251   arm-*-pe*)
2252     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2253     ;;
2254   thumb-*-coff)
2255     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2256     ;;
2257   thumb-*-elf)
2258     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2259     ;;
2260   thumb-*-pe)
2261     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2262     ;;
2263   arm-*-riscix*)
2264     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2265     ;;
2266   avr-*-*)
2267     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2268     ;;
2269   bfin-*-*)
2270     noconfigdirs="$noconfigdirs gdb"
2271     if test x${is_cross_compiler} != xno ; then
2272       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2273     fi
2274     ;;
2275   c4x-*-* | tic4x-*-*)
2276     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2277     ;;
2278   c54x*-*-* | tic54x-*-*)
2279     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2280     ;;
2281   cris-*-* | crisv32-*-*)
2282     unsupported_languages="$unsupported_languages java"
2283     case "${target}" in
2284       *-*-aout)
2285         unsupported_languages="$unsupported_languages fortran"
2286         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2287       *-*-elf)
2288         unsupported_languages="$unsupported_languages fortran"
2289         noconfigdirs="$noconfigdirs target-boehm-gc";;
2290       *-*-linux*)
2291         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2292       *)
2293         unsupported_languages="$unsupported_languages fortran"
2294         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2295     esac
2296     ;;
2297   crx-*-*)
2298     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2299     ;;
2300   d10v-*-*)
2301     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2302     ;;
2303   d30v-*-*)
2304     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2305     ;;
2306   fr30-*-elf*)
2307     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2308     ;;
2309   frv-*-*)
2310     noconfigdirs="$noconfigdirs ${libgcj}"
2311     ;;
2312   h8300*-*-*)
2313     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2314     ;;
2315   h8500-*-*)
2316     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2317     ;;
2318   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2319     ;;
2320   hppa*64*-*-linux* | parisc*64*-*-linux*)
2321     # In this case, it's because the hppa64-linux target is for
2322     # the kernel only at this point and has no libc, and thus no
2323     # headers, crt*.o, etc., all of which are needed by these.
2324     noconfigdirs="$noconfigdirs target-zlib"
2325     ;;
2326   parisc*-*-linux* | hppa*-*-linux*)
2327     ;;
2328   hppa*-*-*elf* | \
2329   hppa*-*-lites* | \
2330   hppa*-*-openbsd* | \
2331   hppa*64*-*-*)
2332     noconfigdirs="$noconfigdirs ${libgcj}"
2333     ;;
2334   hppa*-hp-hpux11*)
2335     noconfigdirs="$noconfigdirs ld shellutils"
2336     ;;
2337   hppa*-*-*)
2338     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2339     # build on HP-UX 10.20.
2340     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2341     ;;
2342   i960-*-*)
2343     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2344     ;;
2345   ia64*-*-elf*)
2346     # No gdb support yet.
2347     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2348     ;;
2349   ia64*-**-hpux*)
2350     # No gdb or ld support yet.
2351     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2352     ;;
2353   i370-*-opened*)
2354     ;;
2355   i[3456789]86-*-coff | i[3456789]86-*-elf)
2356     noconfigdirs="$noconfigdirs ${libgcj}"
2357     ;;
2358   i[3456789]86-*-linux*)
2359     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2360     # not build java stuff by default.
2361     case "${target}" in
2362       *-*-*libc1*)
2363         noconfigdirs="$noconfigdirs ${libgcj}";;
2364     esac
2365
2366     # This section makes it possible to build newlib natively on linux.
2367     # If we are using a cross compiler then don't configure newlib.
2368     if test x${is_cross_compiler} != xno ; then
2369       noconfigdirs="$noconfigdirs target-newlib"
2370     fi
2371     noconfigdirs="$noconfigdirs target-libgloss"
2372     # If we are not using a cross compiler, do configure newlib.
2373     # Note however, that newlib will only be configured in this situation
2374     # if the --with-newlib option has been given, because otherwise
2375     # 'target-newlib' will appear in skipdirs.
2376     ;;
2377   i[3456789]86-*-mingw32*)
2378     target_configdirs="$target_configdirs target-winsup"
2379     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2380     ;;
2381   x86_64-*-mingw*)
2382     target_configdirs="$target_configdirs target-winsup"
2383     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2384     ;;
2385   *-*-cygwin*)
2386     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2387     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2388     # always build newlib if winsup directory is present.
2389     if test -d "$srcdir/winsup/cygwin"; then
2390       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2391     elif test -d "$srcdir/newlib"; then
2392       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2393     fi
2394     ;;
2395   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2396   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2397     ;;
2398   i[3456789]86-*-pe)
2399     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2400     ;;
2401   i[3456789]86-*-sco3.2v5*)
2402     # The linker does not yet know about weak symbols in COFF,
2403     # and is not configured to handle mixed ELF and COFF.
2404     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2405     ;;
2406   i[3456789]86-*-sco*)
2407     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2408     ;;
2409   i[3456789]86-*-solaris2*)
2410     noconfigdirs="$noconfigdirs target-libgloss"
2411     ;;
2412   i[3456789]86-*-sysv4*)
2413     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2414     ;;
2415   i[3456789]86-*-beos*)
2416     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2417     ;;
2418   i[3456789]86-*-rdos*)
2419     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2420     ;;
2421   m32r-*-*)
2422     noconfigdirs="$noconfigdirs ${libgcj}"
2423     ;;
2424   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2425     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2426     ;;
2427   m68k-*-elf*)
2428     noconfigdirs="$noconfigdirs ${libgcj}"
2429     ;;
2430   m68k-*-coff*)
2431     noconfigdirs="$noconfigdirs ${libgcj}"
2432     ;;
2433   mcore-*-pe*)
2434   # The EPOC C++ environment does not support exceptions or rtti,
2435   # and so building libstdc++-v3 tends not to always work.
2436     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2437     ;;
2438   mmix-*-*)
2439     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2440     unsupported_languages="$unsupported_languages fortran java"
2441     ;;
2442   mn10200-*-*)
2443     noconfigdirs="$noconfigdirs ${libgcj}"
2444     ;;
2445   mn10300-*-*)
2446     noconfigdirs="$noconfigdirs ${libgcj}"
2447     ;;
2448   mt-*-*)
2449     noconfigdirs="$noconfigdirs sim"
2450     ;;
2451   powerpc-*-aix*)
2452     # copied from rs6000-*-* entry
2453     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2454     ;;
2455   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2456     target_configdirs="$target_configdirs target-winsup"
2457     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2458     # always build newlib.
2459     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2460     ;;
2461     # This is temporary until we can link against shared libraries
2462   powerpcle-*-solaris*)
2463     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2464     ;;
2465   powerpc-*-beos*)
2466     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2467     ;;
2468   powerpc-*-eabi)
2469     noconfigdirs="$noconfigdirs ${libgcj}"
2470     ;;
2471   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2472     ;;
2473   rs6000-*-lynxos*)
2474     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2475     ;;
2476   rs6000-*-aix*)
2477     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2478     ;;
2479   rs6000-*-*)
2480     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2481     ;;
2482   m68k-apollo-*)
2483     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2484     ;;
2485   mips*-*-irix5*)
2486     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2487     ;;
2488   mips*-*-irix6*)
2489     # Linking libjava exceeds command-line length limits on at least
2490     # IRIX 6.2, but not on IRIX 6.5.
2491     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2492     # <oldham@codesourcery.com>
2493     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2494     ;;
2495   mips*-*-bsd*)
2496     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2497     ;;
2498   mips64*-*-linux*)
2499     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2500     ;;
2501   mips*-*-linux*)
2502     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2503     ;;
2504   mips*-*-*)
2505     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2506     ;;
2507   romp-*-*)
2508     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2509     ;;
2510   sh-*-* | sh64-*-*)
2511     case "${host}" in
2512       i[3456789]86-*-vsta) ;; # don't add gprof back in
2513       i[3456789]86-*-go32*) ;; # don't add gprof back in
2514       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2515       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2516     esac
2517     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2518     ;;
2519   sparc-*-elf*)
2520     noconfigdirs="$noconfigdirs ${libgcj}"
2521     ;;
2522   sparc64-*-elf*)
2523     noconfigdirs="$noconfigdirs ${libgcj}"
2524     ;;
2525   sparclite-*-*)
2526     noconfigdirs="$noconfigdirs ${libgcj}"
2527     ;;
2528   sparc-*-sunos4*)
2529     noconfigdirs="$noconfigdirs ${libgcj}"
2530     if test x${is_cross_compiler} != xno ; then
2531            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2532     else
2533            use_gnu_ld=no
2534     fi
2535     ;;
2536   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2537     noconfigdirs="$noconfigdirs ${libgcj}"
2538     ;;
2539   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2540     ;;
2541   spu-*-*)
2542     skipdirs="target-libssp"
2543     ;;
2544   v810-*-*)
2545     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2546     ;;
2547   v850-*-*)
2548     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2549     ;;
2550   v850e-*-*)
2551     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2552     ;;
2553   v850ea-*-*)
2554     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2555     ;;
2556   vax-*-vms)
2557     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2558     ;;
2559   vax-*-*)
2560     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2561     ;;
2562   xtensa-*-*)
2563     noconfigdirs="$noconfigdirs ${libgcj}"
2564     ;;
2565   ip2k-*-*)
2566     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2567     ;;
2568   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2569     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2570     ;;
2571   *-*-lynxos*)
2572     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2573     ;;
2574   *-*-*)
2575     noconfigdirs="$noconfigdirs ${libgcj}"
2576     ;;
2577 esac
2578
2579 # If we aren't building newlib, then don't build libgloss, since libgloss
2580 # depends upon some newlib header files.
2581 case "${noconfigdirs}" in
2582   *target-libgloss*) ;;
2583   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2584 esac
2585
2586 # Work in distributions that contain no compiler tools, like Autoconf.
2587 tentative_cc=""
2588 host_makefile_frag=/dev/null
2589 if test -d ${srcdir}/config ; then
2590 case "${host}" in
2591   m68k-hp-hpux*)
2592     # Avoid "too much defining" errors from HPUX compiler.
2593     tentative_cc="cc -Wp,-H256000"
2594     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2595     # If it's HP/UX ar, this should be harmless.
2596     RANLIB="ar ts"
2597     ;;
2598   m68k-apollo-sysv*)
2599     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2600     ;;
2601   m68k-apollo-bsd*)
2602     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2603     # chokes on bfd, the compiler won't let you assign integers to enums, and
2604     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2605     # the apollo compiler" (the preferred version of GCC could be called cc,
2606     # or whatever), but I'm not sure leaving CC as cc is any better...
2607     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2608     # Used to have BISON=yacc.
2609     tentative_cc=gcc
2610     ;;
2611   m88k-dg-dgux*)
2612     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2613     ;;
2614   m88k-harris-cxux*)
2615     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2616     tentative_cc="cc -Xa"
2617     host_makefile_frag="config/mh-cxux"
2618     ;;
2619   m88k-motorola-sysv*)
2620     ;;
2621   mips*-dec-ultrix*)
2622     tentative_cc="cc -Wf,-XNg1000"
2623     host_makefile_frag="config/mh-decstation"
2624     ;;
2625   mips*-nec-sysv4*)
2626     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2627     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2628     host_makefile_frag="config/mh-necv4"
2629     ;;
2630   mips*-sgi-irix4*)
2631     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2632     # environment.  Also bump switch table size so that cp-parse will
2633     # compile.  Bump string length limit so linker builds.
2634     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2635     ;;
2636   mips*-*-sysv4*)
2637     host_makefile_frag="config/mh-sysv4"
2638     ;;
2639   mips*-*-sysv*)
2640     # This is for a MIPS running RISC/os 4.52C.
2641
2642     # This is needed for GDB, but needs to be in the top-level make because
2643     # if a library is compiled with the bsd headers and gets linked with the
2644     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2645     # a different size).
2646     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2647     # known except to select the sysv environment.  Could we use /proc instead?
2648     # These "sysv environments" and "bsd environments" often end up being a pain.
2649     #
2650     # This is not part of CFLAGS because perhaps not all C compilers have this
2651     # option.
2652     tentative_cc="cc -systype sysv"
2653     ;;
2654   i370-ibm-opened*)
2655     tentative_cc="c89"
2656     ;;
2657   i[3456789]86-*-sysv5*)
2658     host_makefile_frag="config/mh-sysv5"
2659     ;;
2660   i[3456789]86-*-dgux*)
2661     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2662     host_makefile_frag="config/mh-dgux386"
2663     ;;
2664   i[3456789]86-ncr-sysv4.3*)
2665     # The MetaWare compiler will generate a copyright message unless you
2666     # turn it off by adding the -Hnocopyr flag.
2667     tentative_cc="cc -Hnocopyr"
2668     ;;
2669   i[3456789]86-ncr-sysv4*)
2670     # for an NCR 3000 (i486/SVR4) system.
2671     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2672     # This compiler not only emits obnoxious copyright messages every time
2673     # you run it, but it chokes and dies on a whole bunch of GNU source
2674     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2675     tentative_cc="/usr/ccs/ATT/cc"
2676     host_makefile_frag="config/mh-ncr3000"
2677     ;;
2678   i[3456789]86-*-sco3.2v5*)
2679     ;;
2680   i[3456789]86-*-sco*)
2681     # The native C compiler botches some simple uses of const.  Unfortunately,
2682     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2683     tentative_cc="cc -Dconst="
2684     host_makefile_frag="config/mh-sco"
2685     ;;
2686   i[3456789]86-*-udk*)
2687     host_makefile_frag="config/mh-sysv5"
2688     ;;
2689   i[3456789]86-*-solaris2*)
2690     host_makefile_frag="config/mh-sysv4"
2691     ;;
2692   i[3456789]86-*-msdosdjgpp*)
2693     host_makefile_frag="config/mh-djgpp"
2694     ;;
2695   *-cygwin*)
2696     host_makefile_frag="config/mh-cygwin"
2697     ;;
2698   *-mingw32*)
2699     ;;
2700   *-mingw64*)
2701     ;;
2702   *-interix*)
2703     host_makefile_frag="config/mh-interix"
2704     ;;
2705   vax-*-ultrix2*)
2706     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2707     tentative_cc=gcc
2708     ;;
2709   *-*-solaris2*)
2710     host_makefile_frag="config/mh-solaris"
2711     ;;
2712   m68k-sun-sunos*)
2713     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2714     # without overflowing the jump tables (-J says to use a 32 bit table)
2715     tentative_cc="cc -J"
2716     ;;
2717   *-hp-hpux*)
2718     tentative_cc="cc -Wp,-H256000"
2719     ;;
2720   *-*-hiux*)
2721     tentative_cc="cc -Wp,-H256000"
2722     ;;
2723   rs6000-*-lynxos*)
2724     # /bin/cc is less than useful for our purposes.  Always use GCC
2725     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2726     host_makefile_frag="config/mh-lynxrs6k"
2727     ;;
2728   powerpc-*-darwin*)
2729     host_makefile_frag="config/mh-ppc-darwin"
2730     ;;
2731   powerpc-*-aix*)
2732     host_makefile_frag="config/mh-ppc-aix"
2733     ;;
2734   rs6000-*-aix*)
2735     host_makefile_frag="config/mh-ppc-aix"
2736     ;;
2737   *-*-lynxos*)
2738     # /bin/cc is less than useful for our purposes.  Always use GCC
2739     tentative_cc="/bin/gcc"
2740     ;;
2741   *-*-sysv4*)
2742     host_makefile_frag="config/mh-sysv4"
2743     ;;
2744   # This is placed last to prevent interfering with the cases above.
2745   i[3456789]86-*-*)
2746     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2747     host_makefile_frag="config/mh-x86omitfp"
2748     ;;
2749 esac
2750 fi
2751
2752 # If we aren't going to be using gcc, see if we can extract a definition
2753 # of CC from the fragment.
2754 # Actually, use the 'pre-extracted' version above.
2755 if test -z "${CC}" && test "${build}" = "${host}" ; then
2756   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2757   found=
2758   for dir in $PATH; do
2759     test -z "$dir" && dir=.
2760     if test -f $dir/gcc; then
2761       found=yes
2762       break
2763     fi
2764   done
2765   IFS="$save_ifs"
2766   if test -z "${found}" && test -n "${tentative_cc}" ; then
2767     CC=$tentative_cc
2768   fi
2769 fi
2770
2771 if test "${build}" != "${host}" ; then
2772   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2773 else
2774   CC_FOR_BUILD="\$(CC)"
2775 fi
2776
2777 ac_ext=c
2778 ac_cpp='$CPP $CPPFLAGS'
2779 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2780 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2781 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2782 if test -n "$ac_tool_prefix"; then
2783   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2784 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2785 echo "$as_me:$LINENO: checking for $ac_word" >&5
2786 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2787 if test "${ac_cv_prog_CC+set}" = set; then
2788   echo $ECHO_N "(cached) $ECHO_C" >&6
2789 else
2790   if test -n "$CC"; then
2791   ac_cv_prog_CC="$CC" # Let the user override the test.
2792 else
2793 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2794 for as_dir in $PATH
2795 do
2796   IFS=$as_save_IFS
2797   test -z "$as_dir" && as_dir=.
2798   for ac_exec_ext in '' $ac_executable_extensions; do
2799   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2800     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2801     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2802     break 2
2803   fi
2804 done
2805 done
2806
2807 fi
2808 fi
2809 CC=$ac_cv_prog_CC
2810 if test -n "$CC"; then
2811   echo "$as_me:$LINENO: result: $CC" >&5
2812 echo "${ECHO_T}$CC" >&6
2813 else
2814   echo "$as_me:$LINENO: result: no" >&5
2815 echo "${ECHO_T}no" >&6
2816 fi
2817
2818 fi
2819 if test -z "$ac_cv_prog_CC"; then
2820   ac_ct_CC=$CC
2821   # Extract the first word of "gcc", so it can be a program name with args.
2822 set dummy gcc; ac_word=$2
2823 echo "$as_me:$LINENO: checking for $ac_word" >&5
2824 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2825 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2826   echo $ECHO_N "(cached) $ECHO_C" >&6
2827 else
2828   if test -n "$ac_ct_CC"; then
2829   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2830 else
2831 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2832 for as_dir in $PATH
2833 do
2834   IFS=$as_save_IFS
2835   test -z "$as_dir" && as_dir=.
2836   for ac_exec_ext in '' $ac_executable_extensions; do
2837   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2838     ac_cv_prog_ac_ct_CC="gcc"
2839     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2840     break 2
2841   fi
2842 done
2843 done
2844
2845 fi
2846 fi
2847 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2848 if test -n "$ac_ct_CC"; then
2849   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2850 echo "${ECHO_T}$ac_ct_CC" >&6
2851 else
2852   echo "$as_me:$LINENO: result: no" >&5
2853 echo "${ECHO_T}no" >&6
2854 fi
2855
2856   CC=$ac_ct_CC
2857 else
2858   CC="$ac_cv_prog_CC"
2859 fi
2860
2861 if test -z "$CC"; then
2862   if test -n "$ac_tool_prefix"; then
2863   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2864 set dummy ${ac_tool_prefix}cc; ac_word=$2
2865 echo "$as_me:$LINENO: checking for $ac_word" >&5
2866 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2867 if test "${ac_cv_prog_CC+set}" = set; then
2868   echo $ECHO_N "(cached) $ECHO_C" >&6
2869 else
2870   if test -n "$CC"; then
2871   ac_cv_prog_CC="$CC" # Let the user override the test.
2872 else
2873 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2874 for as_dir in $PATH
2875 do
2876   IFS=$as_save_IFS
2877   test -z "$as_dir" && as_dir=.
2878   for ac_exec_ext in '' $ac_executable_extensions; do
2879   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2880     ac_cv_prog_CC="${ac_tool_prefix}cc"
2881     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2882     break 2
2883   fi
2884 done
2885 done
2886
2887 fi
2888 fi
2889 CC=$ac_cv_prog_CC
2890 if test -n "$CC"; then
2891   echo "$as_me:$LINENO: result: $CC" >&5
2892 echo "${ECHO_T}$CC" >&6
2893 else
2894   echo "$as_me:$LINENO: result: no" >&5
2895 echo "${ECHO_T}no" >&6
2896 fi
2897
2898 fi
2899 if test -z "$ac_cv_prog_CC"; then
2900   ac_ct_CC=$CC
2901   # Extract the first word of "cc", so it can be a program name with args.
2902 set dummy cc; ac_word=$2
2903 echo "$as_me:$LINENO: checking for $ac_word" >&5
2904 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2905 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2906   echo $ECHO_N "(cached) $ECHO_C" >&6
2907 else
2908   if test -n "$ac_ct_CC"; then
2909   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2910 else
2911 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2912 for as_dir in $PATH
2913 do
2914   IFS=$as_save_IFS
2915   test -z "$as_dir" && as_dir=.
2916   for ac_exec_ext in '' $ac_executable_extensions; do
2917   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2918     ac_cv_prog_ac_ct_CC="cc"
2919     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2920     break 2
2921   fi
2922 done
2923 done
2924
2925 fi
2926 fi
2927 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2928 if test -n "$ac_ct_CC"; then
2929   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2930 echo "${ECHO_T}$ac_ct_CC" >&6
2931 else
2932   echo "$as_me:$LINENO: result: no" >&5
2933 echo "${ECHO_T}no" >&6
2934 fi
2935
2936   CC=$ac_ct_CC
2937 else
2938   CC="$ac_cv_prog_CC"
2939 fi
2940
2941 fi
2942 if test -z "$CC"; then
2943   # Extract the first word of "cc", so it can be a program name with args.
2944 set dummy cc; ac_word=$2
2945 echo "$as_me:$LINENO: checking for $ac_word" >&5
2946 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2947 if test "${ac_cv_prog_CC+set}" = set; then
2948   echo $ECHO_N "(cached) $ECHO_C" >&6
2949 else
2950   if test -n "$CC"; then
2951   ac_cv_prog_CC="$CC" # Let the user override the test.
2952 else
2953   ac_prog_rejected=no
2954 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2955 for as_dir in $PATH
2956 do
2957   IFS=$as_save_IFS
2958   test -z "$as_dir" && as_dir=.
2959   for ac_exec_ext in '' $ac_executable_extensions; do
2960   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2961     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2962        ac_prog_rejected=yes
2963        continue
2964      fi
2965     ac_cv_prog_CC="cc"
2966     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2967     break 2
2968   fi
2969 done
2970 done
2971
2972 if test $ac_prog_rejected = yes; then
2973   # We found a bogon in the path, so make sure we never use it.
2974   set dummy $ac_cv_prog_CC
2975   shift
2976   if test $# != 0; then
2977     # We chose a different compiler from the bogus one.
2978     # However, it has the same basename, so the bogon will be chosen
2979     # first if we set CC to just the basename; use the full file name.
2980     shift
2981     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
2982   fi
2983 fi
2984 fi
2985 fi
2986 CC=$ac_cv_prog_CC
2987 if test -n "$CC"; then
2988   echo "$as_me:$LINENO: result: $CC" >&5
2989 echo "${ECHO_T}$CC" >&6
2990 else
2991   echo "$as_me:$LINENO: result: no" >&5
2992 echo "${ECHO_T}no" >&6
2993 fi
2994
2995 fi
2996 if test -z "$CC"; then
2997   if test -n "$ac_tool_prefix"; then
2998   for ac_prog in cl
2999   do
3000     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3001 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3002 echo "$as_me:$LINENO: checking for $ac_word" >&5
3003 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3004 if test "${ac_cv_prog_CC+set}" = set; then
3005   echo $ECHO_N "(cached) $ECHO_C" >&6
3006 else
3007   if test -n "$CC"; then
3008   ac_cv_prog_CC="$CC" # Let the user override the test.
3009 else
3010 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3011 for as_dir in $PATH
3012 do
3013   IFS=$as_save_IFS
3014   test -z "$as_dir" && as_dir=.
3015   for ac_exec_ext in '' $ac_executable_extensions; do
3016   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3017     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3018     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3019     break 2
3020   fi
3021 done
3022 done
3023
3024 fi
3025 fi
3026 CC=$ac_cv_prog_CC
3027 if test -n "$CC"; then
3028   echo "$as_me:$LINENO: result: $CC" >&5
3029 echo "${ECHO_T}$CC" >&6
3030 else
3031   echo "$as_me:$LINENO: result: no" >&5
3032 echo "${ECHO_T}no" >&6
3033 fi
3034
3035     test -n "$CC" && break
3036   done
3037 fi
3038 if test -z "$CC"; then
3039   ac_ct_CC=$CC
3040   for ac_prog in cl
3041 do
3042   # Extract the first word of "$ac_prog", so it can be a program name with args.
3043 set dummy $ac_prog; ac_word=$2
3044 echo "$as_me:$LINENO: checking for $ac_word" >&5
3045 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3046 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3047   echo $ECHO_N "(cached) $ECHO_C" >&6
3048 else
3049   if test -n "$ac_ct_CC"; then
3050   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3051 else
3052 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3053 for as_dir in $PATH
3054 do
3055   IFS=$as_save_IFS
3056   test -z "$as_dir" && as_dir=.
3057   for ac_exec_ext in '' $ac_executable_extensions; do
3058   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3059     ac_cv_prog_ac_ct_CC="$ac_prog"
3060     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3061     break 2
3062   fi
3063 done
3064 done
3065
3066 fi
3067 fi
3068 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3069 if test -n "$ac_ct_CC"; then
3070   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3071 echo "${ECHO_T}$ac_ct_CC" >&6
3072 else
3073   echo "$as_me:$LINENO: result: no" >&5
3074 echo "${ECHO_T}no" >&6
3075 fi
3076
3077   test -n "$ac_ct_CC" && break
3078 done
3079
3080   CC=$ac_ct_CC
3081 fi
3082
3083 fi
3084
3085
3086 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3087 See \`config.log' for more details." >&5
3088 echo "$as_me: error: no acceptable C compiler found in \$PATH
3089 See \`config.log' for more details." >&2;}
3090    { (exit 1); exit 1; }; }
3091
3092 # Provide some information about the compiler.
3093 echo "$as_me:$LINENO:" \
3094      "checking for C compiler version" >&5
3095 ac_compiler=`set X $ac_compile; echo $2`
3096 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3097   (eval $ac_compiler --version </dev/null >&5) 2>&5
3098   ac_status=$?
3099   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3100   (exit $ac_status); }
3101 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3102   (eval $ac_compiler -v </dev/null >&5) 2>&5
3103   ac_status=$?
3104   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3105   (exit $ac_status); }
3106 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3107   (eval $ac_compiler -V </dev/null >&5) 2>&5
3108   ac_status=$?
3109   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3110   (exit $ac_status); }
3111
3112 cat >conftest.$ac_ext <<_ACEOF
3113 /* confdefs.h.  */
3114 _ACEOF
3115 cat confdefs.h >>conftest.$ac_ext
3116 cat >>conftest.$ac_ext <<_ACEOF
3117 /* end confdefs.h.  */
3118
3119 int
3120 main ()
3121 {
3122
3123   ;
3124   return 0;
3125 }
3126 _ACEOF
3127 ac_clean_files_save=$ac_clean_files
3128 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3129 # Try to create an executable without -o first, disregard a.out.
3130 # It will help us diagnose broken compilers, and finding out an intuition
3131 # of exeext.
3132 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3133 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3134 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3135 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3136   (eval $ac_link_default) 2>&5
3137   ac_status=$?
3138   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3139   (exit $ac_status); }; then
3140   # Find the output, starting from the most likely.  This scheme is
3141 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3142 # resort.
3143
3144 # Be careful to initialize this variable, since it used to be cached.
3145 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3146 ac_cv_exeext=
3147 # b.out is created by i960 compilers.
3148 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3149 do
3150   test -f "$ac_file" || continue
3151   case $ac_file in
3152     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3153         ;;
3154     conftest.$ac_ext )
3155         # This is the source file.
3156         ;;
3157     [ab].out )
3158         # We found the default executable, but exeext='' is most
3159         # certainly right.
3160         break;;
3161     *.* )
3162         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3163         # FIXME: I believe we export ac_cv_exeext for Libtool,
3164         # but it would be cool to find out if it's true.  Does anybody
3165         # maintain Libtool? --akim.
3166         export ac_cv_exeext
3167         break;;
3168     * )
3169         break;;
3170   esac
3171 done
3172 else
3173   echo "$as_me: failed program was:" >&5
3174 sed 's/^/| /' conftest.$ac_ext >&5
3175
3176 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3177 See \`config.log' for more details." >&5
3178 echo "$as_me: error: C compiler cannot create executables
3179 See \`config.log' for more details." >&2;}
3180    { (exit 77); exit 77; }; }
3181 fi
3182
3183 ac_exeext=$ac_cv_exeext
3184 echo "$as_me:$LINENO: result: $ac_file" >&5
3185 echo "${ECHO_T}$ac_file" >&6
3186
3187 # Check the compiler produces executables we can run.  If not, either
3188 # the compiler is broken, or we cross compile.
3189 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3190 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3191 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3192 # If not cross compiling, check that we can run a simple program.
3193 if test "$cross_compiling" != yes; then
3194   if { ac_try='./$ac_file'
3195   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3196   (eval $ac_try) 2>&5
3197   ac_status=$?
3198   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3199   (exit $ac_status); }; }; then
3200     cross_compiling=no
3201   else
3202     if test "$cross_compiling" = maybe; then
3203         cross_compiling=yes
3204     else
3205         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3206 If you meant to cross compile, use \`--host'.
3207 See \`config.log' for more details." >&5
3208 echo "$as_me: error: cannot run C compiled programs.
3209 If you meant to cross compile, use \`--host'.
3210 See \`config.log' for more details." >&2;}
3211    { (exit 1); exit 1; }; }
3212     fi
3213   fi
3214 fi
3215 echo "$as_me:$LINENO: result: yes" >&5
3216 echo "${ECHO_T}yes" >&6
3217
3218 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3219 ac_clean_files=$ac_clean_files_save
3220 # Check the compiler produces executables we can run.  If not, either
3221 # the compiler is broken, or we cross compile.
3222 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3223 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3224 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3225 echo "${ECHO_T}$cross_compiling" >&6
3226
3227 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3228 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3229 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3230   (eval $ac_link) 2>&5
3231   ac_status=$?
3232   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3233   (exit $ac_status); }; then
3234   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3235 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3236 # work properly (i.e., refer to `conftest.exe'), while it won't with
3237 # `rm'.
3238 for ac_file in conftest.exe conftest conftest.*; do
3239   test -f "$ac_file" || continue
3240   case $ac_file in
3241     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3242     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3243           export ac_cv_exeext
3244           break;;
3245     * ) break;;
3246   esac
3247 done
3248 else
3249   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3250 See \`config.log' for more details." >&5
3251 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3252 See \`config.log' for more details." >&2;}
3253    { (exit 1); exit 1; }; }
3254 fi
3255
3256 rm -f conftest$ac_cv_exeext
3257 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3258 echo "${ECHO_T}$ac_cv_exeext" >&6
3259
3260 rm -f conftest.$ac_ext
3261 EXEEXT=$ac_cv_exeext
3262 ac_exeext=$EXEEXT
3263 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3264 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3265 if test "${ac_cv_objext+set}" = set; then
3266   echo $ECHO_N "(cached) $ECHO_C" >&6
3267 else
3268   cat >conftest.$ac_ext <<_ACEOF
3269 /* confdefs.h.  */
3270 _ACEOF
3271 cat confdefs.h >>conftest.$ac_ext
3272 cat >>conftest.$ac_ext <<_ACEOF
3273 /* end confdefs.h.  */
3274
3275 int
3276 main ()
3277 {
3278
3279   ;
3280   return 0;
3281 }
3282 _ACEOF
3283 rm -f conftest.o conftest.obj
3284 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3285   (eval $ac_compile) 2>&5
3286   ac_status=$?
3287   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3288   (exit $ac_status); }; then
3289   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3290   case $ac_file in
3291     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3292     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3293        break;;
3294   esac
3295 done
3296 else
3297   echo "$as_me: failed program was:" >&5
3298 sed 's/^/| /' conftest.$ac_ext >&5
3299
3300 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3301 See \`config.log' for more details." >&5
3302 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3303 See \`config.log' for more details." >&2;}
3304    { (exit 1); exit 1; }; }
3305 fi
3306
3307 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3308 fi
3309 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3310 echo "${ECHO_T}$ac_cv_objext" >&6
3311 OBJEXT=$ac_cv_objext
3312 ac_objext=$OBJEXT
3313 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3314 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3315 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3316   echo $ECHO_N "(cached) $ECHO_C" >&6
3317 else
3318   cat >conftest.$ac_ext <<_ACEOF
3319 /* confdefs.h.  */
3320 _ACEOF
3321 cat confdefs.h >>conftest.$ac_ext
3322 cat >>conftest.$ac_ext <<_ACEOF
3323 /* end confdefs.h.  */
3324
3325 int
3326 main ()
3327 {
3328 #ifndef __GNUC__
3329        choke me
3330 #endif
3331
3332   ;
3333   return 0;
3334 }
3335 _ACEOF
3336 rm -f conftest.$ac_objext
3337 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3338   (eval $ac_compile) 2>conftest.er1
3339   ac_status=$?
3340   grep -v '^ *+' conftest.er1 >conftest.err
3341   rm -f conftest.er1
3342   cat conftest.err >&5
3343   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3344   (exit $ac_status); } &&
3345          { ac_try='test -z "$ac_c_werror_flag"
3346                          || test ! -s conftest.err'
3347   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3348   (eval $ac_try) 2>&5
3349   ac_status=$?
3350   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3351   (exit $ac_status); }; } &&
3352          { ac_try='test -s conftest.$ac_objext'
3353   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3354   (eval $ac_try) 2>&5
3355   ac_status=$?
3356   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3357   (exit $ac_status); }; }; then
3358   ac_compiler_gnu=yes
3359 else
3360   echo "$as_me: failed program was:" >&5
3361 sed 's/^/| /' conftest.$ac_ext >&5
3362
3363 ac_compiler_gnu=no
3364 fi
3365 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3366 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3367
3368 fi
3369 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3370 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3371 GCC=`test $ac_compiler_gnu = yes && echo yes`
3372 ac_test_CFLAGS=${CFLAGS+set}
3373 ac_save_CFLAGS=$CFLAGS
3374 CFLAGS="-g"
3375 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3376 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3377 if test "${ac_cv_prog_cc_g+set}" = set; then
3378   echo $ECHO_N "(cached) $ECHO_C" >&6
3379 else
3380   cat >conftest.$ac_ext <<_ACEOF
3381 /* confdefs.h.  */
3382 _ACEOF
3383 cat confdefs.h >>conftest.$ac_ext
3384 cat >>conftest.$ac_ext <<_ACEOF
3385 /* end confdefs.h.  */
3386
3387 int
3388 main ()
3389 {
3390
3391   ;
3392   return 0;
3393 }
3394 _ACEOF
3395 rm -f conftest.$ac_objext
3396 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3397   (eval $ac_compile) 2>conftest.er1
3398   ac_status=$?
3399   grep -v '^ *+' conftest.er1 >conftest.err
3400   rm -f conftest.er1
3401   cat conftest.err >&5
3402   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3403   (exit $ac_status); } &&
3404          { ac_try='test -z "$ac_c_werror_flag"
3405                          || test ! -s conftest.err'
3406   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3407   (eval $ac_try) 2>&5
3408   ac_status=$?
3409   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3410   (exit $ac_status); }; } &&
3411          { ac_try='test -s conftest.$ac_objext'
3412   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3413   (eval $ac_try) 2>&5
3414   ac_status=$?
3415   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3416   (exit $ac_status); }; }; then
3417   ac_cv_prog_cc_g=yes
3418 else
3419   echo "$as_me: failed program was:" >&5
3420 sed 's/^/| /' conftest.$ac_ext >&5
3421
3422 ac_cv_prog_cc_g=no
3423 fi
3424 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3425 fi
3426 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3427 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3428 if test "$ac_test_CFLAGS" = set; then
3429   CFLAGS=$ac_save_CFLAGS
3430 elif test $ac_cv_prog_cc_g = yes; then
3431   if test "$GCC" = yes; then
3432     CFLAGS="-g -O2"
3433   else
3434     CFLAGS="-g"
3435   fi
3436 else
3437   if test "$GCC" = yes; then
3438     CFLAGS="-O2"
3439   else
3440     CFLAGS=
3441   fi
3442 fi
3443 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3444 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3445 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3446   echo $ECHO_N "(cached) $ECHO_C" >&6
3447 else
3448   ac_cv_prog_cc_stdc=no
3449 ac_save_CC=$CC
3450 cat >conftest.$ac_ext <<_ACEOF
3451 /* confdefs.h.  */
3452 _ACEOF
3453 cat confdefs.h >>conftest.$ac_ext
3454 cat >>conftest.$ac_ext <<_ACEOF
3455 /* end confdefs.h.  */
3456 #include <stdarg.h>
3457 #include <stdio.h>
3458 #include <sys/types.h>
3459 #include <sys/stat.h>
3460 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3461 struct buf { int x; };
3462 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3463 static char *e (p, i)
3464      char **p;
3465      int i;
3466 {
3467   return p[i];
3468 }
3469 static char *f (char * (*g) (char **, int), char **p, ...)
3470 {
3471   char *s;
3472   va_list v;
3473   va_start (v,p);
3474   s = g (p, va_arg (v,int));
3475   va_end (v);
3476   return s;
3477 }
3478
3479 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3480    function prototypes and stuff, but not '\xHH' hex character constants.
3481    These don't provoke an error unfortunately, instead are silently treated
3482    as 'x'.  The following induces an error, until -std1 is added to get
3483    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3484    array size at least.  It's necessary to write '\x00'==0 to get something
3485    that's true only with -std1.  */
3486 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3487
3488 int test (int i, double x);
3489 struct s1 {int (*f) (int a);};
3490 struct s2 {int (*f) (double a);};
3491 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3492 int argc;
3493 char **argv;
3494 int
3495 main ()
3496 {
3497 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3498   ;
3499   return 0;
3500 }
3501 _ACEOF
3502 # Don't try gcc -ansi; that turns off useful extensions and
3503 # breaks some systems' header files.
3504 # AIX                   -qlanglvl=ansi
3505 # Ultrix and OSF/1      -std1
3506 # HP-UX 10.20 and later -Ae
3507 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3508 # SVR4                  -Xc -D__EXTENSIONS__
3509 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3510 do
3511   CC="$ac_save_CC $ac_arg"
3512   rm -f conftest.$ac_objext
3513 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3514   (eval $ac_compile) 2>conftest.er1
3515   ac_status=$?
3516   grep -v '^ *+' conftest.er1 >conftest.err
3517   rm -f conftest.er1
3518   cat conftest.err >&5
3519   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3520   (exit $ac_status); } &&
3521          { ac_try='test -z "$ac_c_werror_flag"
3522                          || test ! -s conftest.err'
3523   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3524   (eval $ac_try) 2>&5
3525   ac_status=$?
3526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3527   (exit $ac_status); }; } &&
3528          { ac_try='test -s conftest.$ac_objext'
3529   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3530   (eval $ac_try) 2>&5
3531   ac_status=$?
3532   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3533   (exit $ac_status); }; }; then
3534   ac_cv_prog_cc_stdc=$ac_arg
3535 break
3536 else
3537   echo "$as_me: failed program was:" >&5
3538 sed 's/^/| /' conftest.$ac_ext >&5
3539
3540 fi
3541 rm -f conftest.err conftest.$ac_objext
3542 done
3543 rm -f conftest.$ac_ext conftest.$ac_objext
3544 CC=$ac_save_CC
3545
3546 fi
3547
3548 case "x$ac_cv_prog_cc_stdc" in
3549   x|xno)
3550     echo "$as_me:$LINENO: result: none needed" >&5
3551 echo "${ECHO_T}none needed" >&6 ;;
3552   *)
3553     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3554 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3555     CC="$CC $ac_cv_prog_cc_stdc" ;;
3556 esac
3557
3558 # Some people use a C++ compiler to compile C.  Since we use `exit',
3559 # in C++ we need to declare it.  In case someone uses the same compiler
3560 # for both compiling C and C++ we need to have the C++ compiler decide
3561 # the declaration of exit, since it's the most demanding environment.
3562 cat >conftest.$ac_ext <<_ACEOF
3563 #ifndef __cplusplus
3564   choke me
3565 #endif
3566 _ACEOF
3567 rm -f conftest.$ac_objext
3568 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3569   (eval $ac_compile) 2>conftest.er1
3570   ac_status=$?
3571   grep -v '^ *+' conftest.er1 >conftest.err
3572   rm -f conftest.er1
3573   cat conftest.err >&5
3574   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3575   (exit $ac_status); } &&
3576          { ac_try='test -z "$ac_c_werror_flag"
3577                          || test ! -s conftest.err'
3578   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3579   (eval $ac_try) 2>&5
3580   ac_status=$?
3581   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3582   (exit $ac_status); }; } &&
3583          { ac_try='test -s conftest.$ac_objext'
3584   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3585   (eval $ac_try) 2>&5
3586   ac_status=$?
3587   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3588   (exit $ac_status); }; }; then
3589   for ac_declaration in \
3590    '' \
3591    'extern "C" void std::exit (int) throw (); using std::exit;' \
3592    'extern "C" void std::exit (int); using std::exit;' \
3593    'extern "C" void exit (int) throw ();' \
3594    'extern "C" void exit (int);' \
3595    'void exit (int);'
3596 do
3597   cat >conftest.$ac_ext <<_ACEOF
3598 /* confdefs.h.  */
3599 _ACEOF
3600 cat confdefs.h >>conftest.$ac_ext
3601 cat >>conftest.$ac_ext <<_ACEOF
3602 /* end confdefs.h.  */
3603 $ac_declaration
3604 #include <stdlib.h>
3605 int
3606 main ()
3607 {
3608 exit (42);
3609   ;
3610   return 0;
3611 }
3612 _ACEOF
3613 rm -f conftest.$ac_objext
3614 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3615   (eval $ac_compile) 2>conftest.er1
3616   ac_status=$?
3617   grep -v '^ *+' conftest.er1 >conftest.err
3618   rm -f conftest.er1
3619   cat conftest.err >&5
3620   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3621   (exit $ac_status); } &&
3622          { ac_try='test -z "$ac_c_werror_flag"
3623                          || test ! -s conftest.err'
3624   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3625   (eval $ac_try) 2>&5
3626   ac_status=$?
3627   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3628   (exit $ac_status); }; } &&
3629          { ac_try='test -s conftest.$ac_objext'
3630   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3631   (eval $ac_try) 2>&5
3632   ac_status=$?
3633   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3634   (exit $ac_status); }; }; then
3635   :
3636 else
3637   echo "$as_me: failed program was:" >&5
3638 sed 's/^/| /' conftest.$ac_ext >&5
3639
3640 continue
3641 fi
3642 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3643   cat >conftest.$ac_ext <<_ACEOF
3644 /* confdefs.h.  */
3645 _ACEOF
3646 cat confdefs.h >>conftest.$ac_ext
3647 cat >>conftest.$ac_ext <<_ACEOF
3648 /* end confdefs.h.  */
3649 $ac_declaration
3650 int
3651 main ()
3652 {
3653 exit (42);
3654   ;
3655   return 0;
3656 }
3657 _ACEOF
3658 rm -f conftest.$ac_objext
3659 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3660   (eval $ac_compile) 2>conftest.er1
3661   ac_status=$?
3662   grep -v '^ *+' conftest.er1 >conftest.err
3663   rm -f conftest.er1
3664   cat conftest.err >&5
3665   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3666   (exit $ac_status); } &&
3667          { ac_try='test -z "$ac_c_werror_flag"
3668                          || test ! -s conftest.err'
3669   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3670   (eval $ac_try) 2>&5
3671   ac_status=$?
3672   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3673   (exit $ac_status); }; } &&
3674          { ac_try='test -s conftest.$ac_objext'
3675   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3676   (eval $ac_try) 2>&5
3677   ac_status=$?
3678   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3679   (exit $ac_status); }; }; then
3680   break
3681 else
3682   echo "$as_me: failed program was:" >&5
3683 sed 's/^/| /' conftest.$ac_ext >&5
3684
3685 fi
3686 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3687 done
3688 rm -f conftest*
3689 if test -n "$ac_declaration"; then
3690   echo '#ifdef __cplusplus' >>confdefs.h
3691   echo $ac_declaration      >>confdefs.h
3692   echo '#endif'             >>confdefs.h
3693 fi
3694
3695 else
3696   echo "$as_me: failed program was:" >&5
3697 sed 's/^/| /' conftest.$ac_ext >&5
3698
3699 fi
3700 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3701 ac_ext=c
3702 ac_cpp='$CPP $CPPFLAGS'
3703 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3704 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3705 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3706
3707 ac_ext=cc
3708 ac_cpp='$CXXCPP $CPPFLAGS'
3709 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3710 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3711 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3712 if test -n "$ac_tool_prefix"; then
3713   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3714   do
3715     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3716 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3717 echo "$as_me:$LINENO: checking for $ac_word" >&5
3718 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3719 if test "${ac_cv_prog_CXX+set}" = set; then
3720   echo $ECHO_N "(cached) $ECHO_C" >&6
3721 else
3722   if test -n "$CXX"; then
3723   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3724 else
3725 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3726 for as_dir in $PATH
3727 do
3728   IFS=$as_save_IFS
3729   test -z "$as_dir" && as_dir=.
3730   for ac_exec_ext in '' $ac_executable_extensions; do
3731   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3732     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3733     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3734     break 2
3735   fi
3736 done
3737 done
3738
3739 fi
3740 fi
3741 CXX=$ac_cv_prog_CXX
3742 if test -n "$CXX"; then
3743   echo "$as_me:$LINENO: result: $CXX" >&5
3744 echo "${ECHO_T}$CXX" >&6
3745 else
3746   echo "$as_me:$LINENO: result: no" >&5
3747 echo "${ECHO_T}no" >&6
3748 fi
3749
3750     test -n "$CXX" && break
3751   done
3752 fi
3753 if test -z "$CXX"; then
3754   ac_ct_CXX=$CXX
3755   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3756 do
3757   # Extract the first word of "$ac_prog", so it can be a program name with args.
3758 set dummy $ac_prog; ac_word=$2
3759 echo "$as_me:$LINENO: checking for $ac_word" >&5
3760 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3761 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3762   echo $ECHO_N "(cached) $ECHO_C" >&6
3763 else
3764   if test -n "$ac_ct_CXX"; then
3765   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3766 else
3767 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3768 for as_dir in $PATH
3769 do
3770   IFS=$as_save_IFS
3771   test -z "$as_dir" && as_dir=.
3772   for ac_exec_ext in '' $ac_executable_extensions; do
3773   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3774     ac_cv_prog_ac_ct_CXX="$ac_prog"
3775     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3776     break 2
3777   fi
3778 done
3779 done
3780
3781 fi
3782 fi
3783 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3784 if test -n "$ac_ct_CXX"; then
3785   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3786 echo "${ECHO_T}$ac_ct_CXX" >&6
3787 else
3788   echo "$as_me:$LINENO: result: no" >&5
3789 echo "${ECHO_T}no" >&6
3790 fi
3791
3792   test -n "$ac_ct_CXX" && break
3793 done
3794 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3795
3796   CXX=$ac_ct_CXX
3797 fi
3798
3799
3800 # Provide some information about the compiler.
3801 echo "$as_me:$LINENO:" \
3802      "checking for C++ compiler version" >&5
3803 ac_compiler=`set X $ac_compile; echo $2`
3804 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3805   (eval $ac_compiler --version </dev/null >&5) 2>&5
3806   ac_status=$?
3807   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3808   (exit $ac_status); }
3809 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3810   (eval $ac_compiler -v </dev/null >&5) 2>&5
3811   ac_status=$?
3812   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3813   (exit $ac_status); }
3814 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3815   (eval $ac_compiler -V </dev/null >&5) 2>&5
3816   ac_status=$?
3817   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3818   (exit $ac_status); }
3819
3820 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3821 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3822 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3823   echo $ECHO_N "(cached) $ECHO_C" >&6
3824 else
3825   cat >conftest.$ac_ext <<_ACEOF
3826 /* confdefs.h.  */
3827 _ACEOF
3828 cat confdefs.h >>conftest.$ac_ext
3829 cat >>conftest.$ac_ext <<_ACEOF
3830 /* end confdefs.h.  */
3831
3832 int
3833 main ()
3834 {
3835 #ifndef __GNUC__
3836        choke me
3837 #endif
3838
3839   ;
3840   return 0;
3841 }
3842 _ACEOF
3843 rm -f conftest.$ac_objext
3844 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3845   (eval $ac_compile) 2>conftest.er1
3846   ac_status=$?
3847   grep -v '^ *+' conftest.er1 >conftest.err
3848   rm -f conftest.er1
3849   cat conftest.err >&5
3850   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3851   (exit $ac_status); } &&
3852          { ac_try='test -z "$ac_cxx_werror_flag"
3853                          || test ! -s conftest.err'
3854   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3855   (eval $ac_try) 2>&5
3856   ac_status=$?
3857   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3858   (exit $ac_status); }; } &&
3859          { ac_try='test -s conftest.$ac_objext'
3860   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3861   (eval $ac_try) 2>&5
3862   ac_status=$?
3863   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3864   (exit $ac_status); }; }; then
3865   ac_compiler_gnu=yes
3866 else
3867   echo "$as_me: failed program was:" >&5
3868 sed 's/^/| /' conftest.$ac_ext >&5
3869
3870 ac_compiler_gnu=no
3871 fi
3872 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3873 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3874
3875 fi
3876 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3877 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3878 GXX=`test $ac_compiler_gnu = yes && echo yes`
3879 ac_test_CXXFLAGS=${CXXFLAGS+set}
3880 ac_save_CXXFLAGS=$CXXFLAGS
3881 CXXFLAGS="-g"
3882 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3883 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3884 if test "${ac_cv_prog_cxx_g+set}" = set; then
3885   echo $ECHO_N "(cached) $ECHO_C" >&6
3886 else
3887   cat >conftest.$ac_ext <<_ACEOF
3888 /* confdefs.h.  */
3889 _ACEOF
3890 cat confdefs.h >>conftest.$ac_ext
3891 cat >>conftest.$ac_ext <<_ACEOF
3892 /* end confdefs.h.  */
3893
3894 int
3895 main ()
3896 {
3897
3898   ;
3899   return 0;
3900 }
3901 _ACEOF
3902 rm -f conftest.$ac_objext
3903 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3904   (eval $ac_compile) 2>conftest.er1
3905   ac_status=$?
3906   grep -v '^ *+' conftest.er1 >conftest.err
3907   rm -f conftest.er1
3908   cat conftest.err >&5
3909   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3910   (exit $ac_status); } &&
3911          { ac_try='test -z "$ac_cxx_werror_flag"
3912                          || test ! -s conftest.err'
3913   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3914   (eval $ac_try) 2>&5
3915   ac_status=$?
3916   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3917   (exit $ac_status); }; } &&
3918          { ac_try='test -s conftest.$ac_objext'
3919   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3920   (eval $ac_try) 2>&5
3921   ac_status=$?
3922   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3923   (exit $ac_status); }; }; then
3924   ac_cv_prog_cxx_g=yes
3925 else
3926   echo "$as_me: failed program was:" >&5
3927 sed 's/^/| /' conftest.$ac_ext >&5
3928
3929 ac_cv_prog_cxx_g=no
3930 fi
3931 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3932 fi
3933 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3934 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
3935 if test "$ac_test_CXXFLAGS" = set; then
3936   CXXFLAGS=$ac_save_CXXFLAGS
3937 elif test $ac_cv_prog_cxx_g = yes; then
3938   if test "$GXX" = yes; then
3939     CXXFLAGS="-g -O2"
3940   else
3941     CXXFLAGS="-g"
3942   fi
3943 else
3944   if test "$GXX" = yes; then
3945     CXXFLAGS="-O2"
3946   else
3947     CXXFLAGS=
3948   fi
3949 fi
3950 for ac_declaration in \
3951    '' \
3952    'extern "C" void std::exit (int) throw (); using std::exit;' \
3953    'extern "C" void std::exit (int); using std::exit;' \
3954    'extern "C" void exit (int) throw ();' \
3955    'extern "C" void exit (int);' \
3956    'void exit (int);'
3957 do
3958   cat >conftest.$ac_ext <<_ACEOF
3959 /* confdefs.h.  */
3960 _ACEOF
3961 cat confdefs.h >>conftest.$ac_ext
3962 cat >>conftest.$ac_ext <<_ACEOF
3963 /* end confdefs.h.  */
3964 $ac_declaration
3965 #include <stdlib.h>
3966 int
3967 main ()
3968 {
3969 exit (42);
3970   ;
3971   return 0;
3972 }
3973 _ACEOF
3974 rm -f conftest.$ac_objext
3975 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3976   (eval $ac_compile) 2>conftest.er1
3977   ac_status=$?
3978   grep -v '^ *+' conftest.er1 >conftest.err
3979   rm -f conftest.er1
3980   cat conftest.err >&5
3981   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3982   (exit $ac_status); } &&
3983          { ac_try='test -z "$ac_cxx_werror_flag"
3984                          || test ! -s conftest.err'
3985   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3986   (eval $ac_try) 2>&5
3987   ac_status=$?
3988   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3989   (exit $ac_status); }; } &&
3990          { ac_try='test -s conftest.$ac_objext'
3991   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3992   (eval $ac_try) 2>&5
3993   ac_status=$?
3994   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3995   (exit $ac_status); }; }; then
3996   :
3997 else
3998   echo "$as_me: failed program was:" >&5
3999 sed 's/^/| /' conftest.$ac_ext >&5
4000
4001 continue
4002 fi
4003 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4004   cat >conftest.$ac_ext <<_ACEOF
4005 /* confdefs.h.  */
4006 _ACEOF
4007 cat confdefs.h >>conftest.$ac_ext
4008 cat >>conftest.$ac_ext <<_ACEOF
4009 /* end confdefs.h.  */
4010 $ac_declaration
4011 int
4012 main ()
4013 {
4014 exit (42);
4015   ;
4016   return 0;
4017 }
4018 _ACEOF
4019 rm -f conftest.$ac_objext
4020 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4021   (eval $ac_compile) 2>conftest.er1
4022   ac_status=$?
4023   grep -v '^ *+' conftest.er1 >conftest.err
4024   rm -f conftest.er1
4025   cat conftest.err >&5
4026   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4027   (exit $ac_status); } &&
4028          { ac_try='test -z "$ac_cxx_werror_flag"
4029                          || test ! -s conftest.err'
4030   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4031   (eval $ac_try) 2>&5
4032   ac_status=$?
4033   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4034   (exit $ac_status); }; } &&
4035          { ac_try='test -s conftest.$ac_objext'
4036   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4037   (eval $ac_try) 2>&5
4038   ac_status=$?
4039   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4040   (exit $ac_status); }; }; then
4041   break
4042 else
4043   echo "$as_me: failed program was:" >&5
4044 sed 's/^/| /' conftest.$ac_ext >&5
4045
4046 fi
4047 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4048 done
4049 rm -f conftest*
4050 if test -n "$ac_declaration"; then
4051   echo '#ifdef __cplusplus' >>confdefs.h
4052   echo $ac_declaration      >>confdefs.h
4053   echo '#endif'             >>confdefs.h
4054 fi
4055
4056 ac_ext=c
4057 ac_cpp='$CPP $CPPFLAGS'
4058 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4059 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4060 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4061
4062
4063 # We must set the default linker to the linker used by gcc for the correct
4064 # operation of libtool.  If LD is not defined and we are using gcc, try to
4065 # set the LD default to the ld used by gcc.
4066 if test -z "$LD"; then
4067   if test "$GCC" = yes; then
4068     case $build in
4069     *-*-mingw*)
4070       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4071     *)
4072       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4073     esac
4074     case $gcc_prog_ld in
4075     # Accept absolute paths.
4076     [\\/]* | [A-Za-z]:[\\/]*)
4077       LD="$gcc_prog_ld" ;;
4078     esac
4079   fi
4080 fi
4081
4082
4083
4084
4085 if test -n "$ac_tool_prefix"; then
4086   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4087 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4088 echo "$as_me:$LINENO: checking for $ac_word" >&5
4089 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4090 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4091   echo $ECHO_N "(cached) $ECHO_C" >&6
4092 else
4093   if test -n "$GNATBIND"; then
4094   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4095 else
4096 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4097 for as_dir in $PATH
4098 do
4099   IFS=$as_save_IFS
4100   test -z "$as_dir" && as_dir=.
4101   for ac_exec_ext in '' $ac_executable_extensions; do
4102   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4103     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4104     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4105     break 2
4106   fi
4107 done
4108 done
4109
4110 fi
4111 fi
4112 GNATBIND=$ac_cv_prog_GNATBIND
4113 if test -n "$GNATBIND"; then
4114   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4115 echo "${ECHO_T}$GNATBIND" >&6
4116 else
4117   echo "$as_me:$LINENO: result: no" >&5
4118 echo "${ECHO_T}no" >&6
4119 fi
4120
4121 fi
4122 if test -z "$ac_cv_prog_GNATBIND"; then
4123   ac_ct_GNATBIND=$GNATBIND
4124   # Extract the first word of "gnatbind", so it can be a program name with args.
4125 set dummy gnatbind; ac_word=$2
4126 echo "$as_me:$LINENO: checking for $ac_word" >&5
4127 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4128 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4129   echo $ECHO_N "(cached) $ECHO_C" >&6
4130 else
4131   if test -n "$ac_ct_GNATBIND"; then
4132   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4133 else
4134 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4135 for as_dir in $PATH
4136 do
4137   IFS=$as_save_IFS
4138   test -z "$as_dir" && as_dir=.
4139   for ac_exec_ext in '' $ac_executable_extensions; do
4140   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4141     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4142     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4143     break 2
4144   fi
4145 done
4146 done
4147
4148   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4149 fi
4150 fi
4151 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4152 if test -n "$ac_ct_GNATBIND"; then
4153   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4154 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4155 else
4156   echo "$as_me:$LINENO: result: no" >&5
4157 echo "${ECHO_T}no" >&6
4158 fi
4159
4160   GNATBIND=$ac_ct_GNATBIND
4161 else
4162   GNATBIND="$ac_cv_prog_GNATBIND"
4163 fi
4164
4165 if test -n "$ac_tool_prefix"; then
4166   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4167 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4168 echo "$as_me:$LINENO: checking for $ac_word" >&5
4169 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4170 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4171   echo $ECHO_N "(cached) $ECHO_C" >&6
4172 else
4173   if test -n "$GNATMAKE"; then
4174   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4175 else
4176 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4177 for as_dir in $PATH
4178 do
4179   IFS=$as_save_IFS
4180   test -z "$as_dir" && as_dir=.
4181   for ac_exec_ext in '' $ac_executable_extensions; do
4182   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4183     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4184     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4185     break 2
4186   fi
4187 done
4188 done
4189
4190 fi
4191 fi
4192 GNATMAKE=$ac_cv_prog_GNATMAKE
4193 if test -n "$GNATMAKE"; then
4194   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4195 echo "${ECHO_T}$GNATMAKE" >&6
4196 else
4197   echo "$as_me:$LINENO: result: no" >&5
4198 echo "${ECHO_T}no" >&6
4199 fi
4200
4201 fi
4202 if test -z "$ac_cv_prog_GNATMAKE"; then
4203   ac_ct_GNATMAKE=$GNATMAKE
4204   # Extract the first word of "gnatmake", so it can be a program name with args.
4205 set dummy gnatmake; ac_word=$2
4206 echo "$as_me:$LINENO: checking for $ac_word" >&5
4207 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4208 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4209   echo $ECHO_N "(cached) $ECHO_C" >&6
4210 else
4211   if test -n "$ac_ct_GNATMAKE"; then
4212   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4213 else
4214 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4215 for as_dir in $PATH
4216 do
4217   IFS=$as_save_IFS
4218   test -z "$as_dir" && as_dir=.
4219   for ac_exec_ext in '' $ac_executable_extensions; do
4220   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4221     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4222     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4223     break 2
4224   fi
4225 done
4226 done
4227
4228   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4229 fi
4230 fi
4231 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4232 if test -n "$ac_ct_GNATMAKE"; then
4233   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4234 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4235 else
4236   echo "$as_me:$LINENO: result: no" >&5
4237 echo "${ECHO_T}no" >&6
4238 fi
4239
4240   GNATMAKE=$ac_ct_GNATMAKE
4241 else
4242   GNATMAKE="$ac_cv_prog_GNATMAKE"
4243 fi
4244
4245 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4246 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4247 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4248   echo $ECHO_N "(cached) $ECHO_C" >&6
4249 else
4250   cat >conftest.adb <<EOF
4251 procedure conftest is begin null; end conftest;
4252 EOF
4253 acx_cv_cc_gcc_supports_ada=no
4254 # There is a bug in old released versions of GCC which causes the
4255 # driver to exit successfully when the appropriate language module
4256 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4257 # Therefore we must check for the error message as well as an
4258 # unsuccessful exit.
4259 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4260 # given a .adb file, but produce no object file.  So we must check
4261 # if an object file was really produced to guard against this.
4262 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4263 if test x"$errors" = x && test -f conftest.$ac_objext; then
4264   acx_cv_cc_gcc_supports_ada=yes
4265 fi
4266 rm -f conftest.*
4267 fi
4268 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4269 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4270
4271 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4272   have_gnat=yes
4273 else
4274   have_gnat=no
4275 fi
4276
4277 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4278 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4279 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4280   echo $ECHO_N "(cached) $ECHO_C" >&6
4281 else
4282    echo abfoo >t1
4283   echo cdfoo >t2
4284   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4285   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4286     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4287       :
4288     else
4289       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4290     fi
4291   fi
4292   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4293     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4294       :
4295     else
4296       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4297     fi
4298   fi
4299   rm t1 t2
4300
4301 fi
4302 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4303 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4304 do_compare="$gcc_cv_prog_cmp_skip"
4305
4306
4307
4308 # Check for GMP and MPFR
4309 gmplibs="-lmpfr -lgmp"
4310 gmpinc=
4311 have_gmp=no
4312
4313 # Specify a location for mpfr
4314 # check for this first so it ends up on the link line before gmp.
4315
4316 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4317 if test "${with_mpfr_dir+set}" = set; then
4318   withval="$with_mpfr_dir"
4319   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4320 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4321 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4322 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4323    { (exit 1); exit 1; }; }
4324 fi;
4325
4326
4327 # Check whether --with-mpfr or --without-mpfr was given.
4328 if test "${with_mpfr+set}" = set; then
4329   withval="$with_mpfr"
4330
4331 fi;
4332
4333 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4334 if test "${with_mpfr_include+set}" = set; then
4335   withval="$with_mpfr_include"
4336
4337 fi;
4338
4339 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4340 if test "${with_mpfr_lib+set}" = set; then
4341   withval="$with_mpfr_lib"
4342
4343 fi;
4344
4345 if test "x$with_mpfr" != x; then
4346   gmplibs="-L$with_mpfr/lib $gmplibs"
4347   gmpinc="-I$with_mpfr/include"
4348 fi
4349 if test "x$with_mpfr_include" != x; then
4350   gmpinc="-I$with_mpfr_include"
4351 fi
4352 if test "x$with_mpfr_lib" != x; then
4353   gmplibs="-L$with_mpfr_lib $gmplibs"
4354 fi
4355 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4356   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4357   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4358   # Do not test the mpfr version.  Assume that it is sufficient, since
4359   # it is in the source tree, and the library has not been built yet
4360   # but it would be included on the link line in the version check below
4361   # hence making the test fail.
4362   have_gmp=yes
4363 fi
4364
4365 # Specify a location for gmp
4366
4367 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4368 if test "${with_gmp_dir+set}" = set; then
4369   withval="$with_gmp_dir"
4370   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4371 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4372 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4373 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4374    { (exit 1); exit 1; }; }
4375 fi;
4376
4377
4378 # Check whether --with-gmp or --without-gmp was given.
4379 if test "${with_gmp+set}" = set; then
4380   withval="$with_gmp"
4381
4382 fi;
4383
4384 # Check whether --with-gmp_include or --without-gmp_include was given.
4385 if test "${with_gmp_include+set}" = set; then
4386   withval="$with_gmp_include"
4387
4388 fi;
4389
4390 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4391 if test "${with_gmp_lib+set}" = set; then
4392   withval="$with_gmp_lib"
4393
4394 fi;
4395
4396
4397 if test "x$with_gmp" != x; then
4398   gmplibs="-L$with_gmp/lib $gmplibs"
4399   gmpinc="-I$with_gmp/include $gmpinc"
4400 fi
4401 if test "x$with_gmp_include" != x; then
4402   gmpinc="-I$with_gmp_include $gmpinc"
4403 fi
4404 if test "x$with_gmp_lib" != x; then
4405   gmplibs="-L$with_gmp_lib $gmplibs"
4406 fi
4407 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4408   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4409   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4410   # Do not test the gmp version.  Assume that it is sufficient, since
4411   # it is in the source tree, and the library has not been built yet
4412   # but it would be included on the link line in the version check below
4413   # hence making the test fail.
4414   have_gmp=yes
4415 fi
4416
4417 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4418   have_gmp=yes
4419   saved_CFLAGS="$CFLAGS"
4420   CFLAGS="$CFLAGS $gmpinc"
4421   # Check GMP actually works
4422   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4423 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4424
4425 cat >conftest.$ac_ext <<_ACEOF
4426 /* confdefs.h.  */
4427 _ACEOF
4428 cat confdefs.h >>conftest.$ac_ext
4429 cat >>conftest.$ac_ext <<_ACEOF
4430 /* end confdefs.h.  */
4431 #include "gmp.h"
4432 int
4433 main ()
4434 {
4435
4436   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4437   choke me
4438   #endif
4439
4440   ;
4441   return 0;
4442 }
4443 _ACEOF
4444 rm -f conftest.$ac_objext
4445 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4446   (eval $ac_compile) 2>conftest.er1
4447   ac_status=$?
4448   grep -v '^ *+' conftest.er1 >conftest.err
4449   rm -f conftest.er1
4450   cat conftest.err >&5
4451   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4452   (exit $ac_status); } &&
4453          { ac_try='test -z "$ac_c_werror_flag"
4454                          || test ! -s conftest.err'
4455   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4456   (eval $ac_try) 2>&5
4457   ac_status=$?
4458   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4459   (exit $ac_status); }; } &&
4460          { ac_try='test -s conftest.$ac_objext'
4461   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4462   (eval $ac_try) 2>&5
4463   ac_status=$?
4464   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4465   (exit $ac_status); }; }; then
4466   echo "$as_me:$LINENO: result: yes" >&5
4467 echo "${ECHO_T}yes" >&6
4468 else
4469   echo "$as_me: failed program was:" >&5
4470 sed 's/^/| /' conftest.$ac_ext >&5
4471
4472 echo "$as_me:$LINENO: result: no" >&5
4473 echo "${ECHO_T}no" >&6; have_gmp=no
4474 fi
4475 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4476
4477   if test x"$have_gmp" = xyes; then
4478     saved_LIBS="$LIBS"
4479     LIBS="$LIBS $gmplibs"
4480         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4481 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4482     cat >conftest.$ac_ext <<_ACEOF
4483 /* confdefs.h.  */
4484 _ACEOF
4485 cat confdefs.h >>conftest.$ac_ext
4486 cat >>conftest.$ac_ext <<_ACEOF
4487 /* end confdefs.h.  */
4488 #include <gmp.h>
4489     #include <mpfr.h>
4490 int
4491 main ()
4492 {
4493
4494     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,0)
4495     choke me
4496     #endif
4497     mpfr_t n;
4498     mpfr_t x;
4499     int t;
4500     mpfr_init (n);
4501     mpfr_init (x);
4502     mpfr_atan2 (n, n, x, GMP_RNDN);
4503     mpfr_erfc (n, x, GMP_RNDN);
4504     mpfr_subnormalize (x, t, GMP_RNDN);
4505
4506   ;
4507   return 0;
4508 }
4509 _ACEOF
4510 rm -f conftest.$ac_objext conftest$ac_exeext
4511 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4512   (eval $ac_link) 2>conftest.er1
4513   ac_status=$?
4514   grep -v '^ *+' conftest.er1 >conftest.err
4515   rm -f conftest.er1
4516   cat conftest.err >&5
4517   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4518   (exit $ac_status); } &&
4519          { ac_try='test -z "$ac_c_werror_flag"
4520                          || test ! -s conftest.err'
4521   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4522   (eval $ac_try) 2>&5
4523   ac_status=$?
4524   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4525   (exit $ac_status); }; } &&
4526          { ac_try='test -s conftest$ac_exeext'
4527   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4528   (eval $ac_try) 2>&5
4529   ac_status=$?
4530   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4531   (exit $ac_status); }; }; then
4532   cat >conftest.$ac_ext <<_ACEOF
4533 /* confdefs.h.  */
4534 _ACEOF
4535 cat confdefs.h >>conftest.$ac_ext
4536 cat >>conftest.$ac_ext <<_ACEOF
4537 /* end confdefs.h.  */
4538 #include <gmp.h>
4539     #include <mpfr.h>
4540 int
4541 main ()
4542 {
4543
4544     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4545     choke me
4546     #endif
4547     mpfr_t n; mpfr_init(n);
4548
4549   ;
4550   return 0;
4551 }
4552 _ACEOF
4553 rm -f conftest.$ac_objext conftest$ac_exeext
4554 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4555   (eval $ac_link) 2>conftest.er1
4556   ac_status=$?
4557   grep -v '^ *+' conftest.er1 >conftest.err
4558   rm -f conftest.er1
4559   cat conftest.err >&5
4560   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4561   (exit $ac_status); } &&
4562          { ac_try='test -z "$ac_c_werror_flag"
4563                          || test ! -s conftest.err'
4564   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4565   (eval $ac_try) 2>&5
4566   ac_status=$?
4567   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4568   (exit $ac_status); }; } &&
4569          { ac_try='test -s conftest$ac_exeext'
4570   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4571   (eval $ac_try) 2>&5
4572   ac_status=$?
4573   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4574   (exit $ac_status); }; }; then
4575   echo "$as_me:$LINENO: result: yes" >&5
4576 echo "${ECHO_T}yes" >&6
4577 else
4578   echo "$as_me: failed program was:" >&5
4579 sed 's/^/| /' conftest.$ac_ext >&5
4580
4581 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4582 echo "${ECHO_T}buggy but acceptable" >&6
4583 fi
4584 rm -f conftest.err conftest.$ac_objext \
4585       conftest$ac_exeext conftest.$ac_ext
4586 else
4587   echo "$as_me: failed program was:" >&5
4588 sed 's/^/| /' conftest.$ac_ext >&5
4589
4590 echo "$as_me:$LINENO: result: no" >&5
4591 echo "${ECHO_T}no" >&6; have_gmp=no
4592 fi
4593 rm -f conftest.err conftest.$ac_objext \
4594       conftest$ac_exeext conftest.$ac_ext
4595       LIBS="$saved_LIBS"
4596   fi
4597   CFLAGS="$saved_CFLAGS"
4598
4599   if test x$have_gmp != xyes; then
4600     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4601 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4602 Copies of these libraries' source code can be found at their respective
4603 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4604 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4605 If you obtained GMP and/or MPFR from a vendor distribution package, make
4606 sure that you have installed both the libraries and the header files.
4607 They may be located in separate packages." >&5
4608 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4609 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4610 Copies of these libraries' source code can be found at their respective
4611 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4612 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4613 If you obtained GMP and/or MPFR from a vendor distribution package, make
4614 sure that you have installed both the libraries and the header files.
4615 They may be located in separate packages." >&2;}
4616    { (exit 1); exit 1; }; }
4617   fi
4618 fi
4619
4620 # Flags needed for both GMP and/or MPFR
4621
4622
4623
4624 # By default, C is the only stage 1 language.
4625 stage1_languages=,c,
4626
4627 # Figure out what language subdirectories are present.
4628 # Look if the user specified --enable-languages="..."; if not, use
4629 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4630 # go away some day.
4631 # NB:  embedded tabs in this IF block -- do not untabify
4632 if test -d ${srcdir}/gcc; then
4633   if test x"${enable_languages+set}" != xset; then
4634     if test x"${LANGUAGES+set}" = xset; then
4635       enable_languages="${LANGUAGES}"
4636         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4637     else
4638       enable_languages=all
4639     fi
4640   else
4641     if test x"${enable_languages}" = x ||
4642        test x"${enable_languages}" = xyes;
4643        then
4644       echo configure.in: --enable-languages needs at least one language argument 1>&2
4645       exit 1
4646     fi
4647   fi
4648   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4649
4650   # 'f95' is the old name for the 'fortran' language. We issue a warning
4651   # and make the substitution.
4652   case ,${enable_languages}, in
4653     *,f95,*)
4654       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4655       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4656       ;;
4657   esac
4658
4659   # First scan to see if an enabled language requires some other language.
4660   # We assume that a given config-lang.in will list all the language
4661   # front ends it requires, even if some are required indirectly.
4662   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4663     case ${lang_frag} in
4664       ..) ;;
4665       # The odd quoting in the next line works around
4666       # an apparent bug in bash 1.12 on linux.
4667       ${srcdir}/gcc/[*]/config-lang.in) ;;
4668       *)
4669         # From the config-lang.in, get $language, $lang_requires
4670         language=
4671         lang_requires=
4672         . ${lang_frag}
4673         for other in ${lang_requires} ; do
4674           case ,${enable_languages}, in
4675             *,$other,*) ;;
4676             *,all,*) ;;
4677             *,$language,*)
4678               echo " \`$other' language required by \`$language'; enabling" 1>&2
4679               enable_languages="${enable_languages},${other}"
4680               ;;
4681           esac
4682         done
4683         ;;
4684     esac
4685   done
4686
4687   new_enable_languages=,c,
4688   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4689   potential_languages=,c,
4690
4691   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4692     case ${lang_frag} in
4693       ..) ;;
4694       # The odd quoting in the next line works around
4695       # an apparent bug in bash 1.12 on linux.
4696       ${srcdir}/gcc/[*]/config-lang.in) ;;
4697       *)
4698         # From the config-lang.in, get $language, $target_libs,
4699         # $lang_dirs, $boot_language, and $build_by_default
4700         language=
4701         target_libs=
4702         lang_dirs=
4703         subdir_requires=
4704         boot_language=no
4705         build_by_default=yes
4706         . ${lang_frag}
4707         if test x${language} = x; then
4708           echo "${lang_frag} doesn't set \$language." 1>&2
4709           exit 1
4710         fi
4711
4712         case ,${enable_languages}, in
4713           *,${language},*)
4714             # Language was explicitly selected; include it.
4715             add_this_lang=yes
4716             ;;
4717           *,all,*)
4718             # 'all' was selected, select it if it is a default language
4719             add_this_lang=${build_by_default}
4720             ;;
4721           *)
4722             add_this_lang=no
4723             ;;
4724         esac
4725
4726         # Disable languages that need other directories if these aren't available.
4727         for i in $subdir_requires; do
4728           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4729           case ,${enable_languages}, in
4730             *,${language},*)
4731               # Specifically requested language; tell them.
4732               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4733 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4734    { (exit 1); exit 1; }; }
4735               ;;
4736             *)
4737               # Silently disable.
4738               add_this_lang=unsupported
4739               ;;
4740           esac
4741         done
4742
4743         # Disable Ada if no preexisting GNAT is available.
4744         case ,${enable_languages},:${language}:${have_gnat} in
4745           *,${language},*:ada:no)
4746             # Specifically requested language; tell them.
4747             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4748 echo "$as_me: error: GNAT is required to build $language" >&2;}
4749    { (exit 1); exit 1; }; }
4750             ;;
4751           *:ada:no)
4752             # Silently disable.
4753             add_this_lang=unsupported
4754             ;;
4755         esac
4756
4757         # Disable a language that is unsupported by the target.
4758         case " $unsupported_languages " in
4759           *" $language "*)
4760             add_this_lang=unsupported
4761             ;;
4762         esac
4763
4764         case $add_this_lang in
4765           unsupported)
4766             # Remove language-dependent dirs.
4767             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4768             ;;
4769           no)
4770             # Remove language-dependent dirs; still show language as supported.
4771             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4772             potential_languages="${potential_languages}${language},"
4773             ;;
4774           yes)
4775             new_enable_languages="${new_enable_languages}${language},"
4776             potential_languages="${potential_languages}${language},"
4777             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4778             case ${boot_language} in
4779               yes)
4780                 # Add to (comma-separated) list of stage 1 languages.
4781                 stage1_languages="${stage1_languages}${language},"
4782                 ;;
4783             esac
4784             ;;
4785         esac
4786         ;;
4787     esac
4788   done
4789
4790   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4791 if test "${enable_stage1_languages+set}" = set; then
4792   enableval="$enable_stage1_languages"
4793   case ,${enable_stage1_languages}, in
4794     ,no,|,,)
4795       # Set it to something that will have no effect in the loop below
4796       enable_stage1_languages=c ;;
4797     ,yes,)
4798       enable_stage1_languages=`echo $new_enable_languages | \
4799         sed -e "s/^,//" -e "s/,$//" ` ;;
4800     *,all,*)
4801       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4802         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4803   esac
4804
4805   # Add "good" languages from enable_stage1_languages to stage1_languages,
4806   # while "bad" languages go in missing_languages.  Leave no duplicates.
4807   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4808     case $potential_languages in
4809       *,$i,*)
4810         case $stage1_languages in
4811           *,$i,*) ;;
4812           *) stage1_languages="$stage1_languages$i," ;;
4813         esac ;;
4814       *)
4815         case $missing_languages in
4816           *,$i,*) ;;
4817           *) missing_languages="$missing_languages$i," ;;
4818         esac ;;
4819      esac
4820   done
4821 fi;
4822
4823   # Remove leading/trailing commas that were added for simplicity
4824   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4825   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4826   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4827   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4828
4829   if test "x$missing_languages" != x; then
4830     { { echo "$as_me:$LINENO: error:
4831 The following requested languages could not be built: ${missing_languages}
4832 Supported languages are: ${potential_languages}" >&5
4833 echo "$as_me: error:
4834 The following requested languages could not be built: ${missing_languages}
4835 Supported languages are: ${potential_languages}" >&2;}
4836    { (exit 1); exit 1; }; }
4837   fi
4838   if test "x$new_enable_languages" != "x$enable_languages"; then
4839     echo The following languages will be built: ${new_enable_languages}
4840     enable_languages="$new_enable_languages"
4841   fi
4842
4843
4844   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4845 fi
4846
4847 # Handle --disable-<component> generically.
4848 for dir in $configdirs $build_configdirs $target_configdirs ; do
4849   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4850   if eval test x\${enable_${dirname}} "=" xno ; then
4851     noconfigdirs="$noconfigdirs $dir"
4852   fi
4853 done
4854
4855 # Check for Boehm's garbage collector
4856 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4857 if test "${enable_objc_gc+set}" = set; then
4858   enableval="$enable_objc_gc"
4859   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4860   *,objc,*:*:yes:*target-boehm-gc*)
4861     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4862 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4863    { (exit 1); exit 1; }; }
4864     ;;
4865 esac
4866 fi;
4867
4868 # Make sure we only build Boehm's garbage collector if required.
4869 case ,${enable_languages},:${enable_objc_gc} in
4870   *,objc,*:yes)
4871     # Keep target-boehm-gc if requested for Objective-C.
4872     ;;
4873   *)
4874     # Otherwise remove target-boehm-gc depending on target-libjava.
4875     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4876       noconfigdirs="$noconfigdirs target-boehm-gc"
4877     fi
4878     ;;
4879 esac
4880
4881 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4882 # $build_configdirs and $target_configdirs.
4883 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4884
4885 notsupp=""
4886 for dir in . $skipdirs $noconfigdirs ; do
4887   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4888   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4889     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4890     if test -r $srcdir/$dirname/configure ; then
4891       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4892         true
4893       else
4894         notsupp="$notsupp $dir"
4895       fi
4896     fi
4897   fi
4898   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4899     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4900     if test -r $srcdir/$dirname/configure ; then
4901       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4902         true
4903       else
4904         notsupp="$notsupp $dir"
4905       fi
4906     fi
4907   fi
4908   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4909     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4910     if test -r $srcdir/$dirname/configure ; then
4911       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4912         true
4913       else
4914         notsupp="$notsupp $dir"
4915       fi
4916     fi
4917   fi
4918 done
4919
4920 # Sometimes the tools are distributed with libiberty but with no other
4921 # libraries.  In that case, we don't want to build target-libiberty.
4922 # Don't let libgcc imply libiberty either.
4923 if test -n "${target_configdirs}" ; then
4924   libgcc=
4925   others=
4926   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
4927     if test "$i" = "libgcc"; then
4928       libgcc=target-libgcc
4929     elif test "$i" != "libiberty" ; then
4930       if test -r $srcdir/$i/configure ; then
4931         others=yes;
4932         break;
4933       fi
4934     fi
4935   done
4936   if test -z "${others}" ; then
4937     target_configdirs=$libgcc
4938   fi
4939 fi
4940
4941 # Quietly strip out all directories which aren't configurable in this tree.
4942 # This relies on all configurable subdirectories being autoconfiscated, which
4943 # is now the case.
4944 build_configdirs_all="$build_configdirs"
4945 build_configdirs=
4946 for i in ${build_configdirs_all} ; do
4947   j=`echo $i | sed -e s/build-//g`
4948   if test -f ${srcdir}/$j/configure ; then
4949     build_configdirs="${build_configdirs} $i"
4950   fi
4951 done
4952
4953 configdirs_all="$configdirs"
4954 configdirs=
4955 for i in ${configdirs_all} ; do
4956   if test -f ${srcdir}/$i/configure ; then
4957     configdirs="${configdirs} $i"
4958   fi
4959 done
4960
4961 target_configdirs_all="$target_configdirs"
4962 target_configdirs=
4963 for i in ${target_configdirs_all} ; do
4964   j=`echo $i | sed -e s/target-//g`
4965   if test -f ${srcdir}/$j/configure ; then
4966     target_configdirs="${target_configdirs} $i"
4967   fi
4968 done
4969
4970 # Produce a warning message for the subdirs we can't configure.
4971 # This isn't especially interesting in the Cygnus tree, but in the individual
4972 # FSF releases, it's important to let people know when their machine isn't
4973 # supported by the one or two programs in a package.
4974
4975 if test -n "${notsupp}" && test -z "${norecursion}" ; then
4976   # If $appdirs is non-empty, at least one of those directories must still
4977   # be configured, or we error out.  (E.g., if the gas release supports a
4978   # specified target in some subdirs but not the gas subdir, we shouldn't
4979   # pretend that all is well.)
4980   if test -n "$appdirs" ; then
4981     for dir in $appdirs ; do
4982       if test -r $dir/Makefile.in ; then
4983         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4984           appdirs=""
4985           break
4986         fi
4987         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
4988           appdirs=""
4989           break
4990         fi
4991       fi
4992     done
4993     if test -n "$appdirs" ; then
4994       echo "*** This configuration is not supported by this package." 1>&2
4995       exit 1
4996     fi
4997   fi
4998   # Okay, some application will build, or we don't care to check.  Still
4999   # notify of subdirs not getting built.
5000   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5001   echo "    ${notsupp}" 1>&2
5002   echo "    (Any other directories should still work fine.)" 1>&2
5003 fi
5004
5005 case "$host" in
5006   *msdosdjgpp*)
5007     enable_gdbtk=no ;;
5008 esac
5009
5010 # To find our prefix, in gcc_cv_tool_prefix.
5011
5012 # The user is always right.
5013 if test "${PATH_SEPARATOR+set}" != set; then
5014   echo "#! /bin/sh" >conf$$.sh
5015   echo  "exit 0"   >>conf$$.sh
5016   chmod +x conf$$.sh
5017   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5018     PATH_SEPARATOR=';'
5019   else
5020     PATH_SEPARATOR=:
5021   fi
5022   rm -f conf$$.sh
5023 fi
5024
5025
5026
5027 if test "x$exec_prefix" = xNONE; then
5028         if test "x$prefix" = xNONE; then
5029                 gcc_cv_tool_prefix=$ac_default_prefix
5030         else
5031                 gcc_cv_tool_prefix=$prefix
5032         fi
5033 else
5034         gcc_cv_tool_prefix=$exec_prefix
5035 fi
5036
5037 # If there is no compiler in the tree, use the PATH only.  In any
5038 # case, if there is no compiler in the tree nobody should use
5039 # AS_FOR_TARGET and LD_FOR_TARGET.
5040 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5041     gcc_version=`cat $srcdir/gcc/BASE-VER`
5042     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5043     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5044     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5045     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5046     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5047     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5048 else
5049     gcc_cv_tool_dirs=
5050 fi
5051
5052 if test x$build = x$target && test -n "$md_exec_prefix"; then
5053         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5054 fi
5055
5056
5057
5058 copy_dirs=
5059
5060
5061 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5062 if test "${with_build_sysroot+set}" = set; then
5063   withval="$with_build_sysroot"
5064   if test x"$withval" != x ; then
5065      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5066    fi
5067 else
5068   SYSROOT_CFLAGS_FOR_TARGET=
5069 fi;
5070
5071
5072 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5073 # the named directory are copied to $(tooldir)/sys-include.
5074 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5075   if test x${is_cross_compiler} = xno ; then
5076     echo 1>&2 '***' --with-headers is only supported when cross compiling
5077     exit 1
5078   fi
5079   if test x"${with_headers}" != xyes ; then
5080     x=${gcc_cv_tool_prefix}
5081     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5082   fi
5083 fi
5084
5085 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5086 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5087 # are permitted.
5088 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5089   if test x${is_cross_compiler} = xno ; then
5090     echo 1>&2 '***' --with-libs is only supported when cross compiling
5091     exit 1
5092   fi
5093   if test x"${with_libs}" != xyes ; then
5094     # Copy the libraries in reverse order, so that files in the first named
5095     # library override files in subsequent libraries.
5096     x=${gcc_cv_tool_prefix}
5097     for l in ${with_libs}; do
5098       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5099     done
5100   fi
5101 fi
5102
5103 # Set with_gnu_as and with_gnu_ld as appropriate.
5104 #
5105 # This is done by determining whether or not the appropriate directory
5106 # is available, and by checking whether or not specific configurations
5107 # have requested that this magic not happen.
5108 #
5109 # The command line options always override the explicit settings in
5110 # configure.in, and the settings in configure.in override this magic.
5111 #
5112 # If the default for a toolchain is to use GNU as and ld, and you don't
5113 # want to do that, then you should use the --without-gnu-as and
5114 # --without-gnu-ld options for the configure script.
5115
5116 if test x${use_gnu_as} = x &&
5117    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5118   with_gnu_as=yes
5119   extra_host_args="$extra_host_args --with-gnu-as"
5120 fi
5121
5122 if test x${use_gnu_ld} = x &&
5123    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5124   with_gnu_ld=yes
5125   extra_host_args="$extra_host_args --with-gnu-ld"
5126 fi
5127
5128 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5129 # can detect this case.
5130
5131 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5132   with_newlib=yes
5133   extra_host_args="$extra_host_args --with-newlib"
5134 fi
5135
5136 # Handle ${copy_dirs}
5137 set fnord ${copy_dirs}
5138 shift
5139 while test $# != 0 ; do
5140   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5141     :
5142   else
5143     echo Copying $1 to $2
5144
5145     # Use the install script to create the directory and all required
5146     # parent directories.
5147     if test -d $2 ; then
5148       :
5149     else
5150       echo >config.temp
5151       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5152     fi
5153
5154     # Copy the directory, assuming we have tar.
5155     # FIXME: Should we use B in the second tar?  Not all systems support it.
5156     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5157
5158     # It is the responsibility of the user to correctly adjust all
5159     # symlinks.  If somebody can figure out how to handle them correctly
5160     # here, feel free to add the code.
5161
5162     echo $1 > $2/COPIED
5163   fi
5164   shift; shift
5165 done
5166
5167 # Determine a target-dependent exec_prefix that the installed
5168 # gcc will search in.  Keep this list sorted by triplet, with
5169 # the *-*-osname triplets last.
5170 md_exec_prefix=
5171 case "${target}" in
5172   alpha*-*-*vms*)
5173     md_exec_prefix=/gnu/lib/gcc-lib
5174     ;;
5175   i[34567]86-pc-msdosdjgpp*)
5176     md_exec_prefix=/dev/env/DJDIR/bin
5177     ;;
5178   i[34567]86-*-sco3.2v5*)
5179     if test $with_gnu_as = yes; then
5180       md_exec_prefix=/usr/gnu/bin
5181     else
5182       md_exec_prefix=/usr/ccs/bin/elf
5183     fi
5184     ;;
5185
5186   mn10300-*-* | \
5187   powerpc-*-chorusos* | \
5188   powerpc*-*-eabi* | \
5189   powerpc*-*-sysv* | \
5190   powerpc*-*-kaos* | \
5191   s390x-ibm-tpf*)
5192     md_exec_prefix=/usr/ccs/bin
5193     ;;
5194   sparc64-*-elf*)
5195     ;;
5196   v850*-*-*)
5197     md_exec_prefix=/usr/ccs/bin
5198     ;;
5199   xtensa-*-elf*)
5200     ;;
5201
5202   *-*-beos* | \
5203   *-*-elf* | \
5204   *-*-hpux* | \
5205   *-*-netware* | \
5206   *-*-nto-qnx* | \
5207   *-*-rtems* | \
5208   *-*-solaris2* | \
5209   *-*-sysv[45]* | \
5210   *-*-vxworks* | \
5211   *-wrs-windiss)
5212     md_exec_prefix=/usr/ccs/bin
5213     ;;
5214 esac
5215
5216 extra_arflags_for_target=
5217 extra_nmflags_for_target=
5218 extra_ranlibflags_for_target=
5219 target_makefile_frag=/dev/null
5220 case "${target}" in
5221   mep*-*-*)
5222     target_makefile_frag="config/mt-mep"
5223     ;;
5224   spu-*-*)
5225     target_makefile_frag="config/mt-spu"
5226     ;;
5227   mips*-sde-elf*)
5228     target_makefile_frag="config/mt-sde"
5229     ;;
5230   *-*-netware*)
5231     target_makefile_frag="config/mt-netware"
5232     ;;
5233   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5234     target_makefile_frag="config/mt-gnu"
5235     ;;
5236   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5237     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5238     # commands to handle both 32-bit and 64-bit objects.  These flags are
5239     # harmless if we're using GNU nm or ar.
5240     extra_arflags_for_target=" -X32_64"
5241     extra_nmflags_for_target=" -B -X32_64"
5242     ;;
5243   *-*-darwin*)
5244     # ranlib from Darwin requires the -c flag to look at common symbols.
5245     extra_ranlibflags_for_target=" -c"
5246     ;;
5247   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5248     target_makefile_frag="config/mt-wince"
5249     ;;
5250 esac
5251
5252 alphaieee_frag=/dev/null
5253 case $target in
5254   alpha*-*-*)
5255     # This just makes sure to use the -mieee option to build target libs.
5256     # This should probably be set individually by each library.
5257     alphaieee_frag="config/mt-alphaieee"
5258     ;;
5259 esac
5260
5261 # If --enable-target-optspace always use -Os instead of -O2 to build
5262 # the target libraries, similarly if it is not specified, use -Os
5263 # on selected platforms.
5264 ospace_frag=/dev/null
5265 case "${enable_target_optspace}:${target}" in
5266   yes:*)
5267     ospace_frag="config/mt-ospace"
5268     ;;
5269   :d30v-*)
5270     ospace_frag="config/mt-d30v"
5271     ;;
5272   :m32r-* | :d10v-* | :fr30-*)
5273     ospace_frag="config/mt-ospace"
5274     ;;
5275   no:* | :*)
5276     ;;
5277   *)
5278     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5279     ;;
5280 esac
5281
5282 # Default to using --with-stabs for certain targets.
5283 if test x${with_stabs} = x ; then
5284   case "${target}" in
5285   mips*-*-irix[56]*)
5286     ;;
5287   mips*-*-* | alpha*-*-osf*)
5288     with_stabs=yes;
5289     extra_host_args="${extra_host_args} --with-stabs"
5290     ;;
5291   esac
5292 fi
5293
5294 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5295 # them automatically.
5296 case "${host}" in
5297   hppa*64*-*-hpux11*)
5298     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5299     ;;
5300 esac
5301
5302 # Some systems (e.g., one of the i386-aix systems the gas testers are
5303 # using) don't handle "\$" correctly, so don't use it here.
5304 tooldir='${exec_prefix}'/${target_noncanonical}
5305 build_tooldir=${tooldir}
5306
5307 # Create a .gdbinit file which runs the one in srcdir
5308 # and tells GDB to look there for source files.
5309
5310 if test -r ${srcdir}/.gdbinit ; then
5311   case ${srcdir} in
5312     .) ;;
5313     *) cat > ./.gdbinit <<EOF
5314 # ${NO_EDIT}
5315 dir ${srcdir}
5316 dir .
5317 source ${srcdir}/.gdbinit
5318 EOF
5319     ;;
5320   esac
5321 fi
5322
5323 # Make sure that the compiler is able to generate an executable.  If it
5324 # can't, we are probably in trouble.  We don't care whether we can run the
5325 # executable--we might be using a cross compiler--we only care whether it
5326 # can be created.  At this point the main configure script has set CC.
5327 we_are_ok=no
5328 echo "int main () { return 0; }" > conftest.c
5329 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5330 if test $? = 0 ; then
5331   if test -s conftest || test -s conftest.exe ; then
5332     we_are_ok=yes
5333   fi
5334 fi
5335 case $we_are_ok in
5336   no)
5337     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5338     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5339     rm -f conftest*
5340     exit 1
5341     ;;
5342 esac
5343 rm -f conftest*
5344
5345 # The Solaris /usr/ucb/cc compiler does not appear to work.
5346 case "${host}" in
5347   sparc-sun-solaris2*)
5348       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5349       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5350           could_use=
5351           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5352           if test -d /opt/cygnus/bin ; then
5353               if test "$could_use" = "" ; then
5354                   could_use="/opt/cygnus/bin"
5355               else
5356                   could_use="$could_use or /opt/cygnus/bin"
5357               fi
5358           fi
5359         if test "$could_use" = "" ; then
5360             echo "Warning: compilation may fail because you're using"
5361             echo "/usr/ucb/cc.  You should change your PATH or CC "
5362             echo "variable and rerun configure."
5363         else
5364             echo "Warning: compilation may fail because you're using"
5365             echo "/usr/ucb/cc, when you should use the C compiler from"
5366             echo "$could_use.  You should change your"
5367             echo "PATH or CC variable and rerun configure."
5368         fi
5369       fi
5370   ;;
5371 esac
5372
5373 case "${host}" in
5374   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5375   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5376   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5377 esac
5378
5379 # Record target_configdirs and the configure arguments for target and
5380 # build configuration in Makefile.
5381 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5382 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5383
5384 # Determine whether gdb needs tk/tcl or not.
5385 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5386 # and in that case we want gdb to be built without tk.  Ugh!
5387 # In fact I believe gdb is the *only* package directly dependent on tk,
5388 # so we should be able to put the 'maybe's in unconditionally and
5389 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5390 # 100% sure that that's safe though.
5391
5392 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5393 case "$enable_gdbtk" in
5394   no)
5395     GDB_TK="" ;;
5396   yes)
5397     GDB_TK="${gdb_tk}" ;;
5398   *)
5399     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5400     # distro.  Eventually someone will fix this and move Insight, nee
5401     # gdbtk to a separate directory.
5402     if test -d ${srcdir}/gdb/gdbtk ; then
5403       GDB_TK="${gdb_tk}"
5404     else
5405       GDB_TK=""
5406     fi
5407     ;;
5408 esac
5409 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5410 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5411
5412 # Strip out unwanted targets.
5413
5414 # While at that, we remove Makefiles if we were started for recursive
5415 # configuration, so that the top-level Makefile reconfigures them,
5416 # like we used to do when configure itself was recursive.
5417
5418 # Loop over modules.  $extrasub must be used with care, limiting as
5419 # much as possible the usage of range addresses.  That's because autoconf
5420 # splits the sed script to overcome limits in the number of commands,
5421 # and relying on carefully-timed sed passes may turn out to be very hard
5422 # to maintain later.  In this particular case, you just have to be careful
5423 # not to nest @if/@endif pairs, because configure will not warn you at all.
5424
5425 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5426 if test "${enable_bootstrap+set}" = set; then
5427   enableval="$enable_bootstrap"
5428
5429 else
5430   enable_bootstrap=default
5431 fi;
5432
5433 # Issue errors and warnings for invalid/strange bootstrap combinations.
5434 case "$configdirs" in
5435   *gcc*) have_compiler=yes ;;
5436   *) have_compiler=no ;;
5437 esac
5438
5439 case "$have_compiler:$host:$target:$enable_bootstrap" in
5440   *:*:*:no) ;;
5441
5442   # Default behavior.  Enable bootstrap if we have a compiler
5443   # and we are in a native configuration.
5444   yes:$build:$build:default)
5445     enable_bootstrap=yes ;;
5446
5447   *:*:*:default)
5448     enable_bootstrap=no ;;
5449
5450   # We have a compiler and we are in a native configuration, bootstrap is ok
5451   yes:$build:$build:yes)
5452     ;;
5453
5454   # Other configurations, but we have a compiler.  Assume the user knows
5455   # what he's doing.
5456   yes:*:*:yes)
5457     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5458 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5459     ;;
5460
5461   # No compiler: if they passed --enable-bootstrap explicitly, fail
5462   no:*:*:yes)
5463     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5464 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5465    { (exit 1); exit 1; }; } ;;
5466
5467   # Fail if wrong command line
5468   *)
5469     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5470 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5471    { (exit 1); exit 1; }; }
5472     ;;
5473 esac
5474
5475 # Adjust the toplevel makefile according to whether bootstrap was selected.
5476 case "$enable_bootstrap" in
5477   yes)
5478     bootstrap_suffix=bootstrap ;;
5479   no)
5480     bootstrap_suffix=no-bootstrap ;;
5481 esac
5482
5483 for module in ${build_configdirs} ; do
5484   if test -z "${no_recursion}" \
5485      && test -f ${build_subdir}/${module}/Makefile; then
5486     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5487     rm -f ${build_subdir}/${module}/Makefile
5488   fi
5489   extrasub="$extrasub
5490 /^@if build-$module\$/d
5491 /^@endif build-$module\$/d
5492 /^@if build-$module-$bootstrap_suffix\$/d
5493 /^@endif build-$module-$bootstrap_suffix\$/d"
5494 done
5495 for module in ${configdirs} ; do
5496   if test -z "${no_recursion}"; then
5497     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5498       if test -f ${file}; then
5499         echo 1>&2 "*** removing ${file} to force reconfigure"
5500         rm -f ${file}
5501       fi
5502     done
5503   fi
5504   extrasub="$extrasub
5505 /^@if $module\$/d
5506 /^@endif $module\$/d
5507 /^@if $module-$bootstrap_suffix\$/d
5508 /^@endif $module-$bootstrap_suffix\$/d"
5509 done
5510 for module in ${target_configdirs} ; do
5511   if test -z "${no_recursion}" \
5512      && test -f ${target_subdir}/${module}/Makefile; then
5513     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5514     rm -f ${target_subdir}/${module}/Makefile
5515   fi
5516   extrasub="$extrasub
5517 /^@if target-$module\$/d
5518 /^@endif target-$module\$/d
5519 /^@if target-$module-$bootstrap_suffix\$/d
5520 /^@endif target-$module-$bootstrap_suffix\$/d"
5521 done
5522
5523 extrasub="$extrasub
5524 /^@if /,/^@endif /d"
5525
5526 # Create the serialization dependencies.  This uses a temporary file.
5527
5528 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5529 if test "${enable_serial_configure+set}" = set; then
5530   enableval="$enable_serial_configure"
5531
5532 fi;
5533
5534 case ${enable_serial_configure} in
5535   yes)
5536     enable_serial_build_configure=yes
5537     enable_serial_host_configure=yes
5538     enable_serial_target_configure=yes
5539     ;;
5540 esac
5541
5542 # These force 'configure's to be done one at a time, to avoid problems
5543 # with contention over a shared config.cache.
5544 rm -f serdep.tmp
5545 echo '# serdep.tmp' > serdep.tmp
5546 olditem=
5547 test "x${enable_serial_build_configure}" = xyes &&
5548 for item in ${build_configdirs} ; do
5549   case ${olditem} in
5550     "") ;;
5551     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5552   esac
5553   olditem=${item}
5554 done
5555 olditem=
5556 test "x${enable_serial_host_configure}" = xyes &&
5557 for item in ${configdirs} ; do
5558   case ${olditem} in
5559     "") ;;
5560     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5561   esac
5562   olditem=${item}
5563 done
5564 olditem=
5565 test "x${enable_serial_target_configure}" = xyes &&
5566 for item in ${target_configdirs} ; do
5567   case ${olditem} in
5568     "") ;;
5569     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5570   esac
5571   olditem=${item}
5572 done
5573 serialization_dependencies=serdep.tmp
5574
5575
5576 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5577 # target, nonopt, and variable assignments.  These are the ones we
5578 # might not want to pass down to subconfigures.  Also strip
5579 # program-prefix, program-suffix, and program-transform-name, so that
5580 # we can pass down a consistent program-transform-name.
5581 baseargs=
5582 keep_next=no
5583 skip_next=no
5584 eval "set -- $ac_configure_args"
5585 for ac_arg
5586 do
5587   if test X"$skip_next" = X"yes"; then
5588     skip_next=no
5589     continue
5590   fi
5591   if test X"$keep_next" = X"yes"; then
5592     case $ac_arg in
5593       *\'*)
5594         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5595     esac
5596     baseargs="$baseargs '$ac_arg'"
5597     keep_next=no
5598     continue
5599   fi
5600
5601   # Handle separated arguments.  Based on the logic generated by
5602   # autoconf 2.59.
5603   case $ac_arg in
5604     *=* | --config-cache | -C | -disable-* | --disable-* \
5605       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5606       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5607       | -with-* | --with-* | -without-* | --without-* | --x)
5608       separate_arg=no
5609       ;;
5610     -*)
5611       separate_arg=yes
5612       ;;
5613     *)
5614       separate_arg=no
5615       ;;
5616   esac
5617
5618   case "$ac_arg" in
5619     --no*)
5620       continue
5621       ;;
5622     --c* | \
5623     --sr* | \
5624     --ho* | \
5625     --bu* | \
5626     --t* | \
5627     --program-* | \
5628     -cache_file* | \
5629     -srcdir* | \
5630     -host* | \
5631     -build* | \
5632     -target* | \
5633     -program-prefix* | \
5634     -program-suffix* | \
5635     -program-transform-name* )
5636       skip_next=$separate_arg
5637       continue
5638       ;;
5639     -*)
5640       # An option.  Add it.
5641       case $ac_arg in
5642         *\'*)
5643           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5644       esac
5645       baseargs="$baseargs '$ac_arg'"
5646       keep_next=$separate_arg
5647       ;;
5648     *)
5649       # Either a variable assignment, or a nonopt (triplet).  Don't
5650       # pass it down; let the Makefile handle this.
5651       continue
5652       ;;
5653   esac
5654 done
5655 # Remove the initial space we just introduced and, as these will be
5656 # expanded by make, quote '$'.
5657 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5658
5659 # Add in --program-transform-name, after --program-prefix and
5660 # --program-suffix have been applied to it.  Autoconf has already
5661 # doubled dollar signs and backslashes in program_transform_name; we want
5662 # the backslashes un-doubled, and then the entire thing wrapped in single
5663 # quotes, because this will be expanded first by make and then by the shell.
5664 # Also, because we want to override the logic in subdir configure scripts to
5665 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5666 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5667 ${program_transform_name}
5668 EOF_SED
5669 gcc_transform_name=`cat conftestsed.out`
5670 rm -f conftestsed.out
5671 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5672 if test "$silent" = yes; then
5673   baseargs="$baseargs --silent"
5674 fi
5675
5676 # For the build-side libraries, we just need to pretend we're native,
5677 # and not use the same cache file.  Multilibs are neither needed nor
5678 # desired.
5679 build_configargs="--cache-file=../config.cache ${baseargs}"
5680
5681 # For host modules, accept cache file option, or specification as blank.
5682 case "${cache_file}" in
5683 "") # empty
5684   cache_file_option="" ;;
5685 /* | [A-Za-z]:[\\/]* ) # absolute path
5686   cache_file_option="--cache-file=${cache_file}" ;;
5687 *) # relative path
5688   cache_file_option="--cache-file=../${cache_file}" ;;
5689 esac
5690
5691 # Host dirs don't like to share a cache file either, horribly enough.
5692 # This seems to be due to autoconf 2.5x stupidity.
5693 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5694
5695 target_configargs=${baseargs}
5696
5697 # Passing a --with-cross-host argument lets the target libraries know
5698 # whether they are being built with a cross-compiler or being built
5699 # native.  However, it would be better to use other mechanisms to make the
5700 # sorts of decisions they want to make on this basis.  Please consider
5701 # this option to be deprecated.  FIXME.
5702 if test x${is_cross_compiler} = xyes ; then
5703   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5704 fi
5705
5706 # Default to --enable-multilib.
5707 if test x${enable_multilib} = x ; then
5708   target_configargs="--enable-multilib ${target_configargs}"
5709 fi
5710
5711 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5712 # changed from the earlier setting of with_newlib.
5713 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5714   target_configargs="--with-newlib ${target_configargs}"
5715 fi
5716
5717 # Different target subdirs use different values of certain variables
5718 # (notably CXX).  Worse, multilibs use *lots* of different values.
5719 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5720 # it doesn't automatically accept command-line overrides of them.
5721 # This means it's not safe for target subdirs to share a cache file,
5722 # which is disgusting, but there you have it.  Hopefully this can be
5723 # fixed in future.  It's still worthwhile to use a cache file for each
5724 # directory.  I think.
5725
5726 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5727 # We need to pass --target, as newer autoconf's requires consistency
5728 # for target_alias and gcc doesn't manage it consistently.
5729 target_configargs="--cache-file=./config.cache ${target_configargs}"
5730
5731 FLAGS_FOR_TARGET=
5732 case " $target_configdirs " in
5733  *" newlib "*)
5734   case " $target_configargs " in
5735   *" --with-newlib "*)
5736    case "$target" in
5737    *-cygwin*)
5738      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' ;;
5739    esac
5740
5741    # If we're not building GCC, don't discard standard headers.
5742    if test -d ${srcdir}/gcc; then
5743      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5744
5745      if test "${build}" != "${host}"; then
5746        # On Canadian crosses, CC_FOR_TARGET will have already been set
5747        # by `configure', so we won't have an opportunity to add -Bgcc/
5748        # to it.  This is right: we don't want to search that directory
5749        # for binaries, but we want the header files in there, so add
5750        # them explicitly.
5751        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5752
5753        # Someone might think of using the pre-installed headers on
5754        # Canadian crosses, in case the installed compiler is not fully
5755        # compatible with the compiler being built.  In this case, it
5756        # would be better to flag an error than risking having
5757        # incompatible object files being constructed.  We can't
5758        # guarantee that an error will be flagged, but let's hope the
5759        # compiler will do it, when presented with incompatible header
5760        # files.
5761      fi
5762    fi
5763
5764    case "${target}-${is_cross_compiler}" in
5765    i[3456789]86-*-linux*-no)
5766       # Here host == target, so we don't need to build gcc,
5767       # so we don't want to discard standard headers.
5768       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5769       ;;
5770    *)
5771       # If we're building newlib, use its generic headers last, but search
5772       # for any libc-related directories first (so make it the last -B
5773       # switch).
5774       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5775       ;;
5776    esac
5777    ;;
5778   esac
5779   ;;
5780 esac
5781 case "$target" in
5782 *-mingw*)
5783   # Can't be handled as Cygwin above since Mingw does not use newlib.
5784   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' ;;
5785 esac
5786
5787 # Allow the user to override the flags for
5788 # our build compiler if desired.
5789 CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5790
5791 # On Canadian crosses, we'll be searching the right directories for
5792 # the previously-installed cross compiler, so don't bother to add
5793 # flags for directories within the install tree of the compiler
5794 # being built; programs in there won't even run.
5795 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5796   # Search for pre-installed headers if nothing else fits.
5797   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5798 fi
5799
5800 if test "x${use_gnu_ld}" = x &&
5801    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5802   # Arrange for us to find uninstalled linker scripts.
5803   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5804 fi
5805
5806 # Search for other target-specific linker scripts and such.
5807 case "${target}" in
5808   m32c-*-* )
5809     if test -d ${srcdir}/libgloss/m32c; then
5810       # This is for crt0.o
5811       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5812       # This is for r8c.ld
5813       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5814       # This is for libnosys.a
5815       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5816     fi
5817     ;;
5818   mep*)
5819     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5820     ;;
5821 esac
5822
5823 # Makefile fragments.
5824 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5825 do
5826   eval fragval=\$$frag
5827   if test $fragval != /dev/null; then
5828     eval $frag=${srcdir}/$fragval
5829   fi
5830 done
5831
5832
5833
5834
5835
5836 # Miscellanea: directories, flags, etc.
5837
5838
5839
5840
5841
5842
5843
5844 # Build module lists & subconfigure args.
5845
5846
5847
5848 # Host module lists & subconfigure args.
5849
5850
5851
5852 # Target module lists & subconfigure args.
5853
5854
5855
5856 # Build tools.
5857
5858
5859
5860 # Generate default definitions for YACC, M4, LEX and other programs that run
5861 # on the build machine.  These are used if the Makefile can't locate these
5862 # programs in objdir.
5863 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5864
5865 for ac_prog in 'bison -y' byacc yacc
5866 do
5867   # Extract the first word of "$ac_prog", so it can be a program name with args.
5868 set dummy $ac_prog; ac_word=$2
5869 echo "$as_me:$LINENO: checking for $ac_word" >&5
5870 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5871 if test "${ac_cv_prog_YACC+set}" = set; then
5872   echo $ECHO_N "(cached) $ECHO_C" >&6
5873 else
5874   if test -n "$YACC"; then
5875   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5876 else
5877 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5878 for as_dir in $PATH
5879 do
5880   IFS=$as_save_IFS
5881   test -z "$as_dir" && as_dir=.
5882   for ac_exec_ext in '' $ac_executable_extensions; do
5883   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5884     ac_cv_prog_YACC="$ac_prog"
5885     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5886     break 2
5887   fi
5888 done
5889 done
5890
5891 fi
5892 fi
5893 YACC=$ac_cv_prog_YACC
5894 if test -n "$YACC"; then
5895   echo "$as_me:$LINENO: result: $YACC" >&5
5896 echo "${ECHO_T}$YACC" >&6
5897 else
5898   echo "$as_me:$LINENO: result: no" >&5
5899 echo "${ECHO_T}no" >&6
5900 fi
5901
5902   test -n "$YACC" && break
5903 done
5904 test -n "$YACC" || YACC="$MISSING bison -y"
5905
5906 case " $build_configdirs " in
5907   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
5908   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
5909 esac
5910
5911 for ac_prog in bison
5912 do
5913   # Extract the first word of "$ac_prog", so it can be a program name with args.
5914 set dummy $ac_prog; ac_word=$2
5915 echo "$as_me:$LINENO: checking for $ac_word" >&5
5916 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5917 if test "${ac_cv_prog_BISON+set}" = set; then
5918   echo $ECHO_N "(cached) $ECHO_C" >&6
5919 else
5920   if test -n "$BISON"; then
5921   ac_cv_prog_BISON="$BISON" # Let the user override the test.
5922 else
5923 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5924 for as_dir in $PATH
5925 do
5926   IFS=$as_save_IFS
5927   test -z "$as_dir" && as_dir=.
5928   for ac_exec_ext in '' $ac_executable_extensions; do
5929   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5930     ac_cv_prog_BISON="$ac_prog"
5931     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5932     break 2
5933   fi
5934 done
5935 done
5936
5937 fi
5938 fi
5939 BISON=$ac_cv_prog_BISON
5940 if test -n "$BISON"; then
5941   echo "$as_me:$LINENO: result: $BISON" >&5
5942 echo "${ECHO_T}$BISON" >&6
5943 else
5944   echo "$as_me:$LINENO: result: no" >&5
5945 echo "${ECHO_T}no" >&6
5946 fi
5947
5948   test -n "$BISON" && break
5949 done
5950 test -n "$BISON" || BISON="$MISSING bison"
5951
5952 case " $build_configdirs " in
5953   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
5954 esac
5955
5956 for ac_prog in gm4 gnum4 m4
5957 do
5958   # Extract the first word of "$ac_prog", so it can be a program name with args.
5959 set dummy $ac_prog; ac_word=$2
5960 echo "$as_me:$LINENO: checking for $ac_word" >&5
5961 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5962 if test "${ac_cv_prog_M4+set}" = set; then
5963   echo $ECHO_N "(cached) $ECHO_C" >&6
5964 else
5965   if test -n "$M4"; then
5966   ac_cv_prog_M4="$M4" # Let the user override the test.
5967 else
5968 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5969 for as_dir in $PATH
5970 do
5971   IFS=$as_save_IFS
5972   test -z "$as_dir" && as_dir=.
5973   for ac_exec_ext in '' $ac_executable_extensions; do
5974   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5975     ac_cv_prog_M4="$ac_prog"
5976     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5977     break 2
5978   fi
5979 done
5980 done
5981
5982 fi
5983 fi
5984 M4=$ac_cv_prog_M4
5985 if test -n "$M4"; then
5986   echo "$as_me:$LINENO: result: $M4" >&5
5987 echo "${ECHO_T}$M4" >&6
5988 else
5989   echo "$as_me:$LINENO: result: no" >&5
5990 echo "${ECHO_T}no" >&6
5991 fi
5992
5993   test -n "$M4" && break
5994 done
5995 test -n "$M4" || M4="$MISSING m4"
5996
5997 case " $build_configdirs " in
5998   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
5999 esac
6000
6001 for ac_prog in flex lex
6002 do
6003   # Extract the first word of "$ac_prog", so it can be a program name with args.
6004 set dummy $ac_prog; ac_word=$2
6005 echo "$as_me:$LINENO: checking for $ac_word" >&5
6006 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6007 if test "${ac_cv_prog_LEX+set}" = set; then
6008   echo $ECHO_N "(cached) $ECHO_C" >&6
6009 else
6010   if test -n "$LEX"; then
6011   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6012 else
6013 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6014 for as_dir in $PATH
6015 do
6016   IFS=$as_save_IFS
6017   test -z "$as_dir" && as_dir=.
6018   for ac_exec_ext in '' $ac_executable_extensions; do
6019   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6020     ac_cv_prog_LEX="$ac_prog"
6021     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6022     break 2
6023   fi
6024 done
6025 done
6026
6027 fi
6028 fi
6029 LEX=$ac_cv_prog_LEX
6030 if test -n "$LEX"; then
6031   echo "$as_me:$LINENO: result: $LEX" >&5
6032 echo "${ECHO_T}$LEX" >&6
6033 else
6034   echo "$as_me:$LINENO: result: no" >&5
6035 echo "${ECHO_T}no" >&6
6036 fi
6037
6038   test -n "$LEX" && break
6039 done
6040 test -n "$LEX" || LEX="$MISSING flex"
6041
6042 case " $build_configdirs " in
6043   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6044   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6045 esac
6046
6047 for ac_prog in flex
6048 do
6049   # Extract the first word of "$ac_prog", so it can be a program name with args.
6050 set dummy $ac_prog; ac_word=$2
6051 echo "$as_me:$LINENO: checking for $ac_word" >&5
6052 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6053 if test "${ac_cv_prog_FLEX+set}" = set; then
6054   echo $ECHO_N "(cached) $ECHO_C" >&6
6055 else
6056   if test -n "$FLEX"; then
6057   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6058 else
6059 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6060 for as_dir in $PATH
6061 do
6062   IFS=$as_save_IFS
6063   test -z "$as_dir" && as_dir=.
6064   for ac_exec_ext in '' $ac_executable_extensions; do
6065   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6066     ac_cv_prog_FLEX="$ac_prog"
6067     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6068     break 2
6069   fi
6070 done
6071 done
6072
6073 fi
6074 fi
6075 FLEX=$ac_cv_prog_FLEX
6076 if test -n "$FLEX"; then
6077   echo "$as_me:$LINENO: result: $FLEX" >&5
6078 echo "${ECHO_T}$FLEX" >&6
6079 else
6080   echo "$as_me:$LINENO: result: no" >&5
6081 echo "${ECHO_T}no" >&6
6082 fi
6083
6084   test -n "$FLEX" && break
6085 done
6086 test -n "$FLEX" || FLEX="$MISSING flex"
6087
6088 case " $build_configdirs " in
6089   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6090 esac
6091
6092 for ac_prog in makeinfo
6093 do
6094   # Extract the first word of "$ac_prog", so it can be a program name with args.
6095 set dummy $ac_prog; ac_word=$2
6096 echo "$as_me:$LINENO: checking for $ac_word" >&5
6097 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6098 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6099   echo $ECHO_N "(cached) $ECHO_C" >&6
6100 else
6101   if test -n "$MAKEINFO"; then
6102   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6103 else
6104 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6105 for as_dir in $PATH
6106 do
6107   IFS=$as_save_IFS
6108   test -z "$as_dir" && as_dir=.
6109   for ac_exec_ext in '' $ac_executable_extensions; do
6110   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6111     ac_cv_prog_MAKEINFO="$ac_prog"
6112     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6113     break 2
6114   fi
6115 done
6116 done
6117
6118 fi
6119 fi
6120 MAKEINFO=$ac_cv_prog_MAKEINFO
6121 if test -n "$MAKEINFO"; then
6122   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6123 echo "${ECHO_T}$MAKEINFO" >&6
6124 else
6125   echo "$as_me:$LINENO: result: no" >&5
6126 echo "${ECHO_T}no" >&6
6127 fi
6128
6129   test -n "$MAKEINFO" && break
6130 done
6131 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6132
6133 case " $build_configdirs " in
6134   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6135   *)
6136
6137     # For an installed makeinfo, we require it to be from texinfo 4.4 or
6138     # higher, else we use the "missing" dummy.
6139     if ${MAKEINFO} --version \
6140        | egrep 'texinfo[^0-9]*([1-3][0-9]|4\.[4-9]|[5-9])' >/dev/null 2>&1; then
6141       :
6142     else
6143       MAKEINFO="$MISSING makeinfo"
6144     fi
6145     ;;
6146
6147 esac
6148
6149 # FIXME: expect and dejagnu may become build tools?
6150
6151 for ac_prog in expect
6152 do
6153   # Extract the first word of "$ac_prog", so it can be a program name with args.
6154 set dummy $ac_prog; ac_word=$2
6155 echo "$as_me:$LINENO: checking for $ac_word" >&5
6156 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6157 if test "${ac_cv_prog_EXPECT+set}" = set; then
6158   echo $ECHO_N "(cached) $ECHO_C" >&6
6159 else
6160   if test -n "$EXPECT"; then
6161   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6162 else
6163 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6164 for as_dir in $PATH
6165 do
6166   IFS=$as_save_IFS
6167   test -z "$as_dir" && as_dir=.
6168   for ac_exec_ext in '' $ac_executable_extensions; do
6169   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6170     ac_cv_prog_EXPECT="$ac_prog"
6171     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6172     break 2
6173   fi
6174 done
6175 done
6176
6177 fi
6178 fi
6179 EXPECT=$ac_cv_prog_EXPECT
6180 if test -n "$EXPECT"; then
6181   echo "$as_me:$LINENO: result: $EXPECT" >&5
6182 echo "${ECHO_T}$EXPECT" >&6
6183 else
6184   echo "$as_me:$LINENO: result: no" >&5
6185 echo "${ECHO_T}no" >&6
6186 fi
6187
6188   test -n "$EXPECT" && break
6189 done
6190 test -n "$EXPECT" || EXPECT="expect"
6191
6192 case " $configdirs " in
6193   *" expect "*)
6194     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6195     ;;
6196 esac
6197
6198 for ac_prog in runtest
6199 do
6200   # Extract the first word of "$ac_prog", so it can be a program name with args.
6201 set dummy $ac_prog; ac_word=$2
6202 echo "$as_me:$LINENO: checking for $ac_word" >&5
6203 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6204 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6205   echo $ECHO_N "(cached) $ECHO_C" >&6
6206 else
6207   if test -n "$RUNTEST"; then
6208   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6209 else
6210 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6211 for as_dir in $PATH
6212 do
6213   IFS=$as_save_IFS
6214   test -z "$as_dir" && as_dir=.
6215   for ac_exec_ext in '' $ac_executable_extensions; do
6216   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6217     ac_cv_prog_RUNTEST="$ac_prog"
6218     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6219     break 2
6220   fi
6221 done
6222 done
6223
6224 fi
6225 fi
6226 RUNTEST=$ac_cv_prog_RUNTEST
6227 if test -n "$RUNTEST"; then
6228   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6229 echo "${ECHO_T}$RUNTEST" >&6
6230 else
6231   echo "$as_me:$LINENO: result: no" >&5
6232 echo "${ECHO_T}no" >&6
6233 fi
6234
6235   test -n "$RUNTEST" && break
6236 done
6237 test -n "$RUNTEST" || RUNTEST="runtest"
6238
6239 case " $configdirs " in
6240   *" dejagnu "*)
6241     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6242     ;;
6243 esac
6244
6245
6246 # Host tools.
6247 ncn_tool_prefix=
6248 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6249 ncn_target_tool_prefix=
6250 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6251
6252
6253
6254 if test -n "$AR"; then
6255   ac_cv_prog_AR=$AR
6256 elif test -n "$ac_cv_prog_AR"; then
6257   AR=$ac_cv_prog_AR
6258 fi
6259
6260 if test -n "$ac_cv_prog_AR"; then
6261   for ncn_progname in ar; do
6262     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6263 set dummy ${ncn_progname}; ac_word=$2
6264 echo "$as_me:$LINENO: checking for $ac_word" >&5
6265 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6266 if test "${ac_cv_prog_AR+set}" = set; then
6267   echo $ECHO_N "(cached) $ECHO_C" >&6
6268 else
6269   if test -n "$AR"; then
6270   ac_cv_prog_AR="$AR" # Let the user override the test.
6271 else
6272 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6273 for as_dir in $PATH
6274 do
6275   IFS=$as_save_IFS
6276   test -z "$as_dir" && as_dir=.
6277   for ac_exec_ext in '' $ac_executable_extensions; do
6278   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6279     ac_cv_prog_AR="${ncn_progname}"
6280     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6281     break 2
6282   fi
6283 done
6284 done
6285
6286 fi
6287 fi
6288 AR=$ac_cv_prog_AR
6289 if test -n "$AR"; then
6290   echo "$as_me:$LINENO: result: $AR" >&5
6291 echo "${ECHO_T}$AR" >&6
6292 else
6293   echo "$as_me:$LINENO: result: no" >&5
6294 echo "${ECHO_T}no" >&6
6295 fi
6296
6297   done
6298 fi
6299
6300 for ncn_progname in ar; do
6301   if test -n "$ncn_tool_prefix"; then
6302     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6303 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6304 echo "$as_me:$LINENO: checking for $ac_word" >&5
6305 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6306 if test "${ac_cv_prog_AR+set}" = set; then
6307   echo $ECHO_N "(cached) $ECHO_C" >&6
6308 else
6309   if test -n "$AR"; then
6310   ac_cv_prog_AR="$AR" # Let the user override the test.
6311 else
6312 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6313 for as_dir in $PATH
6314 do
6315   IFS=$as_save_IFS
6316   test -z "$as_dir" && as_dir=.
6317   for ac_exec_ext in '' $ac_executable_extensions; do
6318   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6319     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6320     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6321     break 2
6322   fi
6323 done
6324 done
6325
6326 fi
6327 fi
6328 AR=$ac_cv_prog_AR
6329 if test -n "$AR"; then
6330   echo "$as_me:$LINENO: result: $AR" >&5
6331 echo "${ECHO_T}$AR" >&6
6332 else
6333   echo "$as_me:$LINENO: result: no" >&5
6334 echo "${ECHO_T}no" >&6
6335 fi
6336
6337   fi
6338   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6339     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6340 set dummy ${ncn_progname}; ac_word=$2
6341 echo "$as_me:$LINENO: checking for $ac_word" >&5
6342 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6343 if test "${ac_cv_prog_AR+set}" = set; then
6344   echo $ECHO_N "(cached) $ECHO_C" >&6
6345 else
6346   if test -n "$AR"; then
6347   ac_cv_prog_AR="$AR" # Let the user override the test.
6348 else
6349 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6350 for as_dir in $PATH
6351 do
6352   IFS=$as_save_IFS
6353   test -z "$as_dir" && as_dir=.
6354   for ac_exec_ext in '' $ac_executable_extensions; do
6355   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6356     ac_cv_prog_AR="${ncn_progname}"
6357     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6358     break 2
6359   fi
6360 done
6361 done
6362
6363 fi
6364 fi
6365 AR=$ac_cv_prog_AR
6366 if test -n "$AR"; then
6367   echo "$as_me:$LINENO: result: $AR" >&5
6368 echo "${ECHO_T}$AR" >&6
6369 else
6370   echo "$as_me:$LINENO: result: no" >&5
6371 echo "${ECHO_T}no" >&6
6372 fi
6373
6374   fi
6375   test -n "$ac_cv_prog_AR" && break
6376 done
6377
6378 if test -z "$ac_cv_prog_AR" ; then
6379   set dummy ar
6380   if test $build = $host ; then
6381     AR="$2"
6382   else
6383     AR="${ncn_tool_prefix}$2"
6384   fi
6385 fi
6386
6387
6388
6389 if test -n "$AS"; then
6390   ac_cv_prog_AS=$AS
6391 elif test -n "$ac_cv_prog_AS"; then
6392   AS=$ac_cv_prog_AS
6393 fi
6394
6395 if test -n "$ac_cv_prog_AS"; then
6396   for ncn_progname in as; do
6397     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6398 set dummy ${ncn_progname}; ac_word=$2
6399 echo "$as_me:$LINENO: checking for $ac_word" >&5
6400 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6401 if test "${ac_cv_prog_AS+set}" = set; then
6402   echo $ECHO_N "(cached) $ECHO_C" >&6
6403 else
6404   if test -n "$AS"; then
6405   ac_cv_prog_AS="$AS" # Let the user override the test.
6406 else
6407 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6408 for as_dir in $PATH
6409 do
6410   IFS=$as_save_IFS
6411   test -z "$as_dir" && as_dir=.
6412   for ac_exec_ext in '' $ac_executable_extensions; do
6413   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6414     ac_cv_prog_AS="${ncn_progname}"
6415     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6416     break 2
6417   fi
6418 done
6419 done
6420
6421 fi
6422 fi
6423 AS=$ac_cv_prog_AS
6424 if test -n "$AS"; then
6425   echo "$as_me:$LINENO: result: $AS" >&5
6426 echo "${ECHO_T}$AS" >&6
6427 else
6428   echo "$as_me:$LINENO: result: no" >&5
6429 echo "${ECHO_T}no" >&6
6430 fi
6431
6432   done
6433 fi
6434
6435 for ncn_progname in as; do
6436   if test -n "$ncn_tool_prefix"; then
6437     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6438 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6439 echo "$as_me:$LINENO: checking for $ac_word" >&5
6440 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6441 if test "${ac_cv_prog_AS+set}" = set; then
6442   echo $ECHO_N "(cached) $ECHO_C" >&6
6443 else
6444   if test -n "$AS"; then
6445   ac_cv_prog_AS="$AS" # Let the user override the test.
6446 else
6447 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6448 for as_dir in $PATH
6449 do
6450   IFS=$as_save_IFS
6451   test -z "$as_dir" && as_dir=.
6452   for ac_exec_ext in '' $ac_executable_extensions; do
6453   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6454     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6455     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6456     break 2
6457   fi
6458 done
6459 done
6460
6461 fi
6462 fi
6463 AS=$ac_cv_prog_AS
6464 if test -n "$AS"; then
6465   echo "$as_me:$LINENO: result: $AS" >&5
6466 echo "${ECHO_T}$AS" >&6
6467 else
6468   echo "$as_me:$LINENO: result: no" >&5
6469 echo "${ECHO_T}no" >&6
6470 fi
6471
6472   fi
6473   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6474     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6475 set dummy ${ncn_progname}; ac_word=$2
6476 echo "$as_me:$LINENO: checking for $ac_word" >&5
6477 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6478 if test "${ac_cv_prog_AS+set}" = set; then
6479   echo $ECHO_N "(cached) $ECHO_C" >&6
6480 else
6481   if test -n "$AS"; then
6482   ac_cv_prog_AS="$AS" # Let the user override the test.
6483 else
6484 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6485 for as_dir in $PATH
6486 do
6487   IFS=$as_save_IFS
6488   test -z "$as_dir" && as_dir=.
6489   for ac_exec_ext in '' $ac_executable_extensions; do
6490   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6491     ac_cv_prog_AS="${ncn_progname}"
6492     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6493     break 2
6494   fi
6495 done
6496 done
6497
6498 fi
6499 fi
6500 AS=$ac_cv_prog_AS
6501 if test -n "$AS"; then
6502   echo "$as_me:$LINENO: result: $AS" >&5
6503 echo "${ECHO_T}$AS" >&6
6504 else
6505   echo "$as_me:$LINENO: result: no" >&5
6506 echo "${ECHO_T}no" >&6
6507 fi
6508
6509   fi
6510   test -n "$ac_cv_prog_AS" && break
6511 done
6512
6513 if test -z "$ac_cv_prog_AS" ; then
6514   set dummy as
6515   if test $build = $host ; then
6516     AS="$2"
6517   else
6518     AS="${ncn_tool_prefix}$2"
6519   fi
6520 fi
6521
6522
6523
6524 if test -n "$DLLTOOL"; then
6525   ac_cv_prog_DLLTOOL=$DLLTOOL
6526 elif test -n "$ac_cv_prog_DLLTOOL"; then
6527   DLLTOOL=$ac_cv_prog_DLLTOOL
6528 fi
6529
6530 if test -n "$ac_cv_prog_DLLTOOL"; then
6531   for ncn_progname in dlltool; do
6532     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6533 set dummy ${ncn_progname}; ac_word=$2
6534 echo "$as_me:$LINENO: checking for $ac_word" >&5
6535 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6536 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6537   echo $ECHO_N "(cached) $ECHO_C" >&6
6538 else
6539   if test -n "$DLLTOOL"; then
6540   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6541 else
6542 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6543 for as_dir in $PATH
6544 do
6545   IFS=$as_save_IFS
6546   test -z "$as_dir" && as_dir=.
6547   for ac_exec_ext in '' $ac_executable_extensions; do
6548   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6549     ac_cv_prog_DLLTOOL="${ncn_progname}"
6550     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6551     break 2
6552   fi
6553 done
6554 done
6555
6556 fi
6557 fi
6558 DLLTOOL=$ac_cv_prog_DLLTOOL
6559 if test -n "$DLLTOOL"; then
6560   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6561 echo "${ECHO_T}$DLLTOOL" >&6
6562 else
6563   echo "$as_me:$LINENO: result: no" >&5
6564 echo "${ECHO_T}no" >&6
6565 fi
6566
6567   done
6568 fi
6569
6570 for ncn_progname in dlltool; do
6571   if test -n "$ncn_tool_prefix"; then
6572     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6573 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6574 echo "$as_me:$LINENO: checking for $ac_word" >&5
6575 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6576 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6577   echo $ECHO_N "(cached) $ECHO_C" >&6
6578 else
6579   if test -n "$DLLTOOL"; then
6580   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6581 else
6582 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6583 for as_dir in $PATH
6584 do
6585   IFS=$as_save_IFS
6586   test -z "$as_dir" && as_dir=.
6587   for ac_exec_ext in '' $ac_executable_extensions; do
6588   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6589     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6590     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6591     break 2
6592   fi
6593 done
6594 done
6595
6596 fi
6597 fi
6598 DLLTOOL=$ac_cv_prog_DLLTOOL
6599 if test -n "$DLLTOOL"; then
6600   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6601 echo "${ECHO_T}$DLLTOOL" >&6
6602 else
6603   echo "$as_me:$LINENO: result: no" >&5
6604 echo "${ECHO_T}no" >&6
6605 fi
6606
6607   fi
6608   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6609     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6610 set dummy ${ncn_progname}; ac_word=$2
6611 echo "$as_me:$LINENO: checking for $ac_word" >&5
6612 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6613 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6614   echo $ECHO_N "(cached) $ECHO_C" >&6
6615 else
6616   if test -n "$DLLTOOL"; then
6617   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6618 else
6619 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6620 for as_dir in $PATH
6621 do
6622   IFS=$as_save_IFS
6623   test -z "$as_dir" && as_dir=.
6624   for ac_exec_ext in '' $ac_executable_extensions; do
6625   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6626     ac_cv_prog_DLLTOOL="${ncn_progname}"
6627     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6628     break 2
6629   fi
6630 done
6631 done
6632
6633 fi
6634 fi
6635 DLLTOOL=$ac_cv_prog_DLLTOOL
6636 if test -n "$DLLTOOL"; then
6637   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6638 echo "${ECHO_T}$DLLTOOL" >&6
6639 else
6640   echo "$as_me:$LINENO: result: no" >&5
6641 echo "${ECHO_T}no" >&6
6642 fi
6643
6644   fi
6645   test -n "$ac_cv_prog_DLLTOOL" && break
6646 done
6647
6648 if test -z "$ac_cv_prog_DLLTOOL" ; then
6649   set dummy dlltool
6650   if test $build = $host ; then
6651     DLLTOOL="$2"
6652   else
6653     DLLTOOL="${ncn_tool_prefix}$2"
6654   fi
6655 fi
6656
6657
6658
6659 if test -n "$LD"; then
6660   ac_cv_prog_LD=$LD
6661 elif test -n "$ac_cv_prog_LD"; then
6662   LD=$ac_cv_prog_LD
6663 fi
6664
6665 if test -n "$ac_cv_prog_LD"; then
6666   for ncn_progname in ld; do
6667     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6668 set dummy ${ncn_progname}; ac_word=$2
6669 echo "$as_me:$LINENO: checking for $ac_word" >&5
6670 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6671 if test "${ac_cv_prog_LD+set}" = set; then
6672   echo $ECHO_N "(cached) $ECHO_C" >&6
6673 else
6674   if test -n "$LD"; then
6675   ac_cv_prog_LD="$LD" # Let the user override the test.
6676 else
6677 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6678 for as_dir in $PATH
6679 do
6680   IFS=$as_save_IFS
6681   test -z "$as_dir" && as_dir=.
6682   for ac_exec_ext in '' $ac_executable_extensions; do
6683   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6684     ac_cv_prog_LD="${ncn_progname}"
6685     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6686     break 2
6687   fi
6688 done
6689 done
6690
6691 fi
6692 fi
6693 LD=$ac_cv_prog_LD
6694 if test -n "$LD"; then
6695   echo "$as_me:$LINENO: result: $LD" >&5
6696 echo "${ECHO_T}$LD" >&6
6697 else
6698   echo "$as_me:$LINENO: result: no" >&5
6699 echo "${ECHO_T}no" >&6
6700 fi
6701
6702   done
6703 fi
6704
6705 for ncn_progname in ld; do
6706   if test -n "$ncn_tool_prefix"; then
6707     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6708 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6709 echo "$as_me:$LINENO: checking for $ac_word" >&5
6710 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6711 if test "${ac_cv_prog_LD+set}" = set; then
6712   echo $ECHO_N "(cached) $ECHO_C" >&6
6713 else
6714   if test -n "$LD"; then
6715   ac_cv_prog_LD="$LD" # Let the user override the test.
6716 else
6717 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6718 for as_dir in $PATH
6719 do
6720   IFS=$as_save_IFS
6721   test -z "$as_dir" && as_dir=.
6722   for ac_exec_ext in '' $ac_executable_extensions; do
6723   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6724     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6725     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6726     break 2
6727   fi
6728 done
6729 done
6730
6731 fi
6732 fi
6733 LD=$ac_cv_prog_LD
6734 if test -n "$LD"; then
6735   echo "$as_me:$LINENO: result: $LD" >&5
6736 echo "${ECHO_T}$LD" >&6
6737 else
6738   echo "$as_me:$LINENO: result: no" >&5
6739 echo "${ECHO_T}no" >&6
6740 fi
6741
6742   fi
6743   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6744     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6745 set dummy ${ncn_progname}; ac_word=$2
6746 echo "$as_me:$LINENO: checking for $ac_word" >&5
6747 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6748 if test "${ac_cv_prog_LD+set}" = set; then
6749   echo $ECHO_N "(cached) $ECHO_C" >&6
6750 else
6751   if test -n "$LD"; then
6752   ac_cv_prog_LD="$LD" # Let the user override the test.
6753 else
6754 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6755 for as_dir in $PATH
6756 do
6757   IFS=$as_save_IFS
6758   test -z "$as_dir" && as_dir=.
6759   for ac_exec_ext in '' $ac_executable_extensions; do
6760   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6761     ac_cv_prog_LD="${ncn_progname}"
6762     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6763     break 2
6764   fi
6765 done
6766 done
6767
6768 fi
6769 fi
6770 LD=$ac_cv_prog_LD
6771 if test -n "$LD"; then
6772   echo "$as_me:$LINENO: result: $LD" >&5
6773 echo "${ECHO_T}$LD" >&6
6774 else
6775   echo "$as_me:$LINENO: result: no" >&5
6776 echo "${ECHO_T}no" >&6
6777 fi
6778
6779   fi
6780   test -n "$ac_cv_prog_LD" && break
6781 done
6782
6783 if test -z "$ac_cv_prog_LD" ; then
6784   set dummy ld
6785   if test $build = $host ; then
6786     LD="$2"
6787   else
6788     LD="${ncn_tool_prefix}$2"
6789   fi
6790 fi
6791
6792
6793
6794 if test -n "$LIPO"; then
6795   ac_cv_prog_LIPO=$LIPO
6796 elif test -n "$ac_cv_prog_LIPO"; then
6797   LIPO=$ac_cv_prog_LIPO
6798 fi
6799
6800 if test -n "$ac_cv_prog_LIPO"; then
6801   for ncn_progname in lipo; do
6802     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6803 set dummy ${ncn_progname}; ac_word=$2
6804 echo "$as_me:$LINENO: checking for $ac_word" >&5
6805 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6806 if test "${ac_cv_prog_LIPO+set}" = set; then
6807   echo $ECHO_N "(cached) $ECHO_C" >&6
6808 else
6809   if test -n "$LIPO"; then
6810   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6811 else
6812 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6813 for as_dir in $PATH
6814 do
6815   IFS=$as_save_IFS
6816   test -z "$as_dir" && as_dir=.
6817   for ac_exec_ext in '' $ac_executable_extensions; do
6818   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6819     ac_cv_prog_LIPO="${ncn_progname}"
6820     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6821     break 2
6822   fi
6823 done
6824 done
6825
6826 fi
6827 fi
6828 LIPO=$ac_cv_prog_LIPO
6829 if test -n "$LIPO"; then
6830   echo "$as_me:$LINENO: result: $LIPO" >&5
6831 echo "${ECHO_T}$LIPO" >&6
6832 else
6833   echo "$as_me:$LINENO: result: no" >&5
6834 echo "${ECHO_T}no" >&6
6835 fi
6836
6837   done
6838 fi
6839
6840 for ncn_progname in lipo; do
6841   if test -n "$ncn_tool_prefix"; then
6842     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6843 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6844 echo "$as_me:$LINENO: checking for $ac_word" >&5
6845 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6846 if test "${ac_cv_prog_LIPO+set}" = set; then
6847   echo $ECHO_N "(cached) $ECHO_C" >&6
6848 else
6849   if test -n "$LIPO"; then
6850   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6851 else
6852 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6853 for as_dir in $PATH
6854 do
6855   IFS=$as_save_IFS
6856   test -z "$as_dir" && as_dir=.
6857   for ac_exec_ext in '' $ac_executable_extensions; do
6858   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6859     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6860     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6861     break 2
6862   fi
6863 done
6864 done
6865
6866 fi
6867 fi
6868 LIPO=$ac_cv_prog_LIPO
6869 if test -n "$LIPO"; then
6870   echo "$as_me:$LINENO: result: $LIPO" >&5
6871 echo "${ECHO_T}$LIPO" >&6
6872 else
6873   echo "$as_me:$LINENO: result: no" >&5
6874 echo "${ECHO_T}no" >&6
6875 fi
6876
6877   fi
6878   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6879     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6880 set dummy ${ncn_progname}; ac_word=$2
6881 echo "$as_me:$LINENO: checking for $ac_word" >&5
6882 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6883 if test "${ac_cv_prog_LIPO+set}" = set; then
6884   echo $ECHO_N "(cached) $ECHO_C" >&6
6885 else
6886   if test -n "$LIPO"; then
6887   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6888 else
6889 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6890 for as_dir in $PATH
6891 do
6892   IFS=$as_save_IFS
6893   test -z "$as_dir" && as_dir=.
6894   for ac_exec_ext in '' $ac_executable_extensions; do
6895   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6896     ac_cv_prog_LIPO="${ncn_progname}"
6897     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6898     break 2
6899   fi
6900 done
6901 done
6902
6903 fi
6904 fi
6905 LIPO=$ac_cv_prog_LIPO
6906 if test -n "$LIPO"; then
6907   echo "$as_me:$LINENO: result: $LIPO" >&5
6908 echo "${ECHO_T}$LIPO" >&6
6909 else
6910   echo "$as_me:$LINENO: result: no" >&5
6911 echo "${ECHO_T}no" >&6
6912 fi
6913
6914   fi
6915   test -n "$ac_cv_prog_LIPO" && break
6916 done
6917
6918 if test -z "$ac_cv_prog_LIPO" ; then
6919   set dummy lipo
6920   if test $build = $host ; then
6921     LIPO="$2"
6922   else
6923     LIPO="${ncn_tool_prefix}$2"
6924   fi
6925 fi
6926
6927
6928
6929 if test -n "$NM"; then
6930   ac_cv_prog_NM=$NM
6931 elif test -n "$ac_cv_prog_NM"; then
6932   NM=$ac_cv_prog_NM
6933 fi
6934
6935 if test -n "$ac_cv_prog_NM"; then
6936   for ncn_progname in nm; do
6937     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6938 set dummy ${ncn_progname}; ac_word=$2
6939 echo "$as_me:$LINENO: checking for $ac_word" >&5
6940 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6941 if test "${ac_cv_prog_NM+set}" = set; then
6942   echo $ECHO_N "(cached) $ECHO_C" >&6
6943 else
6944   if test -n "$NM"; then
6945   ac_cv_prog_NM="$NM" # Let the user override the test.
6946 else
6947 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6948 for as_dir in $PATH
6949 do
6950   IFS=$as_save_IFS
6951   test -z "$as_dir" && as_dir=.
6952   for ac_exec_ext in '' $ac_executable_extensions; do
6953   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6954     ac_cv_prog_NM="${ncn_progname}"
6955     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6956     break 2
6957   fi
6958 done
6959 done
6960
6961 fi
6962 fi
6963 NM=$ac_cv_prog_NM
6964 if test -n "$NM"; then
6965   echo "$as_me:$LINENO: result: $NM" >&5
6966 echo "${ECHO_T}$NM" >&6
6967 else
6968   echo "$as_me:$LINENO: result: no" >&5
6969 echo "${ECHO_T}no" >&6
6970 fi
6971
6972   done
6973 fi
6974
6975 for ncn_progname in nm; do
6976   if test -n "$ncn_tool_prefix"; then
6977     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6978 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6979 echo "$as_me:$LINENO: checking for $ac_word" >&5
6980 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6981 if test "${ac_cv_prog_NM+set}" = set; then
6982   echo $ECHO_N "(cached) $ECHO_C" >&6
6983 else
6984   if test -n "$NM"; then
6985   ac_cv_prog_NM="$NM" # Let the user override the test.
6986 else
6987 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6988 for as_dir in $PATH
6989 do
6990   IFS=$as_save_IFS
6991   test -z "$as_dir" && as_dir=.
6992   for ac_exec_ext in '' $ac_executable_extensions; do
6993   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6994     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
6995     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6996     break 2
6997   fi
6998 done
6999 done
7000
7001 fi
7002 fi
7003 NM=$ac_cv_prog_NM
7004 if test -n "$NM"; then
7005   echo "$as_me:$LINENO: result: $NM" >&5
7006 echo "${ECHO_T}$NM" >&6
7007 else
7008   echo "$as_me:$LINENO: result: no" >&5
7009 echo "${ECHO_T}no" >&6
7010 fi
7011
7012   fi
7013   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7014     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7015 set dummy ${ncn_progname}; ac_word=$2
7016 echo "$as_me:$LINENO: checking for $ac_word" >&5
7017 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7018 if test "${ac_cv_prog_NM+set}" = set; then
7019   echo $ECHO_N "(cached) $ECHO_C" >&6
7020 else
7021   if test -n "$NM"; then
7022   ac_cv_prog_NM="$NM" # Let the user override the test.
7023 else
7024 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7025 for as_dir in $PATH
7026 do
7027   IFS=$as_save_IFS
7028   test -z "$as_dir" && as_dir=.
7029   for ac_exec_ext in '' $ac_executable_extensions; do
7030   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7031     ac_cv_prog_NM="${ncn_progname}"
7032     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7033     break 2
7034   fi
7035 done
7036 done
7037
7038 fi
7039 fi
7040 NM=$ac_cv_prog_NM
7041 if test -n "$NM"; then
7042   echo "$as_me:$LINENO: result: $NM" >&5
7043 echo "${ECHO_T}$NM" >&6
7044 else
7045   echo "$as_me:$LINENO: result: no" >&5
7046 echo "${ECHO_T}no" >&6
7047 fi
7048
7049   fi
7050   test -n "$ac_cv_prog_NM" && break
7051 done
7052
7053 if test -z "$ac_cv_prog_NM" ; then
7054   set dummy nm
7055   if test $build = $host ; then
7056     NM="$2"
7057   else
7058     NM="${ncn_tool_prefix}$2"
7059   fi
7060 fi
7061
7062
7063
7064 if test -n "$RANLIB"; then
7065   ac_cv_prog_RANLIB=$RANLIB
7066 elif test -n "$ac_cv_prog_RANLIB"; then
7067   RANLIB=$ac_cv_prog_RANLIB
7068 fi
7069
7070 if test -n "$ac_cv_prog_RANLIB"; then
7071   for ncn_progname in ranlib; do
7072     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7073 set dummy ${ncn_progname}; ac_word=$2
7074 echo "$as_me:$LINENO: checking for $ac_word" >&5
7075 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7076 if test "${ac_cv_prog_RANLIB+set}" = set; then
7077   echo $ECHO_N "(cached) $ECHO_C" >&6
7078 else
7079   if test -n "$RANLIB"; then
7080   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7081 else
7082 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7083 for as_dir in $PATH
7084 do
7085   IFS=$as_save_IFS
7086   test -z "$as_dir" && as_dir=.
7087   for ac_exec_ext in '' $ac_executable_extensions; do
7088   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7089     ac_cv_prog_RANLIB="${ncn_progname}"
7090     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7091     break 2
7092   fi
7093 done
7094 done
7095
7096 fi
7097 fi
7098 RANLIB=$ac_cv_prog_RANLIB
7099 if test -n "$RANLIB"; then
7100   echo "$as_me:$LINENO: result: $RANLIB" >&5
7101 echo "${ECHO_T}$RANLIB" >&6
7102 else
7103   echo "$as_me:$LINENO: result: no" >&5
7104 echo "${ECHO_T}no" >&6
7105 fi
7106
7107   done
7108 fi
7109
7110 for ncn_progname in ranlib; do
7111   if test -n "$ncn_tool_prefix"; then
7112     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7113 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7114 echo "$as_me:$LINENO: checking for $ac_word" >&5
7115 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7116 if test "${ac_cv_prog_RANLIB+set}" = set; then
7117   echo $ECHO_N "(cached) $ECHO_C" >&6
7118 else
7119   if test -n "$RANLIB"; then
7120   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7121 else
7122 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7123 for as_dir in $PATH
7124 do
7125   IFS=$as_save_IFS
7126   test -z "$as_dir" && as_dir=.
7127   for ac_exec_ext in '' $ac_executable_extensions; do
7128   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7129     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7130     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7131     break 2
7132   fi
7133 done
7134 done
7135
7136 fi
7137 fi
7138 RANLIB=$ac_cv_prog_RANLIB
7139 if test -n "$RANLIB"; then
7140   echo "$as_me:$LINENO: result: $RANLIB" >&5
7141 echo "${ECHO_T}$RANLIB" >&6
7142 else
7143   echo "$as_me:$LINENO: result: no" >&5
7144 echo "${ECHO_T}no" >&6
7145 fi
7146
7147   fi
7148   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7149     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7150 set dummy ${ncn_progname}; ac_word=$2
7151 echo "$as_me:$LINENO: checking for $ac_word" >&5
7152 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7153 if test "${ac_cv_prog_RANLIB+set}" = set; then
7154   echo $ECHO_N "(cached) $ECHO_C" >&6
7155 else
7156   if test -n "$RANLIB"; then
7157   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7158 else
7159 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7160 for as_dir in $PATH
7161 do
7162   IFS=$as_save_IFS
7163   test -z "$as_dir" && as_dir=.
7164   for ac_exec_ext in '' $ac_executable_extensions; do
7165   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7166     ac_cv_prog_RANLIB="${ncn_progname}"
7167     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7168     break 2
7169   fi
7170 done
7171 done
7172
7173 fi
7174 fi
7175 RANLIB=$ac_cv_prog_RANLIB
7176 if test -n "$RANLIB"; then
7177   echo "$as_me:$LINENO: result: $RANLIB" >&5
7178 echo "${ECHO_T}$RANLIB" >&6
7179 else
7180   echo "$as_me:$LINENO: result: no" >&5
7181 echo "${ECHO_T}no" >&6
7182 fi
7183
7184   fi
7185   test -n "$ac_cv_prog_RANLIB" && break
7186 done
7187
7188 if test -z "$ac_cv_prog_RANLIB" ; then
7189   RANLIB=":"
7190 fi
7191
7192
7193
7194 if test -n "$STRIP"; then
7195   ac_cv_prog_STRIP=$STRIP
7196 elif test -n "$ac_cv_prog_STRIP"; then
7197   STRIP=$ac_cv_prog_STRIP
7198 fi
7199
7200 if test -n "$ac_cv_prog_STRIP"; then
7201   for ncn_progname in strip; do
7202     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7203 set dummy ${ncn_progname}; ac_word=$2
7204 echo "$as_me:$LINENO: checking for $ac_word" >&5
7205 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7206 if test "${ac_cv_prog_STRIP+set}" = set; then
7207   echo $ECHO_N "(cached) $ECHO_C" >&6
7208 else
7209   if test -n "$STRIP"; then
7210   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7211 else
7212 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7213 for as_dir in $PATH
7214 do
7215   IFS=$as_save_IFS
7216   test -z "$as_dir" && as_dir=.
7217   for ac_exec_ext in '' $ac_executable_extensions; do
7218   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7219     ac_cv_prog_STRIP="${ncn_progname}"
7220     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7221     break 2
7222   fi
7223 done
7224 done
7225
7226 fi
7227 fi
7228 STRIP=$ac_cv_prog_STRIP
7229 if test -n "$STRIP"; then
7230   echo "$as_me:$LINENO: result: $STRIP" >&5
7231 echo "${ECHO_T}$STRIP" >&6
7232 else
7233   echo "$as_me:$LINENO: result: no" >&5
7234 echo "${ECHO_T}no" >&6
7235 fi
7236
7237   done
7238 fi
7239
7240 for ncn_progname in strip; do
7241   if test -n "$ncn_tool_prefix"; then
7242     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7243 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7244 echo "$as_me:$LINENO: checking for $ac_word" >&5
7245 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7246 if test "${ac_cv_prog_STRIP+set}" = set; then
7247   echo $ECHO_N "(cached) $ECHO_C" >&6
7248 else
7249   if test -n "$STRIP"; then
7250   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7251 else
7252 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7253 for as_dir in $PATH
7254 do
7255   IFS=$as_save_IFS
7256   test -z "$as_dir" && as_dir=.
7257   for ac_exec_ext in '' $ac_executable_extensions; do
7258   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7259     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7260     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7261     break 2
7262   fi
7263 done
7264 done
7265
7266 fi
7267 fi
7268 STRIP=$ac_cv_prog_STRIP
7269 if test -n "$STRIP"; then
7270   echo "$as_me:$LINENO: result: $STRIP" >&5
7271 echo "${ECHO_T}$STRIP" >&6
7272 else
7273   echo "$as_me:$LINENO: result: no" >&5
7274 echo "${ECHO_T}no" >&6
7275 fi
7276
7277   fi
7278   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7279     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7280 set dummy ${ncn_progname}; ac_word=$2
7281 echo "$as_me:$LINENO: checking for $ac_word" >&5
7282 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7283 if test "${ac_cv_prog_STRIP+set}" = set; then
7284   echo $ECHO_N "(cached) $ECHO_C" >&6
7285 else
7286   if test -n "$STRIP"; then
7287   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7288 else
7289 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7290 for as_dir in $PATH
7291 do
7292   IFS=$as_save_IFS
7293   test -z "$as_dir" && as_dir=.
7294   for ac_exec_ext in '' $ac_executable_extensions; do
7295   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7296     ac_cv_prog_STRIP="${ncn_progname}"
7297     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7298     break 2
7299   fi
7300 done
7301 done
7302
7303 fi
7304 fi
7305 STRIP=$ac_cv_prog_STRIP
7306 if test -n "$STRIP"; then
7307   echo "$as_me:$LINENO: result: $STRIP" >&5
7308 echo "${ECHO_T}$STRIP" >&6
7309 else
7310   echo "$as_me:$LINENO: result: no" >&5
7311 echo "${ECHO_T}no" >&6
7312 fi
7313
7314   fi
7315   test -n "$ac_cv_prog_STRIP" && break
7316 done
7317
7318 if test -z "$ac_cv_prog_STRIP" ; then
7319   STRIP=":"
7320 fi
7321
7322
7323
7324 if test -n "$WINDRES"; then
7325   ac_cv_prog_WINDRES=$WINDRES
7326 elif test -n "$ac_cv_prog_WINDRES"; then
7327   WINDRES=$ac_cv_prog_WINDRES
7328 fi
7329
7330 if test -n "$ac_cv_prog_WINDRES"; then
7331   for ncn_progname in windres; do
7332     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7333 set dummy ${ncn_progname}; ac_word=$2
7334 echo "$as_me:$LINENO: checking for $ac_word" >&5
7335 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7336 if test "${ac_cv_prog_WINDRES+set}" = set; then
7337   echo $ECHO_N "(cached) $ECHO_C" >&6
7338 else
7339   if test -n "$WINDRES"; then
7340   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7341 else
7342 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7343 for as_dir in $PATH
7344 do
7345   IFS=$as_save_IFS
7346   test -z "$as_dir" && as_dir=.
7347   for ac_exec_ext in '' $ac_executable_extensions; do
7348   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7349     ac_cv_prog_WINDRES="${ncn_progname}"
7350     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7351     break 2
7352   fi
7353 done
7354 done
7355
7356 fi
7357 fi
7358 WINDRES=$ac_cv_prog_WINDRES
7359 if test -n "$WINDRES"; then
7360   echo "$as_me:$LINENO: result: $WINDRES" >&5
7361 echo "${ECHO_T}$WINDRES" >&6
7362 else
7363   echo "$as_me:$LINENO: result: no" >&5
7364 echo "${ECHO_T}no" >&6
7365 fi
7366
7367   done
7368 fi
7369
7370 for ncn_progname in windres; do
7371   if test -n "$ncn_tool_prefix"; then
7372     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7373 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7374 echo "$as_me:$LINENO: checking for $ac_word" >&5
7375 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7376 if test "${ac_cv_prog_WINDRES+set}" = set; then
7377   echo $ECHO_N "(cached) $ECHO_C" >&6
7378 else
7379   if test -n "$WINDRES"; then
7380   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7381 else
7382 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7383 for as_dir in $PATH
7384 do
7385   IFS=$as_save_IFS
7386   test -z "$as_dir" && as_dir=.
7387   for ac_exec_ext in '' $ac_executable_extensions; do
7388   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7389     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7390     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7391     break 2
7392   fi
7393 done
7394 done
7395
7396 fi
7397 fi
7398 WINDRES=$ac_cv_prog_WINDRES
7399 if test -n "$WINDRES"; then
7400   echo "$as_me:$LINENO: result: $WINDRES" >&5
7401 echo "${ECHO_T}$WINDRES" >&6
7402 else
7403   echo "$as_me:$LINENO: result: no" >&5
7404 echo "${ECHO_T}no" >&6
7405 fi
7406
7407   fi
7408   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7409     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7410 set dummy ${ncn_progname}; ac_word=$2
7411 echo "$as_me:$LINENO: checking for $ac_word" >&5
7412 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7413 if test "${ac_cv_prog_WINDRES+set}" = set; then
7414   echo $ECHO_N "(cached) $ECHO_C" >&6
7415 else
7416   if test -n "$WINDRES"; then
7417   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7418 else
7419 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7420 for as_dir in $PATH
7421 do
7422   IFS=$as_save_IFS
7423   test -z "$as_dir" && as_dir=.
7424   for ac_exec_ext in '' $ac_executable_extensions; do
7425   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7426     ac_cv_prog_WINDRES="${ncn_progname}"
7427     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7428     break 2
7429   fi
7430 done
7431 done
7432
7433 fi
7434 fi
7435 WINDRES=$ac_cv_prog_WINDRES
7436 if test -n "$WINDRES"; then
7437   echo "$as_me:$LINENO: result: $WINDRES" >&5
7438 echo "${ECHO_T}$WINDRES" >&6
7439 else
7440   echo "$as_me:$LINENO: result: no" >&5
7441 echo "${ECHO_T}no" >&6
7442 fi
7443
7444   fi
7445   test -n "$ac_cv_prog_WINDRES" && break
7446 done
7447
7448 if test -z "$ac_cv_prog_WINDRES" ; then
7449   set dummy windres
7450   if test $build = $host ; then
7451     WINDRES="$2"
7452   else
7453     WINDRES="${ncn_tool_prefix}$2"
7454   fi
7455 fi
7456
7457
7458
7459 if test -n "$WINDMC"; then
7460   ac_cv_prog_WINDMC=$WINDMC
7461 elif test -n "$ac_cv_prog_WINDMC"; then
7462   WINDMC=$ac_cv_prog_WINDMC
7463 fi
7464
7465 if test -n "$ac_cv_prog_WINDMC"; then
7466   for ncn_progname in windmc; do
7467     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7468 set dummy ${ncn_progname}; ac_word=$2
7469 echo "$as_me:$LINENO: checking for $ac_word" >&5
7470 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7471 if test "${ac_cv_prog_WINDMC+set}" = set; then
7472   echo $ECHO_N "(cached) $ECHO_C" >&6
7473 else
7474   if test -n "$WINDMC"; then
7475   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7476 else
7477 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7478 for as_dir in $PATH
7479 do
7480   IFS=$as_save_IFS
7481   test -z "$as_dir" && as_dir=.
7482   for ac_exec_ext in '' $ac_executable_extensions; do
7483   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7484     ac_cv_prog_WINDMC="${ncn_progname}"
7485     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7486     break 2
7487   fi
7488 done
7489 done
7490
7491 fi
7492 fi
7493 WINDMC=$ac_cv_prog_WINDMC
7494 if test -n "$WINDMC"; then
7495   echo "$as_me:$LINENO: result: $WINDMC" >&5
7496 echo "${ECHO_T}$WINDMC" >&6
7497 else
7498   echo "$as_me:$LINENO: result: no" >&5
7499 echo "${ECHO_T}no" >&6
7500 fi
7501
7502   done
7503 fi
7504
7505 for ncn_progname in windmc; do
7506   if test -n "$ncn_tool_prefix"; then
7507     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7508 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7509 echo "$as_me:$LINENO: checking for $ac_word" >&5
7510 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7511 if test "${ac_cv_prog_WINDMC+set}" = set; then
7512   echo $ECHO_N "(cached) $ECHO_C" >&6
7513 else
7514   if test -n "$WINDMC"; then
7515   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7516 else
7517 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7518 for as_dir in $PATH
7519 do
7520   IFS=$as_save_IFS
7521   test -z "$as_dir" && as_dir=.
7522   for ac_exec_ext in '' $ac_executable_extensions; do
7523   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7524     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7525     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7526     break 2
7527   fi
7528 done
7529 done
7530
7531 fi
7532 fi
7533 WINDMC=$ac_cv_prog_WINDMC
7534 if test -n "$WINDMC"; then
7535   echo "$as_me:$LINENO: result: $WINDMC" >&5
7536 echo "${ECHO_T}$WINDMC" >&6
7537 else
7538   echo "$as_me:$LINENO: result: no" >&5
7539 echo "${ECHO_T}no" >&6
7540 fi
7541
7542   fi
7543   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7544     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7545 set dummy ${ncn_progname}; ac_word=$2
7546 echo "$as_me:$LINENO: checking for $ac_word" >&5
7547 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7548 if test "${ac_cv_prog_WINDMC+set}" = set; then
7549   echo $ECHO_N "(cached) $ECHO_C" >&6
7550 else
7551   if test -n "$WINDMC"; then
7552   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7553 else
7554 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7555 for as_dir in $PATH
7556 do
7557   IFS=$as_save_IFS
7558   test -z "$as_dir" && as_dir=.
7559   for ac_exec_ext in '' $ac_executable_extensions; do
7560   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7561     ac_cv_prog_WINDMC="${ncn_progname}"
7562     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7563     break 2
7564   fi
7565 done
7566 done
7567
7568 fi
7569 fi
7570 WINDMC=$ac_cv_prog_WINDMC
7571 if test -n "$WINDMC"; then
7572   echo "$as_me:$LINENO: result: $WINDMC" >&5
7573 echo "${ECHO_T}$WINDMC" >&6
7574 else
7575   echo "$as_me:$LINENO: result: no" >&5
7576 echo "${ECHO_T}no" >&6
7577 fi
7578
7579   fi
7580   test -n "$ac_cv_prog_WINDMC" && break
7581 done
7582
7583 if test -z "$ac_cv_prog_WINDMC" ; then
7584   set dummy windmc
7585   if test $build = $host ; then
7586     WINDMC="$2"
7587   else
7588     WINDMC="${ncn_tool_prefix}$2"
7589   fi
7590 fi
7591
7592
7593
7594 if test -n "$OBJCOPY"; then
7595   ac_cv_prog_OBJCOPY=$OBJCOPY
7596 elif test -n "$ac_cv_prog_OBJCOPY"; then
7597   OBJCOPY=$ac_cv_prog_OBJCOPY
7598 fi
7599
7600 if test -n "$ac_cv_prog_OBJCOPY"; then
7601   for ncn_progname in objcopy; do
7602     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7603 set dummy ${ncn_progname}; ac_word=$2
7604 echo "$as_me:$LINENO: checking for $ac_word" >&5
7605 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7606 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7607   echo $ECHO_N "(cached) $ECHO_C" >&6
7608 else
7609   if test -n "$OBJCOPY"; then
7610   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7611 else
7612 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7613 for as_dir in $PATH
7614 do
7615   IFS=$as_save_IFS
7616   test -z "$as_dir" && as_dir=.
7617   for ac_exec_ext in '' $ac_executable_extensions; do
7618   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7619     ac_cv_prog_OBJCOPY="${ncn_progname}"
7620     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7621     break 2
7622   fi
7623 done
7624 done
7625
7626 fi
7627 fi
7628 OBJCOPY=$ac_cv_prog_OBJCOPY
7629 if test -n "$OBJCOPY"; then
7630   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7631 echo "${ECHO_T}$OBJCOPY" >&6
7632 else
7633   echo "$as_me:$LINENO: result: no" >&5
7634 echo "${ECHO_T}no" >&6
7635 fi
7636
7637   done
7638 fi
7639
7640 for ncn_progname in objcopy; do
7641   if test -n "$ncn_tool_prefix"; then
7642     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7643 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7644 echo "$as_me:$LINENO: checking for $ac_word" >&5
7645 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7646 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7647   echo $ECHO_N "(cached) $ECHO_C" >&6
7648 else
7649   if test -n "$OBJCOPY"; then
7650   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7651 else
7652 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7653 for as_dir in $PATH
7654 do
7655   IFS=$as_save_IFS
7656   test -z "$as_dir" && as_dir=.
7657   for ac_exec_ext in '' $ac_executable_extensions; do
7658   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7659     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7660     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7661     break 2
7662   fi
7663 done
7664 done
7665
7666 fi
7667 fi
7668 OBJCOPY=$ac_cv_prog_OBJCOPY
7669 if test -n "$OBJCOPY"; then
7670   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7671 echo "${ECHO_T}$OBJCOPY" >&6
7672 else
7673   echo "$as_me:$LINENO: result: no" >&5
7674 echo "${ECHO_T}no" >&6
7675 fi
7676
7677   fi
7678   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7679     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7680 set dummy ${ncn_progname}; ac_word=$2
7681 echo "$as_me:$LINENO: checking for $ac_word" >&5
7682 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7683 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7684   echo $ECHO_N "(cached) $ECHO_C" >&6
7685 else
7686   if test -n "$OBJCOPY"; then
7687   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7688 else
7689 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7690 for as_dir in $PATH
7691 do
7692   IFS=$as_save_IFS
7693   test -z "$as_dir" && as_dir=.
7694   for ac_exec_ext in '' $ac_executable_extensions; do
7695   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7696     ac_cv_prog_OBJCOPY="${ncn_progname}"
7697     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7698     break 2
7699   fi
7700 done
7701 done
7702
7703 fi
7704 fi
7705 OBJCOPY=$ac_cv_prog_OBJCOPY
7706 if test -n "$OBJCOPY"; then
7707   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7708 echo "${ECHO_T}$OBJCOPY" >&6
7709 else
7710   echo "$as_me:$LINENO: result: no" >&5
7711 echo "${ECHO_T}no" >&6
7712 fi
7713
7714   fi
7715   test -n "$ac_cv_prog_OBJCOPY" && break
7716 done
7717
7718 if test -z "$ac_cv_prog_OBJCOPY" ; then
7719   set dummy objcopy
7720   if test $build = $host ; then
7721     OBJCOPY="$2"
7722   else
7723     OBJCOPY="${ncn_tool_prefix}$2"
7724   fi
7725 fi
7726
7727
7728
7729 if test -n "$OBJDUMP"; then
7730   ac_cv_prog_OBJDUMP=$OBJDUMP
7731 elif test -n "$ac_cv_prog_OBJDUMP"; then
7732   OBJDUMP=$ac_cv_prog_OBJDUMP
7733 fi
7734
7735 if test -n "$ac_cv_prog_OBJDUMP"; then
7736   for ncn_progname in objdump; do
7737     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7738 set dummy ${ncn_progname}; ac_word=$2
7739 echo "$as_me:$LINENO: checking for $ac_word" >&5
7740 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7741 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7742   echo $ECHO_N "(cached) $ECHO_C" >&6
7743 else
7744   if test -n "$OBJDUMP"; then
7745   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7746 else
7747 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7748 for as_dir in $PATH
7749 do
7750   IFS=$as_save_IFS
7751   test -z "$as_dir" && as_dir=.
7752   for ac_exec_ext in '' $ac_executable_extensions; do
7753   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7754     ac_cv_prog_OBJDUMP="${ncn_progname}"
7755     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7756     break 2
7757   fi
7758 done
7759 done
7760
7761 fi
7762 fi
7763 OBJDUMP=$ac_cv_prog_OBJDUMP
7764 if test -n "$OBJDUMP"; then
7765   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7766 echo "${ECHO_T}$OBJDUMP" >&6
7767 else
7768   echo "$as_me:$LINENO: result: no" >&5
7769 echo "${ECHO_T}no" >&6
7770 fi
7771
7772   done
7773 fi
7774
7775 for ncn_progname in objdump; do
7776   if test -n "$ncn_tool_prefix"; then
7777     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7778 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7779 echo "$as_me:$LINENO: checking for $ac_word" >&5
7780 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7781 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7782   echo $ECHO_N "(cached) $ECHO_C" >&6
7783 else
7784   if test -n "$OBJDUMP"; then
7785   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7786 else
7787 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7788 for as_dir in $PATH
7789 do
7790   IFS=$as_save_IFS
7791   test -z "$as_dir" && as_dir=.
7792   for ac_exec_ext in '' $ac_executable_extensions; do
7793   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7794     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7795     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7796     break 2
7797   fi
7798 done
7799 done
7800
7801 fi
7802 fi
7803 OBJDUMP=$ac_cv_prog_OBJDUMP
7804 if test -n "$OBJDUMP"; then
7805   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7806 echo "${ECHO_T}$OBJDUMP" >&6
7807 else
7808   echo "$as_me:$LINENO: result: no" >&5
7809 echo "${ECHO_T}no" >&6
7810 fi
7811
7812   fi
7813   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7814     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7815 set dummy ${ncn_progname}; ac_word=$2
7816 echo "$as_me:$LINENO: checking for $ac_word" >&5
7817 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7818 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7819   echo $ECHO_N "(cached) $ECHO_C" >&6
7820 else
7821   if test -n "$OBJDUMP"; then
7822   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7823 else
7824 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7825 for as_dir in $PATH
7826 do
7827   IFS=$as_save_IFS
7828   test -z "$as_dir" && as_dir=.
7829   for ac_exec_ext in '' $ac_executable_extensions; do
7830   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7831     ac_cv_prog_OBJDUMP="${ncn_progname}"
7832     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7833     break 2
7834   fi
7835 done
7836 done
7837
7838 fi
7839 fi
7840 OBJDUMP=$ac_cv_prog_OBJDUMP
7841 if test -n "$OBJDUMP"; then
7842   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7843 echo "${ECHO_T}$OBJDUMP" >&6
7844 else
7845   echo "$as_me:$LINENO: result: no" >&5
7846 echo "${ECHO_T}no" >&6
7847 fi
7848
7849   fi
7850   test -n "$ac_cv_prog_OBJDUMP" && break
7851 done
7852
7853 if test -z "$ac_cv_prog_OBJDUMP" ; then
7854   set dummy objdump
7855   if test $build = $host ; then
7856     OBJDUMP="$2"
7857   else
7858     OBJDUMP="${ncn_tool_prefix}$2"
7859   fi
7860 fi
7861
7862
7863
7864
7865
7866
7867
7868 # Target tools.
7869
7870 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7871 if test "${with_build_time_tools+set}" = set; then
7872   withval="$with_build_time_tools"
7873   case x"$withval" in
7874      x/*) ;;
7875      *)
7876        with_build_time_tools=
7877        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7878 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7879        ;;
7880    esac
7881 else
7882   with_build_time_tools=
7883 fi;
7884
7885
7886
7887 if test -n "$CC_FOR_TARGET"; then
7888   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7889 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7890   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7891 fi
7892
7893 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7894   for ncn_progname in cc gcc; do
7895     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7896 set dummy ${ncn_progname}; ac_word=$2
7897 echo "$as_me:$LINENO: checking for $ac_word" >&5
7898 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7899 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7900   echo $ECHO_N "(cached) $ECHO_C" >&6
7901 else
7902   if test -n "$CC_FOR_TARGET"; then
7903   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7904 else
7905 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7906 for as_dir in $PATH
7907 do
7908   IFS=$as_save_IFS
7909   test -z "$as_dir" && as_dir=.
7910   for ac_exec_ext in '' $ac_executable_extensions; do
7911   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7912     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7913     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7914     break 2
7915   fi
7916 done
7917 done
7918
7919 fi
7920 fi
7921 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7922 if test -n "$CC_FOR_TARGET"; then
7923   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7924 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7925 else
7926   echo "$as_me:$LINENO: result: no" >&5
7927 echo "${ECHO_T}no" >&6
7928 fi
7929
7930   done
7931 fi
7932
7933 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
7934   for ncn_progname in cc gcc; do
7935     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7936 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7937     if test -x $with_build_time_tools/${ncn_progname}; then
7938       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7939       echo "$as_me:$LINENO: result: yes" >&5
7940 echo "${ECHO_T}yes" >&6
7941       break
7942     else
7943       echo "$as_me:$LINENO: result: no" >&5
7944 echo "${ECHO_T}no" >&6
7945     fi
7946   done
7947 fi
7948
7949 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
7950   for ncn_progname in cc gcc; do
7951     if test -n "$ncn_target_tool_prefix"; then
7952       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
7953 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
7954 echo "$as_me:$LINENO: checking for $ac_word" >&5
7955 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7956 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7957   echo $ECHO_N "(cached) $ECHO_C" >&6
7958 else
7959   if test -n "$CC_FOR_TARGET"; then
7960   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7961 else
7962 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7963 for as_dir in $PATH
7964 do
7965   IFS=$as_save_IFS
7966   test -z "$as_dir" && as_dir=.
7967   for ac_exec_ext in '' $ac_executable_extensions; do
7968   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7969     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
7970     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7971     break 2
7972   fi
7973 done
7974 done
7975
7976 fi
7977 fi
7978 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7979 if test -n "$CC_FOR_TARGET"; then
7980   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7981 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7982 else
7983   echo "$as_me:$LINENO: result: no" >&5
7984 echo "${ECHO_T}no" >&6
7985 fi
7986
7987     fi
7988     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
7989       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7990 set dummy ${ncn_progname}; ac_word=$2
7991 echo "$as_me:$LINENO: checking for $ac_word" >&5
7992 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7993 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7994   echo $ECHO_N "(cached) $ECHO_C" >&6
7995 else
7996   if test -n "$CC_FOR_TARGET"; then
7997   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7998 else
7999 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8000 for as_dir in $PATH
8001 do
8002   IFS=$as_save_IFS
8003   test -z "$as_dir" && as_dir=.
8004   for ac_exec_ext in '' $ac_executable_extensions; do
8005   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8006     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8007     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8008     break 2
8009   fi
8010 done
8011 done
8012
8013 fi
8014 fi
8015 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8016 if test -n "$CC_FOR_TARGET"; then
8017   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8018 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8019 else
8020   echo "$as_me:$LINENO: result: no" >&5
8021 echo "${ECHO_T}no" >&6
8022 fi
8023
8024     fi
8025     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8026   done
8027 fi
8028
8029 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8030   set dummy cc gcc
8031   if test $build = $target ; then
8032     CC_FOR_TARGET="$2"
8033   else
8034     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8035   fi
8036 else
8037   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8038 fi
8039
8040
8041
8042 if test -n "$CXX_FOR_TARGET"; then
8043   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8044 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8045   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8046 fi
8047
8048 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8049   for ncn_progname in c++ g++ cxx gxx; do
8050     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8051 set dummy ${ncn_progname}; ac_word=$2
8052 echo "$as_me:$LINENO: checking for $ac_word" >&5
8053 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8054 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8055   echo $ECHO_N "(cached) $ECHO_C" >&6
8056 else
8057   if test -n "$CXX_FOR_TARGET"; then
8058   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8059 else
8060 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8061 for as_dir in $PATH
8062 do
8063   IFS=$as_save_IFS
8064   test -z "$as_dir" && as_dir=.
8065   for ac_exec_ext in '' $ac_executable_extensions; do
8066   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8067     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8068     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8069     break 2
8070   fi
8071 done
8072 done
8073
8074 fi
8075 fi
8076 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8077 if test -n "$CXX_FOR_TARGET"; then
8078   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8079 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8080 else
8081   echo "$as_me:$LINENO: result: no" >&5
8082 echo "${ECHO_T}no" >&6
8083 fi
8084
8085   done
8086 fi
8087
8088 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8089   for ncn_progname in c++ g++ cxx gxx; do
8090     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8091 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8092     if test -x $with_build_time_tools/${ncn_progname}; then
8093       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8094       echo "$as_me:$LINENO: result: yes" >&5
8095 echo "${ECHO_T}yes" >&6
8096       break
8097     else
8098       echo "$as_me:$LINENO: result: no" >&5
8099 echo "${ECHO_T}no" >&6
8100     fi
8101   done
8102 fi
8103
8104 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8105   for ncn_progname in c++ g++ cxx gxx; do
8106     if test -n "$ncn_target_tool_prefix"; then
8107       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8108 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8109 echo "$as_me:$LINENO: checking for $ac_word" >&5
8110 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8111 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8112   echo $ECHO_N "(cached) $ECHO_C" >&6
8113 else
8114   if test -n "$CXX_FOR_TARGET"; then
8115   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8116 else
8117 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8118 for as_dir in $PATH
8119 do
8120   IFS=$as_save_IFS
8121   test -z "$as_dir" && as_dir=.
8122   for ac_exec_ext in '' $ac_executable_extensions; do
8123   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8124     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8125     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8126     break 2
8127   fi
8128 done
8129 done
8130
8131 fi
8132 fi
8133 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8134 if test -n "$CXX_FOR_TARGET"; then
8135   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8136 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8137 else
8138   echo "$as_me:$LINENO: result: no" >&5
8139 echo "${ECHO_T}no" >&6
8140 fi
8141
8142     fi
8143     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8144       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8145 set dummy ${ncn_progname}; ac_word=$2
8146 echo "$as_me:$LINENO: checking for $ac_word" >&5
8147 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8148 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8149   echo $ECHO_N "(cached) $ECHO_C" >&6
8150 else
8151   if test -n "$CXX_FOR_TARGET"; then
8152   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8153 else
8154 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8155 for as_dir in $PATH
8156 do
8157   IFS=$as_save_IFS
8158   test -z "$as_dir" && as_dir=.
8159   for ac_exec_ext in '' $ac_executable_extensions; do
8160   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8161     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8162     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8163     break 2
8164   fi
8165 done
8166 done
8167
8168 fi
8169 fi
8170 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8171 if test -n "$CXX_FOR_TARGET"; then
8172   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8173 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8174 else
8175   echo "$as_me:$LINENO: result: no" >&5
8176 echo "${ECHO_T}no" >&6
8177 fi
8178
8179     fi
8180     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8181   done
8182 fi
8183
8184 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8185   set dummy c++ g++ cxx gxx
8186   if test $build = $target ; then
8187     CXX_FOR_TARGET="$2"
8188   else
8189     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8190   fi
8191 else
8192   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8193 fi
8194
8195
8196
8197 if test -n "$GCC_FOR_TARGET"; then
8198   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8199 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8200   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8201 fi
8202
8203 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8204   for ncn_progname in gcc; do
8205     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8206 set dummy ${ncn_progname}; ac_word=$2
8207 echo "$as_me:$LINENO: checking for $ac_word" >&5
8208 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8209 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8210   echo $ECHO_N "(cached) $ECHO_C" >&6
8211 else
8212   if test -n "$GCC_FOR_TARGET"; then
8213   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8214 else
8215 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8216 for as_dir in $PATH
8217 do
8218   IFS=$as_save_IFS
8219   test -z "$as_dir" && as_dir=.
8220   for ac_exec_ext in '' $ac_executable_extensions; do
8221   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8222     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8223     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8224     break 2
8225   fi
8226 done
8227 done
8228
8229 fi
8230 fi
8231 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8232 if test -n "$GCC_FOR_TARGET"; then
8233   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8234 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8235 else
8236   echo "$as_me:$LINENO: result: no" >&5
8237 echo "${ECHO_T}no" >&6
8238 fi
8239
8240   done
8241 fi
8242
8243 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8244   for ncn_progname in gcc; do
8245     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8246 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8247     if test -x $with_build_time_tools/${ncn_progname}; then
8248       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8249       echo "$as_me:$LINENO: result: yes" >&5
8250 echo "${ECHO_T}yes" >&6
8251       break
8252     else
8253       echo "$as_me:$LINENO: result: no" >&5
8254 echo "${ECHO_T}no" >&6
8255     fi
8256   done
8257 fi
8258
8259 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8260   for ncn_progname in gcc; do
8261     if test -n "$ncn_target_tool_prefix"; then
8262       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8263 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8264 echo "$as_me:$LINENO: checking for $ac_word" >&5
8265 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8266 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8267   echo $ECHO_N "(cached) $ECHO_C" >&6
8268 else
8269   if test -n "$GCC_FOR_TARGET"; then
8270   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8271 else
8272 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8273 for as_dir in $PATH
8274 do
8275   IFS=$as_save_IFS
8276   test -z "$as_dir" && as_dir=.
8277   for ac_exec_ext in '' $ac_executable_extensions; do
8278   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8279     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8280     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8281     break 2
8282   fi
8283 done
8284 done
8285
8286 fi
8287 fi
8288 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8289 if test -n "$GCC_FOR_TARGET"; then
8290   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8291 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8292 else
8293   echo "$as_me:$LINENO: result: no" >&5
8294 echo "${ECHO_T}no" >&6
8295 fi
8296
8297     fi
8298     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8299       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8300 set dummy ${ncn_progname}; ac_word=$2
8301 echo "$as_me:$LINENO: checking for $ac_word" >&5
8302 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8303 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8304   echo $ECHO_N "(cached) $ECHO_C" >&6
8305 else
8306   if test -n "$GCC_FOR_TARGET"; then
8307   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8308 else
8309 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8310 for as_dir in $PATH
8311 do
8312   IFS=$as_save_IFS
8313   test -z "$as_dir" && as_dir=.
8314   for ac_exec_ext in '' $ac_executable_extensions; do
8315   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8316     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8317     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8318     break 2
8319   fi
8320 done
8321 done
8322
8323 fi
8324 fi
8325 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8326 if test -n "$GCC_FOR_TARGET"; then
8327   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8328 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8329 else
8330   echo "$as_me:$LINENO: result: no" >&5
8331 echo "${ECHO_T}no" >&6
8332 fi
8333
8334     fi
8335     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8336   done
8337 fi
8338
8339 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8340   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8341 else
8342   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8343 fi
8344
8345
8346
8347 if test -n "$GCJ_FOR_TARGET"; then
8348   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8349 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8350   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8351 fi
8352
8353 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8354   for ncn_progname in gcj; do
8355     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8356 set dummy ${ncn_progname}; ac_word=$2
8357 echo "$as_me:$LINENO: checking for $ac_word" >&5
8358 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8359 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8360   echo $ECHO_N "(cached) $ECHO_C" >&6
8361 else
8362   if test -n "$GCJ_FOR_TARGET"; then
8363   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8364 else
8365 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8366 for as_dir in $PATH
8367 do
8368   IFS=$as_save_IFS
8369   test -z "$as_dir" && as_dir=.
8370   for ac_exec_ext in '' $ac_executable_extensions; do
8371   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8372     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8373     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8374     break 2
8375   fi
8376 done
8377 done
8378
8379 fi
8380 fi
8381 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8382 if test -n "$GCJ_FOR_TARGET"; then
8383   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8384 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8385 else
8386   echo "$as_me:$LINENO: result: no" >&5
8387 echo "${ECHO_T}no" >&6
8388 fi
8389
8390   done
8391 fi
8392
8393 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8394   for ncn_progname in gcj; do
8395     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8396 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8397     if test -x $with_build_time_tools/${ncn_progname}; then
8398       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8399       echo "$as_me:$LINENO: result: yes" >&5
8400 echo "${ECHO_T}yes" >&6
8401       break
8402     else
8403       echo "$as_me:$LINENO: result: no" >&5
8404 echo "${ECHO_T}no" >&6
8405     fi
8406   done
8407 fi
8408
8409 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8410   for ncn_progname in gcj; do
8411     if test -n "$ncn_target_tool_prefix"; then
8412       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8413 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8414 echo "$as_me:$LINENO: checking for $ac_word" >&5
8415 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8416 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8417   echo $ECHO_N "(cached) $ECHO_C" >&6
8418 else
8419   if test -n "$GCJ_FOR_TARGET"; then
8420   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8421 else
8422 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8423 for as_dir in $PATH
8424 do
8425   IFS=$as_save_IFS
8426   test -z "$as_dir" && as_dir=.
8427   for ac_exec_ext in '' $ac_executable_extensions; do
8428   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8429     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8430     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8431     break 2
8432   fi
8433 done
8434 done
8435
8436 fi
8437 fi
8438 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8439 if test -n "$GCJ_FOR_TARGET"; then
8440   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8441 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8442 else
8443   echo "$as_me:$LINENO: result: no" >&5
8444 echo "${ECHO_T}no" >&6
8445 fi
8446
8447     fi
8448     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8449       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8450 set dummy ${ncn_progname}; ac_word=$2
8451 echo "$as_me:$LINENO: checking for $ac_word" >&5
8452 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8453 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8454   echo $ECHO_N "(cached) $ECHO_C" >&6
8455 else
8456   if test -n "$GCJ_FOR_TARGET"; then
8457   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8458 else
8459 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8460 for as_dir in $PATH
8461 do
8462   IFS=$as_save_IFS
8463   test -z "$as_dir" && as_dir=.
8464   for ac_exec_ext in '' $ac_executable_extensions; do
8465   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8466     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8467     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8468     break 2
8469   fi
8470 done
8471 done
8472
8473 fi
8474 fi
8475 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8476 if test -n "$GCJ_FOR_TARGET"; then
8477   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8478 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8479 else
8480   echo "$as_me:$LINENO: result: no" >&5
8481 echo "${ECHO_T}no" >&6
8482 fi
8483
8484     fi
8485     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8486   done
8487 fi
8488
8489 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8490   set dummy gcj
8491   if test $build = $target ; then
8492     GCJ_FOR_TARGET="$2"
8493   else
8494     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8495   fi
8496 else
8497   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8498 fi
8499
8500
8501
8502 if test -n "$GFORTRAN_FOR_TARGET"; then
8503   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8504 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8505   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8506 fi
8507
8508 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8509   for ncn_progname in gfortran; do
8510     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8511 set dummy ${ncn_progname}; ac_word=$2
8512 echo "$as_me:$LINENO: checking for $ac_word" >&5
8513 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8514 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8515   echo $ECHO_N "(cached) $ECHO_C" >&6
8516 else
8517   if test -n "$GFORTRAN_FOR_TARGET"; then
8518   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8519 else
8520 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8521 for as_dir in $PATH
8522 do
8523   IFS=$as_save_IFS
8524   test -z "$as_dir" && as_dir=.
8525   for ac_exec_ext in '' $ac_executable_extensions; do
8526   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8527     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8528     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8529     break 2
8530   fi
8531 done
8532 done
8533
8534 fi
8535 fi
8536 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8537 if test -n "$GFORTRAN_FOR_TARGET"; then
8538   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8539 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8540 else
8541   echo "$as_me:$LINENO: result: no" >&5
8542 echo "${ECHO_T}no" >&6
8543 fi
8544
8545   done
8546 fi
8547
8548 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8549   for ncn_progname in gfortran; do
8550     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8551 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8552     if test -x $with_build_time_tools/${ncn_progname}; then
8553       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8554       echo "$as_me:$LINENO: result: yes" >&5
8555 echo "${ECHO_T}yes" >&6
8556       break
8557     else
8558       echo "$as_me:$LINENO: result: no" >&5
8559 echo "${ECHO_T}no" >&6
8560     fi
8561   done
8562 fi
8563
8564 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8565   for ncn_progname in gfortran; do
8566     if test -n "$ncn_target_tool_prefix"; then
8567       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8568 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8569 echo "$as_me:$LINENO: checking for $ac_word" >&5
8570 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8571 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8572   echo $ECHO_N "(cached) $ECHO_C" >&6
8573 else
8574   if test -n "$GFORTRAN_FOR_TARGET"; then
8575   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8576 else
8577 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8578 for as_dir in $PATH
8579 do
8580   IFS=$as_save_IFS
8581   test -z "$as_dir" && as_dir=.
8582   for ac_exec_ext in '' $ac_executable_extensions; do
8583   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8584     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8585     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8586     break 2
8587   fi
8588 done
8589 done
8590
8591 fi
8592 fi
8593 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8594 if test -n "$GFORTRAN_FOR_TARGET"; then
8595   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8596 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8597 else
8598   echo "$as_me:$LINENO: result: no" >&5
8599 echo "${ECHO_T}no" >&6
8600 fi
8601
8602     fi
8603     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8604       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8605 set dummy ${ncn_progname}; ac_word=$2
8606 echo "$as_me:$LINENO: checking for $ac_word" >&5
8607 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8608 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8609   echo $ECHO_N "(cached) $ECHO_C" >&6
8610 else
8611   if test -n "$GFORTRAN_FOR_TARGET"; then
8612   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8613 else
8614 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8615 for as_dir in $PATH
8616 do
8617   IFS=$as_save_IFS
8618   test -z "$as_dir" && as_dir=.
8619   for ac_exec_ext in '' $ac_executable_extensions; do
8620   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8621     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8622     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8623     break 2
8624   fi
8625 done
8626 done
8627
8628 fi
8629 fi
8630 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8631 if test -n "$GFORTRAN_FOR_TARGET"; then
8632   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8633 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8634 else
8635   echo "$as_me:$LINENO: result: no" >&5
8636 echo "${ECHO_T}no" >&6
8637 fi
8638
8639     fi
8640     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8641   done
8642 fi
8643
8644 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8645   set dummy gfortran
8646   if test $build = $target ; then
8647     GFORTRAN_FOR_TARGET="$2"
8648   else
8649     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8650   fi
8651 else
8652   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8653 fi
8654
8655
8656
8657 cat > conftest.c << \EOF
8658 #ifdef __GNUC__
8659   gcc_yay;
8660 #endif
8661 EOF
8662 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8663   have_gcc_for_target=yes
8664 else
8665   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8666   have_gcc_for_target=no
8667 fi
8668 rm conftest.c
8669
8670
8671
8672
8673 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8674   if test -n "$with_build_time_tools"; then
8675     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8676 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8677     if test -x $with_build_time_tools/ar; then
8678       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8679       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8680       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8681 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8682     else
8683       echo "$as_me:$LINENO: result: no" >&5
8684 echo "${ECHO_T}no" >&6
8685     fi
8686   elif test $build != $host && test $have_gcc_for_target = yes; then
8687     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8688     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8689     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8690   fi
8691 fi
8692 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8693   # Extract the first word of "ar", so it can be a program name with args.
8694 set dummy ar; ac_word=$2
8695 echo "$as_me:$LINENO: checking for $ac_word" >&5
8696 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8697 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8698   echo $ECHO_N "(cached) $ECHO_C" >&6
8699 else
8700   case $AR_FOR_TARGET in
8701   [\\/]* | ?:[\\/]*)
8702   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8703   ;;
8704   *)
8705   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8706 for as_dir in $gcc_cv_tool_dirs
8707 do
8708   IFS=$as_save_IFS
8709   test -z "$as_dir" && as_dir=.
8710   for ac_exec_ext in '' $ac_executable_extensions; do
8711   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8712     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8713     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8714     break 2
8715   fi
8716 done
8717 done
8718
8719   ;;
8720 esac
8721 fi
8722 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8723
8724 if test -n "$AR_FOR_TARGET"; then
8725   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8726 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8727 else
8728   echo "$as_me:$LINENO: result: no" >&5
8729 echo "${ECHO_T}no" >&6
8730 fi
8731
8732 fi
8733 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8734
8735
8736 if test -n "$AR_FOR_TARGET"; then
8737   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8738 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8739   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8740 fi
8741
8742 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8743   for ncn_progname in ar; do
8744     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8745 set dummy ${ncn_progname}; ac_word=$2
8746 echo "$as_me:$LINENO: checking for $ac_word" >&5
8747 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8748 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8749   echo $ECHO_N "(cached) $ECHO_C" >&6
8750 else
8751   if test -n "$AR_FOR_TARGET"; then
8752   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8753 else
8754 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8755 for as_dir in $PATH
8756 do
8757   IFS=$as_save_IFS
8758   test -z "$as_dir" && as_dir=.
8759   for ac_exec_ext in '' $ac_executable_extensions; do
8760   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8761     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8762     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8763     break 2
8764   fi
8765 done
8766 done
8767
8768 fi
8769 fi
8770 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8771 if test -n "$AR_FOR_TARGET"; then
8772   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8773 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8774 else
8775   echo "$as_me:$LINENO: result: no" >&5
8776 echo "${ECHO_T}no" >&6
8777 fi
8778
8779   done
8780 fi
8781
8782 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8783   for ncn_progname in ar; do
8784     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8785 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8786     if test -x $with_build_time_tools/${ncn_progname}; then
8787       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8788       echo "$as_me:$LINENO: result: yes" >&5
8789 echo "${ECHO_T}yes" >&6
8790       break
8791     else
8792       echo "$as_me:$LINENO: result: no" >&5
8793 echo "${ECHO_T}no" >&6
8794     fi
8795   done
8796 fi
8797
8798 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8799   for ncn_progname in ar; do
8800     if test -n "$ncn_target_tool_prefix"; then
8801       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8802 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8803 echo "$as_me:$LINENO: checking for $ac_word" >&5
8804 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8805 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8806   echo $ECHO_N "(cached) $ECHO_C" >&6
8807 else
8808   if test -n "$AR_FOR_TARGET"; then
8809   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8810 else
8811 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8812 for as_dir in $PATH
8813 do
8814   IFS=$as_save_IFS
8815   test -z "$as_dir" && as_dir=.
8816   for ac_exec_ext in '' $ac_executable_extensions; do
8817   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8818     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8819     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8820     break 2
8821   fi
8822 done
8823 done
8824
8825 fi
8826 fi
8827 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8828 if test -n "$AR_FOR_TARGET"; then
8829   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8830 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8831 else
8832   echo "$as_me:$LINENO: result: no" >&5
8833 echo "${ECHO_T}no" >&6
8834 fi
8835
8836     fi
8837     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8838       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8839 set dummy ${ncn_progname}; ac_word=$2
8840 echo "$as_me:$LINENO: checking for $ac_word" >&5
8841 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8842 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8843   echo $ECHO_N "(cached) $ECHO_C" >&6
8844 else
8845   if test -n "$AR_FOR_TARGET"; then
8846   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8847 else
8848 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8849 for as_dir in $PATH
8850 do
8851   IFS=$as_save_IFS
8852   test -z "$as_dir" && as_dir=.
8853   for ac_exec_ext in '' $ac_executable_extensions; do
8854   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8855     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8856     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8857     break 2
8858   fi
8859 done
8860 done
8861
8862 fi
8863 fi
8864 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8865 if test -n "$AR_FOR_TARGET"; then
8866   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8867 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8868 else
8869   echo "$as_me:$LINENO: result: no" >&5
8870 echo "${ECHO_T}no" >&6
8871 fi
8872
8873     fi
8874     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8875   done
8876 fi
8877
8878 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8879   set dummy ar
8880   if test $build = $target ; then
8881     AR_FOR_TARGET="$2"
8882   else
8883     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8884   fi
8885 else
8886   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
8887 fi
8888
8889 else
8890   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8891 fi
8892
8893
8894
8895
8896 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8897   if test -n "$with_build_time_tools"; then
8898     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
8899 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
8900     if test -x $with_build_time_tools/as; then
8901       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
8902       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8903       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
8904 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
8905     else
8906       echo "$as_me:$LINENO: result: no" >&5
8907 echo "${ECHO_T}no" >&6
8908     fi
8909   elif test $build != $host && test $have_gcc_for_target = yes; then
8910     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
8911     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
8912     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8913   fi
8914 fi
8915 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8916   # Extract the first word of "as", so it can be a program name with args.
8917 set dummy as; ac_word=$2
8918 echo "$as_me:$LINENO: checking for $ac_word" >&5
8919 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8920 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
8921   echo $ECHO_N "(cached) $ECHO_C" >&6
8922 else
8923   case $AS_FOR_TARGET in
8924   [\\/]* | ?:[\\/]*)
8925   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
8926   ;;
8927   *)
8928   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8929 for as_dir in $gcc_cv_tool_dirs
8930 do
8931   IFS=$as_save_IFS
8932   test -z "$as_dir" && as_dir=.
8933   for ac_exec_ext in '' $ac_executable_extensions; do
8934   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8935     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8936     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8937     break 2
8938   fi
8939 done
8940 done
8941
8942   ;;
8943 esac
8944 fi
8945 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8946
8947 if test -n "$AS_FOR_TARGET"; then
8948   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8949 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8950 else
8951   echo "$as_me:$LINENO: result: no" >&5
8952 echo "${ECHO_T}no" >&6
8953 fi
8954
8955 fi
8956 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8957
8958
8959 if test -n "$AS_FOR_TARGET"; then
8960   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
8961 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8962   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8963 fi
8964
8965 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8966   for ncn_progname in as; do
8967     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8968 set dummy ${ncn_progname}; ac_word=$2
8969 echo "$as_me:$LINENO: checking for $ac_word" >&5
8970 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8971 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8972   echo $ECHO_N "(cached) $ECHO_C" >&6
8973 else
8974   if test -n "$AS_FOR_TARGET"; then
8975   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8976 else
8977 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8978 for as_dir in $PATH
8979 do
8980   IFS=$as_save_IFS
8981   test -z "$as_dir" && as_dir=.
8982   for ac_exec_ext in '' $ac_executable_extensions; do
8983   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8984     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
8985     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8986     break 2
8987   fi
8988 done
8989 done
8990
8991 fi
8992 fi
8993 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8994 if test -n "$AS_FOR_TARGET"; then
8995   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8996 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8997 else
8998   echo "$as_me:$LINENO: result: no" >&5
8999 echo "${ECHO_T}no" >&6
9000 fi
9001
9002   done
9003 fi
9004
9005 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9006   for ncn_progname in as; do
9007     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9008 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9009     if test -x $with_build_time_tools/${ncn_progname}; then
9010       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9011       echo "$as_me:$LINENO: result: yes" >&5
9012 echo "${ECHO_T}yes" >&6
9013       break
9014     else
9015       echo "$as_me:$LINENO: result: no" >&5
9016 echo "${ECHO_T}no" >&6
9017     fi
9018   done
9019 fi
9020
9021 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9022   for ncn_progname in as; do
9023     if test -n "$ncn_target_tool_prefix"; then
9024       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9025 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9026 echo "$as_me:$LINENO: checking for $ac_word" >&5
9027 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9028 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9029   echo $ECHO_N "(cached) $ECHO_C" >&6
9030 else
9031   if test -n "$AS_FOR_TARGET"; then
9032   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9033 else
9034 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9035 for as_dir in $PATH
9036 do
9037   IFS=$as_save_IFS
9038   test -z "$as_dir" && as_dir=.
9039   for ac_exec_ext in '' $ac_executable_extensions; do
9040   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9041     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9042     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9043     break 2
9044   fi
9045 done
9046 done
9047
9048 fi
9049 fi
9050 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9051 if test -n "$AS_FOR_TARGET"; then
9052   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9053 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9054 else
9055   echo "$as_me:$LINENO: result: no" >&5
9056 echo "${ECHO_T}no" >&6
9057 fi
9058
9059     fi
9060     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9061       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9062 set dummy ${ncn_progname}; ac_word=$2
9063 echo "$as_me:$LINENO: checking for $ac_word" >&5
9064 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9065 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9066   echo $ECHO_N "(cached) $ECHO_C" >&6
9067 else
9068   if test -n "$AS_FOR_TARGET"; then
9069   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9070 else
9071 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9072 for as_dir in $PATH
9073 do
9074   IFS=$as_save_IFS
9075   test -z "$as_dir" && as_dir=.
9076   for ac_exec_ext in '' $ac_executable_extensions; do
9077   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9078     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9079     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9080     break 2
9081   fi
9082 done
9083 done
9084
9085 fi
9086 fi
9087 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9088 if test -n "$AS_FOR_TARGET"; then
9089   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9090 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9091 else
9092   echo "$as_me:$LINENO: result: no" >&5
9093 echo "${ECHO_T}no" >&6
9094 fi
9095
9096     fi
9097     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9098   done
9099 fi
9100
9101 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9102   set dummy as
9103   if test $build = $target ; then
9104     AS_FOR_TARGET="$2"
9105   else
9106     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9107   fi
9108 else
9109   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9110 fi
9111
9112 else
9113   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9114 fi
9115
9116
9117
9118
9119 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9120   if test -n "$with_build_time_tools"; then
9121     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9122 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9123     if test -x $with_build_time_tools/dlltool; then
9124       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9125       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9126       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9127 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9128     else
9129       echo "$as_me:$LINENO: result: no" >&5
9130 echo "${ECHO_T}no" >&6
9131     fi
9132   elif test $build != $host && test $have_gcc_for_target = yes; then
9133     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9134     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9135     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9136   fi
9137 fi
9138 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9139   # Extract the first word of "dlltool", so it can be a program name with args.
9140 set dummy dlltool; ac_word=$2
9141 echo "$as_me:$LINENO: checking for $ac_word" >&5
9142 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9143 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9144   echo $ECHO_N "(cached) $ECHO_C" >&6
9145 else
9146   case $DLLTOOL_FOR_TARGET in
9147   [\\/]* | ?:[\\/]*)
9148   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9149   ;;
9150   *)
9151   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9152 for as_dir in $gcc_cv_tool_dirs
9153 do
9154   IFS=$as_save_IFS
9155   test -z "$as_dir" && as_dir=.
9156   for ac_exec_ext in '' $ac_executable_extensions; do
9157   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9158     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9159     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9160     break 2
9161   fi
9162 done
9163 done
9164
9165   ;;
9166 esac
9167 fi
9168 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9169
9170 if test -n "$DLLTOOL_FOR_TARGET"; then
9171   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9172 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9173 else
9174   echo "$as_me:$LINENO: result: no" >&5
9175 echo "${ECHO_T}no" >&6
9176 fi
9177
9178 fi
9179 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9180
9181
9182 if test -n "$DLLTOOL_FOR_TARGET"; then
9183   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9184 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9185   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9186 fi
9187
9188 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9189   for ncn_progname in dlltool; do
9190     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9191 set dummy ${ncn_progname}; ac_word=$2
9192 echo "$as_me:$LINENO: checking for $ac_word" >&5
9193 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9194 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9195   echo $ECHO_N "(cached) $ECHO_C" >&6
9196 else
9197   if test -n "$DLLTOOL_FOR_TARGET"; then
9198   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9199 else
9200 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9201 for as_dir in $PATH
9202 do
9203   IFS=$as_save_IFS
9204   test -z "$as_dir" && as_dir=.
9205   for ac_exec_ext in '' $ac_executable_extensions; do
9206   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9207     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9208     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9209     break 2
9210   fi
9211 done
9212 done
9213
9214 fi
9215 fi
9216 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9217 if test -n "$DLLTOOL_FOR_TARGET"; then
9218   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9219 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9220 else
9221   echo "$as_me:$LINENO: result: no" >&5
9222 echo "${ECHO_T}no" >&6
9223 fi
9224
9225   done
9226 fi
9227
9228 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9229   for ncn_progname in dlltool; do
9230     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9231 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9232     if test -x $with_build_time_tools/${ncn_progname}; then
9233       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9234       echo "$as_me:$LINENO: result: yes" >&5
9235 echo "${ECHO_T}yes" >&6
9236       break
9237     else
9238       echo "$as_me:$LINENO: result: no" >&5
9239 echo "${ECHO_T}no" >&6
9240     fi
9241   done
9242 fi
9243
9244 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9245   for ncn_progname in dlltool; do
9246     if test -n "$ncn_target_tool_prefix"; then
9247       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9248 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9249 echo "$as_me:$LINENO: checking for $ac_word" >&5
9250 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9251 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9252   echo $ECHO_N "(cached) $ECHO_C" >&6
9253 else
9254   if test -n "$DLLTOOL_FOR_TARGET"; then
9255   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9256 else
9257 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9258 for as_dir in $PATH
9259 do
9260   IFS=$as_save_IFS
9261   test -z "$as_dir" && as_dir=.
9262   for ac_exec_ext in '' $ac_executable_extensions; do
9263   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9264     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9265     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9266     break 2
9267   fi
9268 done
9269 done
9270
9271 fi
9272 fi
9273 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9274 if test -n "$DLLTOOL_FOR_TARGET"; then
9275   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9276 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9277 else
9278   echo "$as_me:$LINENO: result: no" >&5
9279 echo "${ECHO_T}no" >&6
9280 fi
9281
9282     fi
9283     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9284       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9285 set dummy ${ncn_progname}; ac_word=$2
9286 echo "$as_me:$LINENO: checking for $ac_word" >&5
9287 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9288 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9289   echo $ECHO_N "(cached) $ECHO_C" >&6
9290 else
9291   if test -n "$DLLTOOL_FOR_TARGET"; then
9292   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9293 else
9294 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9295 for as_dir in $PATH
9296 do
9297   IFS=$as_save_IFS
9298   test -z "$as_dir" && as_dir=.
9299   for ac_exec_ext in '' $ac_executable_extensions; do
9300   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9301     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9302     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9303     break 2
9304   fi
9305 done
9306 done
9307
9308 fi
9309 fi
9310 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9311 if test -n "$DLLTOOL_FOR_TARGET"; then
9312   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9313 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9314 else
9315   echo "$as_me:$LINENO: result: no" >&5
9316 echo "${ECHO_T}no" >&6
9317 fi
9318
9319     fi
9320     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9321   done
9322 fi
9323
9324 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9325   set dummy dlltool
9326   if test $build = $target ; then
9327     DLLTOOL_FOR_TARGET="$2"
9328   else
9329     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9330   fi
9331 else
9332   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9333 fi
9334
9335 else
9336   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9337 fi
9338
9339
9340
9341
9342 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9343   if test -n "$with_build_time_tools"; then
9344     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9345 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9346     if test -x $with_build_time_tools/ld; then
9347       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9348       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9349       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9350 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9351     else
9352       echo "$as_me:$LINENO: result: no" >&5
9353 echo "${ECHO_T}no" >&6
9354     fi
9355   elif test $build != $host && test $have_gcc_for_target = yes; then
9356     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9357     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9358     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9359   fi
9360 fi
9361 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9362   # Extract the first word of "ld", so it can be a program name with args.
9363 set dummy ld; ac_word=$2
9364 echo "$as_me:$LINENO: checking for $ac_word" >&5
9365 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9366 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9367   echo $ECHO_N "(cached) $ECHO_C" >&6
9368 else
9369   case $LD_FOR_TARGET in
9370   [\\/]* | ?:[\\/]*)
9371   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9372   ;;
9373   *)
9374   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9375 for as_dir in $gcc_cv_tool_dirs
9376 do
9377   IFS=$as_save_IFS
9378   test -z "$as_dir" && as_dir=.
9379   for ac_exec_ext in '' $ac_executable_extensions; do
9380   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9381     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9382     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9383     break 2
9384   fi
9385 done
9386 done
9387
9388   ;;
9389 esac
9390 fi
9391 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9392
9393 if test -n "$LD_FOR_TARGET"; then
9394   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9395 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9396 else
9397   echo "$as_me:$LINENO: result: no" >&5
9398 echo "${ECHO_T}no" >&6
9399 fi
9400
9401 fi
9402 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9403
9404
9405 if test -n "$LD_FOR_TARGET"; then
9406   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9407 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9408   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9409 fi
9410
9411 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9412   for ncn_progname in ld; do
9413     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9414 set dummy ${ncn_progname}; ac_word=$2
9415 echo "$as_me:$LINENO: checking for $ac_word" >&5
9416 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9417 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9418   echo $ECHO_N "(cached) $ECHO_C" >&6
9419 else
9420   if test -n "$LD_FOR_TARGET"; then
9421   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9422 else
9423 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9424 for as_dir in $PATH
9425 do
9426   IFS=$as_save_IFS
9427   test -z "$as_dir" && as_dir=.
9428   for ac_exec_ext in '' $ac_executable_extensions; do
9429   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9430     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9431     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9432     break 2
9433   fi
9434 done
9435 done
9436
9437 fi
9438 fi
9439 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9440 if test -n "$LD_FOR_TARGET"; then
9441   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9442 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9443 else
9444   echo "$as_me:$LINENO: result: no" >&5
9445 echo "${ECHO_T}no" >&6
9446 fi
9447
9448   done
9449 fi
9450
9451 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9452   for ncn_progname in ld; do
9453     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9454 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9455     if test -x $with_build_time_tools/${ncn_progname}; then
9456       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9457       echo "$as_me:$LINENO: result: yes" >&5
9458 echo "${ECHO_T}yes" >&6
9459       break
9460     else
9461       echo "$as_me:$LINENO: result: no" >&5
9462 echo "${ECHO_T}no" >&6
9463     fi
9464   done
9465 fi
9466
9467 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9468   for ncn_progname in ld; do
9469     if test -n "$ncn_target_tool_prefix"; then
9470       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9471 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9472 echo "$as_me:$LINENO: checking for $ac_word" >&5
9473 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9474 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9475   echo $ECHO_N "(cached) $ECHO_C" >&6
9476 else
9477   if test -n "$LD_FOR_TARGET"; then
9478   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9479 else
9480 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9481 for as_dir in $PATH
9482 do
9483   IFS=$as_save_IFS
9484   test -z "$as_dir" && as_dir=.
9485   for ac_exec_ext in '' $ac_executable_extensions; do
9486   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9487     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9488     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9489     break 2
9490   fi
9491 done
9492 done
9493
9494 fi
9495 fi
9496 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9497 if test -n "$LD_FOR_TARGET"; then
9498   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9499 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9500 else
9501   echo "$as_me:$LINENO: result: no" >&5
9502 echo "${ECHO_T}no" >&6
9503 fi
9504
9505     fi
9506     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9507       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9508 set dummy ${ncn_progname}; ac_word=$2
9509 echo "$as_me:$LINENO: checking for $ac_word" >&5
9510 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9511 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9512   echo $ECHO_N "(cached) $ECHO_C" >&6
9513 else
9514   if test -n "$LD_FOR_TARGET"; then
9515   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9516 else
9517 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9518 for as_dir in $PATH
9519 do
9520   IFS=$as_save_IFS
9521   test -z "$as_dir" && as_dir=.
9522   for ac_exec_ext in '' $ac_executable_extensions; do
9523   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9524     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9525     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9526     break 2
9527   fi
9528 done
9529 done
9530
9531 fi
9532 fi
9533 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9534 if test -n "$LD_FOR_TARGET"; then
9535   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9536 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9537 else
9538   echo "$as_me:$LINENO: result: no" >&5
9539 echo "${ECHO_T}no" >&6
9540 fi
9541
9542     fi
9543     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9544   done
9545 fi
9546
9547 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9548   set dummy ld
9549   if test $build = $target ; then
9550     LD_FOR_TARGET="$2"
9551   else
9552     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9553   fi
9554 else
9555   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9556 fi
9557
9558 else
9559   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9560 fi
9561
9562
9563
9564
9565 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9566   if test -n "$with_build_time_tools"; then
9567     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9568 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9569     if test -x $with_build_time_tools/lipo; then
9570       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9571       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9572       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9573 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9574     else
9575       echo "$as_me:$LINENO: result: no" >&5
9576 echo "${ECHO_T}no" >&6
9577     fi
9578   elif test $build != $host && test $have_gcc_for_target = yes; then
9579     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9580     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9581     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9582   fi
9583 fi
9584 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9585   # Extract the first word of "lipo", so it can be a program name with args.
9586 set dummy lipo; ac_word=$2
9587 echo "$as_me:$LINENO: checking for $ac_word" >&5
9588 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9589 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9590   echo $ECHO_N "(cached) $ECHO_C" >&6
9591 else
9592   case $LIPO_FOR_TARGET in
9593   [\\/]* | ?:[\\/]*)
9594   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9595   ;;
9596   *)
9597   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9598 for as_dir in $gcc_cv_tool_dirs
9599 do
9600   IFS=$as_save_IFS
9601   test -z "$as_dir" && as_dir=.
9602   for ac_exec_ext in '' $ac_executable_extensions; do
9603   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9604     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9605     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9606     break 2
9607   fi
9608 done
9609 done
9610
9611   ;;
9612 esac
9613 fi
9614 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9615
9616 if test -n "$LIPO_FOR_TARGET"; then
9617   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9618 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9619 else
9620   echo "$as_me:$LINENO: result: no" >&5
9621 echo "${ECHO_T}no" >&6
9622 fi
9623
9624 fi
9625 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9626
9627
9628 if test -n "$LIPO_FOR_TARGET"; then
9629   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9630 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9631   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9632 fi
9633
9634 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9635   for ncn_progname in lipo; do
9636     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9637 set dummy ${ncn_progname}; ac_word=$2
9638 echo "$as_me:$LINENO: checking for $ac_word" >&5
9639 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9640 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9641   echo $ECHO_N "(cached) $ECHO_C" >&6
9642 else
9643   if test -n "$LIPO_FOR_TARGET"; then
9644   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9645 else
9646 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9647 for as_dir in $PATH
9648 do
9649   IFS=$as_save_IFS
9650   test -z "$as_dir" && as_dir=.
9651   for ac_exec_ext in '' $ac_executable_extensions; do
9652   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9653     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9654     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9655     break 2
9656   fi
9657 done
9658 done
9659
9660 fi
9661 fi
9662 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9663 if test -n "$LIPO_FOR_TARGET"; then
9664   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9665 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9666 else
9667   echo "$as_me:$LINENO: result: no" >&5
9668 echo "${ECHO_T}no" >&6
9669 fi
9670
9671   done
9672 fi
9673
9674 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9675   for ncn_progname in lipo; do
9676     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9677 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9678     if test -x $with_build_time_tools/${ncn_progname}; then
9679       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9680       echo "$as_me:$LINENO: result: yes" >&5
9681 echo "${ECHO_T}yes" >&6
9682       break
9683     else
9684       echo "$as_me:$LINENO: result: no" >&5
9685 echo "${ECHO_T}no" >&6
9686     fi
9687   done
9688 fi
9689
9690 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9691   for ncn_progname in lipo; do
9692     if test -n "$ncn_target_tool_prefix"; then
9693       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9694 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9695 echo "$as_me:$LINENO: checking for $ac_word" >&5
9696 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9697 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9698   echo $ECHO_N "(cached) $ECHO_C" >&6
9699 else
9700   if test -n "$LIPO_FOR_TARGET"; then
9701   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9702 else
9703 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9704 for as_dir in $PATH
9705 do
9706   IFS=$as_save_IFS
9707   test -z "$as_dir" && as_dir=.
9708   for ac_exec_ext in '' $ac_executable_extensions; do
9709   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9710     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9711     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9712     break 2
9713   fi
9714 done
9715 done
9716
9717 fi
9718 fi
9719 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9720 if test -n "$LIPO_FOR_TARGET"; then
9721   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9722 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9723 else
9724   echo "$as_me:$LINENO: result: no" >&5
9725 echo "${ECHO_T}no" >&6
9726 fi
9727
9728     fi
9729     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9730       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9731 set dummy ${ncn_progname}; ac_word=$2
9732 echo "$as_me:$LINENO: checking for $ac_word" >&5
9733 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9734 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9735   echo $ECHO_N "(cached) $ECHO_C" >&6
9736 else
9737   if test -n "$LIPO_FOR_TARGET"; then
9738   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9739 else
9740 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9741 for as_dir in $PATH
9742 do
9743   IFS=$as_save_IFS
9744   test -z "$as_dir" && as_dir=.
9745   for ac_exec_ext in '' $ac_executable_extensions; do
9746   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9747     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9748     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9749     break 2
9750   fi
9751 done
9752 done
9753
9754 fi
9755 fi
9756 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9757 if test -n "$LIPO_FOR_TARGET"; then
9758   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9759 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9760 else
9761   echo "$as_me:$LINENO: result: no" >&5
9762 echo "${ECHO_T}no" >&6
9763 fi
9764
9765     fi
9766     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9767   done
9768 fi
9769
9770 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9771   set dummy lipo
9772   if test $build = $target ; then
9773     LIPO_FOR_TARGET="$2"
9774   else
9775     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9776   fi
9777 else
9778   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9779 fi
9780
9781 else
9782   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9783 fi
9784
9785
9786
9787
9788 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9789   if test -n "$with_build_time_tools"; then
9790     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9791 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9792     if test -x $with_build_time_tools/nm; then
9793       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9794       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9795       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9796 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9797     else
9798       echo "$as_me:$LINENO: result: no" >&5
9799 echo "${ECHO_T}no" >&6
9800     fi
9801   elif test $build != $host && test $have_gcc_for_target = yes; then
9802     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9803     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9804     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9805   fi
9806 fi
9807 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9808   # Extract the first word of "nm", so it can be a program name with args.
9809 set dummy nm; ac_word=$2
9810 echo "$as_me:$LINENO: checking for $ac_word" >&5
9811 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9812 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9813   echo $ECHO_N "(cached) $ECHO_C" >&6
9814 else
9815   case $NM_FOR_TARGET in
9816   [\\/]* | ?:[\\/]*)
9817   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9818   ;;
9819   *)
9820   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9821 for as_dir in $gcc_cv_tool_dirs
9822 do
9823   IFS=$as_save_IFS
9824   test -z "$as_dir" && as_dir=.
9825   for ac_exec_ext in '' $ac_executable_extensions; do
9826   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9827     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9828     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9829     break 2
9830   fi
9831 done
9832 done
9833
9834   ;;
9835 esac
9836 fi
9837 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9838
9839 if test -n "$NM_FOR_TARGET"; then
9840   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9841 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9842 else
9843   echo "$as_me:$LINENO: result: no" >&5
9844 echo "${ECHO_T}no" >&6
9845 fi
9846
9847 fi
9848 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9849
9850
9851 if test -n "$NM_FOR_TARGET"; then
9852   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9853 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9854   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9855 fi
9856
9857 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9858   for ncn_progname in nm; do
9859     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9860 set dummy ${ncn_progname}; ac_word=$2
9861 echo "$as_me:$LINENO: checking for $ac_word" >&5
9862 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9863 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9864   echo $ECHO_N "(cached) $ECHO_C" >&6
9865 else
9866   if test -n "$NM_FOR_TARGET"; then
9867   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9868 else
9869 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9870 for as_dir in $PATH
9871 do
9872   IFS=$as_save_IFS
9873   test -z "$as_dir" && as_dir=.
9874   for ac_exec_ext in '' $ac_executable_extensions; do
9875   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9876     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9877     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9878     break 2
9879   fi
9880 done
9881 done
9882
9883 fi
9884 fi
9885 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9886 if test -n "$NM_FOR_TARGET"; then
9887   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9888 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9889 else
9890   echo "$as_me:$LINENO: result: no" >&5
9891 echo "${ECHO_T}no" >&6
9892 fi
9893
9894   done
9895 fi
9896
9897 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
9898   for ncn_progname in nm; do
9899     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9900 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9901     if test -x $with_build_time_tools/${ncn_progname}; then
9902       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9903       echo "$as_me:$LINENO: result: yes" >&5
9904 echo "${ECHO_T}yes" >&6
9905       break
9906     else
9907       echo "$as_me:$LINENO: result: no" >&5
9908 echo "${ECHO_T}no" >&6
9909     fi
9910   done
9911 fi
9912
9913 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
9914   for ncn_progname in nm; do
9915     if test -n "$ncn_target_tool_prefix"; then
9916       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9917 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9918 echo "$as_me:$LINENO: checking for $ac_word" >&5
9919 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9920 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9921   echo $ECHO_N "(cached) $ECHO_C" >&6
9922 else
9923   if test -n "$NM_FOR_TARGET"; then
9924   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9925 else
9926 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9927 for as_dir in $PATH
9928 do
9929   IFS=$as_save_IFS
9930   test -z "$as_dir" && as_dir=.
9931   for ac_exec_ext in '' $ac_executable_extensions; do
9932   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9933     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9934     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9935     break 2
9936   fi
9937 done
9938 done
9939
9940 fi
9941 fi
9942 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9943 if test -n "$NM_FOR_TARGET"; then
9944   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9945 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9946 else
9947   echo "$as_me:$LINENO: result: no" >&5
9948 echo "${ECHO_T}no" >&6
9949 fi
9950
9951     fi
9952     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
9953       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9954 set dummy ${ncn_progname}; ac_word=$2
9955 echo "$as_me:$LINENO: checking for $ac_word" >&5
9956 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9957 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9958   echo $ECHO_N "(cached) $ECHO_C" >&6
9959 else
9960   if test -n "$NM_FOR_TARGET"; then
9961   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9962 else
9963 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9964 for as_dir in $PATH
9965 do
9966   IFS=$as_save_IFS
9967   test -z "$as_dir" && as_dir=.
9968   for ac_exec_ext in '' $ac_executable_extensions; do
9969   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9970     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9971     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9972     break 2
9973   fi
9974 done
9975 done
9976
9977 fi
9978 fi
9979 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9980 if test -n "$NM_FOR_TARGET"; then
9981   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9982 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9983 else
9984   echo "$as_me:$LINENO: result: no" >&5
9985 echo "${ECHO_T}no" >&6
9986 fi
9987
9988     fi
9989     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
9990   done
9991 fi
9992
9993 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
9994   set dummy nm
9995   if test $build = $target ; then
9996     NM_FOR_TARGET="$2"
9997   else
9998     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
9999   fi
10000 else
10001   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10002 fi
10003
10004 else
10005   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10006 fi
10007
10008
10009
10010
10011 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10012   if test -n "$with_build_time_tools"; then
10013     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10014 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10015     if test -x $with_build_time_tools/objdump; then
10016       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10017       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10018       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10019 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10020     else
10021       echo "$as_me:$LINENO: result: no" >&5
10022 echo "${ECHO_T}no" >&6
10023     fi
10024   elif test $build != $host && test $have_gcc_for_target = yes; then
10025     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10026     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10027     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10028   fi
10029 fi
10030 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10031   # Extract the first word of "objdump", so it can be a program name with args.
10032 set dummy objdump; ac_word=$2
10033 echo "$as_me:$LINENO: checking for $ac_word" >&5
10034 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10035 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10036   echo $ECHO_N "(cached) $ECHO_C" >&6
10037 else
10038   case $OBJDUMP_FOR_TARGET in
10039   [\\/]* | ?:[\\/]*)
10040   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10041   ;;
10042   *)
10043   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10044 for as_dir in $gcc_cv_tool_dirs
10045 do
10046   IFS=$as_save_IFS
10047   test -z "$as_dir" && as_dir=.
10048   for ac_exec_ext in '' $ac_executable_extensions; do
10049   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10050     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10051     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10052     break 2
10053   fi
10054 done
10055 done
10056
10057   ;;
10058 esac
10059 fi
10060 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10061
10062 if test -n "$OBJDUMP_FOR_TARGET"; then
10063   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10064 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10065 else
10066   echo "$as_me:$LINENO: result: no" >&5
10067 echo "${ECHO_T}no" >&6
10068 fi
10069
10070 fi
10071 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10072
10073
10074 if test -n "$OBJDUMP_FOR_TARGET"; then
10075   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10076 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10077   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10078 fi
10079
10080 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10081   for ncn_progname in objdump; do
10082     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10083 set dummy ${ncn_progname}; ac_word=$2
10084 echo "$as_me:$LINENO: checking for $ac_word" >&5
10085 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10086 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10087   echo $ECHO_N "(cached) $ECHO_C" >&6
10088 else
10089   if test -n "$OBJDUMP_FOR_TARGET"; then
10090   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10091 else
10092 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10093 for as_dir in $PATH
10094 do
10095   IFS=$as_save_IFS
10096   test -z "$as_dir" && as_dir=.
10097   for ac_exec_ext in '' $ac_executable_extensions; do
10098   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10099     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10100     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10101     break 2
10102   fi
10103 done
10104 done
10105
10106 fi
10107 fi
10108 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10109 if test -n "$OBJDUMP_FOR_TARGET"; then
10110   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10111 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10112 else
10113   echo "$as_me:$LINENO: result: no" >&5
10114 echo "${ECHO_T}no" >&6
10115 fi
10116
10117   done
10118 fi
10119
10120 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10121   for ncn_progname in objdump; do
10122     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10123 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10124     if test -x $with_build_time_tools/${ncn_progname}; then
10125       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10126       echo "$as_me:$LINENO: result: yes" >&5
10127 echo "${ECHO_T}yes" >&6
10128       break
10129     else
10130       echo "$as_me:$LINENO: result: no" >&5
10131 echo "${ECHO_T}no" >&6
10132     fi
10133   done
10134 fi
10135
10136 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10137   for ncn_progname in objdump; do
10138     if test -n "$ncn_target_tool_prefix"; then
10139       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10140 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10141 echo "$as_me:$LINENO: checking for $ac_word" >&5
10142 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10143 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10144   echo $ECHO_N "(cached) $ECHO_C" >&6
10145 else
10146   if test -n "$OBJDUMP_FOR_TARGET"; then
10147   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10148 else
10149 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10150 for as_dir in $PATH
10151 do
10152   IFS=$as_save_IFS
10153   test -z "$as_dir" && as_dir=.
10154   for ac_exec_ext in '' $ac_executable_extensions; do
10155   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10156     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10157     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10158     break 2
10159   fi
10160 done
10161 done
10162
10163 fi
10164 fi
10165 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10166 if test -n "$OBJDUMP_FOR_TARGET"; then
10167   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10168 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10169 else
10170   echo "$as_me:$LINENO: result: no" >&5
10171 echo "${ECHO_T}no" >&6
10172 fi
10173
10174     fi
10175     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10176       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10177 set dummy ${ncn_progname}; ac_word=$2
10178 echo "$as_me:$LINENO: checking for $ac_word" >&5
10179 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10180 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10181   echo $ECHO_N "(cached) $ECHO_C" >&6
10182 else
10183   if test -n "$OBJDUMP_FOR_TARGET"; then
10184   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10185 else
10186 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10187 for as_dir in $PATH
10188 do
10189   IFS=$as_save_IFS
10190   test -z "$as_dir" && as_dir=.
10191   for ac_exec_ext in '' $ac_executable_extensions; do
10192   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10193     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10194     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10195     break 2
10196   fi
10197 done
10198 done
10199
10200 fi
10201 fi
10202 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10203 if test -n "$OBJDUMP_FOR_TARGET"; then
10204   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10205 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10206 else
10207   echo "$as_me:$LINENO: result: no" >&5
10208 echo "${ECHO_T}no" >&6
10209 fi
10210
10211     fi
10212     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10213   done
10214 fi
10215
10216 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10217   set dummy objdump
10218   if test $build = $target ; then
10219     OBJDUMP_FOR_TARGET="$2"
10220   else
10221     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10222   fi
10223 else
10224   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10225 fi
10226
10227 else
10228   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10229 fi
10230
10231
10232
10233
10234 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10235   if test -n "$with_build_time_tools"; then
10236     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10237 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10238     if test -x $with_build_time_tools/ranlib; then
10239       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10240       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10241       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10242 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10243     else
10244       echo "$as_me:$LINENO: result: no" >&5
10245 echo "${ECHO_T}no" >&6
10246     fi
10247   elif test $build != $host && test $have_gcc_for_target = yes; then
10248     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10249     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10250     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10251   fi
10252 fi
10253 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10254   # Extract the first word of "ranlib", so it can be a program name with args.
10255 set dummy ranlib; ac_word=$2
10256 echo "$as_me:$LINENO: checking for $ac_word" >&5
10257 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10258 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10259   echo $ECHO_N "(cached) $ECHO_C" >&6
10260 else
10261   case $RANLIB_FOR_TARGET in
10262   [\\/]* | ?:[\\/]*)
10263   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10264   ;;
10265   *)
10266   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10267 for as_dir in $gcc_cv_tool_dirs
10268 do
10269   IFS=$as_save_IFS
10270   test -z "$as_dir" && as_dir=.
10271   for ac_exec_ext in '' $ac_executable_extensions; do
10272   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10273     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10274     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10275     break 2
10276   fi
10277 done
10278 done
10279
10280   ;;
10281 esac
10282 fi
10283 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10284
10285 if test -n "$RANLIB_FOR_TARGET"; then
10286   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10287 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10288 else
10289   echo "$as_me:$LINENO: result: no" >&5
10290 echo "${ECHO_T}no" >&6
10291 fi
10292
10293 fi
10294 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10295
10296
10297 if test -n "$RANLIB_FOR_TARGET"; then
10298   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10299 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10300   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10301 fi
10302
10303 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10304   for ncn_progname in ranlib; do
10305     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10306 set dummy ${ncn_progname}; ac_word=$2
10307 echo "$as_me:$LINENO: checking for $ac_word" >&5
10308 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10309 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10310   echo $ECHO_N "(cached) $ECHO_C" >&6
10311 else
10312   if test -n "$RANLIB_FOR_TARGET"; then
10313   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10314 else
10315 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10316 for as_dir in $PATH
10317 do
10318   IFS=$as_save_IFS
10319   test -z "$as_dir" && as_dir=.
10320   for ac_exec_ext in '' $ac_executable_extensions; do
10321   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10322     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10323     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10324     break 2
10325   fi
10326 done
10327 done
10328
10329 fi
10330 fi
10331 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10332 if test -n "$RANLIB_FOR_TARGET"; then
10333   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10334 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10335 else
10336   echo "$as_me:$LINENO: result: no" >&5
10337 echo "${ECHO_T}no" >&6
10338 fi
10339
10340   done
10341 fi
10342
10343 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10344   for ncn_progname in ranlib; do
10345     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10346 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10347     if test -x $with_build_time_tools/${ncn_progname}; then
10348       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10349       echo "$as_me:$LINENO: result: yes" >&5
10350 echo "${ECHO_T}yes" >&6
10351       break
10352     else
10353       echo "$as_me:$LINENO: result: no" >&5
10354 echo "${ECHO_T}no" >&6
10355     fi
10356   done
10357 fi
10358
10359 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10360   for ncn_progname in ranlib; do
10361     if test -n "$ncn_target_tool_prefix"; then
10362       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10363 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10364 echo "$as_me:$LINENO: checking for $ac_word" >&5
10365 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10366 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10367   echo $ECHO_N "(cached) $ECHO_C" >&6
10368 else
10369   if test -n "$RANLIB_FOR_TARGET"; then
10370   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10371 else
10372 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10373 for as_dir in $PATH
10374 do
10375   IFS=$as_save_IFS
10376   test -z "$as_dir" && as_dir=.
10377   for ac_exec_ext in '' $ac_executable_extensions; do
10378   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10379     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10380     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10381     break 2
10382   fi
10383 done
10384 done
10385
10386 fi
10387 fi
10388 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10389 if test -n "$RANLIB_FOR_TARGET"; then
10390   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10391 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10392 else
10393   echo "$as_me:$LINENO: result: no" >&5
10394 echo "${ECHO_T}no" >&6
10395 fi
10396
10397     fi
10398     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10399       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10400 set dummy ${ncn_progname}; ac_word=$2
10401 echo "$as_me:$LINENO: checking for $ac_word" >&5
10402 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10403 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10404   echo $ECHO_N "(cached) $ECHO_C" >&6
10405 else
10406   if test -n "$RANLIB_FOR_TARGET"; then
10407   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10408 else
10409 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10410 for as_dir in $PATH
10411 do
10412   IFS=$as_save_IFS
10413   test -z "$as_dir" && as_dir=.
10414   for ac_exec_ext in '' $ac_executable_extensions; do
10415   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10416     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10417     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10418     break 2
10419   fi
10420 done
10421 done
10422
10423 fi
10424 fi
10425 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10426 if test -n "$RANLIB_FOR_TARGET"; then
10427   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10428 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10429 else
10430   echo "$as_me:$LINENO: result: no" >&5
10431 echo "${ECHO_T}no" >&6
10432 fi
10433
10434     fi
10435     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10436   done
10437 fi
10438
10439 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10440   set dummy ranlib
10441   if test $build = $target ; then
10442     RANLIB_FOR_TARGET="$2"
10443   else
10444     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10445   fi
10446 else
10447   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10448 fi
10449
10450 else
10451   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10452 fi
10453
10454
10455
10456
10457 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10458   if test -n "$with_build_time_tools"; then
10459     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10460 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10461     if test -x $with_build_time_tools/strip; then
10462       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10463       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10464       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10465 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10466     else
10467       echo "$as_me:$LINENO: result: no" >&5
10468 echo "${ECHO_T}no" >&6
10469     fi
10470   elif test $build != $host && test $have_gcc_for_target = yes; then
10471     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10472     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10473     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10474   fi
10475 fi
10476 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10477   # Extract the first word of "strip", so it can be a program name with args.
10478 set dummy strip; ac_word=$2
10479 echo "$as_me:$LINENO: checking for $ac_word" >&5
10480 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10481 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10482   echo $ECHO_N "(cached) $ECHO_C" >&6
10483 else
10484   case $STRIP_FOR_TARGET in
10485   [\\/]* | ?:[\\/]*)
10486   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10487   ;;
10488   *)
10489   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10490 for as_dir in $gcc_cv_tool_dirs
10491 do
10492   IFS=$as_save_IFS
10493   test -z "$as_dir" && as_dir=.
10494   for ac_exec_ext in '' $ac_executable_extensions; do
10495   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10496     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10497     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10498     break 2
10499   fi
10500 done
10501 done
10502
10503   ;;
10504 esac
10505 fi
10506 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10507
10508 if test -n "$STRIP_FOR_TARGET"; then
10509   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10510 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10511 else
10512   echo "$as_me:$LINENO: result: no" >&5
10513 echo "${ECHO_T}no" >&6
10514 fi
10515
10516 fi
10517 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10518
10519
10520 if test -n "$STRIP_FOR_TARGET"; then
10521   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10522 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10523   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10524 fi
10525
10526 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10527   for ncn_progname in strip; do
10528     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10529 set dummy ${ncn_progname}; ac_word=$2
10530 echo "$as_me:$LINENO: checking for $ac_word" >&5
10531 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10532 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10533   echo $ECHO_N "(cached) $ECHO_C" >&6
10534 else
10535   if test -n "$STRIP_FOR_TARGET"; then
10536   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10537 else
10538 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10539 for as_dir in $PATH
10540 do
10541   IFS=$as_save_IFS
10542   test -z "$as_dir" && as_dir=.
10543   for ac_exec_ext in '' $ac_executable_extensions; do
10544   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10545     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10546     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10547     break 2
10548   fi
10549 done
10550 done
10551
10552 fi
10553 fi
10554 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10555 if test -n "$STRIP_FOR_TARGET"; then
10556   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10557 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10558 else
10559   echo "$as_me:$LINENO: result: no" >&5
10560 echo "${ECHO_T}no" >&6
10561 fi
10562
10563   done
10564 fi
10565
10566 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10567   for ncn_progname in strip; do
10568     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10569 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10570     if test -x $with_build_time_tools/${ncn_progname}; then
10571       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10572       echo "$as_me:$LINENO: result: yes" >&5
10573 echo "${ECHO_T}yes" >&6
10574       break
10575     else
10576       echo "$as_me:$LINENO: result: no" >&5
10577 echo "${ECHO_T}no" >&6
10578     fi
10579   done
10580 fi
10581
10582 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10583   for ncn_progname in strip; do
10584     if test -n "$ncn_target_tool_prefix"; then
10585       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10586 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10587 echo "$as_me:$LINENO: checking for $ac_word" >&5
10588 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10589 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10590   echo $ECHO_N "(cached) $ECHO_C" >&6
10591 else
10592   if test -n "$STRIP_FOR_TARGET"; then
10593   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10594 else
10595 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10596 for as_dir in $PATH
10597 do
10598   IFS=$as_save_IFS
10599   test -z "$as_dir" && as_dir=.
10600   for ac_exec_ext in '' $ac_executable_extensions; do
10601   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10602     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10603     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10604     break 2
10605   fi
10606 done
10607 done
10608
10609 fi
10610 fi
10611 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10612 if test -n "$STRIP_FOR_TARGET"; then
10613   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10614 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10615 else
10616   echo "$as_me:$LINENO: result: no" >&5
10617 echo "${ECHO_T}no" >&6
10618 fi
10619
10620     fi
10621     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10622       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10623 set dummy ${ncn_progname}; ac_word=$2
10624 echo "$as_me:$LINENO: checking for $ac_word" >&5
10625 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10626 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10627   echo $ECHO_N "(cached) $ECHO_C" >&6
10628 else
10629   if test -n "$STRIP_FOR_TARGET"; then
10630   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10631 else
10632 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10633 for as_dir in $PATH
10634 do
10635   IFS=$as_save_IFS
10636   test -z "$as_dir" && as_dir=.
10637   for ac_exec_ext in '' $ac_executable_extensions; do
10638   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10639     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10640     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10641     break 2
10642   fi
10643 done
10644 done
10645
10646 fi
10647 fi
10648 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10649 if test -n "$STRIP_FOR_TARGET"; then
10650   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10651 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10652 else
10653   echo "$as_me:$LINENO: result: no" >&5
10654 echo "${ECHO_T}no" >&6
10655 fi
10656
10657     fi
10658     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10659   done
10660 fi
10661
10662 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10663   set dummy strip
10664   if test $build = $target ; then
10665     STRIP_FOR_TARGET="$2"
10666   else
10667     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10668   fi
10669 else
10670   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10671 fi
10672
10673 else
10674   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10675 fi
10676
10677
10678
10679
10680 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10681   if test -n "$with_build_time_tools"; then
10682     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10683 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10684     if test -x $with_build_time_tools/windres; then
10685       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10686       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10687       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10688 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10689     else
10690       echo "$as_me:$LINENO: result: no" >&5
10691 echo "${ECHO_T}no" >&6
10692     fi
10693   elif test $build != $host && test $have_gcc_for_target = yes; then
10694     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10695     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10696     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10697   fi
10698 fi
10699 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10700   # Extract the first word of "windres", so it can be a program name with args.
10701 set dummy windres; ac_word=$2
10702 echo "$as_me:$LINENO: checking for $ac_word" >&5
10703 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10704 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10705   echo $ECHO_N "(cached) $ECHO_C" >&6
10706 else
10707   case $WINDRES_FOR_TARGET in
10708   [\\/]* | ?:[\\/]*)
10709   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10710   ;;
10711   *)
10712   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10713 for as_dir in $gcc_cv_tool_dirs
10714 do
10715   IFS=$as_save_IFS
10716   test -z "$as_dir" && as_dir=.
10717   for ac_exec_ext in '' $ac_executable_extensions; do
10718   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10719     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10720     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10721     break 2
10722   fi
10723 done
10724 done
10725
10726   ;;
10727 esac
10728 fi
10729 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10730
10731 if test -n "$WINDRES_FOR_TARGET"; then
10732   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10733 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10734 else
10735   echo "$as_me:$LINENO: result: no" >&5
10736 echo "${ECHO_T}no" >&6
10737 fi
10738
10739 fi
10740 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10741
10742
10743 if test -n "$WINDRES_FOR_TARGET"; then
10744   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10745 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10746   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10747 fi
10748
10749 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10750   for ncn_progname in windres; do
10751     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10752 set dummy ${ncn_progname}; ac_word=$2
10753 echo "$as_me:$LINENO: checking for $ac_word" >&5
10754 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10755 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10756   echo $ECHO_N "(cached) $ECHO_C" >&6
10757 else
10758   if test -n "$WINDRES_FOR_TARGET"; then
10759   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10760 else
10761 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10762 for as_dir in $PATH
10763 do
10764   IFS=$as_save_IFS
10765   test -z "$as_dir" && as_dir=.
10766   for ac_exec_ext in '' $ac_executable_extensions; do
10767   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10768     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10769     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10770     break 2
10771   fi
10772 done
10773 done
10774
10775 fi
10776 fi
10777 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10778 if test -n "$WINDRES_FOR_TARGET"; then
10779   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10780 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10781 else
10782   echo "$as_me:$LINENO: result: no" >&5
10783 echo "${ECHO_T}no" >&6
10784 fi
10785
10786   done
10787 fi
10788
10789 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10790   for ncn_progname in windres; do
10791     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10792 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10793     if test -x $with_build_time_tools/${ncn_progname}; then
10794       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10795       echo "$as_me:$LINENO: result: yes" >&5
10796 echo "${ECHO_T}yes" >&6
10797       break
10798     else
10799       echo "$as_me:$LINENO: result: no" >&5
10800 echo "${ECHO_T}no" >&6
10801     fi
10802   done
10803 fi
10804
10805 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10806   for ncn_progname in windres; do
10807     if test -n "$ncn_target_tool_prefix"; then
10808       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10809 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10810 echo "$as_me:$LINENO: checking for $ac_word" >&5
10811 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10812 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10813   echo $ECHO_N "(cached) $ECHO_C" >&6
10814 else
10815   if test -n "$WINDRES_FOR_TARGET"; then
10816   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10817 else
10818 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10819 for as_dir in $PATH
10820 do
10821   IFS=$as_save_IFS
10822   test -z "$as_dir" && as_dir=.
10823   for ac_exec_ext in '' $ac_executable_extensions; do
10824   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10825     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10826     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10827     break 2
10828   fi
10829 done
10830 done
10831
10832 fi
10833 fi
10834 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10835 if test -n "$WINDRES_FOR_TARGET"; then
10836   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10837 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10838 else
10839   echo "$as_me:$LINENO: result: no" >&5
10840 echo "${ECHO_T}no" >&6
10841 fi
10842
10843     fi
10844     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10845       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10846 set dummy ${ncn_progname}; ac_word=$2
10847 echo "$as_me:$LINENO: checking for $ac_word" >&5
10848 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10849 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10850   echo $ECHO_N "(cached) $ECHO_C" >&6
10851 else
10852   if test -n "$WINDRES_FOR_TARGET"; then
10853   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10854 else
10855 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10856 for as_dir in $PATH
10857 do
10858   IFS=$as_save_IFS
10859   test -z "$as_dir" && as_dir=.
10860   for ac_exec_ext in '' $ac_executable_extensions; do
10861   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10862     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10863     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10864     break 2
10865   fi
10866 done
10867 done
10868
10869 fi
10870 fi
10871 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10872 if test -n "$WINDRES_FOR_TARGET"; then
10873   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10874 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10875 else
10876   echo "$as_me:$LINENO: result: no" >&5
10877 echo "${ECHO_T}no" >&6
10878 fi
10879
10880     fi
10881     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10882   done
10883 fi
10884
10885 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10886   set dummy windres
10887   if test $build = $target ; then
10888     WINDRES_FOR_TARGET="$2"
10889   else
10890     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10891   fi
10892 else
10893   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
10894 fi
10895
10896 else
10897   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10898 fi
10899
10900
10901
10902
10903 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
10904   if test -n "$with_build_time_tools"; then
10905     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
10906 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
10907     if test -x $with_build_time_tools/windmc; then
10908       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
10909       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10910       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
10911 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
10912     else
10913       echo "$as_me:$LINENO: result: no" >&5
10914 echo "${ECHO_T}no" >&6
10915     fi
10916   elif test $build != $host && test $have_gcc_for_target = yes; then
10917     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
10918     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
10919     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10920   fi
10921 fi
10922 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10923   # Extract the first word of "windmc", so it can be a program name with args.
10924 set dummy windmc; ac_word=$2
10925 echo "$as_me:$LINENO: checking for $ac_word" >&5
10926 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10927 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
10928   echo $ECHO_N "(cached) $ECHO_C" >&6
10929 else
10930   case $WINDMC_FOR_TARGET in
10931   [\\/]* | ?:[\\/]*)
10932   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
10933   ;;
10934   *)
10935   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10936 for as_dir in $gcc_cv_tool_dirs
10937 do
10938   IFS=$as_save_IFS
10939   test -z "$as_dir" && as_dir=.
10940   for ac_exec_ext in '' $ac_executable_extensions; do
10941   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10942     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10943     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10944     break 2
10945   fi
10946 done
10947 done
10948
10949   ;;
10950 esac
10951 fi
10952 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
10953
10954 if test -n "$WINDMC_FOR_TARGET"; then
10955   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
10956 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
10957 else
10958   echo "$as_me:$LINENO: result: no" >&5
10959 echo "${ECHO_T}no" >&6
10960 fi
10961
10962 fi
10963 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
10964
10965
10966 if test -n "$WINDMC_FOR_TARGET"; then
10967   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10968 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
10969   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
10970 fi
10971
10972 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
10973   for ncn_progname in windmc; do
10974     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10975 set dummy ${ncn_progname}; ac_word=$2
10976 echo "$as_me:$LINENO: checking for $ac_word" >&5
10977 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10978 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
10979   echo $ECHO_N "(cached) $ECHO_C" >&6
10980 else
10981   if test -n "$WINDMC_FOR_TARGET"; then
10982   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
10983 else
10984 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10985 for as_dir in $PATH
10986 do
10987   IFS=$as_save_IFS
10988   test -z "$as_dir" && as_dir=.
10989   for ac_exec_ext in '' $ac_executable_extensions; do
10990   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10991     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
10992     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10993     break 2
10994   fi
10995 done
10996 done
10997
10998 fi
10999 fi
11000 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11001 if test -n "$WINDMC_FOR_TARGET"; then
11002   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11003 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11004 else
11005   echo "$as_me:$LINENO: result: no" >&5
11006 echo "${ECHO_T}no" >&6
11007 fi
11008
11009   done
11010 fi
11011
11012 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11013   for ncn_progname in windmc; do
11014     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11015 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11016     if test -x $with_build_time_tools/${ncn_progname}; then
11017       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11018       echo "$as_me:$LINENO: result: yes" >&5
11019 echo "${ECHO_T}yes" >&6
11020       break
11021     else
11022       echo "$as_me:$LINENO: result: no" >&5
11023 echo "${ECHO_T}no" >&6
11024     fi
11025   done
11026 fi
11027
11028 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11029   for ncn_progname in windmc; do
11030     if test -n "$ncn_target_tool_prefix"; then
11031       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11032 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11033 echo "$as_me:$LINENO: checking for $ac_word" >&5
11034 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11035 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11036   echo $ECHO_N "(cached) $ECHO_C" >&6
11037 else
11038   if test -n "$WINDMC_FOR_TARGET"; then
11039   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11040 else
11041 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11042 for as_dir in $PATH
11043 do
11044   IFS=$as_save_IFS
11045   test -z "$as_dir" && as_dir=.
11046   for ac_exec_ext in '' $ac_executable_extensions; do
11047   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11048     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11049     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11050     break 2
11051   fi
11052 done
11053 done
11054
11055 fi
11056 fi
11057 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11058 if test -n "$WINDMC_FOR_TARGET"; then
11059   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11060 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11061 else
11062   echo "$as_me:$LINENO: result: no" >&5
11063 echo "${ECHO_T}no" >&6
11064 fi
11065
11066     fi
11067     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11068       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11069 set dummy ${ncn_progname}; ac_word=$2
11070 echo "$as_me:$LINENO: checking for $ac_word" >&5
11071 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11072 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11073   echo $ECHO_N "(cached) $ECHO_C" >&6
11074 else
11075   if test -n "$WINDMC_FOR_TARGET"; then
11076   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11077 else
11078 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11079 for as_dir in $PATH
11080 do
11081   IFS=$as_save_IFS
11082   test -z "$as_dir" && as_dir=.
11083   for ac_exec_ext in '' $ac_executable_extensions; do
11084   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11085     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11086     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11087     break 2
11088   fi
11089 done
11090 done
11091
11092 fi
11093 fi
11094 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11095 if test -n "$WINDMC_FOR_TARGET"; then
11096   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11097 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11098 else
11099   echo "$as_me:$LINENO: result: no" >&5
11100 echo "${ECHO_T}no" >&6
11101 fi
11102
11103     fi
11104     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11105   done
11106 fi
11107
11108 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11109   set dummy windmc
11110   if test $build = $target ; then
11111     WINDMC_FOR_TARGET="$2"
11112   else
11113     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11114   fi
11115 else
11116   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11117 fi
11118
11119 else
11120   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11121 fi
11122
11123
11124 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11125
11126 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11127 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11128 if test "x${build}" != "x${host}" ; then
11129   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11130     # We already found the complete path
11131     ac_dir=`dirname $AR_FOR_TARGET`
11132     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11133 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11134   else
11135     # Canadian cross, just use what we found
11136     echo "$as_me:$LINENO: result: pre-installed" >&5
11137 echo "${ECHO_T}pre-installed" >&6
11138   fi
11139 else
11140   ok=yes
11141   case " ${configdirs} " in
11142     *" binutils "*) ;;
11143     *) ok=no ;;
11144   esac
11145
11146   if test $ok = yes; then
11147     # An in-tree tool is available and we can use it
11148     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11149     echo "$as_me:$LINENO: result: just compiled" >&5
11150 echo "${ECHO_T}just compiled" >&6
11151   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11152     # We already found the complete path
11153     ac_dir=`dirname $AR_FOR_TARGET`
11154     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11155 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11156   elif test "x$target" = "x$host"; then
11157     # We can use an host tool
11158     AR_FOR_TARGET='$(AR)'
11159     echo "$as_me:$LINENO: result: host tool" >&5
11160 echo "${ECHO_T}host tool" >&6
11161   else
11162     # We need a cross tool
11163     echo "$as_me:$LINENO: result: pre-installed" >&5
11164 echo "${ECHO_T}pre-installed" >&6
11165   fi
11166 fi
11167
11168 echo "$as_me:$LINENO: checking where to find the target as" >&5
11169 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11170 if test "x${build}" != "x${host}" ; then
11171   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11172     # We already found the complete path
11173     ac_dir=`dirname $AS_FOR_TARGET`
11174     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11175 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11176   else
11177     # Canadian cross, just use what we found
11178     echo "$as_me:$LINENO: result: pre-installed" >&5
11179 echo "${ECHO_T}pre-installed" >&6
11180   fi
11181 else
11182   ok=yes
11183   case " ${configdirs} " in
11184     *" gas "*) ;;
11185     *) ok=no ;;
11186   esac
11187
11188   if test $ok = yes; then
11189     # An in-tree tool is available and we can use it
11190     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11191     echo "$as_me:$LINENO: result: just compiled" >&5
11192 echo "${ECHO_T}just compiled" >&6
11193   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11194     # We already found the complete path
11195     ac_dir=`dirname $AS_FOR_TARGET`
11196     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11197 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11198   elif test "x$target" = "x$host"; then
11199     # We can use an host tool
11200     AS_FOR_TARGET='$(AS)'
11201     echo "$as_me:$LINENO: result: host tool" >&5
11202 echo "${ECHO_T}host tool" >&6
11203   else
11204     # We need a cross tool
11205     echo "$as_me:$LINENO: result: pre-installed" >&5
11206 echo "${ECHO_T}pre-installed" >&6
11207   fi
11208 fi
11209
11210 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11211 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11212 if test "x${build}" != "x${host}" ; then
11213   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11214     # We already found the complete path
11215     ac_dir=`dirname $CC_FOR_TARGET`
11216     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11217 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11218   else
11219     # Canadian cross, just use what we found
11220     echo "$as_me:$LINENO: result: pre-installed" >&5
11221 echo "${ECHO_T}pre-installed" >&6
11222   fi
11223 else
11224   ok=yes
11225   case " ${configdirs} " in
11226     *" gcc "*) ;;
11227     *) ok=no ;;
11228   esac
11229
11230   if test $ok = yes; then
11231     # An in-tree tool is available and we can use it
11232     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11233     echo "$as_me:$LINENO: result: just compiled" >&5
11234 echo "${ECHO_T}just compiled" >&6
11235   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11236     # We already found the complete path
11237     ac_dir=`dirname $CC_FOR_TARGET`
11238     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11239 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11240   elif test "x$target" = "x$host"; then
11241     # We can use an host tool
11242     CC_FOR_TARGET='$(CC)'
11243     echo "$as_me:$LINENO: result: host tool" >&5
11244 echo "${ECHO_T}host tool" >&6
11245   else
11246     # We need a cross tool
11247     echo "$as_me:$LINENO: result: pre-installed" >&5
11248 echo "${ECHO_T}pre-installed" >&6
11249   fi
11250 fi
11251
11252 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11253 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11254 if test "x${build}" != "x${host}" ; then
11255   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11256     # We already found the complete path
11257     ac_dir=`dirname $CXX_FOR_TARGET`
11258     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11259 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11260   else
11261     # Canadian cross, just use what we found
11262     echo "$as_me:$LINENO: result: pre-installed" >&5
11263 echo "${ECHO_T}pre-installed" >&6
11264   fi
11265 else
11266   ok=yes
11267   case " ${configdirs} " in
11268     *" gcc "*) ;;
11269     *) ok=no ;;
11270   esac
11271   case ,${enable_languages}, in
11272     *,c++,*) ;;
11273     *) ok=no ;;
11274   esac
11275   if test $ok = yes; then
11276     # An in-tree tool is available and we can use it
11277     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'
11278     echo "$as_me:$LINENO: result: just compiled" >&5
11279 echo "${ECHO_T}just compiled" >&6
11280   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11281     # We already found the complete path
11282     ac_dir=`dirname $CXX_FOR_TARGET`
11283     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11284 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11285   elif test "x$target" = "x$host"; then
11286     # We can use an host tool
11287     CXX_FOR_TARGET='$(CXX)'
11288     echo "$as_me:$LINENO: result: host tool" >&5
11289 echo "${ECHO_T}host tool" >&6
11290   else
11291     # We need a cross tool
11292     echo "$as_me:$LINENO: result: pre-installed" >&5
11293 echo "${ECHO_T}pre-installed" >&6
11294   fi
11295 fi
11296
11297 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11298 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11299 if test "x${build}" != "x${host}" ; then
11300   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11301     # We already found the complete path
11302     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11303     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11304 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11305   else
11306     # Canadian cross, just use what we found
11307     echo "$as_me:$LINENO: result: pre-installed" >&5
11308 echo "${ECHO_T}pre-installed" >&6
11309   fi
11310 else
11311   ok=yes
11312   case " ${configdirs} " in
11313     *" gcc "*) ;;
11314     *) ok=no ;;
11315   esac
11316   case ,${enable_languages}, in
11317     *,c++,*) ;;
11318     *) ok=no ;;
11319   esac
11320   if test $ok = yes; then
11321     # An in-tree tool is available and we can use it
11322     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'
11323     echo "$as_me:$LINENO: result: just compiled" >&5
11324 echo "${ECHO_T}just compiled" >&6
11325   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11326     # We already found the complete path
11327     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11328     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11329 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11330   elif test "x$target" = "x$host"; then
11331     # We can use an host tool
11332     RAW_CXX_FOR_TARGET='$(CXX)'
11333     echo "$as_me:$LINENO: result: host tool" >&5
11334 echo "${ECHO_T}host tool" >&6
11335   else
11336     # We need a cross tool
11337     echo "$as_me:$LINENO: result: pre-installed" >&5
11338 echo "${ECHO_T}pre-installed" >&6
11339   fi
11340 fi
11341
11342 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11343 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11344 if test "x${build}" != "x${host}" ; then
11345   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11346     # We already found the complete path
11347     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11348     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11349 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11350   else
11351     # Canadian cross, just use what we found
11352     echo "$as_me:$LINENO: result: pre-installed" >&5
11353 echo "${ECHO_T}pre-installed" >&6
11354   fi
11355 else
11356   ok=yes
11357   case " ${configdirs} " in
11358     *" binutils "*) ;;
11359     *) ok=no ;;
11360   esac
11361
11362   if test $ok = yes; then
11363     # An in-tree tool is available and we can use it
11364     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11365     echo "$as_me:$LINENO: result: just compiled" >&5
11366 echo "${ECHO_T}just compiled" >&6
11367   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11368     # We already found the complete path
11369     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11370     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11371 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11372   elif test "x$target" = "x$host"; then
11373     # We can use an host tool
11374     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11375     echo "$as_me:$LINENO: result: host tool" >&5
11376 echo "${ECHO_T}host tool" >&6
11377   else
11378     # We need a cross tool
11379     echo "$as_me:$LINENO: result: pre-installed" >&5
11380 echo "${ECHO_T}pre-installed" >&6
11381   fi
11382 fi
11383
11384 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11385 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11386 if test "x${build}" != "x${host}" ; then
11387   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11388     # We already found the complete path
11389     ac_dir=`dirname $GCC_FOR_TARGET`
11390     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11391 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11392   else
11393     # Canadian cross, just use what we found
11394     echo "$as_me:$LINENO: result: pre-installed" >&5
11395 echo "${ECHO_T}pre-installed" >&6
11396   fi
11397 else
11398   ok=yes
11399   case " ${configdirs} " in
11400     *" gcc "*) ;;
11401     *) ok=no ;;
11402   esac
11403
11404   if test $ok = yes; then
11405     # An in-tree tool is available and we can use it
11406     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11407     echo "$as_me:$LINENO: result: just compiled" >&5
11408 echo "${ECHO_T}just compiled" >&6
11409   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11410     # We already found the complete path
11411     ac_dir=`dirname $GCC_FOR_TARGET`
11412     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11413 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11414   elif test "x$target" = "x$host"; then
11415     # We can use an host tool
11416     GCC_FOR_TARGET='$()'
11417     echo "$as_me:$LINENO: result: host tool" >&5
11418 echo "${ECHO_T}host tool" >&6
11419   else
11420     # We need a cross tool
11421     echo "$as_me:$LINENO: result: pre-installed" >&5
11422 echo "${ECHO_T}pre-installed" >&6
11423   fi
11424 fi
11425
11426 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11427 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11428 if test "x${build}" != "x${host}" ; then
11429   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11430     # We already found the complete path
11431     ac_dir=`dirname $GCJ_FOR_TARGET`
11432     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11433 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11434   else
11435     # Canadian cross, just use what we found
11436     echo "$as_me:$LINENO: result: pre-installed" >&5
11437 echo "${ECHO_T}pre-installed" >&6
11438   fi
11439 else
11440   ok=yes
11441   case " ${configdirs} " in
11442     *" gcc "*) ;;
11443     *) ok=no ;;
11444   esac
11445   case ,${enable_languages}, in
11446     *,java,*) ;;
11447     *) ok=no ;;
11448   esac
11449   if test $ok = yes; then
11450     # An in-tree tool is available and we can use it
11451     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11452     echo "$as_me:$LINENO: result: just compiled" >&5
11453 echo "${ECHO_T}just compiled" >&6
11454   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11455     # We already found the complete path
11456     ac_dir=`dirname $GCJ_FOR_TARGET`
11457     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11458 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11459   elif test "x$target" = "x$host"; then
11460     # We can use an host tool
11461     GCJ_FOR_TARGET='$(GCJ)'
11462     echo "$as_me:$LINENO: result: host tool" >&5
11463 echo "${ECHO_T}host tool" >&6
11464   else
11465     # We need a cross tool
11466     echo "$as_me:$LINENO: result: pre-installed" >&5
11467 echo "${ECHO_T}pre-installed" >&6
11468   fi
11469 fi
11470
11471 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11472 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11473 if test "x${build}" != "x${host}" ; then
11474   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11475     # We already found the complete path
11476     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11477     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11478 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11479   else
11480     # Canadian cross, just use what we found
11481     echo "$as_me:$LINENO: result: pre-installed" >&5
11482 echo "${ECHO_T}pre-installed" >&6
11483   fi
11484 else
11485   ok=yes
11486   case " ${configdirs} " in
11487     *" gcc "*) ;;
11488     *) ok=no ;;
11489   esac
11490   case ,${enable_languages}, in
11491     *,fortran,*) ;;
11492     *) ok=no ;;
11493   esac
11494   if test $ok = yes; then
11495     # An in-tree tool is available and we can use it
11496     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11497     echo "$as_me:$LINENO: result: just compiled" >&5
11498 echo "${ECHO_T}just compiled" >&6
11499   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11500     # We already found the complete path
11501     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11502     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11503 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11504   elif test "x$target" = "x$host"; then
11505     # We can use an host tool
11506     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11507     echo "$as_me:$LINENO: result: host tool" >&5
11508 echo "${ECHO_T}host tool" >&6
11509   else
11510     # We need a cross tool
11511     echo "$as_me:$LINENO: result: pre-installed" >&5
11512 echo "${ECHO_T}pre-installed" >&6
11513   fi
11514 fi
11515
11516 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11517 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11518 if test "x${build}" != "x${host}" ; then
11519   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11520     # We already found the complete path
11521     ac_dir=`dirname $LD_FOR_TARGET`
11522     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11523 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11524   else
11525     # Canadian cross, just use what we found
11526     echo "$as_me:$LINENO: result: pre-installed" >&5
11527 echo "${ECHO_T}pre-installed" >&6
11528   fi
11529 else
11530   ok=yes
11531   case " ${configdirs} " in
11532     *" ld "*) ;;
11533     *) ok=no ;;
11534   esac
11535
11536   if test $ok = yes; then
11537     # An in-tree tool is available and we can use it
11538     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11539     echo "$as_me:$LINENO: result: just compiled" >&5
11540 echo "${ECHO_T}just compiled" >&6
11541   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11542     # We already found the complete path
11543     ac_dir=`dirname $LD_FOR_TARGET`
11544     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11545 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11546   elif test "x$target" = "x$host"; then
11547     # We can use an host tool
11548     LD_FOR_TARGET='$(LD)'
11549     echo "$as_me:$LINENO: result: host tool" >&5
11550 echo "${ECHO_T}host tool" >&6
11551   else
11552     # We need a cross tool
11553     echo "$as_me:$LINENO: result: pre-installed" >&5
11554 echo "${ECHO_T}pre-installed" >&6
11555   fi
11556 fi
11557
11558 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11559 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11560 if test "x${build}" != "x${host}" ; then
11561   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11562     # We already found the complete path
11563     ac_dir=`dirname $LIPO_FOR_TARGET`
11564     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11565 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11566   else
11567     # Canadian cross, just use what we found
11568     echo "$as_me:$LINENO: result: pre-installed" >&5
11569 echo "${ECHO_T}pre-installed" >&6
11570   fi
11571 else
11572   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11573     # We already found the complete path
11574     ac_dir=`dirname $LIPO_FOR_TARGET`
11575     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11576 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11577   elif test "x$target" = "x$host"; then
11578     # We can use an host tool
11579     LIPO_FOR_TARGET='$(LIPO)'
11580     echo "$as_me:$LINENO: result: host tool" >&5
11581 echo "${ECHO_T}host tool" >&6
11582   else
11583     # We need a cross tool
11584     echo "$as_me:$LINENO: result: pre-installed" >&5
11585 echo "${ECHO_T}pre-installed" >&6
11586   fi
11587 fi
11588
11589 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11590 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11591 if test "x${build}" != "x${host}" ; then
11592   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11593     # We already found the complete path
11594     ac_dir=`dirname $NM_FOR_TARGET`
11595     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11596 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11597   else
11598     # Canadian cross, just use what we found
11599     echo "$as_me:$LINENO: result: pre-installed" >&5
11600 echo "${ECHO_T}pre-installed" >&6
11601   fi
11602 else
11603   ok=yes
11604   case " ${configdirs} " in
11605     *" binutils "*) ;;
11606     *) ok=no ;;
11607   esac
11608
11609   if test $ok = yes; then
11610     # An in-tree tool is available and we can use it
11611     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11612     echo "$as_me:$LINENO: result: just compiled" >&5
11613 echo "${ECHO_T}just compiled" >&6
11614   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11615     # We already found the complete path
11616     ac_dir=`dirname $NM_FOR_TARGET`
11617     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11618 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11619   elif test "x$target" = "x$host"; then
11620     # We can use an host tool
11621     NM_FOR_TARGET='$(NM)'
11622     echo "$as_me:$LINENO: result: host tool" >&5
11623 echo "${ECHO_T}host tool" >&6
11624   else
11625     # We need a cross tool
11626     echo "$as_me:$LINENO: result: pre-installed" >&5
11627 echo "${ECHO_T}pre-installed" >&6
11628   fi
11629 fi
11630
11631 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11632 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11633 if test "x${build}" != "x${host}" ; then
11634   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11635     # We already found the complete path
11636     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11637     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11638 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11639   else
11640     # Canadian cross, just use what we found
11641     echo "$as_me:$LINENO: result: pre-installed" >&5
11642 echo "${ECHO_T}pre-installed" >&6
11643   fi
11644 else
11645   ok=yes
11646   case " ${configdirs} " in
11647     *" binutils "*) ;;
11648     *) ok=no ;;
11649   esac
11650
11651   if test $ok = yes; then
11652     # An in-tree tool is available and we can use it
11653     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11654     echo "$as_me:$LINENO: result: just compiled" >&5
11655 echo "${ECHO_T}just compiled" >&6
11656   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11657     # We already found the complete path
11658     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11659     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11660 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11661   elif test "x$target" = "x$host"; then
11662     # We can use an host tool
11663     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11664     echo "$as_me:$LINENO: result: host tool" >&5
11665 echo "${ECHO_T}host tool" >&6
11666   else
11667     # We need a cross tool
11668     echo "$as_me:$LINENO: result: pre-installed" >&5
11669 echo "${ECHO_T}pre-installed" >&6
11670   fi
11671 fi
11672
11673 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11674 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11675 if test "x${build}" != "x${host}" ; then
11676   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11677     # We already found the complete path
11678     ac_dir=`dirname $RANLIB_FOR_TARGET`
11679     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11680 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11681   else
11682     # Canadian cross, just use what we found
11683     echo "$as_me:$LINENO: result: pre-installed" >&5
11684 echo "${ECHO_T}pre-installed" >&6
11685   fi
11686 else
11687   ok=yes
11688   case " ${configdirs} " in
11689     *" binutils "*) ;;
11690     *) ok=no ;;
11691   esac
11692
11693   if test $ok = yes; then
11694     # An in-tree tool is available and we can use it
11695     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11696     echo "$as_me:$LINENO: result: just compiled" >&5
11697 echo "${ECHO_T}just compiled" >&6
11698   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11699     # We already found the complete path
11700     ac_dir=`dirname $RANLIB_FOR_TARGET`
11701     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11702 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11703   elif test "x$target" = "x$host"; then
11704     # We can use an host tool
11705     RANLIB_FOR_TARGET='$(RANLIB)'
11706     echo "$as_me:$LINENO: result: host tool" >&5
11707 echo "${ECHO_T}host tool" >&6
11708   else
11709     # We need a cross tool
11710     echo "$as_me:$LINENO: result: pre-installed" >&5
11711 echo "${ECHO_T}pre-installed" >&6
11712   fi
11713 fi
11714
11715 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11716 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11717 if test "x${build}" != "x${host}" ; then
11718   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11719     # We already found the complete path
11720     ac_dir=`dirname $STRIP_FOR_TARGET`
11721     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11722 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11723   else
11724     # Canadian cross, just use what we found
11725     echo "$as_me:$LINENO: result: pre-installed" >&5
11726 echo "${ECHO_T}pre-installed" >&6
11727   fi
11728 else
11729   ok=yes
11730   case " ${configdirs} " in
11731     *" binutils "*) ;;
11732     *) ok=no ;;
11733   esac
11734
11735   if test $ok = yes; then
11736     # An in-tree tool is available and we can use it
11737     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11738     echo "$as_me:$LINENO: result: just compiled" >&5
11739 echo "${ECHO_T}just compiled" >&6
11740   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11741     # We already found the complete path
11742     ac_dir=`dirname $STRIP_FOR_TARGET`
11743     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11744 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11745   elif test "x$target" = "x$host"; then
11746     # We can use an host tool
11747     STRIP_FOR_TARGET='$(STRIP)'
11748     echo "$as_me:$LINENO: result: host tool" >&5
11749 echo "${ECHO_T}host tool" >&6
11750   else
11751     # We need a cross tool
11752     echo "$as_me:$LINENO: result: pre-installed" >&5
11753 echo "${ECHO_T}pre-installed" >&6
11754   fi
11755 fi
11756
11757 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11758 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11759 if test "x${build}" != "x${host}" ; then
11760   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11761     # We already found the complete path
11762     ac_dir=`dirname $WINDRES_FOR_TARGET`
11763     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11764 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11765   else
11766     # Canadian cross, just use what we found
11767     echo "$as_me:$LINENO: result: pre-installed" >&5
11768 echo "${ECHO_T}pre-installed" >&6
11769   fi
11770 else
11771   ok=yes
11772   case " ${configdirs} " in
11773     *" binutils "*) ;;
11774     *) ok=no ;;
11775   esac
11776
11777   if test $ok = yes; then
11778     # An in-tree tool is available and we can use it
11779     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11780     echo "$as_me:$LINENO: result: just compiled" >&5
11781 echo "${ECHO_T}just compiled" >&6
11782   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11783     # We already found the complete path
11784     ac_dir=`dirname $WINDRES_FOR_TARGET`
11785     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11786 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11787   elif test "x$target" = "x$host"; then
11788     # We can use an host tool
11789     WINDRES_FOR_TARGET='$(WINDRES)'
11790     echo "$as_me:$LINENO: result: host tool" >&5
11791 echo "${ECHO_T}host tool" >&6
11792   else
11793     # We need a cross tool
11794     echo "$as_me:$LINENO: result: pre-installed" >&5
11795 echo "${ECHO_T}pre-installed" >&6
11796   fi
11797 fi
11798
11799 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
11800 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
11801 if test "x${build}" != "x${host}" ; then
11802   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11803     # We already found the complete path
11804     ac_dir=`dirname $WINDMC_FOR_TARGET`
11805     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11806 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11807   else
11808     # Canadian cross, just use what we found
11809     echo "$as_me:$LINENO: result: pre-installed" >&5
11810 echo "${ECHO_T}pre-installed" >&6
11811   fi
11812 else
11813   ok=yes
11814   case " ${configdirs} " in
11815     *" binutils "*) ;;
11816     *) ok=no ;;
11817   esac
11818
11819   if test $ok = yes; then
11820     # An in-tree tool is available and we can use it
11821     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
11822     echo "$as_me:$LINENO: result: just compiled" >&5
11823 echo "${ECHO_T}just compiled" >&6
11824   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11825     # We already found the complete path
11826     ac_dir=`dirname $WINDMC_FOR_TARGET`
11827     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11828 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11829   elif test "x$target" = "x$host"; then
11830     # We can use an host tool
11831     WINDMC_FOR_TARGET='$(WINDMC)'
11832     echo "$as_me:$LINENO: result: host tool" >&5
11833 echo "${ECHO_T}host tool" >&6
11834   else
11835     # We need a cross tool
11836     echo "$as_me:$LINENO: result: pre-installed" >&5
11837 echo "${ECHO_T}pre-installed" >&6
11838   fi
11839 fi
11840
11841
11842
11843
11844
11845 # Certain tools may need extra flags.
11846 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11847 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11848 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11849
11850 # When building target libraries, except in a Canadian cross, we use
11851 # the same toolchain as the compiler we just built.
11852 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11853 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11854 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11855 if test $host = $build; then
11856   case " $configdirs " in
11857     *" gcc "*)
11858       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11859       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11860       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11861       ;;
11862   esac
11863 fi
11864
11865
11866
11867
11868
11869 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11870 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11871 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11872 if test "${enable_maintainer_mode+set}" = set; then
11873   enableval="$enable_maintainer_mode"
11874   USE_MAINTAINER_MODE=$enableval
11875 else
11876   USE_MAINTAINER_MODE=no
11877 fi;
11878 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11879 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11880
11881
11882 if test "$USE_MAINTAINER_MODE" = yes; then
11883   MAINTAINER_MODE_TRUE=
11884   MAINTAINER_MODE_FALSE='#'
11885 else
11886   MAINTAINER_MODE_TRUE='#'
11887   MAINTAINER_MODE_FALSE=
11888 fi
11889 MAINT=$MAINTAINER_MODE_TRUE
11890
11891 # ---------------------
11892 # GCC bootstrap support
11893 # ---------------------
11894
11895 # Stage specific cflags for build.
11896 stage1_cflags="-g"
11897 case $build in
11898   vax-*-*)
11899     case ${GCC} in
11900       yes) stage1_cflags="-g -Wa,-J" ;;
11901       *) stage1_cflags="-g -J" ;;
11902     esac ;;
11903 esac
11904
11905 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
11906 if test "$GCC" = yes; then
11907   saved_CFLAGS="$CFLAGS"
11908
11909   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
11910   CFLAGS="$CFLAGS -fkeep-inline-functions"
11911   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
11912 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
11913   cat >conftest.$ac_ext <<_ACEOF
11914 /* confdefs.h.  */
11915 _ACEOF
11916 cat confdefs.h >>conftest.$ac_ext
11917 cat >>conftest.$ac_ext <<_ACEOF
11918 /* end confdefs.h.  */
11919
11920 #if (__GNUC__ < 3) \
11921     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
11922                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
11923 #error http://gcc.gnu.org/PR29382
11924 #endif
11925
11926 int
11927 main ()
11928 {
11929
11930   ;
11931   return 0;
11932 }
11933 _ACEOF
11934 rm -f conftest.$ac_objext
11935 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11936   (eval $ac_compile) 2>conftest.er1
11937   ac_status=$?
11938   grep -v '^ *+' conftest.er1 >conftest.err
11939   rm -f conftest.er1
11940   cat conftest.err >&5
11941   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11942   (exit $ac_status); } &&
11943          { ac_try='test -z "$ac_c_werror_flag"
11944                          || test ! -s conftest.err'
11945   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11946   (eval $ac_try) 2>&5
11947   ac_status=$?
11948   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11949   (exit $ac_status); }; } &&
11950          { ac_try='test -s conftest.$ac_objext'
11951   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11952   (eval $ac_try) 2>&5
11953   ac_status=$?
11954   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11955   (exit $ac_status); }; }; then
11956   echo "$as_me:$LINENO: result: yes" >&5
11957 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
11958 else
11959   echo "$as_me: failed program was:" >&5
11960 sed 's/^/| /' conftest.$ac_ext >&5
11961
11962 echo "$as_me:$LINENO: result: no" >&5
11963 echo "${ECHO_T}no" >&6
11964 fi
11965 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11966
11967   CFLAGS="$saved_CFLAGS"
11968 fi
11969
11970
11971
11972 # Enable --enable-checking in stage1 of the compiler.
11973 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
11974 if test "${enable_stage1_checking+set}" = set; then
11975   enableval="$enable_stage1_checking"
11976   stage1_checking=--enable-checking=${enable_stage1_checking}
11977 else
11978   if test "x$enable_checking" = xno; then
11979   stage1_checking=--enable-checking=yes,types
11980 else
11981   stage1_checking=--enable-checking=types${enable_checking+,}$enable_checking
11982 fi
11983 fi;
11984
11985
11986 # Enable -Werror in bootstrap stage2 and later.
11987 # Check whether --enable-werror or --disable-werror was given.
11988 if test "${enable_werror+set}" = set; then
11989   enableval="$enable_werror"
11990
11991 else
11992   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
11993   enable_werror=yes
11994 else
11995   enable_werror=no
11996 fi
11997 fi;
11998 case ${enable_werror} in
11999   yes) stage2_werror_flag="--enable-werror-always" ;;
12000   *) stage2_werror_flag="" ;;
12001 esac
12002
12003
12004 # Flags needed to enable html installing and building
12005
12006 # Check whether --with-datarootdir or --without-datarootdir was given.
12007 if test "${with_datarootdir+set}" = set; then
12008   withval="$with_datarootdir"
12009   datarootdir="\${prefix}/${withval}"
12010 else
12011   datarootdir="\${prefix}/share"
12012 fi;
12013
12014
12015 # Check whether --with-docdir or --without-docdir was given.
12016 if test "${with_docdir+set}" = set; then
12017   withval="$with_docdir"
12018   docdir="\${prefix}/${withval}"
12019 else
12020   docdir="\${datarootdir}/doc"
12021 fi;
12022
12023
12024 # Check whether --with-pdfdir or --without-pdfdir was given.
12025 if test "${with_pdfdir+set}" = set; then
12026   withval="$with_pdfdir"
12027   pdfdir="\${prefix}/${withval}"
12028 else
12029   pdfdir="\${docdir}"
12030 fi;
12031
12032
12033 # Check whether --with-htmldir or --without-htmldir was given.
12034 if test "${with_htmldir+set}" = set; then
12035   withval="$with_htmldir"
12036   htmldir="\${prefix}/${withval}"
12037 else
12038   htmldir="\${docdir}"
12039 fi;
12040
12041
12042
12043
12044
12045
12046           ac_config_files="$ac_config_files Makefile"
12047 cat >confcache <<\_ACEOF
12048 # This file is a shell script that caches the results of configure
12049 # tests run on this system so they can be shared between configure
12050 # scripts and configure runs, see configure's option --config-cache.
12051 # It is not useful on other systems.  If it contains results you don't
12052 # want to keep, you may remove or edit it.
12053 #
12054 # config.status only pays attention to the cache file if you give it
12055 # the --recheck option to rerun configure.
12056 #
12057 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12058 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12059 # following values.
12060
12061 _ACEOF
12062
12063 # The following way of writing the cache mishandles newlines in values,
12064 # but we know of no workaround that is simple, portable, and efficient.
12065 # So, don't put newlines in cache variables' values.
12066 # Ultrix sh set writes to stderr and can't be redirected directly,
12067 # and sets the high bit in the cache file unless we assign to the vars.
12068 {
12069   (set) 2>&1 |
12070     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12071     *ac_space=\ *)
12072       # `set' does not quote correctly, so add quotes (double-quote
12073       # substitution turns \\\\ into \\, and sed turns \\ into \).
12074       sed -n \
12075         "s/'/'\\\\''/g;
12076           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12077       ;;
12078     *)
12079       # `set' quotes correctly as required by POSIX, so do not add quotes.
12080       sed -n \
12081         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12082       ;;
12083     esac;
12084 } |
12085   sed '
12086      t clear
12087      : clear
12088      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12089      t end
12090      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12091      : end' >>confcache
12092 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12093   if test -w $cache_file; then
12094     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12095     cat confcache >$cache_file
12096   else
12097     echo "not updating unwritable cache $cache_file"
12098   fi
12099 fi
12100 rm -f confcache
12101
12102 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12103 # Let make expand exec_prefix.
12104 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12105
12106 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12107 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12108 # trailing colons and then remove the whole line if VPATH becomes empty
12109 # (actually we leave an empty line to preserve line numbers).
12110 if test "x$srcdir" = x.; then
12111   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12112 s/:*\$(srcdir):*/:/;
12113 s/:*\${srcdir}:*/:/;
12114 s/:*@srcdir@:*/:/;
12115 s/^\([^=]*=[     ]*\):*/\1/;
12116 s/:*$//;
12117 s/^[^=]*=[       ]*$//;
12118 }'
12119 fi
12120
12121 # Transform confdefs.h into DEFS.
12122 # Protect against shell expansion while executing Makefile rules.
12123 # Protect against Makefile macro expansion.
12124 #
12125 # If the first sed substitution is executed (which looks for macros that
12126 # take arguments), then we branch to the quote section.  Otherwise,
12127 # look for a macro that doesn't take arguments.
12128 cat >confdef2opt.sed <<\_ACEOF
12129 t clear
12130 : clear
12131 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12132 t quote
12133 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12134 t quote
12135 d
12136 : quote
12137 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12138 s,\[,\\&,g
12139 s,\],\\&,g
12140 s,\$,$$,g
12141 p
12142 _ACEOF
12143 # We use echo to avoid assuming a particular line-breaking character.
12144 # The extra dot is to prevent the shell from consuming trailing
12145 # line-breaks from the sub-command output.  A line-break within
12146 # single-quotes doesn't work because, if this script is created in a
12147 # platform that uses two characters for line-breaks (e.g., DOS), tr
12148 # would break.
12149 ac_LF_and_DOT=`echo; echo .`
12150 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12151 rm -f confdef2opt.sed
12152
12153
12154 ac_libobjs=
12155 ac_ltlibobjs=
12156 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12157   # 1. Remove the extension, and $U if already installed.
12158   ac_i=`echo "$ac_i" |
12159          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12160   # 2. Add them.
12161   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12162   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12163 done
12164 LIBOBJS=$ac_libobjs
12165
12166 LTLIBOBJS=$ac_ltlibobjs
12167
12168
12169
12170 : ${CONFIG_STATUS=./config.status}
12171 ac_clean_files_save=$ac_clean_files
12172 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12173 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12174 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12175 cat >$CONFIG_STATUS <<_ACEOF
12176 #! $SHELL
12177 # Generated by $as_me.
12178 # Run this file to recreate the current configuration.
12179 # Compiler output produced by configure, useful for debugging
12180 # configure, is in config.log if it exists.
12181
12182 debug=false
12183 ac_cs_recheck=false
12184 ac_cs_silent=false
12185 SHELL=\${CONFIG_SHELL-$SHELL}
12186 _ACEOF
12187
12188 cat >>$CONFIG_STATUS <<\_ACEOF
12189 ## --------------------- ##
12190 ## M4sh Initialization.  ##
12191 ## --------------------- ##
12192
12193 # Be Bourne compatible
12194 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12195   emulate sh
12196   NULLCMD=:
12197   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12198   # is contrary to our usage.  Disable this feature.
12199   alias -g '${1+"$@"}'='"$@"'
12200 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12201   set -o posix
12202 fi
12203 DUALCASE=1; export DUALCASE # for MKS sh
12204
12205 # Support unset when possible.
12206 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12207   as_unset=unset
12208 else
12209   as_unset=false
12210 fi
12211
12212
12213 # Work around bugs in pre-3.0 UWIN ksh.
12214 $as_unset ENV MAIL MAILPATH
12215 PS1='$ '
12216 PS2='> '
12217 PS4='+ '
12218
12219 # NLS nuisances.
12220 for as_var in \
12221   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12222   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12223   LC_TELEPHONE LC_TIME
12224 do
12225   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12226     eval $as_var=C; export $as_var
12227   else
12228     $as_unset $as_var
12229   fi
12230 done
12231
12232 # Required to use basename.
12233 if expr a : '\(a\)' >/dev/null 2>&1; then
12234   as_expr=expr
12235 else
12236   as_expr=false
12237 fi
12238
12239 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12240   as_basename=basename
12241 else
12242   as_basename=false
12243 fi
12244
12245
12246 # Name of the executable.
12247 as_me=`$as_basename "$0" ||
12248 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12249          X"$0" : 'X\(//\)$' \| \
12250          X"$0" : 'X\(/\)$' \| \
12251          .     : '\(.\)' 2>/dev/null ||
12252 echo X/"$0" |
12253     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12254           /^X\/\(\/\/\)$/{ s//\1/; q; }
12255           /^X\/\(\/\).*/{ s//\1/; q; }
12256           s/.*/./; q'`
12257
12258
12259 # PATH needs CR, and LINENO needs CR and PATH.
12260 # Avoid depending upon Character Ranges.
12261 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12262 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12263 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12264 as_cr_digits='0123456789'
12265 as_cr_alnum=$as_cr_Letters$as_cr_digits
12266
12267 # The user is always right.
12268 if test "${PATH_SEPARATOR+set}" != set; then
12269   echo "#! /bin/sh" >conf$$.sh
12270   echo  "exit 0"   >>conf$$.sh
12271   chmod +x conf$$.sh
12272   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12273     PATH_SEPARATOR=';'
12274   else
12275     PATH_SEPARATOR=:
12276   fi
12277   rm -f conf$$.sh
12278 fi
12279
12280
12281   as_lineno_1=$LINENO
12282   as_lineno_2=$LINENO
12283   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12284   test "x$as_lineno_1" != "x$as_lineno_2" &&
12285   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12286   # Find who we are.  Look in the path if we contain no path at all
12287   # relative or not.
12288   case $0 in
12289     *[\\/]* ) as_myself=$0 ;;
12290     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12291 for as_dir in $PATH
12292 do
12293   IFS=$as_save_IFS
12294   test -z "$as_dir" && as_dir=.
12295   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12296 done
12297
12298        ;;
12299   esac
12300   # We did not find ourselves, most probably we were run as `sh COMMAND'
12301   # in which case we are not to be found in the path.
12302   if test "x$as_myself" = x; then
12303     as_myself=$0
12304   fi
12305   if test ! -f "$as_myself"; then
12306     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12307 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12308    { (exit 1); exit 1; }; }
12309   fi
12310   case $CONFIG_SHELL in
12311   '')
12312     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12313 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12314 do
12315   IFS=$as_save_IFS
12316   test -z "$as_dir" && as_dir=.
12317   for as_base in sh bash ksh sh5; do
12318          case $as_dir in
12319          /*)
12320            if ("$as_dir/$as_base" -c '
12321   as_lineno_1=$LINENO
12322   as_lineno_2=$LINENO
12323   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12324   test "x$as_lineno_1" != "x$as_lineno_2" &&
12325   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12326              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12327              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12328              CONFIG_SHELL=$as_dir/$as_base
12329              export CONFIG_SHELL
12330              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12331            fi;;
12332          esac
12333        done
12334 done
12335 ;;
12336   esac
12337
12338   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12339   # uniformly replaced by the line number.  The first 'sed' inserts a
12340   # line-number line before each line; the second 'sed' does the real
12341   # work.  The second script uses 'N' to pair each line-number line
12342   # with the numbered line, and appends trailing '-' during
12343   # substitution so that $LINENO is not a special case at line end.
12344   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12345   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12346   sed '=' <$as_myself |
12347     sed '
12348       N
12349       s,$,-,
12350       : loop
12351       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12352       t loop
12353       s,-$,,
12354       s,^['$as_cr_digits']*\n,,
12355     ' >$as_me.lineno &&
12356   chmod +x $as_me.lineno ||
12357     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12358 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12359    { (exit 1); exit 1; }; }
12360
12361   # Don't try to exec as it changes $[0], causing all sort of problems
12362   # (the dirname of $[0] is not the place where we might find the
12363   # original and so on.  Autoconf is especially sensible to this).
12364   . ./$as_me.lineno
12365   # Exit status is that of the last command.
12366   exit
12367 }
12368
12369
12370 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12371   *c*,-n*) ECHO_N= ECHO_C='
12372 ' ECHO_T='      ' ;;
12373   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12374   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12375 esac
12376
12377 if expr a : '\(a\)' >/dev/null 2>&1; then
12378   as_expr=expr
12379 else
12380   as_expr=false
12381 fi
12382
12383 rm -f conf$$ conf$$.exe conf$$.file
12384 echo >conf$$.file
12385 if ln -s conf$$.file conf$$ 2>/dev/null; then
12386   # We could just check for DJGPP; but this test a) works b) is more generic
12387   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12388   if test -f conf$$.exe; then
12389     # Don't use ln at all; we don't have any links
12390     as_ln_s='cp -p'
12391   else
12392     as_ln_s='ln -s'
12393   fi
12394 elif ln conf$$.file conf$$ 2>/dev/null; then
12395   as_ln_s=ln
12396 else
12397   as_ln_s='cp -p'
12398 fi
12399 rm -f conf$$ conf$$.exe conf$$.file
12400
12401 if mkdir -p . 2>/dev/null; then
12402   as_mkdir_p=:
12403 else
12404   test -d ./-p && rmdir ./-p
12405   as_mkdir_p=false
12406 fi
12407
12408 as_executable_p="test -f"
12409
12410 # Sed expression to map a string onto a valid CPP name.
12411 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12412
12413 # Sed expression to map a string onto a valid variable name.
12414 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12415
12416
12417 # IFS
12418 # We need space, tab and new line, in precisely that order.
12419 as_nl='
12420 '
12421 IFS="   $as_nl"
12422
12423 # CDPATH.
12424 $as_unset CDPATH
12425
12426 exec 6>&1
12427
12428 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12429 # report actual input values of CONFIG_FILES etc. instead of their
12430 # values after options handling.  Logging --version etc. is OK.
12431 exec 5>>config.log
12432 {
12433   echo
12434   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12435 ## Running $as_me. ##
12436 _ASBOX
12437 } >&5
12438 cat >&5 <<_CSEOF
12439
12440 This file was extended by $as_me, which was
12441 generated by GNU Autoconf 2.59.  Invocation command line was
12442
12443   CONFIG_FILES    = $CONFIG_FILES
12444   CONFIG_HEADERS  = $CONFIG_HEADERS
12445   CONFIG_LINKS    = $CONFIG_LINKS
12446   CONFIG_COMMANDS = $CONFIG_COMMANDS
12447   $ $0 $@
12448
12449 _CSEOF
12450 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12451 echo >&5
12452 _ACEOF
12453
12454 # Files that config.status was made for.
12455 if test -n "$ac_config_files"; then
12456   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12457 fi
12458
12459 if test -n "$ac_config_headers"; then
12460   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12461 fi
12462
12463 if test -n "$ac_config_links"; then
12464   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12465 fi
12466
12467 if test -n "$ac_config_commands"; then
12468   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12469 fi
12470
12471 cat >>$CONFIG_STATUS <<\_ACEOF
12472
12473 ac_cs_usage="\
12474 \`$as_me' instantiates files from templates according to the
12475 current configuration.
12476
12477 Usage: $0 [OPTIONS] [FILE]...
12478
12479   -h, --help       print this help, then exit
12480   -V, --version    print version number, then exit
12481   -q, --quiet      do not print progress messages
12482   -d, --debug      don't remove temporary files
12483       --recheck    update $as_me by reconfiguring in the same conditions
12484   --file=FILE[:TEMPLATE]
12485                    instantiate the configuration file FILE
12486
12487 Configuration files:
12488 $config_files
12489
12490 Report bugs to <bug-autoconf@gnu.org>."
12491 _ACEOF
12492
12493 cat >>$CONFIG_STATUS <<_ACEOF
12494 ac_cs_version="\\
12495 config.status
12496 configured by $0, generated by GNU Autoconf 2.59,
12497   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12498
12499 Copyright (C) 2003 Free Software Foundation, Inc.
12500 This config.status script is free software; the Free Software Foundation
12501 gives unlimited permission to copy, distribute and modify it."
12502 srcdir=$srcdir
12503 INSTALL="$INSTALL"
12504 _ACEOF
12505
12506 cat >>$CONFIG_STATUS <<\_ACEOF
12507 # If no file are specified by the user, then we need to provide default
12508 # value.  By we need to know if files were specified by the user.
12509 ac_need_defaults=:
12510 while test $# != 0
12511 do
12512   case $1 in
12513   --*=*)
12514     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12515     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12516     ac_shift=:
12517     ;;
12518   -*)
12519     ac_option=$1
12520     ac_optarg=$2
12521     ac_shift=shift
12522     ;;
12523   *) # This is not an option, so the user has probably given explicit
12524      # arguments.
12525      ac_option=$1
12526      ac_need_defaults=false;;
12527   esac
12528
12529   case $ac_option in
12530   # Handling of the options.
12531 _ACEOF
12532 cat >>$CONFIG_STATUS <<\_ACEOF
12533   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12534     ac_cs_recheck=: ;;
12535   --version | --vers* | -V )
12536     echo "$ac_cs_version"; exit 0 ;;
12537   --he | --h)
12538     # Conflict between --help and --header
12539     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12540 Try \`$0 --help' for more information." >&5
12541 echo "$as_me: error: ambiguous option: $1
12542 Try \`$0 --help' for more information." >&2;}
12543    { (exit 1); exit 1; }; };;
12544   --help | --hel | -h )
12545     echo "$ac_cs_usage"; exit 0 ;;
12546   --debug | --d* | -d )
12547     debug=: ;;
12548   --file | --fil | --fi | --f )
12549     $ac_shift
12550     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12551     ac_need_defaults=false;;
12552   --header | --heade | --head | --hea )
12553     $ac_shift
12554     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12555     ac_need_defaults=false;;
12556   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12557   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12558     ac_cs_silent=: ;;
12559
12560   # This is an error.
12561   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12562 Try \`$0 --help' for more information." >&5
12563 echo "$as_me: error: unrecognized option: $1
12564 Try \`$0 --help' for more information." >&2;}
12565    { (exit 1); exit 1; }; } ;;
12566
12567   *) ac_config_targets="$ac_config_targets $1" ;;
12568
12569   esac
12570   shift
12571 done
12572
12573 ac_configure_extra_args=
12574
12575 if $ac_cs_silent; then
12576   exec 6>/dev/null
12577   ac_configure_extra_args="$ac_configure_extra_args --silent"
12578 fi
12579
12580 _ACEOF
12581 cat >>$CONFIG_STATUS <<_ACEOF
12582 if \$ac_cs_recheck; then
12583   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12584   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12585 fi
12586
12587 _ACEOF
12588
12589
12590
12591
12592
12593 cat >>$CONFIG_STATUS <<\_ACEOF
12594 for ac_config_target in $ac_config_targets
12595 do
12596   case "$ac_config_target" in
12597   # Handling of arguments.
12598   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12599   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12600 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12601    { (exit 1); exit 1; }; };;
12602   esac
12603 done
12604
12605 # If the user did not use the arguments to specify the items to instantiate,
12606 # then the envvar interface is used.  Set only those that are not.
12607 # We use the long form for the default assignment because of an extremely
12608 # bizarre bug on SunOS 4.1.3.
12609 if $ac_need_defaults; then
12610   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12611 fi
12612
12613 # Have a temporary directory for convenience.  Make it in the build tree
12614 # simply because there is no reason to put it here, and in addition,
12615 # creating and moving files from /tmp can sometimes cause problems.
12616 # Create a temporary directory, and hook for its removal unless debugging.
12617 $debug ||
12618 {
12619   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12620   trap '{ (exit 1); exit 1; }' 1 2 13 15
12621 }
12622
12623 # Create a (secure) tmp directory for tmp files.
12624
12625 {
12626   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12627   test -n "$tmp" && test -d "$tmp"
12628 }  ||
12629 {
12630   tmp=./confstat$$-$RANDOM
12631   (umask 077 && mkdir $tmp)
12632 } ||
12633 {
12634    echo "$me: cannot create a temporary directory in ." >&2
12635    { (exit 1); exit 1; }
12636 }
12637
12638 _ACEOF
12639
12640 cat >>$CONFIG_STATUS <<_ACEOF
12641
12642 #
12643 # CONFIG_FILES section.
12644 #
12645
12646 # No need to generate the scripts if there are no CONFIG_FILES.
12647 # This happens for instance when ./config.status config.h
12648 if test -n "\$CONFIG_FILES"; then
12649   # Protect against being on the right side of a sed subst in config.status.
12650   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12651    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12652 s,@SHELL@,$SHELL,;t t
12653 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12654 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12655 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12656 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12657 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12658 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12659 s,@exec_prefix@,$exec_prefix,;t t
12660 s,@prefix@,$prefix,;t t
12661 s,@program_transform_name@,$program_transform_name,;t t
12662 s,@bindir@,$bindir,;t t
12663 s,@sbindir@,$sbindir,;t t
12664 s,@libexecdir@,$libexecdir,;t t
12665 s,@datadir@,$datadir,;t t
12666 s,@sysconfdir@,$sysconfdir,;t t
12667 s,@sharedstatedir@,$sharedstatedir,;t t
12668 s,@localstatedir@,$localstatedir,;t t
12669 s,@libdir@,$libdir,;t t
12670 s,@includedir@,$includedir,;t t
12671 s,@oldincludedir@,$oldincludedir,;t t
12672 s,@infodir@,$infodir,;t t
12673 s,@mandir@,$mandir,;t t
12674 s,@build_alias@,$build_alias,;t t
12675 s,@host_alias@,$host_alias,;t t
12676 s,@target_alias@,$target_alias,;t t
12677 s,@DEFS@,$DEFS,;t t
12678 s,@ECHO_C@,$ECHO_C,;t t
12679 s,@ECHO_N@,$ECHO_N,;t t
12680 s,@ECHO_T@,$ECHO_T,;t t
12681 s,@LIBS@,$LIBS,;t t
12682 s,@build@,$build,;t t
12683 s,@build_cpu@,$build_cpu,;t t
12684 s,@build_vendor@,$build_vendor,;t t
12685 s,@build_os@,$build_os,;t t
12686 s,@build_noncanonical@,$build_noncanonical,;t t
12687 s,@host_noncanonical@,$host_noncanonical,;t t
12688 s,@target_noncanonical@,$target_noncanonical,;t t
12689 s,@host@,$host,;t t
12690 s,@host_cpu@,$host_cpu,;t t
12691 s,@host_vendor@,$host_vendor,;t t
12692 s,@host_os@,$host_os,;t t
12693 s,@target@,$target,;t t
12694 s,@target_cpu@,$target_cpu,;t t
12695 s,@target_vendor@,$target_vendor,;t t
12696 s,@target_os@,$target_os,;t t
12697 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12698 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12699 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12700 s,@LN@,$LN,;t t
12701 s,@LN_S@,$LN_S,;t t
12702 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12703 s,@build_libsubdir@,$build_libsubdir,;t t
12704 s,@build_subdir@,$build_subdir,;t t
12705 s,@host_subdir@,$host_subdir,;t t
12706 s,@target_subdir@,$target_subdir,;t t
12707 s,@CC@,$CC,;t t
12708 s,@CFLAGS@,$CFLAGS,;t t
12709 s,@LDFLAGS@,$LDFLAGS,;t t
12710 s,@CPPFLAGS@,$CPPFLAGS,;t t
12711 s,@ac_ct_CC@,$ac_ct_CC,;t t
12712 s,@EXEEXT@,$EXEEXT,;t t
12713 s,@OBJEXT@,$OBJEXT,;t t
12714 s,@CXX@,$CXX,;t t
12715 s,@CXXFLAGS@,$CXXFLAGS,;t t
12716 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12717 s,@GNATBIND@,$GNATBIND,;t t
12718 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12719 s,@GNATMAKE@,$GNATMAKE,;t t
12720 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12721 s,@do_compare@,$do_compare,;t t
12722 s,@gmplibs@,$gmplibs,;t t
12723 s,@gmpinc@,$gmpinc,;t t
12724 s,@stage1_languages@,$stage1_languages,;t t
12725 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12726 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12727 s,@tooldir@,$tooldir,;t t
12728 s,@build_tooldir@,$build_tooldir,;t t
12729 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12730 s,@GDB_TK@,$GDB_TK,;t t
12731 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12732 s,@build_configargs@,$build_configargs,;t t
12733 s,@build_configdirs@,$build_configdirs,;t t
12734 s,@host_configargs@,$host_configargs,;t t
12735 s,@configdirs@,$configdirs,;t t
12736 s,@target_configargs@,$target_configargs,;t t
12737 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12738 s,@config_shell@,$config_shell,;t t
12739 s,@YACC@,$YACC,;t t
12740 s,@BISON@,$BISON,;t t
12741 s,@M4@,$M4,;t t
12742 s,@LEX@,$LEX,;t t
12743 s,@FLEX@,$FLEX,;t t
12744 s,@MAKEINFO@,$MAKEINFO,;t t
12745 s,@EXPECT@,$EXPECT,;t t
12746 s,@RUNTEST@,$RUNTEST,;t t
12747 s,@AR@,$AR,;t t
12748 s,@AS@,$AS,;t t
12749 s,@DLLTOOL@,$DLLTOOL,;t t
12750 s,@LD@,$LD,;t t
12751 s,@LIPO@,$LIPO,;t t
12752 s,@NM@,$NM,;t t
12753 s,@RANLIB@,$RANLIB,;t t
12754 s,@STRIP@,$STRIP,;t t
12755 s,@WINDRES@,$WINDRES,;t t
12756 s,@WINDMC@,$WINDMC,;t t
12757 s,@OBJCOPY@,$OBJCOPY,;t t
12758 s,@OBJDUMP@,$OBJDUMP,;t t
12759 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12760 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12761 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12762 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12763 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12764 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12765 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12766 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12767 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12768 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12769 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12770 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12771 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12772 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12773 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12774 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12775 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12776 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12777 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12778 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12779 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12780 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12781 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12782 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12783 s,@MAINT@,$MAINT,;t t
12784 s,@stage1_cflags@,$stage1_cflags,;t t
12785 s,@stage1_checking@,$stage1_checking,;t t
12786 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12787 s,@datarootdir@,$datarootdir,;t t
12788 s,@docdir@,$docdir,;t t
12789 s,@pdfdir@,$pdfdir,;t t
12790 s,@htmldir@,$htmldir,;t t
12791 s,@LIBOBJS@,$LIBOBJS,;t t
12792 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12793 /@serialization_dependencies@/r $serialization_dependencies
12794 s,@serialization_dependencies@,,;t t
12795 /@host_makefile_frag@/r $host_makefile_frag
12796 s,@host_makefile_frag@,,;t t
12797 /@target_makefile_frag@/r $target_makefile_frag
12798 s,@target_makefile_frag@,,;t t
12799 /@alphaieee_frag@/r $alphaieee_frag
12800 s,@alphaieee_frag@,,;t t
12801 /@ospace_frag@/r $ospace_frag
12802 s,@ospace_frag@,,;t t
12803 CEOF
12804
12805 _ACEOF
12806
12807   cat >>$CONFIG_STATUS <<\_ACEOF
12808   # Split the substitutions into bite-sized pieces for seds with
12809   # small command number limits, like on Digital OSF/1 and HP-UX.
12810   ac_max_sed_lines=48
12811   ac_sed_frag=1 # Number of current file.
12812   ac_beg=1 # First line for current file.
12813   ac_end=$ac_max_sed_lines # Line after last line for current file.
12814   ac_more_lines=:
12815   ac_sed_cmds=
12816   while $ac_more_lines; do
12817     if test $ac_beg -gt 1; then
12818       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12819     else
12820       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12821     fi
12822     if test ! -s $tmp/subs.frag; then
12823       ac_more_lines=false
12824     else
12825       # The purpose of the label and of the branching condition is to
12826       # speed up the sed processing (if there are no `@' at all, there
12827       # is no need to browse any of the substitutions).
12828       # These are the two extra sed commands mentioned above.
12829       (echo ':t
12830   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12831       if test -z "$ac_sed_cmds"; then
12832         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12833       else
12834         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12835       fi
12836       ac_sed_frag=`expr $ac_sed_frag + 1`
12837       ac_beg=$ac_end
12838       ac_end=`expr $ac_end + $ac_max_sed_lines`
12839     fi
12840   done
12841   if test -z "$ac_sed_cmds"; then
12842     ac_sed_cmds=cat
12843   fi
12844 fi # test -n "$CONFIG_FILES"
12845
12846 _ACEOF
12847 cat >>$CONFIG_STATUS <<\_ACEOF
12848 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12849   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12850   case $ac_file in
12851   - | *:- | *:-:* ) # input from stdin
12852         cat >$tmp/stdin
12853         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12854         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12855   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12856         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12857   * )   ac_file_in=$ac_file.in ;;
12858   esac
12859
12860   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12861   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12862 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12863          X"$ac_file" : 'X\(//\)[^/]' \| \
12864          X"$ac_file" : 'X\(//\)$' \| \
12865          X"$ac_file" : 'X\(/\)' \| \
12866          .     : '\(.\)' 2>/dev/null ||
12867 echo X"$ac_file" |
12868     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12869           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12870           /^X\(\/\/\)$/{ s//\1/; q; }
12871           /^X\(\/\).*/{ s//\1/; q; }
12872           s/.*/./; q'`
12873   { if $as_mkdir_p; then
12874     mkdir -p "$ac_dir"
12875   else
12876     as_dir="$ac_dir"
12877     as_dirs=
12878     while test ! -d "$as_dir"; do
12879       as_dirs="$as_dir $as_dirs"
12880       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12881 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12882          X"$as_dir" : 'X\(//\)[^/]' \| \
12883          X"$as_dir" : 'X\(//\)$' \| \
12884          X"$as_dir" : 'X\(/\)' \| \
12885          .     : '\(.\)' 2>/dev/null ||
12886 echo X"$as_dir" |
12887     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12888           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12889           /^X\(\/\/\)$/{ s//\1/; q; }
12890           /^X\(\/\).*/{ s//\1/; q; }
12891           s/.*/./; q'`
12892     done
12893     test ! -n "$as_dirs" || mkdir $as_dirs
12894   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
12895 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
12896    { (exit 1); exit 1; }; }; }
12897
12898   ac_builddir=.
12899
12900 if test "$ac_dir" != .; then
12901   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
12902   # A "../" for each directory in $ac_dir_suffix.
12903   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
12904 else
12905   ac_dir_suffix= ac_top_builddir=
12906 fi
12907
12908 case $srcdir in
12909   .)  # No --srcdir option.  We are building in place.
12910     ac_srcdir=.
12911     if test -z "$ac_top_builddir"; then
12912        ac_top_srcdir=.
12913     else
12914        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
12915     fi ;;
12916   [\\/]* | ?:[\\/]* )  # Absolute path.
12917     ac_srcdir=$srcdir$ac_dir_suffix;
12918     ac_top_srcdir=$srcdir ;;
12919   *) # Relative path.
12920     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
12921     ac_top_srcdir=$ac_top_builddir$srcdir ;;
12922 esac
12923
12924 # Do not use `cd foo && pwd` to compute absolute paths, because
12925 # the directories may not exist.
12926 case `pwd` in
12927 .) ac_abs_builddir="$ac_dir";;
12928 *)
12929   case "$ac_dir" in
12930   .) ac_abs_builddir=`pwd`;;
12931   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
12932   *) ac_abs_builddir=`pwd`/"$ac_dir";;
12933   esac;;
12934 esac
12935 case $ac_abs_builddir in
12936 .) ac_abs_top_builddir=${ac_top_builddir}.;;
12937 *)
12938   case ${ac_top_builddir}. in
12939   .) ac_abs_top_builddir=$ac_abs_builddir;;
12940   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
12941   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
12942   esac;;
12943 esac
12944 case $ac_abs_builddir in
12945 .) ac_abs_srcdir=$ac_srcdir;;
12946 *)
12947   case $ac_srcdir in
12948   .) ac_abs_srcdir=$ac_abs_builddir;;
12949   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
12950   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
12951   esac;;
12952 esac
12953 case $ac_abs_builddir in
12954 .) ac_abs_top_srcdir=$ac_top_srcdir;;
12955 *)
12956   case $ac_top_srcdir in
12957   .) ac_abs_top_srcdir=$ac_abs_builddir;;
12958   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
12959   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
12960   esac;;
12961 esac
12962
12963
12964   case $INSTALL in
12965   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
12966   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
12967   esac
12968
12969   if test x"$ac_file" != x-; then
12970     { echo "$as_me:$LINENO: creating $ac_file" >&5
12971 echo "$as_me: creating $ac_file" >&6;}
12972     rm -f "$ac_file"
12973   fi
12974   # Let's still pretend it is `configure' which instantiates (i.e., don't
12975   # use $as_me), people would be surprised to read:
12976   #    /* config.h.  Generated by config.status.  */
12977   if test x"$ac_file" = x-; then
12978     configure_input=
12979   else
12980     configure_input="$ac_file.  "
12981   fi
12982   configure_input=$configure_input"Generated from `echo $ac_file_in |
12983                                      sed 's,.*/,,'` by configure."
12984
12985   # First look for the input files in the build tree, otherwise in the
12986   # src tree.
12987   ac_file_inputs=`IFS=:
12988     for f in $ac_file_in; do
12989       case $f in
12990       -) echo $tmp/stdin ;;
12991       [\\/$]*)
12992          # Absolute (can't be DOS-style, as IFS=:)
12993          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
12994 echo "$as_me: error: cannot find input file: $f" >&2;}
12995    { (exit 1); exit 1; }; }
12996          echo "$f";;
12997       *) # Relative
12998          if test -f "$f"; then
12999            # Build tree
13000            echo "$f"
13001          elif test -f "$srcdir/$f"; then
13002            # Source tree
13003            echo "$srcdir/$f"
13004          else
13005            # /dev/null tree
13006            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13007 echo "$as_me: error: cannot find input file: $f" >&2;}
13008    { (exit 1); exit 1; }; }
13009          fi;;
13010       esac
13011     done` || { (exit 1); exit 1; }
13012 _ACEOF
13013 cat >>$CONFIG_STATUS <<_ACEOF
13014   sed "$ac_vpsub
13015 $extrasub
13016 _ACEOF
13017 cat >>$CONFIG_STATUS <<\_ACEOF
13018 :t
13019 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13020 s,@configure_input@,$configure_input,;t t
13021 s,@srcdir@,$ac_srcdir,;t t
13022 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13023 s,@top_srcdir@,$ac_top_srcdir,;t t
13024 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13025 s,@builddir@,$ac_builddir,;t t
13026 s,@abs_builddir@,$ac_abs_builddir,;t t
13027 s,@top_builddir@,$ac_top_builddir,;t t
13028 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13029 s,@INSTALL@,$ac_INSTALL,;t t
13030 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13031   rm -f $tmp/stdin
13032   if test x"$ac_file" != x-; then
13033     mv $tmp/out $ac_file
13034   else
13035     cat $tmp/out
13036     rm -f $tmp/out
13037   fi
13038
13039 done
13040 _ACEOF
13041
13042 cat >>$CONFIG_STATUS <<\_ACEOF
13043
13044 { (exit 0); exit 0; }
13045 _ACEOF
13046 chmod +x $CONFIG_STATUS
13047 ac_clean_files=$ac_clean_files_save
13048
13049
13050 # configure is writing to config.log, and then calls config.status.
13051 # config.status does its own redirection, appending to config.log.
13052 # Unfortunately, on DOS this fails, as config.log is still kept open
13053 # by configure, so config.status won't be able to write to it; its
13054 # output is simply discarded.  So we exec the FD to /dev/null,
13055 # effectively closing config.log, so it can be properly (re)opened and
13056 # appended to by config.status.  When coming back to configure, we
13057 # need to make the FD available again.
13058 if test "$no_create" != yes; then
13059   ac_cs_success=:
13060   ac_config_status_args=
13061   test "$silent" = yes &&
13062     ac_config_status_args="$ac_config_status_args --quiet"
13063   exec 5>/dev/null
13064   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13065   exec 5>>config.log
13066   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13067   # would make configure fail if this is the last instruction.
13068   $ac_cs_success || { (exit 1); exit 1; }
13069 fi
13070