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   *-*-netware*)
5228     target_makefile_frag="config/mt-netware"
5229     ;;
5230   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5231     target_makefile_frag="config/mt-gnu"
5232     ;;
5233   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5234     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5235     # commands to handle both 32-bit and 64-bit objects.  These flags are
5236     # harmless if we're using GNU nm or ar.
5237     extra_arflags_for_target=" -X32_64"
5238     extra_nmflags_for_target=" -B -X32_64"
5239     ;;
5240   *-*-darwin*)
5241     # ranlib from Darwin requires the -c flag to look at common symbols.
5242     extra_ranlibflags_for_target=" -c"
5243     ;;
5244   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5245     target_makefile_frag="config/mt-wince"
5246     ;;
5247 esac
5248
5249 alphaieee_frag=/dev/null
5250 case $target in
5251   alpha*-*-*)
5252     # This just makes sure to use the -mieee option to build target libs.
5253     # This should probably be set individually by each library.
5254     alphaieee_frag="config/mt-alphaieee"
5255     ;;
5256 esac
5257
5258 # If --enable-target-optspace always use -Os instead of -O2 to build
5259 # the target libraries, similarly if it is not specified, use -Os
5260 # on selected platforms.
5261 ospace_frag=/dev/null
5262 case "${enable_target_optspace}:${target}" in
5263   yes:*)
5264     ospace_frag="config/mt-ospace"
5265     ;;
5266   :d30v-*)
5267     ospace_frag="config/mt-d30v"
5268     ;;
5269   :m32r-* | :d10v-* | :fr30-*)
5270     ospace_frag="config/mt-ospace"
5271     ;;
5272   no:* | :*)
5273     ;;
5274   *)
5275     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5276     ;;
5277 esac
5278
5279 # Default to using --with-stabs for certain targets.
5280 if test x${with_stabs} = x ; then
5281   case "${target}" in
5282   mips*-*-irix[56]*)
5283     ;;
5284   mips*-*-* | alpha*-*-osf*)
5285     with_stabs=yes;
5286     extra_host_args="${extra_host_args} --with-stabs"
5287     ;;
5288   esac
5289 fi
5290
5291 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5292 # them automatically.
5293 case "${host}" in
5294   hppa*64*-*-hpux11*)
5295     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5296     ;;
5297 esac
5298
5299 # Some systems (e.g., one of the i386-aix systems the gas testers are
5300 # using) don't handle "\$" correctly, so don't use it here.
5301 tooldir='${exec_prefix}'/${target_noncanonical}
5302 build_tooldir=${tooldir}
5303
5304 # Create a .gdbinit file which runs the one in srcdir
5305 # and tells GDB to look there for source files.
5306
5307 if test -r ${srcdir}/.gdbinit ; then
5308   case ${srcdir} in
5309     .) ;;
5310     *) cat > ./.gdbinit <<EOF
5311 # ${NO_EDIT}
5312 dir ${srcdir}
5313 dir .
5314 source ${srcdir}/.gdbinit
5315 EOF
5316     ;;
5317   esac
5318 fi
5319
5320 # Make sure that the compiler is able to generate an executable.  If it
5321 # can't, we are probably in trouble.  We don't care whether we can run the
5322 # executable--we might be using a cross compiler--we only care whether it
5323 # can be created.  At this point the main configure script has set CC.
5324 we_are_ok=no
5325 echo "int main () { return 0; }" > conftest.c
5326 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5327 if test $? = 0 ; then
5328   if test -s conftest || test -s conftest.exe ; then
5329     we_are_ok=yes
5330   fi
5331 fi
5332 case $we_are_ok in
5333   no)
5334     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5335     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5336     rm -f conftest*
5337     exit 1
5338     ;;
5339 esac
5340 rm -f conftest*
5341
5342 # The Solaris /usr/ucb/cc compiler does not appear to work.
5343 case "${host}" in
5344   sparc-sun-solaris2*)
5345       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5346       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5347           could_use=
5348           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5349           if test -d /opt/cygnus/bin ; then
5350               if test "$could_use" = "" ; then
5351                   could_use="/opt/cygnus/bin"
5352               else
5353                   could_use="$could_use or /opt/cygnus/bin"
5354               fi
5355           fi
5356         if test "$could_use" = "" ; then
5357             echo "Warning: compilation may fail because you're using"
5358             echo "/usr/ucb/cc.  You should change your PATH or CC "
5359             echo "variable and rerun configure."
5360         else
5361             echo "Warning: compilation may fail because you're using"
5362             echo "/usr/ucb/cc, when you should use the C compiler from"
5363             echo "$could_use.  You should change your"
5364             echo "PATH or CC variable and rerun configure."
5365         fi
5366       fi
5367   ;;
5368 esac
5369
5370 case "${host}" in
5371   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5372   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5373   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5374 esac
5375
5376 # Record target_configdirs and the configure arguments for target and
5377 # build configuration in Makefile.
5378 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5379 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5380
5381 # Determine whether gdb needs tk/tcl or not.
5382 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5383 # and in that case we want gdb to be built without tk.  Ugh!
5384 # In fact I believe gdb is the *only* package directly dependent on tk,
5385 # so we should be able to put the 'maybe's in unconditionally and
5386 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5387 # 100% sure that that's safe though.
5388
5389 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5390 case "$enable_gdbtk" in
5391   no)
5392     GDB_TK="" ;;
5393   yes)
5394     GDB_TK="${gdb_tk}" ;;
5395   *)
5396     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5397     # distro.  Eventually someone will fix this and move Insight, nee
5398     # gdbtk to a separate directory.
5399     if test -d ${srcdir}/gdb/gdbtk ; then
5400       GDB_TK="${gdb_tk}"
5401     else
5402       GDB_TK=""
5403     fi
5404     ;;
5405 esac
5406 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5407 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5408
5409 # Strip out unwanted targets.
5410
5411 # While at that, we remove Makefiles if we were started for recursive
5412 # configuration, so that the top-level Makefile reconfigures them,
5413 # like we used to do when configure itself was recursive.
5414
5415 # Loop over modules.  $extrasub must be used with care, limiting as
5416 # much as possible the usage of range addresses.  That's because autoconf
5417 # splits the sed script to overcome limits in the number of commands,
5418 # and relying on carefully-timed sed passes may turn out to be very hard
5419 # to maintain later.  In this particular case, you just have to be careful
5420 # not to nest @if/@endif pairs, because configure will not warn you at all.
5421
5422 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5423 if test "${enable_bootstrap+set}" = set; then
5424   enableval="$enable_bootstrap"
5425
5426 else
5427   enable_bootstrap=default
5428 fi;
5429
5430 # Issue errors and warnings for invalid/strange bootstrap combinations.
5431 case "$configdirs" in
5432   *gcc*) have_compiler=yes ;;
5433   *) have_compiler=no ;;
5434 esac
5435
5436 case "$have_compiler:$host:$target:$enable_bootstrap" in
5437   *:*:*:no) ;;
5438
5439   # Default behavior.  Enable bootstrap if we have a compiler
5440   # and we are in a native configuration.
5441   yes:$build:$build:default)
5442     enable_bootstrap=yes ;;
5443
5444   *:*:*:default)
5445     enable_bootstrap=no ;;
5446
5447   # We have a compiler and we are in a native configuration, bootstrap is ok
5448   yes:$build:$build:yes)
5449     ;;
5450
5451   # Other configurations, but we have a compiler.  Assume the user knows
5452   # what he's doing.
5453   yes:*:*:yes)
5454     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5455 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5456     ;;
5457
5458   # No compiler: if they passed --enable-bootstrap explicitly, fail
5459   no:*:*:yes)
5460     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5461 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5462    { (exit 1); exit 1; }; } ;;
5463
5464   # Fail if wrong command line
5465   *)
5466     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5467 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5468    { (exit 1); exit 1; }; }
5469     ;;
5470 esac
5471
5472 # Adjust the toplevel makefile according to whether bootstrap was selected.
5473 case "$enable_bootstrap" in
5474   yes)
5475     bootstrap_suffix=bootstrap ;;
5476   no)
5477     bootstrap_suffix=no-bootstrap ;;
5478 esac
5479
5480 for module in ${build_configdirs} ; do
5481   if test -z "${no_recursion}" \
5482      && test -f ${build_subdir}/${module}/Makefile; then
5483     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5484     rm -f ${build_subdir}/${module}/Makefile
5485   fi
5486   extrasub="$extrasub
5487 /^@if build-$module\$/d
5488 /^@endif build-$module\$/d
5489 /^@if build-$module-$bootstrap_suffix\$/d
5490 /^@endif build-$module-$bootstrap_suffix\$/d"
5491 done
5492 for module in ${configdirs} ; do
5493   if test -z "${no_recursion}"; then
5494     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5495       if test -f ${file}; then
5496         echo 1>&2 "*** removing ${file} to force reconfigure"
5497         rm -f ${file}
5498       fi
5499     done
5500   fi
5501   extrasub="$extrasub
5502 /^@if $module\$/d
5503 /^@endif $module\$/d
5504 /^@if $module-$bootstrap_suffix\$/d
5505 /^@endif $module-$bootstrap_suffix\$/d"
5506 done
5507 for module in ${target_configdirs} ; do
5508   if test -z "${no_recursion}" \
5509      && test -f ${target_subdir}/${module}/Makefile; then
5510     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5511     rm -f ${target_subdir}/${module}/Makefile
5512   fi
5513   extrasub="$extrasub
5514 /^@if target-$module\$/d
5515 /^@endif target-$module\$/d
5516 /^@if target-$module-$bootstrap_suffix\$/d
5517 /^@endif target-$module-$bootstrap_suffix\$/d"
5518 done
5519
5520 extrasub="$extrasub
5521 /^@if /,/^@endif /d"
5522
5523 # Create the serialization dependencies.  This uses a temporary file.
5524
5525 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5526 if test "${enable_serial_configure+set}" = set; then
5527   enableval="$enable_serial_configure"
5528
5529 fi;
5530
5531 case ${enable_serial_configure} in
5532   yes)
5533     enable_serial_build_configure=yes
5534     enable_serial_host_configure=yes
5535     enable_serial_target_configure=yes
5536     ;;
5537 esac
5538
5539 # These force 'configure's to be done one at a time, to avoid problems
5540 # with contention over a shared config.cache.
5541 rm -f serdep.tmp
5542 echo '# serdep.tmp' > serdep.tmp
5543 olditem=
5544 test "x${enable_serial_build_configure}" = xyes &&
5545 for item in ${build_configdirs} ; do
5546   case ${olditem} in
5547     "") ;;
5548     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5549   esac
5550   olditem=${item}
5551 done
5552 olditem=
5553 test "x${enable_serial_host_configure}" = xyes &&
5554 for item in ${configdirs} ; do
5555   case ${olditem} in
5556     "") ;;
5557     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5558   esac
5559   olditem=${item}
5560 done
5561 olditem=
5562 test "x${enable_serial_target_configure}" = xyes &&
5563 for item in ${target_configdirs} ; do
5564   case ${olditem} in
5565     "") ;;
5566     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5567   esac
5568   olditem=${item}
5569 done
5570 serialization_dependencies=serdep.tmp
5571
5572
5573 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5574 # target, nonopt, and variable assignments.  These are the ones we
5575 # might not want to pass down to subconfigures.  Also strip
5576 # program-prefix, program-suffix, and program-transform-name, so that
5577 # we can pass down a consistent program-transform-name.
5578 baseargs=
5579 keep_next=no
5580 skip_next=no
5581 eval "set -- $ac_configure_args"
5582 for ac_arg
5583 do
5584   if test X"$skip_next" = X"yes"; then
5585     skip_next=no
5586     continue
5587   fi
5588   if test X"$keep_next" = X"yes"; then
5589     case $ac_arg in
5590       *\'*)
5591         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5592     esac
5593     baseargs="$baseargs '$ac_arg'"
5594     keep_next=no
5595     continue
5596   fi
5597
5598   # Handle separated arguments.  Based on the logic generated by
5599   # autoconf 2.59.
5600   case $ac_arg in
5601     *=* | --config-cache | -C | -disable-* | --disable-* \
5602       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5603       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5604       | -with-* | --with-* | -without-* | --without-* | --x)
5605       separate_arg=no
5606       ;;
5607     -*)
5608       separate_arg=yes
5609       ;;
5610     *)
5611       separate_arg=no
5612       ;;
5613   esac
5614
5615   case "$ac_arg" in
5616     --no*)
5617       continue
5618       ;;
5619     --c* | \
5620     --sr* | \
5621     --ho* | \
5622     --bu* | \
5623     --t* | \
5624     --program-* | \
5625     -cache_file* | \
5626     -srcdir* | \
5627     -host* | \
5628     -build* | \
5629     -target* | \
5630     -program-prefix* | \
5631     -program-suffix* | \
5632     -program-transform-name* )
5633       skip_next=$separate_arg
5634       continue
5635       ;;
5636     -*)
5637       # An option.  Add it.
5638       case $ac_arg in
5639         *\'*)
5640           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5641       esac
5642       baseargs="$baseargs '$ac_arg'"
5643       keep_next=$separate_arg
5644       ;;
5645     *)
5646       # Either a variable assignment, or a nonopt (triplet).  Don't
5647       # pass it down; let the Makefile handle this.
5648       continue
5649       ;;
5650   esac
5651 done
5652 # Remove the initial space we just introduced and, as these will be
5653 # expanded by make, quote '$'.
5654 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5655
5656 # Add in --program-transform-name, after --program-prefix and
5657 # --program-suffix have been applied to it.  Autoconf has already
5658 # doubled dollar signs and backslashes in program_transform_name; we want
5659 # the backslashes un-doubled, and then the entire thing wrapped in single
5660 # quotes, because this will be expanded first by make and then by the shell.
5661 # Also, because we want to override the logic in subdir configure scripts to
5662 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5663 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5664 ${program_transform_name}
5665 EOF_SED
5666 gcc_transform_name=`cat conftestsed.out`
5667 rm -f conftestsed.out
5668 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5669 if test "$silent" = yes; then
5670   baseargs="$baseargs --silent"
5671 fi
5672
5673 # For the build-side libraries, we just need to pretend we're native,
5674 # and not use the same cache file.  Multilibs are neither needed nor
5675 # desired.
5676 build_configargs="--cache-file=../config.cache ${baseargs}"
5677
5678 # For host modules, accept cache file option, or specification as blank.
5679 case "${cache_file}" in
5680 "") # empty
5681   cache_file_option="" ;;
5682 /* | [A-Za-z]:[\\/]* ) # absolute path
5683   cache_file_option="--cache-file=${cache_file}" ;;
5684 *) # relative path
5685   cache_file_option="--cache-file=../${cache_file}" ;;
5686 esac
5687
5688 # Host dirs don't like to share a cache file either, horribly enough.
5689 # This seems to be due to autoconf 2.5x stupidity.
5690 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5691
5692 target_configargs=${baseargs}
5693
5694 # Passing a --with-cross-host argument lets the target libraries know
5695 # whether they are being built with a cross-compiler or being built
5696 # native.  However, it would be better to use other mechanisms to make the
5697 # sorts of decisions they want to make on this basis.  Please consider
5698 # this option to be deprecated.  FIXME.
5699 if test x${is_cross_compiler} = xyes ; then
5700   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5701 fi
5702
5703 # Default to --enable-multilib.
5704 if test x${enable_multilib} = x ; then
5705   target_configargs="--enable-multilib ${target_configargs}"
5706 fi
5707
5708 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5709 # changed from the earlier setting of with_newlib.
5710 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5711   target_configargs="--with-newlib ${target_configargs}"
5712 fi
5713
5714 # Different target subdirs use different values of certain variables
5715 # (notably CXX).  Worse, multilibs use *lots* of different values.
5716 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5717 # it doesn't automatically accept command-line overrides of them.
5718 # This means it's not safe for target subdirs to share a cache file,
5719 # which is disgusting, but there you have it.  Hopefully this can be
5720 # fixed in future.  It's still worthwhile to use a cache file for each
5721 # directory.  I think.
5722
5723 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5724 # We need to pass --target, as newer autoconf's requires consistency
5725 # for target_alias and gcc doesn't manage it consistently.
5726 target_configargs="--cache-file=./config.cache ${target_configargs}"
5727
5728 FLAGS_FOR_TARGET=
5729 case " $target_configdirs " in
5730  *" newlib "*)
5731   case " $target_configargs " in
5732   *" --with-newlib "*)
5733    case "$target" in
5734    *-cygwin*)
5735      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' ;;
5736    esac
5737
5738    # If we're not building GCC, don't discard standard headers.
5739    if test -d ${srcdir}/gcc; then
5740      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5741
5742      if test "${build}" != "${host}"; then
5743        # On Canadian crosses, CC_FOR_TARGET will have already been set
5744        # by `configure', so we won't have an opportunity to add -Bgcc/
5745        # to it.  This is right: we don't want to search that directory
5746        # for binaries, but we want the header files in there, so add
5747        # them explicitly.
5748        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5749
5750        # Someone might think of using the pre-installed headers on
5751        # Canadian crosses, in case the installed compiler is not fully
5752        # compatible with the compiler being built.  In this case, it
5753        # would be better to flag an error than risking having
5754        # incompatible object files being constructed.  We can't
5755        # guarantee that an error will be flagged, but let's hope the
5756        # compiler will do it, when presented with incompatible header
5757        # files.
5758      fi
5759    fi
5760
5761    case "${target}-${is_cross_compiler}" in
5762    i[3456789]86-*-linux*-no)
5763       # Here host == target, so we don't need to build gcc,
5764       # so we don't want to discard standard headers.
5765       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5766       ;;
5767    *)
5768       # If we're building newlib, use its generic headers last, but search
5769       # for any libc-related directories first (so make it the last -B
5770       # switch).
5771       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5772       ;;
5773    esac
5774    ;;
5775   esac
5776   ;;
5777 esac
5778 case "$target" in
5779 *-mingw*)
5780   # Can't be handled as Cygwin above since Mingw does not use newlib.
5781   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' ;;
5782 esac
5783
5784 # Allow the user to override the flags for
5785 # our build compiler if desired.
5786 CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5787
5788 # On Canadian crosses, we'll be searching the right directories for
5789 # the previously-installed cross compiler, so don't bother to add
5790 # flags for directories within the install tree of the compiler
5791 # being built; programs in there won't even run.
5792 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5793   # Search for pre-installed headers if nothing else fits.
5794   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5795 fi
5796
5797 if test "x${use_gnu_ld}" = x &&
5798    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5799   # Arrange for us to find uninstalled linker scripts.
5800   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5801 fi
5802
5803 # Search for other target-specific linker scripts and such.
5804 case "${target}" in
5805   m32c-*-* )
5806     if test -d ${srcdir}/libgloss/m32c; then
5807       # This is for crt0.o
5808       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5809       # This is for r8c.ld
5810       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5811       # This is for libnosys.a
5812       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5813     fi
5814     ;;
5815   mep*)
5816     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5817     ;;
5818 esac
5819
5820 # Makefile fragments.
5821 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5822 do
5823   eval fragval=\$$frag
5824   if test $fragval != /dev/null; then
5825     eval $frag=${srcdir}/$fragval
5826   fi
5827 done
5828
5829
5830
5831
5832
5833 # Miscellanea: directories, flags, etc.
5834
5835
5836
5837
5838
5839
5840
5841 # Build module lists & subconfigure args.
5842
5843
5844
5845 # Host module lists & subconfigure args.
5846
5847
5848
5849 # Target module lists & subconfigure args.
5850
5851
5852
5853 # Build tools.
5854
5855
5856
5857 # Generate default definitions for YACC, M4, LEX and other programs that run
5858 # on the build machine.  These are used if the Makefile can't locate these
5859 # programs in objdir.
5860 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5861
5862 for ac_prog in 'bison -y' byacc yacc
5863 do
5864   # Extract the first word of "$ac_prog", so it can be a program name with args.
5865 set dummy $ac_prog; ac_word=$2
5866 echo "$as_me:$LINENO: checking for $ac_word" >&5
5867 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5868 if test "${ac_cv_prog_YACC+set}" = set; then
5869   echo $ECHO_N "(cached) $ECHO_C" >&6
5870 else
5871   if test -n "$YACC"; then
5872   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5873 else
5874 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5875 for as_dir in $PATH
5876 do
5877   IFS=$as_save_IFS
5878   test -z "$as_dir" && as_dir=.
5879   for ac_exec_ext in '' $ac_executable_extensions; do
5880   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5881     ac_cv_prog_YACC="$ac_prog"
5882     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5883     break 2
5884   fi
5885 done
5886 done
5887
5888 fi
5889 fi
5890 YACC=$ac_cv_prog_YACC
5891 if test -n "$YACC"; then
5892   echo "$as_me:$LINENO: result: $YACC" >&5
5893 echo "${ECHO_T}$YACC" >&6
5894 else
5895   echo "$as_me:$LINENO: result: no" >&5
5896 echo "${ECHO_T}no" >&6
5897 fi
5898
5899   test -n "$YACC" && break
5900 done
5901 test -n "$YACC" || YACC="$MISSING bison -y"
5902
5903 case " $build_configdirs " in
5904   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
5905   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
5906 esac
5907
5908 for ac_prog in bison
5909 do
5910   # Extract the first word of "$ac_prog", so it can be a program name with args.
5911 set dummy $ac_prog; ac_word=$2
5912 echo "$as_me:$LINENO: checking for $ac_word" >&5
5913 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5914 if test "${ac_cv_prog_BISON+set}" = set; then
5915   echo $ECHO_N "(cached) $ECHO_C" >&6
5916 else
5917   if test -n "$BISON"; then
5918   ac_cv_prog_BISON="$BISON" # Let the user override the test.
5919 else
5920 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5921 for as_dir in $PATH
5922 do
5923   IFS=$as_save_IFS
5924   test -z "$as_dir" && as_dir=.
5925   for ac_exec_ext in '' $ac_executable_extensions; do
5926   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5927     ac_cv_prog_BISON="$ac_prog"
5928     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5929     break 2
5930   fi
5931 done
5932 done
5933
5934 fi
5935 fi
5936 BISON=$ac_cv_prog_BISON
5937 if test -n "$BISON"; then
5938   echo "$as_me:$LINENO: result: $BISON" >&5
5939 echo "${ECHO_T}$BISON" >&6
5940 else
5941   echo "$as_me:$LINENO: result: no" >&5
5942 echo "${ECHO_T}no" >&6
5943 fi
5944
5945   test -n "$BISON" && break
5946 done
5947 test -n "$BISON" || BISON="$MISSING bison"
5948
5949 case " $build_configdirs " in
5950   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
5951 esac
5952
5953 for ac_prog in gm4 gnum4 m4
5954 do
5955   # Extract the first word of "$ac_prog", so it can be a program name with args.
5956 set dummy $ac_prog; ac_word=$2
5957 echo "$as_me:$LINENO: checking for $ac_word" >&5
5958 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5959 if test "${ac_cv_prog_M4+set}" = set; then
5960   echo $ECHO_N "(cached) $ECHO_C" >&6
5961 else
5962   if test -n "$M4"; then
5963   ac_cv_prog_M4="$M4" # Let the user override the test.
5964 else
5965 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5966 for as_dir in $PATH
5967 do
5968   IFS=$as_save_IFS
5969   test -z "$as_dir" && as_dir=.
5970   for ac_exec_ext in '' $ac_executable_extensions; do
5971   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5972     ac_cv_prog_M4="$ac_prog"
5973     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5974     break 2
5975   fi
5976 done
5977 done
5978
5979 fi
5980 fi
5981 M4=$ac_cv_prog_M4
5982 if test -n "$M4"; then
5983   echo "$as_me:$LINENO: result: $M4" >&5
5984 echo "${ECHO_T}$M4" >&6
5985 else
5986   echo "$as_me:$LINENO: result: no" >&5
5987 echo "${ECHO_T}no" >&6
5988 fi
5989
5990   test -n "$M4" && break
5991 done
5992 test -n "$M4" || M4="$MISSING m4"
5993
5994 case " $build_configdirs " in
5995   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
5996 esac
5997
5998 for ac_prog in flex lex
5999 do
6000   # Extract the first word of "$ac_prog", so it can be a program name with args.
6001 set dummy $ac_prog; ac_word=$2
6002 echo "$as_me:$LINENO: checking for $ac_word" >&5
6003 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6004 if test "${ac_cv_prog_LEX+set}" = set; then
6005   echo $ECHO_N "(cached) $ECHO_C" >&6
6006 else
6007   if test -n "$LEX"; then
6008   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6009 else
6010 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6011 for as_dir in $PATH
6012 do
6013   IFS=$as_save_IFS
6014   test -z "$as_dir" && as_dir=.
6015   for ac_exec_ext in '' $ac_executable_extensions; do
6016   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6017     ac_cv_prog_LEX="$ac_prog"
6018     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6019     break 2
6020   fi
6021 done
6022 done
6023
6024 fi
6025 fi
6026 LEX=$ac_cv_prog_LEX
6027 if test -n "$LEX"; then
6028   echo "$as_me:$LINENO: result: $LEX" >&5
6029 echo "${ECHO_T}$LEX" >&6
6030 else
6031   echo "$as_me:$LINENO: result: no" >&5
6032 echo "${ECHO_T}no" >&6
6033 fi
6034
6035   test -n "$LEX" && break
6036 done
6037 test -n "$LEX" || LEX="$MISSING flex"
6038
6039 case " $build_configdirs " in
6040   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6041   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6042 esac
6043
6044 for ac_prog in flex
6045 do
6046   # Extract the first word of "$ac_prog", so it can be a program name with args.
6047 set dummy $ac_prog; ac_word=$2
6048 echo "$as_me:$LINENO: checking for $ac_word" >&5
6049 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6050 if test "${ac_cv_prog_FLEX+set}" = set; then
6051   echo $ECHO_N "(cached) $ECHO_C" >&6
6052 else
6053   if test -n "$FLEX"; then
6054   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6055 else
6056 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6057 for as_dir in $PATH
6058 do
6059   IFS=$as_save_IFS
6060   test -z "$as_dir" && as_dir=.
6061   for ac_exec_ext in '' $ac_executable_extensions; do
6062   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6063     ac_cv_prog_FLEX="$ac_prog"
6064     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6065     break 2
6066   fi
6067 done
6068 done
6069
6070 fi
6071 fi
6072 FLEX=$ac_cv_prog_FLEX
6073 if test -n "$FLEX"; then
6074   echo "$as_me:$LINENO: result: $FLEX" >&5
6075 echo "${ECHO_T}$FLEX" >&6
6076 else
6077   echo "$as_me:$LINENO: result: no" >&5
6078 echo "${ECHO_T}no" >&6
6079 fi
6080
6081   test -n "$FLEX" && break
6082 done
6083 test -n "$FLEX" || FLEX="$MISSING flex"
6084
6085 case " $build_configdirs " in
6086   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6087 esac
6088
6089 for ac_prog in makeinfo
6090 do
6091   # Extract the first word of "$ac_prog", so it can be a program name with args.
6092 set dummy $ac_prog; ac_word=$2
6093 echo "$as_me:$LINENO: checking for $ac_word" >&5
6094 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6095 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6096   echo $ECHO_N "(cached) $ECHO_C" >&6
6097 else
6098   if test -n "$MAKEINFO"; then
6099   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6100 else
6101 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6102 for as_dir in $PATH
6103 do
6104   IFS=$as_save_IFS
6105   test -z "$as_dir" && as_dir=.
6106   for ac_exec_ext in '' $ac_executable_extensions; do
6107   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6108     ac_cv_prog_MAKEINFO="$ac_prog"
6109     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6110     break 2
6111   fi
6112 done
6113 done
6114
6115 fi
6116 fi
6117 MAKEINFO=$ac_cv_prog_MAKEINFO
6118 if test -n "$MAKEINFO"; then
6119   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6120 echo "${ECHO_T}$MAKEINFO" >&6
6121 else
6122   echo "$as_me:$LINENO: result: no" >&5
6123 echo "${ECHO_T}no" >&6
6124 fi
6125
6126   test -n "$MAKEINFO" && break
6127 done
6128 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6129
6130 case " $build_configdirs " in
6131   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6132   *)
6133
6134     # For an installed makeinfo, we require it to be from texinfo 4.4 or
6135     # higher, else we use the "missing" dummy.
6136     if ${MAKEINFO} --version \
6137        | egrep 'texinfo[^0-9]*([1-3][0-9]|4\.[4-9]|[5-9])' >/dev/null 2>&1; then
6138       :
6139     else
6140       MAKEINFO="$MISSING makeinfo"
6141     fi
6142     ;;
6143
6144 esac
6145
6146 # FIXME: expect and dejagnu may become build tools?
6147
6148 for ac_prog in expect
6149 do
6150   # Extract the first word of "$ac_prog", so it can be a program name with args.
6151 set dummy $ac_prog; ac_word=$2
6152 echo "$as_me:$LINENO: checking for $ac_word" >&5
6153 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6154 if test "${ac_cv_prog_EXPECT+set}" = set; then
6155   echo $ECHO_N "(cached) $ECHO_C" >&6
6156 else
6157   if test -n "$EXPECT"; then
6158   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6159 else
6160 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6161 for as_dir in $PATH
6162 do
6163   IFS=$as_save_IFS
6164   test -z "$as_dir" && as_dir=.
6165   for ac_exec_ext in '' $ac_executable_extensions; do
6166   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6167     ac_cv_prog_EXPECT="$ac_prog"
6168     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6169     break 2
6170   fi
6171 done
6172 done
6173
6174 fi
6175 fi
6176 EXPECT=$ac_cv_prog_EXPECT
6177 if test -n "$EXPECT"; then
6178   echo "$as_me:$LINENO: result: $EXPECT" >&5
6179 echo "${ECHO_T}$EXPECT" >&6
6180 else
6181   echo "$as_me:$LINENO: result: no" >&5
6182 echo "${ECHO_T}no" >&6
6183 fi
6184
6185   test -n "$EXPECT" && break
6186 done
6187 test -n "$EXPECT" || EXPECT="expect"
6188
6189 case " $configdirs " in
6190   *" expect "*)
6191     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6192     ;;
6193 esac
6194
6195 for ac_prog in runtest
6196 do
6197   # Extract the first word of "$ac_prog", so it can be a program name with args.
6198 set dummy $ac_prog; ac_word=$2
6199 echo "$as_me:$LINENO: checking for $ac_word" >&5
6200 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6201 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6202   echo $ECHO_N "(cached) $ECHO_C" >&6
6203 else
6204   if test -n "$RUNTEST"; then
6205   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6206 else
6207 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6208 for as_dir in $PATH
6209 do
6210   IFS=$as_save_IFS
6211   test -z "$as_dir" && as_dir=.
6212   for ac_exec_ext in '' $ac_executable_extensions; do
6213   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6214     ac_cv_prog_RUNTEST="$ac_prog"
6215     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6216     break 2
6217   fi
6218 done
6219 done
6220
6221 fi
6222 fi
6223 RUNTEST=$ac_cv_prog_RUNTEST
6224 if test -n "$RUNTEST"; then
6225   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6226 echo "${ECHO_T}$RUNTEST" >&6
6227 else
6228   echo "$as_me:$LINENO: result: no" >&5
6229 echo "${ECHO_T}no" >&6
6230 fi
6231
6232   test -n "$RUNTEST" && break
6233 done
6234 test -n "$RUNTEST" || RUNTEST="runtest"
6235
6236 case " $configdirs " in
6237   *" dejagnu "*)
6238     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6239     ;;
6240 esac
6241
6242
6243 # Host tools.
6244 ncn_tool_prefix=
6245 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6246 ncn_target_tool_prefix=
6247 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6248
6249
6250
6251 if test -n "$AR"; then
6252   ac_cv_prog_AR=$AR
6253 elif test -n "$ac_cv_prog_AR"; then
6254   AR=$ac_cv_prog_AR
6255 fi
6256
6257 if test -n "$ac_cv_prog_AR"; then
6258   for ncn_progname in ar; do
6259     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6260 set dummy ${ncn_progname}; ac_word=$2
6261 echo "$as_me:$LINENO: checking for $ac_word" >&5
6262 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6263 if test "${ac_cv_prog_AR+set}" = set; then
6264   echo $ECHO_N "(cached) $ECHO_C" >&6
6265 else
6266   if test -n "$AR"; then
6267   ac_cv_prog_AR="$AR" # Let the user override the test.
6268 else
6269 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6270 for as_dir in $PATH
6271 do
6272   IFS=$as_save_IFS
6273   test -z "$as_dir" && as_dir=.
6274   for ac_exec_ext in '' $ac_executable_extensions; do
6275   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6276     ac_cv_prog_AR="${ncn_progname}"
6277     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6278     break 2
6279   fi
6280 done
6281 done
6282
6283 fi
6284 fi
6285 AR=$ac_cv_prog_AR
6286 if test -n "$AR"; then
6287   echo "$as_me:$LINENO: result: $AR" >&5
6288 echo "${ECHO_T}$AR" >&6
6289 else
6290   echo "$as_me:$LINENO: result: no" >&5
6291 echo "${ECHO_T}no" >&6
6292 fi
6293
6294   done
6295 fi
6296
6297 for ncn_progname in ar; do
6298   if test -n "$ncn_tool_prefix"; then
6299     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6300 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6301 echo "$as_me:$LINENO: checking for $ac_word" >&5
6302 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6303 if test "${ac_cv_prog_AR+set}" = set; then
6304   echo $ECHO_N "(cached) $ECHO_C" >&6
6305 else
6306   if test -n "$AR"; then
6307   ac_cv_prog_AR="$AR" # Let the user override the test.
6308 else
6309 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6310 for as_dir in $PATH
6311 do
6312   IFS=$as_save_IFS
6313   test -z "$as_dir" && as_dir=.
6314   for ac_exec_ext in '' $ac_executable_extensions; do
6315   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6316     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6317     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6318     break 2
6319   fi
6320 done
6321 done
6322
6323 fi
6324 fi
6325 AR=$ac_cv_prog_AR
6326 if test -n "$AR"; then
6327   echo "$as_me:$LINENO: result: $AR" >&5
6328 echo "${ECHO_T}$AR" >&6
6329 else
6330   echo "$as_me:$LINENO: result: no" >&5
6331 echo "${ECHO_T}no" >&6
6332 fi
6333
6334   fi
6335   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6336     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6337 set dummy ${ncn_progname}; ac_word=$2
6338 echo "$as_me:$LINENO: checking for $ac_word" >&5
6339 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6340 if test "${ac_cv_prog_AR+set}" = set; then
6341   echo $ECHO_N "(cached) $ECHO_C" >&6
6342 else
6343   if test -n "$AR"; then
6344   ac_cv_prog_AR="$AR" # Let the user override the test.
6345 else
6346 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6347 for as_dir in $PATH
6348 do
6349   IFS=$as_save_IFS
6350   test -z "$as_dir" && as_dir=.
6351   for ac_exec_ext in '' $ac_executable_extensions; do
6352   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6353     ac_cv_prog_AR="${ncn_progname}"
6354     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6355     break 2
6356   fi
6357 done
6358 done
6359
6360 fi
6361 fi
6362 AR=$ac_cv_prog_AR
6363 if test -n "$AR"; then
6364   echo "$as_me:$LINENO: result: $AR" >&5
6365 echo "${ECHO_T}$AR" >&6
6366 else
6367   echo "$as_me:$LINENO: result: no" >&5
6368 echo "${ECHO_T}no" >&6
6369 fi
6370
6371   fi
6372   test -n "$ac_cv_prog_AR" && break
6373 done
6374
6375 if test -z "$ac_cv_prog_AR" ; then
6376   set dummy ar
6377   if test $build = $host ; then
6378     AR="$2"
6379   else
6380     AR="${ncn_tool_prefix}$2"
6381   fi
6382 fi
6383
6384
6385
6386 if test -n "$AS"; then
6387   ac_cv_prog_AS=$AS
6388 elif test -n "$ac_cv_prog_AS"; then
6389   AS=$ac_cv_prog_AS
6390 fi
6391
6392 if test -n "$ac_cv_prog_AS"; then
6393   for ncn_progname in as; do
6394     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6395 set dummy ${ncn_progname}; ac_word=$2
6396 echo "$as_me:$LINENO: checking for $ac_word" >&5
6397 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6398 if test "${ac_cv_prog_AS+set}" = set; then
6399   echo $ECHO_N "(cached) $ECHO_C" >&6
6400 else
6401   if test -n "$AS"; then
6402   ac_cv_prog_AS="$AS" # Let the user override the test.
6403 else
6404 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6405 for as_dir in $PATH
6406 do
6407   IFS=$as_save_IFS
6408   test -z "$as_dir" && as_dir=.
6409   for ac_exec_ext in '' $ac_executable_extensions; do
6410   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6411     ac_cv_prog_AS="${ncn_progname}"
6412     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6413     break 2
6414   fi
6415 done
6416 done
6417
6418 fi
6419 fi
6420 AS=$ac_cv_prog_AS
6421 if test -n "$AS"; then
6422   echo "$as_me:$LINENO: result: $AS" >&5
6423 echo "${ECHO_T}$AS" >&6
6424 else
6425   echo "$as_me:$LINENO: result: no" >&5
6426 echo "${ECHO_T}no" >&6
6427 fi
6428
6429   done
6430 fi
6431
6432 for ncn_progname in as; do
6433   if test -n "$ncn_tool_prefix"; then
6434     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6435 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6436 echo "$as_me:$LINENO: checking for $ac_word" >&5
6437 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6438 if test "${ac_cv_prog_AS+set}" = set; then
6439   echo $ECHO_N "(cached) $ECHO_C" >&6
6440 else
6441   if test -n "$AS"; then
6442   ac_cv_prog_AS="$AS" # Let the user override the test.
6443 else
6444 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6445 for as_dir in $PATH
6446 do
6447   IFS=$as_save_IFS
6448   test -z "$as_dir" && as_dir=.
6449   for ac_exec_ext in '' $ac_executable_extensions; do
6450   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6451     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6452     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6453     break 2
6454   fi
6455 done
6456 done
6457
6458 fi
6459 fi
6460 AS=$ac_cv_prog_AS
6461 if test -n "$AS"; then
6462   echo "$as_me:$LINENO: result: $AS" >&5
6463 echo "${ECHO_T}$AS" >&6
6464 else
6465   echo "$as_me:$LINENO: result: no" >&5
6466 echo "${ECHO_T}no" >&6
6467 fi
6468
6469   fi
6470   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6471     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6472 set dummy ${ncn_progname}; ac_word=$2
6473 echo "$as_me:$LINENO: checking for $ac_word" >&5
6474 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6475 if test "${ac_cv_prog_AS+set}" = set; then
6476   echo $ECHO_N "(cached) $ECHO_C" >&6
6477 else
6478   if test -n "$AS"; then
6479   ac_cv_prog_AS="$AS" # Let the user override the test.
6480 else
6481 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6482 for as_dir in $PATH
6483 do
6484   IFS=$as_save_IFS
6485   test -z "$as_dir" && as_dir=.
6486   for ac_exec_ext in '' $ac_executable_extensions; do
6487   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6488     ac_cv_prog_AS="${ncn_progname}"
6489     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6490     break 2
6491   fi
6492 done
6493 done
6494
6495 fi
6496 fi
6497 AS=$ac_cv_prog_AS
6498 if test -n "$AS"; then
6499   echo "$as_me:$LINENO: result: $AS" >&5
6500 echo "${ECHO_T}$AS" >&6
6501 else
6502   echo "$as_me:$LINENO: result: no" >&5
6503 echo "${ECHO_T}no" >&6
6504 fi
6505
6506   fi
6507   test -n "$ac_cv_prog_AS" && break
6508 done
6509
6510 if test -z "$ac_cv_prog_AS" ; then
6511   set dummy as
6512   if test $build = $host ; then
6513     AS="$2"
6514   else
6515     AS="${ncn_tool_prefix}$2"
6516   fi
6517 fi
6518
6519
6520
6521 if test -n "$DLLTOOL"; then
6522   ac_cv_prog_DLLTOOL=$DLLTOOL
6523 elif test -n "$ac_cv_prog_DLLTOOL"; then
6524   DLLTOOL=$ac_cv_prog_DLLTOOL
6525 fi
6526
6527 if test -n "$ac_cv_prog_DLLTOOL"; then
6528   for ncn_progname in dlltool; do
6529     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6530 set dummy ${ncn_progname}; ac_word=$2
6531 echo "$as_me:$LINENO: checking for $ac_word" >&5
6532 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6533 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6534   echo $ECHO_N "(cached) $ECHO_C" >&6
6535 else
6536   if test -n "$DLLTOOL"; then
6537   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6538 else
6539 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6540 for as_dir in $PATH
6541 do
6542   IFS=$as_save_IFS
6543   test -z "$as_dir" && as_dir=.
6544   for ac_exec_ext in '' $ac_executable_extensions; do
6545   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6546     ac_cv_prog_DLLTOOL="${ncn_progname}"
6547     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6548     break 2
6549   fi
6550 done
6551 done
6552
6553 fi
6554 fi
6555 DLLTOOL=$ac_cv_prog_DLLTOOL
6556 if test -n "$DLLTOOL"; then
6557   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6558 echo "${ECHO_T}$DLLTOOL" >&6
6559 else
6560   echo "$as_me:$LINENO: result: no" >&5
6561 echo "${ECHO_T}no" >&6
6562 fi
6563
6564   done
6565 fi
6566
6567 for ncn_progname in dlltool; do
6568   if test -n "$ncn_tool_prefix"; then
6569     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6570 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6571 echo "$as_me:$LINENO: checking for $ac_word" >&5
6572 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6573 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6574   echo $ECHO_N "(cached) $ECHO_C" >&6
6575 else
6576   if test -n "$DLLTOOL"; then
6577   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6578 else
6579 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6580 for as_dir in $PATH
6581 do
6582   IFS=$as_save_IFS
6583   test -z "$as_dir" && as_dir=.
6584   for ac_exec_ext in '' $ac_executable_extensions; do
6585   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6586     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6587     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6588     break 2
6589   fi
6590 done
6591 done
6592
6593 fi
6594 fi
6595 DLLTOOL=$ac_cv_prog_DLLTOOL
6596 if test -n "$DLLTOOL"; then
6597   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6598 echo "${ECHO_T}$DLLTOOL" >&6
6599 else
6600   echo "$as_me:$LINENO: result: no" >&5
6601 echo "${ECHO_T}no" >&6
6602 fi
6603
6604   fi
6605   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6606     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6607 set dummy ${ncn_progname}; ac_word=$2
6608 echo "$as_me:$LINENO: checking for $ac_word" >&5
6609 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6610 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6611   echo $ECHO_N "(cached) $ECHO_C" >&6
6612 else
6613   if test -n "$DLLTOOL"; then
6614   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6615 else
6616 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6617 for as_dir in $PATH
6618 do
6619   IFS=$as_save_IFS
6620   test -z "$as_dir" && as_dir=.
6621   for ac_exec_ext in '' $ac_executable_extensions; do
6622   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6623     ac_cv_prog_DLLTOOL="${ncn_progname}"
6624     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6625     break 2
6626   fi
6627 done
6628 done
6629
6630 fi
6631 fi
6632 DLLTOOL=$ac_cv_prog_DLLTOOL
6633 if test -n "$DLLTOOL"; then
6634   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6635 echo "${ECHO_T}$DLLTOOL" >&6
6636 else
6637   echo "$as_me:$LINENO: result: no" >&5
6638 echo "${ECHO_T}no" >&6
6639 fi
6640
6641   fi
6642   test -n "$ac_cv_prog_DLLTOOL" && break
6643 done
6644
6645 if test -z "$ac_cv_prog_DLLTOOL" ; then
6646   set dummy dlltool
6647   if test $build = $host ; then
6648     DLLTOOL="$2"
6649   else
6650     DLLTOOL="${ncn_tool_prefix}$2"
6651   fi
6652 fi
6653
6654
6655
6656 if test -n "$LD"; then
6657   ac_cv_prog_LD=$LD
6658 elif test -n "$ac_cv_prog_LD"; then
6659   LD=$ac_cv_prog_LD
6660 fi
6661
6662 if test -n "$ac_cv_prog_LD"; then
6663   for ncn_progname in ld; do
6664     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6665 set dummy ${ncn_progname}; ac_word=$2
6666 echo "$as_me:$LINENO: checking for $ac_word" >&5
6667 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6668 if test "${ac_cv_prog_LD+set}" = set; then
6669   echo $ECHO_N "(cached) $ECHO_C" >&6
6670 else
6671   if test -n "$LD"; then
6672   ac_cv_prog_LD="$LD" # Let the user override the test.
6673 else
6674 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6675 for as_dir in $PATH
6676 do
6677   IFS=$as_save_IFS
6678   test -z "$as_dir" && as_dir=.
6679   for ac_exec_ext in '' $ac_executable_extensions; do
6680   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6681     ac_cv_prog_LD="${ncn_progname}"
6682     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6683     break 2
6684   fi
6685 done
6686 done
6687
6688 fi
6689 fi
6690 LD=$ac_cv_prog_LD
6691 if test -n "$LD"; then
6692   echo "$as_me:$LINENO: result: $LD" >&5
6693 echo "${ECHO_T}$LD" >&6
6694 else
6695   echo "$as_me:$LINENO: result: no" >&5
6696 echo "${ECHO_T}no" >&6
6697 fi
6698
6699   done
6700 fi
6701
6702 for ncn_progname in ld; do
6703   if test -n "$ncn_tool_prefix"; then
6704     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6705 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6706 echo "$as_me:$LINENO: checking for $ac_word" >&5
6707 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6708 if test "${ac_cv_prog_LD+set}" = set; then
6709   echo $ECHO_N "(cached) $ECHO_C" >&6
6710 else
6711   if test -n "$LD"; then
6712   ac_cv_prog_LD="$LD" # Let the user override the test.
6713 else
6714 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6715 for as_dir in $PATH
6716 do
6717   IFS=$as_save_IFS
6718   test -z "$as_dir" && as_dir=.
6719   for ac_exec_ext in '' $ac_executable_extensions; do
6720   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6721     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6722     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6723     break 2
6724   fi
6725 done
6726 done
6727
6728 fi
6729 fi
6730 LD=$ac_cv_prog_LD
6731 if test -n "$LD"; then
6732   echo "$as_me:$LINENO: result: $LD" >&5
6733 echo "${ECHO_T}$LD" >&6
6734 else
6735   echo "$as_me:$LINENO: result: no" >&5
6736 echo "${ECHO_T}no" >&6
6737 fi
6738
6739   fi
6740   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6741     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6742 set dummy ${ncn_progname}; ac_word=$2
6743 echo "$as_me:$LINENO: checking for $ac_word" >&5
6744 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6745 if test "${ac_cv_prog_LD+set}" = set; then
6746   echo $ECHO_N "(cached) $ECHO_C" >&6
6747 else
6748   if test -n "$LD"; then
6749   ac_cv_prog_LD="$LD" # Let the user override the test.
6750 else
6751 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6752 for as_dir in $PATH
6753 do
6754   IFS=$as_save_IFS
6755   test -z "$as_dir" && as_dir=.
6756   for ac_exec_ext in '' $ac_executable_extensions; do
6757   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6758     ac_cv_prog_LD="${ncn_progname}"
6759     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6760     break 2
6761   fi
6762 done
6763 done
6764
6765 fi
6766 fi
6767 LD=$ac_cv_prog_LD
6768 if test -n "$LD"; then
6769   echo "$as_me:$LINENO: result: $LD" >&5
6770 echo "${ECHO_T}$LD" >&6
6771 else
6772   echo "$as_me:$LINENO: result: no" >&5
6773 echo "${ECHO_T}no" >&6
6774 fi
6775
6776   fi
6777   test -n "$ac_cv_prog_LD" && break
6778 done
6779
6780 if test -z "$ac_cv_prog_LD" ; then
6781   set dummy ld
6782   if test $build = $host ; then
6783     LD="$2"
6784   else
6785     LD="${ncn_tool_prefix}$2"
6786   fi
6787 fi
6788
6789
6790
6791 if test -n "$LIPO"; then
6792   ac_cv_prog_LIPO=$LIPO
6793 elif test -n "$ac_cv_prog_LIPO"; then
6794   LIPO=$ac_cv_prog_LIPO
6795 fi
6796
6797 if test -n "$ac_cv_prog_LIPO"; then
6798   for ncn_progname in lipo; do
6799     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6800 set dummy ${ncn_progname}; ac_word=$2
6801 echo "$as_me:$LINENO: checking for $ac_word" >&5
6802 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6803 if test "${ac_cv_prog_LIPO+set}" = set; then
6804   echo $ECHO_N "(cached) $ECHO_C" >&6
6805 else
6806   if test -n "$LIPO"; then
6807   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6808 else
6809 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6810 for as_dir in $PATH
6811 do
6812   IFS=$as_save_IFS
6813   test -z "$as_dir" && as_dir=.
6814   for ac_exec_ext in '' $ac_executable_extensions; do
6815   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6816     ac_cv_prog_LIPO="${ncn_progname}"
6817     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6818     break 2
6819   fi
6820 done
6821 done
6822
6823 fi
6824 fi
6825 LIPO=$ac_cv_prog_LIPO
6826 if test -n "$LIPO"; then
6827   echo "$as_me:$LINENO: result: $LIPO" >&5
6828 echo "${ECHO_T}$LIPO" >&6
6829 else
6830   echo "$as_me:$LINENO: result: no" >&5
6831 echo "${ECHO_T}no" >&6
6832 fi
6833
6834   done
6835 fi
6836
6837 for ncn_progname in lipo; do
6838   if test -n "$ncn_tool_prefix"; then
6839     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6840 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6841 echo "$as_me:$LINENO: checking for $ac_word" >&5
6842 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6843 if test "${ac_cv_prog_LIPO+set}" = set; then
6844   echo $ECHO_N "(cached) $ECHO_C" >&6
6845 else
6846   if test -n "$LIPO"; then
6847   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6848 else
6849 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6850 for as_dir in $PATH
6851 do
6852   IFS=$as_save_IFS
6853   test -z "$as_dir" && as_dir=.
6854   for ac_exec_ext in '' $ac_executable_extensions; do
6855   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6856     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6857     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6858     break 2
6859   fi
6860 done
6861 done
6862
6863 fi
6864 fi
6865 LIPO=$ac_cv_prog_LIPO
6866 if test -n "$LIPO"; then
6867   echo "$as_me:$LINENO: result: $LIPO" >&5
6868 echo "${ECHO_T}$LIPO" >&6
6869 else
6870   echo "$as_me:$LINENO: result: no" >&5
6871 echo "${ECHO_T}no" >&6
6872 fi
6873
6874   fi
6875   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6876     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6877 set dummy ${ncn_progname}; ac_word=$2
6878 echo "$as_me:$LINENO: checking for $ac_word" >&5
6879 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6880 if test "${ac_cv_prog_LIPO+set}" = set; then
6881   echo $ECHO_N "(cached) $ECHO_C" >&6
6882 else
6883   if test -n "$LIPO"; then
6884   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6885 else
6886 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6887 for as_dir in $PATH
6888 do
6889   IFS=$as_save_IFS
6890   test -z "$as_dir" && as_dir=.
6891   for ac_exec_ext in '' $ac_executable_extensions; do
6892   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6893     ac_cv_prog_LIPO="${ncn_progname}"
6894     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6895     break 2
6896   fi
6897 done
6898 done
6899
6900 fi
6901 fi
6902 LIPO=$ac_cv_prog_LIPO
6903 if test -n "$LIPO"; then
6904   echo "$as_me:$LINENO: result: $LIPO" >&5
6905 echo "${ECHO_T}$LIPO" >&6
6906 else
6907   echo "$as_me:$LINENO: result: no" >&5
6908 echo "${ECHO_T}no" >&6
6909 fi
6910
6911   fi
6912   test -n "$ac_cv_prog_LIPO" && break
6913 done
6914
6915 if test -z "$ac_cv_prog_LIPO" ; then
6916   set dummy lipo
6917   if test $build = $host ; then
6918     LIPO="$2"
6919   else
6920     LIPO="${ncn_tool_prefix}$2"
6921   fi
6922 fi
6923
6924
6925
6926 if test -n "$NM"; then
6927   ac_cv_prog_NM=$NM
6928 elif test -n "$ac_cv_prog_NM"; then
6929   NM=$ac_cv_prog_NM
6930 fi
6931
6932 if test -n "$ac_cv_prog_NM"; then
6933   for ncn_progname in nm; do
6934     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6935 set dummy ${ncn_progname}; ac_word=$2
6936 echo "$as_me:$LINENO: checking for $ac_word" >&5
6937 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6938 if test "${ac_cv_prog_NM+set}" = set; then
6939   echo $ECHO_N "(cached) $ECHO_C" >&6
6940 else
6941   if test -n "$NM"; then
6942   ac_cv_prog_NM="$NM" # Let the user override the test.
6943 else
6944 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6945 for as_dir in $PATH
6946 do
6947   IFS=$as_save_IFS
6948   test -z "$as_dir" && as_dir=.
6949   for ac_exec_ext in '' $ac_executable_extensions; do
6950   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6951     ac_cv_prog_NM="${ncn_progname}"
6952     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6953     break 2
6954   fi
6955 done
6956 done
6957
6958 fi
6959 fi
6960 NM=$ac_cv_prog_NM
6961 if test -n "$NM"; then
6962   echo "$as_me:$LINENO: result: $NM" >&5
6963 echo "${ECHO_T}$NM" >&6
6964 else
6965   echo "$as_me:$LINENO: result: no" >&5
6966 echo "${ECHO_T}no" >&6
6967 fi
6968
6969   done
6970 fi
6971
6972 for ncn_progname in nm; do
6973   if test -n "$ncn_tool_prefix"; then
6974     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6975 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6976 echo "$as_me:$LINENO: checking for $ac_word" >&5
6977 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6978 if test "${ac_cv_prog_NM+set}" = set; then
6979   echo $ECHO_N "(cached) $ECHO_C" >&6
6980 else
6981   if test -n "$NM"; then
6982   ac_cv_prog_NM="$NM" # Let the user override the test.
6983 else
6984 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6985 for as_dir in $PATH
6986 do
6987   IFS=$as_save_IFS
6988   test -z "$as_dir" && as_dir=.
6989   for ac_exec_ext in '' $ac_executable_extensions; do
6990   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6991     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
6992     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6993     break 2
6994   fi
6995 done
6996 done
6997
6998 fi
6999 fi
7000 NM=$ac_cv_prog_NM
7001 if test -n "$NM"; then
7002   echo "$as_me:$LINENO: result: $NM" >&5
7003 echo "${ECHO_T}$NM" >&6
7004 else
7005   echo "$as_me:$LINENO: result: no" >&5
7006 echo "${ECHO_T}no" >&6
7007 fi
7008
7009   fi
7010   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7011     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7012 set dummy ${ncn_progname}; ac_word=$2
7013 echo "$as_me:$LINENO: checking for $ac_word" >&5
7014 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7015 if test "${ac_cv_prog_NM+set}" = set; then
7016   echo $ECHO_N "(cached) $ECHO_C" >&6
7017 else
7018   if test -n "$NM"; then
7019   ac_cv_prog_NM="$NM" # Let the user override the test.
7020 else
7021 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7022 for as_dir in $PATH
7023 do
7024   IFS=$as_save_IFS
7025   test -z "$as_dir" && as_dir=.
7026   for ac_exec_ext in '' $ac_executable_extensions; do
7027   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7028     ac_cv_prog_NM="${ncn_progname}"
7029     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7030     break 2
7031   fi
7032 done
7033 done
7034
7035 fi
7036 fi
7037 NM=$ac_cv_prog_NM
7038 if test -n "$NM"; then
7039   echo "$as_me:$LINENO: result: $NM" >&5
7040 echo "${ECHO_T}$NM" >&6
7041 else
7042   echo "$as_me:$LINENO: result: no" >&5
7043 echo "${ECHO_T}no" >&6
7044 fi
7045
7046   fi
7047   test -n "$ac_cv_prog_NM" && break
7048 done
7049
7050 if test -z "$ac_cv_prog_NM" ; then
7051   set dummy nm
7052   if test $build = $host ; then
7053     NM="$2"
7054   else
7055     NM="${ncn_tool_prefix}$2"
7056   fi
7057 fi
7058
7059
7060
7061 if test -n "$RANLIB"; then
7062   ac_cv_prog_RANLIB=$RANLIB
7063 elif test -n "$ac_cv_prog_RANLIB"; then
7064   RANLIB=$ac_cv_prog_RANLIB
7065 fi
7066
7067 if test -n "$ac_cv_prog_RANLIB"; then
7068   for ncn_progname in ranlib; do
7069     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7070 set dummy ${ncn_progname}; ac_word=$2
7071 echo "$as_me:$LINENO: checking for $ac_word" >&5
7072 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7073 if test "${ac_cv_prog_RANLIB+set}" = set; then
7074   echo $ECHO_N "(cached) $ECHO_C" >&6
7075 else
7076   if test -n "$RANLIB"; then
7077   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7078 else
7079 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7080 for as_dir in $PATH
7081 do
7082   IFS=$as_save_IFS
7083   test -z "$as_dir" && as_dir=.
7084   for ac_exec_ext in '' $ac_executable_extensions; do
7085   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7086     ac_cv_prog_RANLIB="${ncn_progname}"
7087     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7088     break 2
7089   fi
7090 done
7091 done
7092
7093 fi
7094 fi
7095 RANLIB=$ac_cv_prog_RANLIB
7096 if test -n "$RANLIB"; then
7097   echo "$as_me:$LINENO: result: $RANLIB" >&5
7098 echo "${ECHO_T}$RANLIB" >&6
7099 else
7100   echo "$as_me:$LINENO: result: no" >&5
7101 echo "${ECHO_T}no" >&6
7102 fi
7103
7104   done
7105 fi
7106
7107 for ncn_progname in ranlib; do
7108   if test -n "$ncn_tool_prefix"; then
7109     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7110 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7111 echo "$as_me:$LINENO: checking for $ac_word" >&5
7112 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7113 if test "${ac_cv_prog_RANLIB+set}" = set; then
7114   echo $ECHO_N "(cached) $ECHO_C" >&6
7115 else
7116   if test -n "$RANLIB"; then
7117   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7118 else
7119 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7120 for as_dir in $PATH
7121 do
7122   IFS=$as_save_IFS
7123   test -z "$as_dir" && as_dir=.
7124   for ac_exec_ext in '' $ac_executable_extensions; do
7125   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7126     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7127     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7128     break 2
7129   fi
7130 done
7131 done
7132
7133 fi
7134 fi
7135 RANLIB=$ac_cv_prog_RANLIB
7136 if test -n "$RANLIB"; then
7137   echo "$as_me:$LINENO: result: $RANLIB" >&5
7138 echo "${ECHO_T}$RANLIB" >&6
7139 else
7140   echo "$as_me:$LINENO: result: no" >&5
7141 echo "${ECHO_T}no" >&6
7142 fi
7143
7144   fi
7145   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7146     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7147 set dummy ${ncn_progname}; ac_word=$2
7148 echo "$as_me:$LINENO: checking for $ac_word" >&5
7149 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7150 if test "${ac_cv_prog_RANLIB+set}" = set; then
7151   echo $ECHO_N "(cached) $ECHO_C" >&6
7152 else
7153   if test -n "$RANLIB"; then
7154   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7155 else
7156 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7157 for as_dir in $PATH
7158 do
7159   IFS=$as_save_IFS
7160   test -z "$as_dir" && as_dir=.
7161   for ac_exec_ext in '' $ac_executable_extensions; do
7162   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7163     ac_cv_prog_RANLIB="${ncn_progname}"
7164     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7165     break 2
7166   fi
7167 done
7168 done
7169
7170 fi
7171 fi
7172 RANLIB=$ac_cv_prog_RANLIB
7173 if test -n "$RANLIB"; then
7174   echo "$as_me:$LINENO: result: $RANLIB" >&5
7175 echo "${ECHO_T}$RANLIB" >&6
7176 else
7177   echo "$as_me:$LINENO: result: no" >&5
7178 echo "${ECHO_T}no" >&6
7179 fi
7180
7181   fi
7182   test -n "$ac_cv_prog_RANLIB" && break
7183 done
7184
7185 if test -z "$ac_cv_prog_RANLIB" ; then
7186   RANLIB=":"
7187 fi
7188
7189
7190
7191 if test -n "$STRIP"; then
7192   ac_cv_prog_STRIP=$STRIP
7193 elif test -n "$ac_cv_prog_STRIP"; then
7194   STRIP=$ac_cv_prog_STRIP
7195 fi
7196
7197 if test -n "$ac_cv_prog_STRIP"; then
7198   for ncn_progname in strip; do
7199     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7200 set dummy ${ncn_progname}; ac_word=$2
7201 echo "$as_me:$LINENO: checking for $ac_word" >&5
7202 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7203 if test "${ac_cv_prog_STRIP+set}" = set; then
7204   echo $ECHO_N "(cached) $ECHO_C" >&6
7205 else
7206   if test -n "$STRIP"; then
7207   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7208 else
7209 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7210 for as_dir in $PATH
7211 do
7212   IFS=$as_save_IFS
7213   test -z "$as_dir" && as_dir=.
7214   for ac_exec_ext in '' $ac_executable_extensions; do
7215   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7216     ac_cv_prog_STRIP="${ncn_progname}"
7217     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7218     break 2
7219   fi
7220 done
7221 done
7222
7223 fi
7224 fi
7225 STRIP=$ac_cv_prog_STRIP
7226 if test -n "$STRIP"; then
7227   echo "$as_me:$LINENO: result: $STRIP" >&5
7228 echo "${ECHO_T}$STRIP" >&6
7229 else
7230   echo "$as_me:$LINENO: result: no" >&5
7231 echo "${ECHO_T}no" >&6
7232 fi
7233
7234   done
7235 fi
7236
7237 for ncn_progname in strip; do
7238   if test -n "$ncn_tool_prefix"; then
7239     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7240 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7241 echo "$as_me:$LINENO: checking for $ac_word" >&5
7242 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7243 if test "${ac_cv_prog_STRIP+set}" = set; then
7244   echo $ECHO_N "(cached) $ECHO_C" >&6
7245 else
7246   if test -n "$STRIP"; then
7247   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7248 else
7249 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7250 for as_dir in $PATH
7251 do
7252   IFS=$as_save_IFS
7253   test -z "$as_dir" && as_dir=.
7254   for ac_exec_ext in '' $ac_executable_extensions; do
7255   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7256     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7257     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7258     break 2
7259   fi
7260 done
7261 done
7262
7263 fi
7264 fi
7265 STRIP=$ac_cv_prog_STRIP
7266 if test -n "$STRIP"; then
7267   echo "$as_me:$LINENO: result: $STRIP" >&5
7268 echo "${ECHO_T}$STRIP" >&6
7269 else
7270   echo "$as_me:$LINENO: result: no" >&5
7271 echo "${ECHO_T}no" >&6
7272 fi
7273
7274   fi
7275   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7276     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7277 set dummy ${ncn_progname}; ac_word=$2
7278 echo "$as_me:$LINENO: checking for $ac_word" >&5
7279 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7280 if test "${ac_cv_prog_STRIP+set}" = set; then
7281   echo $ECHO_N "(cached) $ECHO_C" >&6
7282 else
7283   if test -n "$STRIP"; then
7284   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7285 else
7286 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7287 for as_dir in $PATH
7288 do
7289   IFS=$as_save_IFS
7290   test -z "$as_dir" && as_dir=.
7291   for ac_exec_ext in '' $ac_executable_extensions; do
7292   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7293     ac_cv_prog_STRIP="${ncn_progname}"
7294     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7295     break 2
7296   fi
7297 done
7298 done
7299
7300 fi
7301 fi
7302 STRIP=$ac_cv_prog_STRIP
7303 if test -n "$STRIP"; then
7304   echo "$as_me:$LINENO: result: $STRIP" >&5
7305 echo "${ECHO_T}$STRIP" >&6
7306 else
7307   echo "$as_me:$LINENO: result: no" >&5
7308 echo "${ECHO_T}no" >&6
7309 fi
7310
7311   fi
7312   test -n "$ac_cv_prog_STRIP" && break
7313 done
7314
7315 if test -z "$ac_cv_prog_STRIP" ; then
7316   STRIP=":"
7317 fi
7318
7319
7320
7321 if test -n "$WINDRES"; then
7322   ac_cv_prog_WINDRES=$WINDRES
7323 elif test -n "$ac_cv_prog_WINDRES"; then
7324   WINDRES=$ac_cv_prog_WINDRES
7325 fi
7326
7327 if test -n "$ac_cv_prog_WINDRES"; then
7328   for ncn_progname in windres; do
7329     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7330 set dummy ${ncn_progname}; ac_word=$2
7331 echo "$as_me:$LINENO: checking for $ac_word" >&5
7332 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7333 if test "${ac_cv_prog_WINDRES+set}" = set; then
7334   echo $ECHO_N "(cached) $ECHO_C" >&6
7335 else
7336   if test -n "$WINDRES"; then
7337   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7338 else
7339 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7340 for as_dir in $PATH
7341 do
7342   IFS=$as_save_IFS
7343   test -z "$as_dir" && as_dir=.
7344   for ac_exec_ext in '' $ac_executable_extensions; do
7345   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7346     ac_cv_prog_WINDRES="${ncn_progname}"
7347     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7348     break 2
7349   fi
7350 done
7351 done
7352
7353 fi
7354 fi
7355 WINDRES=$ac_cv_prog_WINDRES
7356 if test -n "$WINDRES"; then
7357   echo "$as_me:$LINENO: result: $WINDRES" >&5
7358 echo "${ECHO_T}$WINDRES" >&6
7359 else
7360   echo "$as_me:$LINENO: result: no" >&5
7361 echo "${ECHO_T}no" >&6
7362 fi
7363
7364   done
7365 fi
7366
7367 for ncn_progname in windres; do
7368   if test -n "$ncn_tool_prefix"; then
7369     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7370 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7371 echo "$as_me:$LINENO: checking for $ac_word" >&5
7372 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7373 if test "${ac_cv_prog_WINDRES+set}" = set; then
7374   echo $ECHO_N "(cached) $ECHO_C" >&6
7375 else
7376   if test -n "$WINDRES"; then
7377   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7378 else
7379 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7380 for as_dir in $PATH
7381 do
7382   IFS=$as_save_IFS
7383   test -z "$as_dir" && as_dir=.
7384   for ac_exec_ext in '' $ac_executable_extensions; do
7385   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7386     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7387     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7388     break 2
7389   fi
7390 done
7391 done
7392
7393 fi
7394 fi
7395 WINDRES=$ac_cv_prog_WINDRES
7396 if test -n "$WINDRES"; then
7397   echo "$as_me:$LINENO: result: $WINDRES" >&5
7398 echo "${ECHO_T}$WINDRES" >&6
7399 else
7400   echo "$as_me:$LINENO: result: no" >&5
7401 echo "${ECHO_T}no" >&6
7402 fi
7403
7404   fi
7405   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7406     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7407 set dummy ${ncn_progname}; ac_word=$2
7408 echo "$as_me:$LINENO: checking for $ac_word" >&5
7409 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7410 if test "${ac_cv_prog_WINDRES+set}" = set; then
7411   echo $ECHO_N "(cached) $ECHO_C" >&6
7412 else
7413   if test -n "$WINDRES"; then
7414   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7415 else
7416 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7417 for as_dir in $PATH
7418 do
7419   IFS=$as_save_IFS
7420   test -z "$as_dir" && as_dir=.
7421   for ac_exec_ext in '' $ac_executable_extensions; do
7422   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7423     ac_cv_prog_WINDRES="${ncn_progname}"
7424     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7425     break 2
7426   fi
7427 done
7428 done
7429
7430 fi
7431 fi
7432 WINDRES=$ac_cv_prog_WINDRES
7433 if test -n "$WINDRES"; then
7434   echo "$as_me:$LINENO: result: $WINDRES" >&5
7435 echo "${ECHO_T}$WINDRES" >&6
7436 else
7437   echo "$as_me:$LINENO: result: no" >&5
7438 echo "${ECHO_T}no" >&6
7439 fi
7440
7441   fi
7442   test -n "$ac_cv_prog_WINDRES" && break
7443 done
7444
7445 if test -z "$ac_cv_prog_WINDRES" ; then
7446   set dummy windres
7447   if test $build = $host ; then
7448     WINDRES="$2"
7449   else
7450     WINDRES="${ncn_tool_prefix}$2"
7451   fi
7452 fi
7453
7454
7455
7456 if test -n "$WINDMC"; then
7457   ac_cv_prog_WINDMC=$WINDMC
7458 elif test -n "$ac_cv_prog_WINDMC"; then
7459   WINDMC=$ac_cv_prog_WINDMC
7460 fi
7461
7462 if test -n "$ac_cv_prog_WINDMC"; then
7463   for ncn_progname in windmc; do
7464     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7465 set dummy ${ncn_progname}; ac_word=$2
7466 echo "$as_me:$LINENO: checking for $ac_word" >&5
7467 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7468 if test "${ac_cv_prog_WINDMC+set}" = set; then
7469   echo $ECHO_N "(cached) $ECHO_C" >&6
7470 else
7471   if test -n "$WINDMC"; then
7472   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7473 else
7474 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7475 for as_dir in $PATH
7476 do
7477   IFS=$as_save_IFS
7478   test -z "$as_dir" && as_dir=.
7479   for ac_exec_ext in '' $ac_executable_extensions; do
7480   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7481     ac_cv_prog_WINDMC="${ncn_progname}"
7482     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7483     break 2
7484   fi
7485 done
7486 done
7487
7488 fi
7489 fi
7490 WINDMC=$ac_cv_prog_WINDMC
7491 if test -n "$WINDMC"; then
7492   echo "$as_me:$LINENO: result: $WINDMC" >&5
7493 echo "${ECHO_T}$WINDMC" >&6
7494 else
7495   echo "$as_me:$LINENO: result: no" >&5
7496 echo "${ECHO_T}no" >&6
7497 fi
7498
7499   done
7500 fi
7501
7502 for ncn_progname in windmc; do
7503   if test -n "$ncn_tool_prefix"; then
7504     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7505 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7506 echo "$as_me:$LINENO: checking for $ac_word" >&5
7507 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7508 if test "${ac_cv_prog_WINDMC+set}" = set; then
7509   echo $ECHO_N "(cached) $ECHO_C" >&6
7510 else
7511   if test -n "$WINDMC"; then
7512   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7513 else
7514 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7515 for as_dir in $PATH
7516 do
7517   IFS=$as_save_IFS
7518   test -z "$as_dir" && as_dir=.
7519   for ac_exec_ext in '' $ac_executable_extensions; do
7520   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7521     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7522     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7523     break 2
7524   fi
7525 done
7526 done
7527
7528 fi
7529 fi
7530 WINDMC=$ac_cv_prog_WINDMC
7531 if test -n "$WINDMC"; then
7532   echo "$as_me:$LINENO: result: $WINDMC" >&5
7533 echo "${ECHO_T}$WINDMC" >&6
7534 else
7535   echo "$as_me:$LINENO: result: no" >&5
7536 echo "${ECHO_T}no" >&6
7537 fi
7538
7539   fi
7540   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7541     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7542 set dummy ${ncn_progname}; ac_word=$2
7543 echo "$as_me:$LINENO: checking for $ac_word" >&5
7544 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7545 if test "${ac_cv_prog_WINDMC+set}" = set; then
7546   echo $ECHO_N "(cached) $ECHO_C" >&6
7547 else
7548   if test -n "$WINDMC"; then
7549   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7550 else
7551 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7552 for as_dir in $PATH
7553 do
7554   IFS=$as_save_IFS
7555   test -z "$as_dir" && as_dir=.
7556   for ac_exec_ext in '' $ac_executable_extensions; do
7557   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7558     ac_cv_prog_WINDMC="${ncn_progname}"
7559     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7560     break 2
7561   fi
7562 done
7563 done
7564
7565 fi
7566 fi
7567 WINDMC=$ac_cv_prog_WINDMC
7568 if test -n "$WINDMC"; then
7569   echo "$as_me:$LINENO: result: $WINDMC" >&5
7570 echo "${ECHO_T}$WINDMC" >&6
7571 else
7572   echo "$as_me:$LINENO: result: no" >&5
7573 echo "${ECHO_T}no" >&6
7574 fi
7575
7576   fi
7577   test -n "$ac_cv_prog_WINDMC" && break
7578 done
7579
7580 if test -z "$ac_cv_prog_WINDMC" ; then
7581   set dummy windmc
7582   if test $build = $host ; then
7583     WINDMC="$2"
7584   else
7585     WINDMC="${ncn_tool_prefix}$2"
7586   fi
7587 fi
7588
7589
7590
7591 if test -n "$OBJCOPY"; then
7592   ac_cv_prog_OBJCOPY=$OBJCOPY
7593 elif test -n "$ac_cv_prog_OBJCOPY"; then
7594   OBJCOPY=$ac_cv_prog_OBJCOPY
7595 fi
7596
7597 if test -n "$ac_cv_prog_OBJCOPY"; then
7598   for ncn_progname in objcopy; do
7599     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7600 set dummy ${ncn_progname}; ac_word=$2
7601 echo "$as_me:$LINENO: checking for $ac_word" >&5
7602 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7603 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7604   echo $ECHO_N "(cached) $ECHO_C" >&6
7605 else
7606   if test -n "$OBJCOPY"; then
7607   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7608 else
7609 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7610 for as_dir in $PATH
7611 do
7612   IFS=$as_save_IFS
7613   test -z "$as_dir" && as_dir=.
7614   for ac_exec_ext in '' $ac_executable_extensions; do
7615   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7616     ac_cv_prog_OBJCOPY="${ncn_progname}"
7617     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7618     break 2
7619   fi
7620 done
7621 done
7622
7623 fi
7624 fi
7625 OBJCOPY=$ac_cv_prog_OBJCOPY
7626 if test -n "$OBJCOPY"; then
7627   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7628 echo "${ECHO_T}$OBJCOPY" >&6
7629 else
7630   echo "$as_me:$LINENO: result: no" >&5
7631 echo "${ECHO_T}no" >&6
7632 fi
7633
7634   done
7635 fi
7636
7637 for ncn_progname in objcopy; do
7638   if test -n "$ncn_tool_prefix"; then
7639     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7640 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7641 echo "$as_me:$LINENO: checking for $ac_word" >&5
7642 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7643 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7644   echo $ECHO_N "(cached) $ECHO_C" >&6
7645 else
7646   if test -n "$OBJCOPY"; then
7647   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7648 else
7649 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7650 for as_dir in $PATH
7651 do
7652   IFS=$as_save_IFS
7653   test -z "$as_dir" && as_dir=.
7654   for ac_exec_ext in '' $ac_executable_extensions; do
7655   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7656     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7657     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7658     break 2
7659   fi
7660 done
7661 done
7662
7663 fi
7664 fi
7665 OBJCOPY=$ac_cv_prog_OBJCOPY
7666 if test -n "$OBJCOPY"; then
7667   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7668 echo "${ECHO_T}$OBJCOPY" >&6
7669 else
7670   echo "$as_me:$LINENO: result: no" >&5
7671 echo "${ECHO_T}no" >&6
7672 fi
7673
7674   fi
7675   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7676     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7677 set dummy ${ncn_progname}; ac_word=$2
7678 echo "$as_me:$LINENO: checking for $ac_word" >&5
7679 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7680 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7681   echo $ECHO_N "(cached) $ECHO_C" >&6
7682 else
7683   if test -n "$OBJCOPY"; then
7684   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7685 else
7686 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7687 for as_dir in $PATH
7688 do
7689   IFS=$as_save_IFS
7690   test -z "$as_dir" && as_dir=.
7691   for ac_exec_ext in '' $ac_executable_extensions; do
7692   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7693     ac_cv_prog_OBJCOPY="${ncn_progname}"
7694     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7695     break 2
7696   fi
7697 done
7698 done
7699
7700 fi
7701 fi
7702 OBJCOPY=$ac_cv_prog_OBJCOPY
7703 if test -n "$OBJCOPY"; then
7704   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7705 echo "${ECHO_T}$OBJCOPY" >&6
7706 else
7707   echo "$as_me:$LINENO: result: no" >&5
7708 echo "${ECHO_T}no" >&6
7709 fi
7710
7711   fi
7712   test -n "$ac_cv_prog_OBJCOPY" && break
7713 done
7714
7715 if test -z "$ac_cv_prog_OBJCOPY" ; then
7716   set dummy objcopy
7717   if test $build = $host ; then
7718     OBJCOPY="$2"
7719   else
7720     OBJCOPY="${ncn_tool_prefix}$2"
7721   fi
7722 fi
7723
7724
7725
7726 if test -n "$OBJDUMP"; then
7727   ac_cv_prog_OBJDUMP=$OBJDUMP
7728 elif test -n "$ac_cv_prog_OBJDUMP"; then
7729   OBJDUMP=$ac_cv_prog_OBJDUMP
7730 fi
7731
7732 if test -n "$ac_cv_prog_OBJDUMP"; then
7733   for ncn_progname in objdump; do
7734     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7735 set dummy ${ncn_progname}; ac_word=$2
7736 echo "$as_me:$LINENO: checking for $ac_word" >&5
7737 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7738 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7739   echo $ECHO_N "(cached) $ECHO_C" >&6
7740 else
7741   if test -n "$OBJDUMP"; then
7742   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7743 else
7744 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7745 for as_dir in $PATH
7746 do
7747   IFS=$as_save_IFS
7748   test -z "$as_dir" && as_dir=.
7749   for ac_exec_ext in '' $ac_executable_extensions; do
7750   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7751     ac_cv_prog_OBJDUMP="${ncn_progname}"
7752     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7753     break 2
7754   fi
7755 done
7756 done
7757
7758 fi
7759 fi
7760 OBJDUMP=$ac_cv_prog_OBJDUMP
7761 if test -n "$OBJDUMP"; then
7762   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7763 echo "${ECHO_T}$OBJDUMP" >&6
7764 else
7765   echo "$as_me:$LINENO: result: no" >&5
7766 echo "${ECHO_T}no" >&6
7767 fi
7768
7769   done
7770 fi
7771
7772 for ncn_progname in objdump; do
7773   if test -n "$ncn_tool_prefix"; then
7774     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7775 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7776 echo "$as_me:$LINENO: checking for $ac_word" >&5
7777 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7778 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7779   echo $ECHO_N "(cached) $ECHO_C" >&6
7780 else
7781   if test -n "$OBJDUMP"; then
7782   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7783 else
7784 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7785 for as_dir in $PATH
7786 do
7787   IFS=$as_save_IFS
7788   test -z "$as_dir" && as_dir=.
7789   for ac_exec_ext in '' $ac_executable_extensions; do
7790   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7791     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7792     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7793     break 2
7794   fi
7795 done
7796 done
7797
7798 fi
7799 fi
7800 OBJDUMP=$ac_cv_prog_OBJDUMP
7801 if test -n "$OBJDUMP"; then
7802   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7803 echo "${ECHO_T}$OBJDUMP" >&6
7804 else
7805   echo "$as_me:$LINENO: result: no" >&5
7806 echo "${ECHO_T}no" >&6
7807 fi
7808
7809   fi
7810   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7811     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7812 set dummy ${ncn_progname}; ac_word=$2
7813 echo "$as_me:$LINENO: checking for $ac_word" >&5
7814 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7815 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7816   echo $ECHO_N "(cached) $ECHO_C" >&6
7817 else
7818   if test -n "$OBJDUMP"; then
7819   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7820 else
7821 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7822 for as_dir in $PATH
7823 do
7824   IFS=$as_save_IFS
7825   test -z "$as_dir" && as_dir=.
7826   for ac_exec_ext in '' $ac_executable_extensions; do
7827   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7828     ac_cv_prog_OBJDUMP="${ncn_progname}"
7829     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7830     break 2
7831   fi
7832 done
7833 done
7834
7835 fi
7836 fi
7837 OBJDUMP=$ac_cv_prog_OBJDUMP
7838 if test -n "$OBJDUMP"; then
7839   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7840 echo "${ECHO_T}$OBJDUMP" >&6
7841 else
7842   echo "$as_me:$LINENO: result: no" >&5
7843 echo "${ECHO_T}no" >&6
7844 fi
7845
7846   fi
7847   test -n "$ac_cv_prog_OBJDUMP" && break
7848 done
7849
7850 if test -z "$ac_cv_prog_OBJDUMP" ; then
7851   set dummy objdump
7852   if test $build = $host ; then
7853     OBJDUMP="$2"
7854   else
7855     OBJDUMP="${ncn_tool_prefix}$2"
7856   fi
7857 fi
7858
7859
7860
7861
7862
7863
7864
7865 # Target tools.
7866
7867 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7868 if test "${with_build_time_tools+set}" = set; then
7869   withval="$with_build_time_tools"
7870   case x"$withval" in
7871      x/*) ;;
7872      *)
7873        with_build_time_tools=
7874        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7875 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7876        ;;
7877    esac
7878 else
7879   with_build_time_tools=
7880 fi;
7881
7882
7883
7884 if test -n "$CC_FOR_TARGET"; then
7885   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7886 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7887   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7888 fi
7889
7890 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7891   for ncn_progname in cc gcc; do
7892     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7893 set dummy ${ncn_progname}; ac_word=$2
7894 echo "$as_me:$LINENO: checking for $ac_word" >&5
7895 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7896 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7897   echo $ECHO_N "(cached) $ECHO_C" >&6
7898 else
7899   if test -n "$CC_FOR_TARGET"; then
7900   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7901 else
7902 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7903 for as_dir in $PATH
7904 do
7905   IFS=$as_save_IFS
7906   test -z "$as_dir" && as_dir=.
7907   for ac_exec_ext in '' $ac_executable_extensions; do
7908   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7909     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7910     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7911     break 2
7912   fi
7913 done
7914 done
7915
7916 fi
7917 fi
7918 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7919 if test -n "$CC_FOR_TARGET"; then
7920   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7921 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7922 else
7923   echo "$as_me:$LINENO: result: no" >&5
7924 echo "${ECHO_T}no" >&6
7925 fi
7926
7927   done
7928 fi
7929
7930 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
7931   for ncn_progname in cc gcc; do
7932     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7933 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7934     if test -x $with_build_time_tools/${ncn_progname}; then
7935       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7936       echo "$as_me:$LINENO: result: yes" >&5
7937 echo "${ECHO_T}yes" >&6
7938       break
7939     else
7940       echo "$as_me:$LINENO: result: no" >&5
7941 echo "${ECHO_T}no" >&6
7942     fi
7943   done
7944 fi
7945
7946 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
7947   for ncn_progname in cc gcc; do
7948     if test -n "$ncn_target_tool_prefix"; then
7949       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
7950 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
7951 echo "$as_me:$LINENO: checking for $ac_word" >&5
7952 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7953 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7954   echo $ECHO_N "(cached) $ECHO_C" >&6
7955 else
7956   if test -n "$CC_FOR_TARGET"; then
7957   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7958 else
7959 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7960 for as_dir in $PATH
7961 do
7962   IFS=$as_save_IFS
7963   test -z "$as_dir" && as_dir=.
7964   for ac_exec_ext in '' $ac_executable_extensions; do
7965   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7966     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
7967     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7968     break 2
7969   fi
7970 done
7971 done
7972
7973 fi
7974 fi
7975 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7976 if test -n "$CC_FOR_TARGET"; then
7977   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7978 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7979 else
7980   echo "$as_me:$LINENO: result: no" >&5
7981 echo "${ECHO_T}no" >&6
7982 fi
7983
7984     fi
7985     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
7986       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7987 set dummy ${ncn_progname}; ac_word=$2
7988 echo "$as_me:$LINENO: checking for $ac_word" >&5
7989 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7990 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7991   echo $ECHO_N "(cached) $ECHO_C" >&6
7992 else
7993   if test -n "$CC_FOR_TARGET"; then
7994   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7995 else
7996 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7997 for as_dir in $PATH
7998 do
7999   IFS=$as_save_IFS
8000   test -z "$as_dir" && as_dir=.
8001   for ac_exec_ext in '' $ac_executable_extensions; do
8002   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8003     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8004     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8005     break 2
8006   fi
8007 done
8008 done
8009
8010 fi
8011 fi
8012 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8013 if test -n "$CC_FOR_TARGET"; then
8014   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8015 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8016 else
8017   echo "$as_me:$LINENO: result: no" >&5
8018 echo "${ECHO_T}no" >&6
8019 fi
8020
8021     fi
8022     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8023   done
8024 fi
8025
8026 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8027   set dummy cc gcc
8028   if test $build = $target ; then
8029     CC_FOR_TARGET="$2"
8030   else
8031     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8032   fi
8033 else
8034   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8035 fi
8036
8037
8038
8039 if test -n "$CXX_FOR_TARGET"; then
8040   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8041 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8042   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8043 fi
8044
8045 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8046   for ncn_progname in c++ g++ cxx gxx; do
8047     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8048 set dummy ${ncn_progname}; ac_word=$2
8049 echo "$as_me:$LINENO: checking for $ac_word" >&5
8050 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8051 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8052   echo $ECHO_N "(cached) $ECHO_C" >&6
8053 else
8054   if test -n "$CXX_FOR_TARGET"; then
8055   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8056 else
8057 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8058 for as_dir in $PATH
8059 do
8060   IFS=$as_save_IFS
8061   test -z "$as_dir" && as_dir=.
8062   for ac_exec_ext in '' $ac_executable_extensions; do
8063   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8064     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8065     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8066     break 2
8067   fi
8068 done
8069 done
8070
8071 fi
8072 fi
8073 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8074 if test -n "$CXX_FOR_TARGET"; then
8075   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8076 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8077 else
8078   echo "$as_me:$LINENO: result: no" >&5
8079 echo "${ECHO_T}no" >&6
8080 fi
8081
8082   done
8083 fi
8084
8085 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8086   for ncn_progname in c++ g++ cxx gxx; do
8087     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8088 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8089     if test -x $with_build_time_tools/${ncn_progname}; then
8090       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8091       echo "$as_me:$LINENO: result: yes" >&5
8092 echo "${ECHO_T}yes" >&6
8093       break
8094     else
8095       echo "$as_me:$LINENO: result: no" >&5
8096 echo "${ECHO_T}no" >&6
8097     fi
8098   done
8099 fi
8100
8101 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8102   for ncn_progname in c++ g++ cxx gxx; do
8103     if test -n "$ncn_target_tool_prefix"; then
8104       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8105 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8106 echo "$as_me:$LINENO: checking for $ac_word" >&5
8107 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8108 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8109   echo $ECHO_N "(cached) $ECHO_C" >&6
8110 else
8111   if test -n "$CXX_FOR_TARGET"; then
8112   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8113 else
8114 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8115 for as_dir in $PATH
8116 do
8117   IFS=$as_save_IFS
8118   test -z "$as_dir" && as_dir=.
8119   for ac_exec_ext in '' $ac_executable_extensions; do
8120   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8121     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8122     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8123     break 2
8124   fi
8125 done
8126 done
8127
8128 fi
8129 fi
8130 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8131 if test -n "$CXX_FOR_TARGET"; then
8132   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8133 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8134 else
8135   echo "$as_me:$LINENO: result: no" >&5
8136 echo "${ECHO_T}no" >&6
8137 fi
8138
8139     fi
8140     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8141       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8142 set dummy ${ncn_progname}; ac_word=$2
8143 echo "$as_me:$LINENO: checking for $ac_word" >&5
8144 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8145 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8146   echo $ECHO_N "(cached) $ECHO_C" >&6
8147 else
8148   if test -n "$CXX_FOR_TARGET"; then
8149   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8150 else
8151 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8152 for as_dir in $PATH
8153 do
8154   IFS=$as_save_IFS
8155   test -z "$as_dir" && as_dir=.
8156   for ac_exec_ext in '' $ac_executable_extensions; do
8157   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8158     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8159     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8160     break 2
8161   fi
8162 done
8163 done
8164
8165 fi
8166 fi
8167 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8168 if test -n "$CXX_FOR_TARGET"; then
8169   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8170 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8171 else
8172   echo "$as_me:$LINENO: result: no" >&5
8173 echo "${ECHO_T}no" >&6
8174 fi
8175
8176     fi
8177     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8178   done
8179 fi
8180
8181 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8182   set dummy c++ g++ cxx gxx
8183   if test $build = $target ; then
8184     CXX_FOR_TARGET="$2"
8185   else
8186     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8187   fi
8188 else
8189   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8190 fi
8191
8192
8193
8194 if test -n "$GCC_FOR_TARGET"; then
8195   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8196 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8197   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8198 fi
8199
8200 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8201   for ncn_progname in gcc; do
8202     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8203 set dummy ${ncn_progname}; ac_word=$2
8204 echo "$as_me:$LINENO: checking for $ac_word" >&5
8205 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8206 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8207   echo $ECHO_N "(cached) $ECHO_C" >&6
8208 else
8209   if test -n "$GCC_FOR_TARGET"; then
8210   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8211 else
8212 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8213 for as_dir in $PATH
8214 do
8215   IFS=$as_save_IFS
8216   test -z "$as_dir" && as_dir=.
8217   for ac_exec_ext in '' $ac_executable_extensions; do
8218   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8219     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8220     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8221     break 2
8222   fi
8223 done
8224 done
8225
8226 fi
8227 fi
8228 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8229 if test -n "$GCC_FOR_TARGET"; then
8230   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8231 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8232 else
8233   echo "$as_me:$LINENO: result: no" >&5
8234 echo "${ECHO_T}no" >&6
8235 fi
8236
8237   done
8238 fi
8239
8240 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8241   for ncn_progname in gcc; do
8242     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8243 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8244     if test -x $with_build_time_tools/${ncn_progname}; then
8245       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8246       echo "$as_me:$LINENO: result: yes" >&5
8247 echo "${ECHO_T}yes" >&6
8248       break
8249     else
8250       echo "$as_me:$LINENO: result: no" >&5
8251 echo "${ECHO_T}no" >&6
8252     fi
8253   done
8254 fi
8255
8256 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8257   for ncn_progname in gcc; do
8258     if test -n "$ncn_target_tool_prefix"; then
8259       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8260 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8261 echo "$as_me:$LINENO: checking for $ac_word" >&5
8262 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8263 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8264   echo $ECHO_N "(cached) $ECHO_C" >&6
8265 else
8266   if test -n "$GCC_FOR_TARGET"; then
8267   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8268 else
8269 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8270 for as_dir in $PATH
8271 do
8272   IFS=$as_save_IFS
8273   test -z "$as_dir" && as_dir=.
8274   for ac_exec_ext in '' $ac_executable_extensions; do
8275   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8276     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8277     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8278     break 2
8279   fi
8280 done
8281 done
8282
8283 fi
8284 fi
8285 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8286 if test -n "$GCC_FOR_TARGET"; then
8287   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8288 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8289 else
8290   echo "$as_me:$LINENO: result: no" >&5
8291 echo "${ECHO_T}no" >&6
8292 fi
8293
8294     fi
8295     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8296       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8297 set dummy ${ncn_progname}; ac_word=$2
8298 echo "$as_me:$LINENO: checking for $ac_word" >&5
8299 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8300 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8301   echo $ECHO_N "(cached) $ECHO_C" >&6
8302 else
8303   if test -n "$GCC_FOR_TARGET"; then
8304   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8305 else
8306 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8307 for as_dir in $PATH
8308 do
8309   IFS=$as_save_IFS
8310   test -z "$as_dir" && as_dir=.
8311   for ac_exec_ext in '' $ac_executable_extensions; do
8312   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8313     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8314     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8315     break 2
8316   fi
8317 done
8318 done
8319
8320 fi
8321 fi
8322 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8323 if test -n "$GCC_FOR_TARGET"; then
8324   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8325 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8326 else
8327   echo "$as_me:$LINENO: result: no" >&5
8328 echo "${ECHO_T}no" >&6
8329 fi
8330
8331     fi
8332     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8333   done
8334 fi
8335
8336 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8337   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8338 else
8339   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8340 fi
8341
8342
8343
8344 if test -n "$GCJ_FOR_TARGET"; then
8345   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8346 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8347   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8348 fi
8349
8350 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8351   for ncn_progname in gcj; do
8352     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8353 set dummy ${ncn_progname}; ac_word=$2
8354 echo "$as_me:$LINENO: checking for $ac_word" >&5
8355 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8356 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8357   echo $ECHO_N "(cached) $ECHO_C" >&6
8358 else
8359   if test -n "$GCJ_FOR_TARGET"; then
8360   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8361 else
8362 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8363 for as_dir in $PATH
8364 do
8365   IFS=$as_save_IFS
8366   test -z "$as_dir" && as_dir=.
8367   for ac_exec_ext in '' $ac_executable_extensions; do
8368   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8369     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8370     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8371     break 2
8372   fi
8373 done
8374 done
8375
8376 fi
8377 fi
8378 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8379 if test -n "$GCJ_FOR_TARGET"; then
8380   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8381 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8382 else
8383   echo "$as_me:$LINENO: result: no" >&5
8384 echo "${ECHO_T}no" >&6
8385 fi
8386
8387   done
8388 fi
8389
8390 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8391   for ncn_progname in gcj; do
8392     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8393 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8394     if test -x $with_build_time_tools/${ncn_progname}; then
8395       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8396       echo "$as_me:$LINENO: result: yes" >&5
8397 echo "${ECHO_T}yes" >&6
8398       break
8399     else
8400       echo "$as_me:$LINENO: result: no" >&5
8401 echo "${ECHO_T}no" >&6
8402     fi
8403   done
8404 fi
8405
8406 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8407   for ncn_progname in gcj; do
8408     if test -n "$ncn_target_tool_prefix"; then
8409       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8410 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8411 echo "$as_me:$LINENO: checking for $ac_word" >&5
8412 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8413 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8414   echo $ECHO_N "(cached) $ECHO_C" >&6
8415 else
8416   if test -n "$GCJ_FOR_TARGET"; then
8417   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8418 else
8419 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8420 for as_dir in $PATH
8421 do
8422   IFS=$as_save_IFS
8423   test -z "$as_dir" && as_dir=.
8424   for ac_exec_ext in '' $ac_executable_extensions; do
8425   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8426     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8427     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8428     break 2
8429   fi
8430 done
8431 done
8432
8433 fi
8434 fi
8435 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8436 if test -n "$GCJ_FOR_TARGET"; then
8437   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8438 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8439 else
8440   echo "$as_me:$LINENO: result: no" >&5
8441 echo "${ECHO_T}no" >&6
8442 fi
8443
8444     fi
8445     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8446       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8447 set dummy ${ncn_progname}; ac_word=$2
8448 echo "$as_me:$LINENO: checking for $ac_word" >&5
8449 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8450 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8451   echo $ECHO_N "(cached) $ECHO_C" >&6
8452 else
8453   if test -n "$GCJ_FOR_TARGET"; then
8454   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8455 else
8456 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8457 for as_dir in $PATH
8458 do
8459   IFS=$as_save_IFS
8460   test -z "$as_dir" && as_dir=.
8461   for ac_exec_ext in '' $ac_executable_extensions; do
8462   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8463     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8464     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8465     break 2
8466   fi
8467 done
8468 done
8469
8470 fi
8471 fi
8472 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8473 if test -n "$GCJ_FOR_TARGET"; then
8474   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8475 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8476 else
8477   echo "$as_me:$LINENO: result: no" >&5
8478 echo "${ECHO_T}no" >&6
8479 fi
8480
8481     fi
8482     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8483   done
8484 fi
8485
8486 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8487   set dummy gcj
8488   if test $build = $target ; then
8489     GCJ_FOR_TARGET="$2"
8490   else
8491     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8492   fi
8493 else
8494   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8495 fi
8496
8497
8498
8499 if test -n "$GFORTRAN_FOR_TARGET"; then
8500   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8501 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8502   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8503 fi
8504
8505 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8506   for ncn_progname in gfortran; do
8507     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8508 set dummy ${ncn_progname}; ac_word=$2
8509 echo "$as_me:$LINENO: checking for $ac_word" >&5
8510 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8511 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8512   echo $ECHO_N "(cached) $ECHO_C" >&6
8513 else
8514   if test -n "$GFORTRAN_FOR_TARGET"; then
8515   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8516 else
8517 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8518 for as_dir in $PATH
8519 do
8520   IFS=$as_save_IFS
8521   test -z "$as_dir" && as_dir=.
8522   for ac_exec_ext in '' $ac_executable_extensions; do
8523   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8524     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8525     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8526     break 2
8527   fi
8528 done
8529 done
8530
8531 fi
8532 fi
8533 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8534 if test -n "$GFORTRAN_FOR_TARGET"; then
8535   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8536 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8537 else
8538   echo "$as_me:$LINENO: result: no" >&5
8539 echo "${ECHO_T}no" >&6
8540 fi
8541
8542   done
8543 fi
8544
8545 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8546   for ncn_progname in gfortran; do
8547     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8548 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8549     if test -x $with_build_time_tools/${ncn_progname}; then
8550       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8551       echo "$as_me:$LINENO: result: yes" >&5
8552 echo "${ECHO_T}yes" >&6
8553       break
8554     else
8555       echo "$as_me:$LINENO: result: no" >&5
8556 echo "${ECHO_T}no" >&6
8557     fi
8558   done
8559 fi
8560
8561 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8562   for ncn_progname in gfortran; do
8563     if test -n "$ncn_target_tool_prefix"; then
8564       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8565 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8566 echo "$as_me:$LINENO: checking for $ac_word" >&5
8567 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8568 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8569   echo $ECHO_N "(cached) $ECHO_C" >&6
8570 else
8571   if test -n "$GFORTRAN_FOR_TARGET"; then
8572   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8573 else
8574 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8575 for as_dir in $PATH
8576 do
8577   IFS=$as_save_IFS
8578   test -z "$as_dir" && as_dir=.
8579   for ac_exec_ext in '' $ac_executable_extensions; do
8580   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8581     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8582     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8583     break 2
8584   fi
8585 done
8586 done
8587
8588 fi
8589 fi
8590 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8591 if test -n "$GFORTRAN_FOR_TARGET"; then
8592   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8593 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8594 else
8595   echo "$as_me:$LINENO: result: no" >&5
8596 echo "${ECHO_T}no" >&6
8597 fi
8598
8599     fi
8600     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8601       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8602 set dummy ${ncn_progname}; ac_word=$2
8603 echo "$as_me:$LINENO: checking for $ac_word" >&5
8604 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8605 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8606   echo $ECHO_N "(cached) $ECHO_C" >&6
8607 else
8608   if test -n "$GFORTRAN_FOR_TARGET"; then
8609   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8610 else
8611 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8612 for as_dir in $PATH
8613 do
8614   IFS=$as_save_IFS
8615   test -z "$as_dir" && as_dir=.
8616   for ac_exec_ext in '' $ac_executable_extensions; do
8617   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8618     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8619     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8620     break 2
8621   fi
8622 done
8623 done
8624
8625 fi
8626 fi
8627 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8628 if test -n "$GFORTRAN_FOR_TARGET"; then
8629   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8630 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8631 else
8632   echo "$as_me:$LINENO: result: no" >&5
8633 echo "${ECHO_T}no" >&6
8634 fi
8635
8636     fi
8637     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8638   done
8639 fi
8640
8641 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8642   set dummy gfortran
8643   if test $build = $target ; then
8644     GFORTRAN_FOR_TARGET="$2"
8645   else
8646     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8647   fi
8648 else
8649   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8650 fi
8651
8652
8653
8654 cat > conftest.c << \EOF
8655 #ifdef __GNUC__
8656   gcc_yay;
8657 #endif
8658 EOF
8659 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8660   have_gcc_for_target=yes
8661 else
8662   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8663   have_gcc_for_target=no
8664 fi
8665 rm conftest.c
8666
8667
8668
8669
8670 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8671   if test -n "$with_build_time_tools"; then
8672     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8673 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8674     if test -x $with_build_time_tools/ar; then
8675       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8676       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8677       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8678 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8679     else
8680       echo "$as_me:$LINENO: result: no" >&5
8681 echo "${ECHO_T}no" >&6
8682     fi
8683   elif test $build != $host && test $have_gcc_for_target = yes; then
8684     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8685     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8686     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8687   fi
8688 fi
8689 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8690   # Extract the first word of "ar", so it can be a program name with args.
8691 set dummy ar; ac_word=$2
8692 echo "$as_me:$LINENO: checking for $ac_word" >&5
8693 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8694 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8695   echo $ECHO_N "(cached) $ECHO_C" >&6
8696 else
8697   case $AR_FOR_TARGET in
8698   [\\/]* | ?:[\\/]*)
8699   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8700   ;;
8701   *)
8702   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8703 for as_dir in $gcc_cv_tool_dirs
8704 do
8705   IFS=$as_save_IFS
8706   test -z "$as_dir" && as_dir=.
8707   for ac_exec_ext in '' $ac_executable_extensions; do
8708   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8709     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8710     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8711     break 2
8712   fi
8713 done
8714 done
8715
8716   ;;
8717 esac
8718 fi
8719 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8720
8721 if test -n "$AR_FOR_TARGET"; then
8722   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8723 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8724 else
8725   echo "$as_me:$LINENO: result: no" >&5
8726 echo "${ECHO_T}no" >&6
8727 fi
8728
8729 fi
8730 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8731
8732
8733 if test -n "$AR_FOR_TARGET"; then
8734   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8735 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8736   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8737 fi
8738
8739 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8740   for ncn_progname in ar; do
8741     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8742 set dummy ${ncn_progname}; ac_word=$2
8743 echo "$as_me:$LINENO: checking for $ac_word" >&5
8744 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8745 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8746   echo $ECHO_N "(cached) $ECHO_C" >&6
8747 else
8748   if test -n "$AR_FOR_TARGET"; then
8749   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8750 else
8751 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8752 for as_dir in $PATH
8753 do
8754   IFS=$as_save_IFS
8755   test -z "$as_dir" && as_dir=.
8756   for ac_exec_ext in '' $ac_executable_extensions; do
8757   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8758     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8759     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8760     break 2
8761   fi
8762 done
8763 done
8764
8765 fi
8766 fi
8767 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8768 if test -n "$AR_FOR_TARGET"; then
8769   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8770 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8771 else
8772   echo "$as_me:$LINENO: result: no" >&5
8773 echo "${ECHO_T}no" >&6
8774 fi
8775
8776   done
8777 fi
8778
8779 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8780   for ncn_progname in ar; do
8781     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8782 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8783     if test -x $with_build_time_tools/${ncn_progname}; then
8784       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8785       echo "$as_me:$LINENO: result: yes" >&5
8786 echo "${ECHO_T}yes" >&6
8787       break
8788     else
8789       echo "$as_me:$LINENO: result: no" >&5
8790 echo "${ECHO_T}no" >&6
8791     fi
8792   done
8793 fi
8794
8795 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8796   for ncn_progname in ar; do
8797     if test -n "$ncn_target_tool_prefix"; then
8798       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8799 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8800 echo "$as_me:$LINENO: checking for $ac_word" >&5
8801 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8802 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8803   echo $ECHO_N "(cached) $ECHO_C" >&6
8804 else
8805   if test -n "$AR_FOR_TARGET"; then
8806   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8807 else
8808 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8809 for as_dir in $PATH
8810 do
8811   IFS=$as_save_IFS
8812   test -z "$as_dir" && as_dir=.
8813   for ac_exec_ext in '' $ac_executable_extensions; do
8814   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8815     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8816     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8817     break 2
8818   fi
8819 done
8820 done
8821
8822 fi
8823 fi
8824 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8825 if test -n "$AR_FOR_TARGET"; then
8826   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8827 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8828 else
8829   echo "$as_me:$LINENO: result: no" >&5
8830 echo "${ECHO_T}no" >&6
8831 fi
8832
8833     fi
8834     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8835       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8836 set dummy ${ncn_progname}; ac_word=$2
8837 echo "$as_me:$LINENO: checking for $ac_word" >&5
8838 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8839 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8840   echo $ECHO_N "(cached) $ECHO_C" >&6
8841 else
8842   if test -n "$AR_FOR_TARGET"; then
8843   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8844 else
8845 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8846 for as_dir in $PATH
8847 do
8848   IFS=$as_save_IFS
8849   test -z "$as_dir" && as_dir=.
8850   for ac_exec_ext in '' $ac_executable_extensions; do
8851   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8852     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8853     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8854     break 2
8855   fi
8856 done
8857 done
8858
8859 fi
8860 fi
8861 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8862 if test -n "$AR_FOR_TARGET"; then
8863   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8864 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8865 else
8866   echo "$as_me:$LINENO: result: no" >&5
8867 echo "${ECHO_T}no" >&6
8868 fi
8869
8870     fi
8871     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8872   done
8873 fi
8874
8875 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8876   set dummy ar
8877   if test $build = $target ; then
8878     AR_FOR_TARGET="$2"
8879   else
8880     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8881   fi
8882 else
8883   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
8884 fi
8885
8886 else
8887   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8888 fi
8889
8890
8891
8892
8893 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8894   if test -n "$with_build_time_tools"; then
8895     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
8896 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
8897     if test -x $with_build_time_tools/as; then
8898       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
8899       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8900       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
8901 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
8902     else
8903       echo "$as_me:$LINENO: result: no" >&5
8904 echo "${ECHO_T}no" >&6
8905     fi
8906   elif test $build != $host && test $have_gcc_for_target = yes; then
8907     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
8908     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
8909     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8910   fi
8911 fi
8912 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8913   # Extract the first word of "as", so it can be a program name with args.
8914 set dummy as; ac_word=$2
8915 echo "$as_me:$LINENO: checking for $ac_word" >&5
8916 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8917 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
8918   echo $ECHO_N "(cached) $ECHO_C" >&6
8919 else
8920   case $AS_FOR_TARGET in
8921   [\\/]* | ?:[\\/]*)
8922   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
8923   ;;
8924   *)
8925   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8926 for as_dir in $gcc_cv_tool_dirs
8927 do
8928   IFS=$as_save_IFS
8929   test -z "$as_dir" && as_dir=.
8930   for ac_exec_ext in '' $ac_executable_extensions; do
8931   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8932     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8933     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8934     break 2
8935   fi
8936 done
8937 done
8938
8939   ;;
8940 esac
8941 fi
8942 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8943
8944 if test -n "$AS_FOR_TARGET"; then
8945   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8946 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8947 else
8948   echo "$as_me:$LINENO: result: no" >&5
8949 echo "${ECHO_T}no" >&6
8950 fi
8951
8952 fi
8953 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8954
8955
8956 if test -n "$AS_FOR_TARGET"; then
8957   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
8958 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8959   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8960 fi
8961
8962 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8963   for ncn_progname in as; do
8964     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8965 set dummy ${ncn_progname}; ac_word=$2
8966 echo "$as_me:$LINENO: checking for $ac_word" >&5
8967 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8968 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8969   echo $ECHO_N "(cached) $ECHO_C" >&6
8970 else
8971   if test -n "$AS_FOR_TARGET"; then
8972   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8973 else
8974 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8975 for as_dir in $PATH
8976 do
8977   IFS=$as_save_IFS
8978   test -z "$as_dir" && as_dir=.
8979   for ac_exec_ext in '' $ac_executable_extensions; do
8980   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8981     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
8982     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8983     break 2
8984   fi
8985 done
8986 done
8987
8988 fi
8989 fi
8990 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8991 if test -n "$AS_FOR_TARGET"; then
8992   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8993 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8994 else
8995   echo "$as_me:$LINENO: result: no" >&5
8996 echo "${ECHO_T}no" >&6
8997 fi
8998
8999   done
9000 fi
9001
9002 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9003   for ncn_progname in as; do
9004     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9005 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9006     if test -x $with_build_time_tools/${ncn_progname}; then
9007       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9008       echo "$as_me:$LINENO: result: yes" >&5
9009 echo "${ECHO_T}yes" >&6
9010       break
9011     else
9012       echo "$as_me:$LINENO: result: no" >&5
9013 echo "${ECHO_T}no" >&6
9014     fi
9015   done
9016 fi
9017
9018 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9019   for ncn_progname in as; do
9020     if test -n "$ncn_target_tool_prefix"; then
9021       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9022 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9023 echo "$as_me:$LINENO: checking for $ac_word" >&5
9024 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9025 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9026   echo $ECHO_N "(cached) $ECHO_C" >&6
9027 else
9028   if test -n "$AS_FOR_TARGET"; then
9029   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9030 else
9031 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9032 for as_dir in $PATH
9033 do
9034   IFS=$as_save_IFS
9035   test -z "$as_dir" && as_dir=.
9036   for ac_exec_ext in '' $ac_executable_extensions; do
9037   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9038     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9039     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9040     break 2
9041   fi
9042 done
9043 done
9044
9045 fi
9046 fi
9047 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9048 if test -n "$AS_FOR_TARGET"; then
9049   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9050 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9051 else
9052   echo "$as_me:$LINENO: result: no" >&5
9053 echo "${ECHO_T}no" >&6
9054 fi
9055
9056     fi
9057     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9058       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9059 set dummy ${ncn_progname}; ac_word=$2
9060 echo "$as_me:$LINENO: checking for $ac_word" >&5
9061 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9062 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9063   echo $ECHO_N "(cached) $ECHO_C" >&6
9064 else
9065   if test -n "$AS_FOR_TARGET"; then
9066   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9067 else
9068 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9069 for as_dir in $PATH
9070 do
9071   IFS=$as_save_IFS
9072   test -z "$as_dir" && as_dir=.
9073   for ac_exec_ext in '' $ac_executable_extensions; do
9074   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9075     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9076     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9077     break 2
9078   fi
9079 done
9080 done
9081
9082 fi
9083 fi
9084 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9085 if test -n "$AS_FOR_TARGET"; then
9086   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9087 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9088 else
9089   echo "$as_me:$LINENO: result: no" >&5
9090 echo "${ECHO_T}no" >&6
9091 fi
9092
9093     fi
9094     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9095   done
9096 fi
9097
9098 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9099   set dummy as
9100   if test $build = $target ; then
9101     AS_FOR_TARGET="$2"
9102   else
9103     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9104   fi
9105 else
9106   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9107 fi
9108
9109 else
9110   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9111 fi
9112
9113
9114
9115
9116 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9117   if test -n "$with_build_time_tools"; then
9118     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9119 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9120     if test -x $with_build_time_tools/dlltool; then
9121       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9122       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9123       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9124 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9125     else
9126       echo "$as_me:$LINENO: result: no" >&5
9127 echo "${ECHO_T}no" >&6
9128     fi
9129   elif test $build != $host && test $have_gcc_for_target = yes; then
9130     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9131     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9132     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9133   fi
9134 fi
9135 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9136   # Extract the first word of "dlltool", so it can be a program name with args.
9137 set dummy dlltool; ac_word=$2
9138 echo "$as_me:$LINENO: checking for $ac_word" >&5
9139 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9140 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9141   echo $ECHO_N "(cached) $ECHO_C" >&6
9142 else
9143   case $DLLTOOL_FOR_TARGET in
9144   [\\/]* | ?:[\\/]*)
9145   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9146   ;;
9147   *)
9148   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9149 for as_dir in $gcc_cv_tool_dirs
9150 do
9151   IFS=$as_save_IFS
9152   test -z "$as_dir" && as_dir=.
9153   for ac_exec_ext in '' $ac_executable_extensions; do
9154   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9155     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9156     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9157     break 2
9158   fi
9159 done
9160 done
9161
9162   ;;
9163 esac
9164 fi
9165 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9166
9167 if test -n "$DLLTOOL_FOR_TARGET"; then
9168   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9169 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9170 else
9171   echo "$as_me:$LINENO: result: no" >&5
9172 echo "${ECHO_T}no" >&6
9173 fi
9174
9175 fi
9176 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9177
9178
9179 if test -n "$DLLTOOL_FOR_TARGET"; then
9180   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9181 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9182   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9183 fi
9184
9185 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9186   for ncn_progname in dlltool; do
9187     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9188 set dummy ${ncn_progname}; ac_word=$2
9189 echo "$as_me:$LINENO: checking for $ac_word" >&5
9190 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9191 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9192   echo $ECHO_N "(cached) $ECHO_C" >&6
9193 else
9194   if test -n "$DLLTOOL_FOR_TARGET"; then
9195   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9196 else
9197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9198 for as_dir in $PATH
9199 do
9200   IFS=$as_save_IFS
9201   test -z "$as_dir" && as_dir=.
9202   for ac_exec_ext in '' $ac_executable_extensions; do
9203   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9204     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9205     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9206     break 2
9207   fi
9208 done
9209 done
9210
9211 fi
9212 fi
9213 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9214 if test -n "$DLLTOOL_FOR_TARGET"; then
9215   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9216 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9217 else
9218   echo "$as_me:$LINENO: result: no" >&5
9219 echo "${ECHO_T}no" >&6
9220 fi
9221
9222   done
9223 fi
9224
9225 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9226   for ncn_progname in dlltool; do
9227     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9228 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9229     if test -x $with_build_time_tools/${ncn_progname}; then
9230       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9231       echo "$as_me:$LINENO: result: yes" >&5
9232 echo "${ECHO_T}yes" >&6
9233       break
9234     else
9235       echo "$as_me:$LINENO: result: no" >&5
9236 echo "${ECHO_T}no" >&6
9237     fi
9238   done
9239 fi
9240
9241 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9242   for ncn_progname in dlltool; do
9243     if test -n "$ncn_target_tool_prefix"; then
9244       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9245 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9246 echo "$as_me:$LINENO: checking for $ac_word" >&5
9247 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9248 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9249   echo $ECHO_N "(cached) $ECHO_C" >&6
9250 else
9251   if test -n "$DLLTOOL_FOR_TARGET"; then
9252   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9253 else
9254 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9255 for as_dir in $PATH
9256 do
9257   IFS=$as_save_IFS
9258   test -z "$as_dir" && as_dir=.
9259   for ac_exec_ext in '' $ac_executable_extensions; do
9260   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9261     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9262     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9263     break 2
9264   fi
9265 done
9266 done
9267
9268 fi
9269 fi
9270 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9271 if test -n "$DLLTOOL_FOR_TARGET"; then
9272   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9273 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9274 else
9275   echo "$as_me:$LINENO: result: no" >&5
9276 echo "${ECHO_T}no" >&6
9277 fi
9278
9279     fi
9280     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9281       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9282 set dummy ${ncn_progname}; ac_word=$2
9283 echo "$as_me:$LINENO: checking for $ac_word" >&5
9284 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9285 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9286   echo $ECHO_N "(cached) $ECHO_C" >&6
9287 else
9288   if test -n "$DLLTOOL_FOR_TARGET"; then
9289   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9290 else
9291 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9292 for as_dir in $PATH
9293 do
9294   IFS=$as_save_IFS
9295   test -z "$as_dir" && as_dir=.
9296   for ac_exec_ext in '' $ac_executable_extensions; do
9297   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9298     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9299     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9300     break 2
9301   fi
9302 done
9303 done
9304
9305 fi
9306 fi
9307 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9308 if test -n "$DLLTOOL_FOR_TARGET"; then
9309   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9310 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9311 else
9312   echo "$as_me:$LINENO: result: no" >&5
9313 echo "${ECHO_T}no" >&6
9314 fi
9315
9316     fi
9317     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9318   done
9319 fi
9320
9321 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9322   set dummy dlltool
9323   if test $build = $target ; then
9324     DLLTOOL_FOR_TARGET="$2"
9325   else
9326     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9327   fi
9328 else
9329   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9330 fi
9331
9332 else
9333   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9334 fi
9335
9336
9337
9338
9339 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9340   if test -n "$with_build_time_tools"; then
9341     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9342 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9343     if test -x $with_build_time_tools/ld; then
9344       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9345       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9346       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9347 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9348     else
9349       echo "$as_me:$LINENO: result: no" >&5
9350 echo "${ECHO_T}no" >&6
9351     fi
9352   elif test $build != $host && test $have_gcc_for_target = yes; then
9353     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9354     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9355     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9356   fi
9357 fi
9358 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9359   # Extract the first word of "ld", so it can be a program name with args.
9360 set dummy ld; ac_word=$2
9361 echo "$as_me:$LINENO: checking for $ac_word" >&5
9362 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9363 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9364   echo $ECHO_N "(cached) $ECHO_C" >&6
9365 else
9366   case $LD_FOR_TARGET in
9367   [\\/]* | ?:[\\/]*)
9368   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9369   ;;
9370   *)
9371   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9372 for as_dir in $gcc_cv_tool_dirs
9373 do
9374   IFS=$as_save_IFS
9375   test -z "$as_dir" && as_dir=.
9376   for ac_exec_ext in '' $ac_executable_extensions; do
9377   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9378     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9379     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9380     break 2
9381   fi
9382 done
9383 done
9384
9385   ;;
9386 esac
9387 fi
9388 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9389
9390 if test -n "$LD_FOR_TARGET"; then
9391   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9392 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9393 else
9394   echo "$as_me:$LINENO: result: no" >&5
9395 echo "${ECHO_T}no" >&6
9396 fi
9397
9398 fi
9399 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9400
9401
9402 if test -n "$LD_FOR_TARGET"; then
9403   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9404 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9405   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9406 fi
9407
9408 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9409   for ncn_progname in ld; do
9410     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9411 set dummy ${ncn_progname}; ac_word=$2
9412 echo "$as_me:$LINENO: checking for $ac_word" >&5
9413 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9414 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9415   echo $ECHO_N "(cached) $ECHO_C" >&6
9416 else
9417   if test -n "$LD_FOR_TARGET"; then
9418   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9419 else
9420 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9421 for as_dir in $PATH
9422 do
9423   IFS=$as_save_IFS
9424   test -z "$as_dir" && as_dir=.
9425   for ac_exec_ext in '' $ac_executable_extensions; do
9426   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9427     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9428     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9429     break 2
9430   fi
9431 done
9432 done
9433
9434 fi
9435 fi
9436 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9437 if test -n "$LD_FOR_TARGET"; then
9438   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9439 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9440 else
9441   echo "$as_me:$LINENO: result: no" >&5
9442 echo "${ECHO_T}no" >&6
9443 fi
9444
9445   done
9446 fi
9447
9448 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9449   for ncn_progname in ld; do
9450     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9451 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9452     if test -x $with_build_time_tools/${ncn_progname}; then
9453       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9454       echo "$as_me:$LINENO: result: yes" >&5
9455 echo "${ECHO_T}yes" >&6
9456       break
9457     else
9458       echo "$as_me:$LINENO: result: no" >&5
9459 echo "${ECHO_T}no" >&6
9460     fi
9461   done
9462 fi
9463
9464 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9465   for ncn_progname in ld; do
9466     if test -n "$ncn_target_tool_prefix"; then
9467       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9468 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9469 echo "$as_me:$LINENO: checking for $ac_word" >&5
9470 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9471 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9472   echo $ECHO_N "(cached) $ECHO_C" >&6
9473 else
9474   if test -n "$LD_FOR_TARGET"; then
9475   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9476 else
9477 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9478 for as_dir in $PATH
9479 do
9480   IFS=$as_save_IFS
9481   test -z "$as_dir" && as_dir=.
9482   for ac_exec_ext in '' $ac_executable_extensions; do
9483   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9484     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9485     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9486     break 2
9487   fi
9488 done
9489 done
9490
9491 fi
9492 fi
9493 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9494 if test -n "$LD_FOR_TARGET"; then
9495   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9496 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9497 else
9498   echo "$as_me:$LINENO: result: no" >&5
9499 echo "${ECHO_T}no" >&6
9500 fi
9501
9502     fi
9503     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9504       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9505 set dummy ${ncn_progname}; ac_word=$2
9506 echo "$as_me:$LINENO: checking for $ac_word" >&5
9507 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9508 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9509   echo $ECHO_N "(cached) $ECHO_C" >&6
9510 else
9511   if test -n "$LD_FOR_TARGET"; then
9512   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9513 else
9514 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9515 for as_dir in $PATH
9516 do
9517   IFS=$as_save_IFS
9518   test -z "$as_dir" && as_dir=.
9519   for ac_exec_ext in '' $ac_executable_extensions; do
9520   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9521     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9522     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9523     break 2
9524   fi
9525 done
9526 done
9527
9528 fi
9529 fi
9530 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9531 if test -n "$LD_FOR_TARGET"; then
9532   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9533 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9534 else
9535   echo "$as_me:$LINENO: result: no" >&5
9536 echo "${ECHO_T}no" >&6
9537 fi
9538
9539     fi
9540     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9541   done
9542 fi
9543
9544 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9545   set dummy ld
9546   if test $build = $target ; then
9547     LD_FOR_TARGET="$2"
9548   else
9549     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9550   fi
9551 else
9552   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9553 fi
9554
9555 else
9556   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9557 fi
9558
9559
9560
9561
9562 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9563   if test -n "$with_build_time_tools"; then
9564     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9565 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9566     if test -x $with_build_time_tools/lipo; then
9567       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9568       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9569       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9570 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9571     else
9572       echo "$as_me:$LINENO: result: no" >&5
9573 echo "${ECHO_T}no" >&6
9574     fi
9575   elif test $build != $host && test $have_gcc_for_target = yes; then
9576     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9577     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9578     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9579   fi
9580 fi
9581 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9582   # Extract the first word of "lipo", so it can be a program name with args.
9583 set dummy lipo; ac_word=$2
9584 echo "$as_me:$LINENO: checking for $ac_word" >&5
9585 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9586 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9587   echo $ECHO_N "(cached) $ECHO_C" >&6
9588 else
9589   case $LIPO_FOR_TARGET in
9590   [\\/]* | ?:[\\/]*)
9591   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9592   ;;
9593   *)
9594   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9595 for as_dir in $gcc_cv_tool_dirs
9596 do
9597   IFS=$as_save_IFS
9598   test -z "$as_dir" && as_dir=.
9599   for ac_exec_ext in '' $ac_executable_extensions; do
9600   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9601     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9602     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9603     break 2
9604   fi
9605 done
9606 done
9607
9608   ;;
9609 esac
9610 fi
9611 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9612
9613 if test -n "$LIPO_FOR_TARGET"; then
9614   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9615 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9616 else
9617   echo "$as_me:$LINENO: result: no" >&5
9618 echo "${ECHO_T}no" >&6
9619 fi
9620
9621 fi
9622 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9623
9624
9625 if test -n "$LIPO_FOR_TARGET"; then
9626   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9627 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9628   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9629 fi
9630
9631 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9632   for ncn_progname in lipo; do
9633     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9634 set dummy ${ncn_progname}; ac_word=$2
9635 echo "$as_me:$LINENO: checking for $ac_word" >&5
9636 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9637 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9638   echo $ECHO_N "(cached) $ECHO_C" >&6
9639 else
9640   if test -n "$LIPO_FOR_TARGET"; then
9641   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9642 else
9643 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9644 for as_dir in $PATH
9645 do
9646   IFS=$as_save_IFS
9647   test -z "$as_dir" && as_dir=.
9648   for ac_exec_ext in '' $ac_executable_extensions; do
9649   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9650     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9651     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9652     break 2
9653   fi
9654 done
9655 done
9656
9657 fi
9658 fi
9659 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9660 if test -n "$LIPO_FOR_TARGET"; then
9661   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9662 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9663 else
9664   echo "$as_me:$LINENO: result: no" >&5
9665 echo "${ECHO_T}no" >&6
9666 fi
9667
9668   done
9669 fi
9670
9671 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9672   for ncn_progname in lipo; do
9673     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9674 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9675     if test -x $with_build_time_tools/${ncn_progname}; then
9676       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9677       echo "$as_me:$LINENO: result: yes" >&5
9678 echo "${ECHO_T}yes" >&6
9679       break
9680     else
9681       echo "$as_me:$LINENO: result: no" >&5
9682 echo "${ECHO_T}no" >&6
9683     fi
9684   done
9685 fi
9686
9687 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9688   for ncn_progname in lipo; do
9689     if test -n "$ncn_target_tool_prefix"; then
9690       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9691 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9692 echo "$as_me:$LINENO: checking for $ac_word" >&5
9693 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9694 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9695   echo $ECHO_N "(cached) $ECHO_C" >&6
9696 else
9697   if test -n "$LIPO_FOR_TARGET"; then
9698   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9699 else
9700 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9701 for as_dir in $PATH
9702 do
9703   IFS=$as_save_IFS
9704   test -z "$as_dir" && as_dir=.
9705   for ac_exec_ext in '' $ac_executable_extensions; do
9706   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9707     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9708     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9709     break 2
9710   fi
9711 done
9712 done
9713
9714 fi
9715 fi
9716 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9717 if test -n "$LIPO_FOR_TARGET"; then
9718   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9719 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9720 else
9721   echo "$as_me:$LINENO: result: no" >&5
9722 echo "${ECHO_T}no" >&6
9723 fi
9724
9725     fi
9726     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9727       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9728 set dummy ${ncn_progname}; ac_word=$2
9729 echo "$as_me:$LINENO: checking for $ac_word" >&5
9730 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9731 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9732   echo $ECHO_N "(cached) $ECHO_C" >&6
9733 else
9734   if test -n "$LIPO_FOR_TARGET"; then
9735   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9736 else
9737 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9738 for as_dir in $PATH
9739 do
9740   IFS=$as_save_IFS
9741   test -z "$as_dir" && as_dir=.
9742   for ac_exec_ext in '' $ac_executable_extensions; do
9743   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9744     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9745     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9746     break 2
9747   fi
9748 done
9749 done
9750
9751 fi
9752 fi
9753 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9754 if test -n "$LIPO_FOR_TARGET"; then
9755   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9756 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9757 else
9758   echo "$as_me:$LINENO: result: no" >&5
9759 echo "${ECHO_T}no" >&6
9760 fi
9761
9762     fi
9763     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9764   done
9765 fi
9766
9767 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9768   set dummy lipo
9769   if test $build = $target ; then
9770     LIPO_FOR_TARGET="$2"
9771   else
9772     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9773   fi
9774 else
9775   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9776 fi
9777
9778 else
9779   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9780 fi
9781
9782
9783
9784
9785 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9786   if test -n "$with_build_time_tools"; then
9787     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9788 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9789     if test -x $with_build_time_tools/nm; then
9790       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9791       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9792       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9793 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9794     else
9795       echo "$as_me:$LINENO: result: no" >&5
9796 echo "${ECHO_T}no" >&6
9797     fi
9798   elif test $build != $host && test $have_gcc_for_target = yes; then
9799     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9800     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9801     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9802   fi
9803 fi
9804 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9805   # Extract the first word of "nm", so it can be a program name with args.
9806 set dummy nm; ac_word=$2
9807 echo "$as_me:$LINENO: checking for $ac_word" >&5
9808 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9809 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9810   echo $ECHO_N "(cached) $ECHO_C" >&6
9811 else
9812   case $NM_FOR_TARGET in
9813   [\\/]* | ?:[\\/]*)
9814   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9815   ;;
9816   *)
9817   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9818 for as_dir in $gcc_cv_tool_dirs
9819 do
9820   IFS=$as_save_IFS
9821   test -z "$as_dir" && as_dir=.
9822   for ac_exec_ext in '' $ac_executable_extensions; do
9823   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9824     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9825     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9826     break 2
9827   fi
9828 done
9829 done
9830
9831   ;;
9832 esac
9833 fi
9834 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9835
9836 if test -n "$NM_FOR_TARGET"; then
9837   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9838 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9839 else
9840   echo "$as_me:$LINENO: result: no" >&5
9841 echo "${ECHO_T}no" >&6
9842 fi
9843
9844 fi
9845 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9846
9847
9848 if test -n "$NM_FOR_TARGET"; then
9849   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9850 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9851   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9852 fi
9853
9854 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9855   for ncn_progname in nm; do
9856     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9857 set dummy ${ncn_progname}; ac_word=$2
9858 echo "$as_me:$LINENO: checking for $ac_word" >&5
9859 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9860 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9861   echo $ECHO_N "(cached) $ECHO_C" >&6
9862 else
9863   if test -n "$NM_FOR_TARGET"; then
9864   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9865 else
9866 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9867 for as_dir in $PATH
9868 do
9869   IFS=$as_save_IFS
9870   test -z "$as_dir" && as_dir=.
9871   for ac_exec_ext in '' $ac_executable_extensions; do
9872   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9873     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9874     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9875     break 2
9876   fi
9877 done
9878 done
9879
9880 fi
9881 fi
9882 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9883 if test -n "$NM_FOR_TARGET"; then
9884   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9885 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9886 else
9887   echo "$as_me:$LINENO: result: no" >&5
9888 echo "${ECHO_T}no" >&6
9889 fi
9890
9891   done
9892 fi
9893
9894 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
9895   for ncn_progname in nm; do
9896     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9897 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9898     if test -x $with_build_time_tools/${ncn_progname}; then
9899       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9900       echo "$as_me:$LINENO: result: yes" >&5
9901 echo "${ECHO_T}yes" >&6
9902       break
9903     else
9904       echo "$as_me:$LINENO: result: no" >&5
9905 echo "${ECHO_T}no" >&6
9906     fi
9907   done
9908 fi
9909
9910 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
9911   for ncn_progname in nm; do
9912     if test -n "$ncn_target_tool_prefix"; then
9913       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9914 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9915 echo "$as_me:$LINENO: checking for $ac_word" >&5
9916 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9917 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9918   echo $ECHO_N "(cached) $ECHO_C" >&6
9919 else
9920   if test -n "$NM_FOR_TARGET"; then
9921   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9922 else
9923 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9924 for as_dir in $PATH
9925 do
9926   IFS=$as_save_IFS
9927   test -z "$as_dir" && as_dir=.
9928   for ac_exec_ext in '' $ac_executable_extensions; do
9929   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9930     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9931     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9932     break 2
9933   fi
9934 done
9935 done
9936
9937 fi
9938 fi
9939 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9940 if test -n "$NM_FOR_TARGET"; then
9941   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9942 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9943 else
9944   echo "$as_me:$LINENO: result: no" >&5
9945 echo "${ECHO_T}no" >&6
9946 fi
9947
9948     fi
9949     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
9950       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9951 set dummy ${ncn_progname}; ac_word=$2
9952 echo "$as_me:$LINENO: checking for $ac_word" >&5
9953 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9954 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9955   echo $ECHO_N "(cached) $ECHO_C" >&6
9956 else
9957   if test -n "$NM_FOR_TARGET"; then
9958   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9959 else
9960 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9961 for as_dir in $PATH
9962 do
9963   IFS=$as_save_IFS
9964   test -z "$as_dir" && as_dir=.
9965   for ac_exec_ext in '' $ac_executable_extensions; do
9966   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9967     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9968     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9969     break 2
9970   fi
9971 done
9972 done
9973
9974 fi
9975 fi
9976 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9977 if test -n "$NM_FOR_TARGET"; then
9978   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9979 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9980 else
9981   echo "$as_me:$LINENO: result: no" >&5
9982 echo "${ECHO_T}no" >&6
9983 fi
9984
9985     fi
9986     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
9987   done
9988 fi
9989
9990 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
9991   set dummy nm
9992   if test $build = $target ; then
9993     NM_FOR_TARGET="$2"
9994   else
9995     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
9996   fi
9997 else
9998   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
9999 fi
10000
10001 else
10002   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10003 fi
10004
10005
10006
10007
10008 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10009   if test -n "$with_build_time_tools"; then
10010     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10011 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10012     if test -x $with_build_time_tools/objdump; then
10013       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10014       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10015       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10016 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10017     else
10018       echo "$as_me:$LINENO: result: no" >&5
10019 echo "${ECHO_T}no" >&6
10020     fi
10021   elif test $build != $host && test $have_gcc_for_target = yes; then
10022     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10023     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10024     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10025   fi
10026 fi
10027 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10028   # Extract the first word of "objdump", so it can be a program name with args.
10029 set dummy objdump; ac_word=$2
10030 echo "$as_me:$LINENO: checking for $ac_word" >&5
10031 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10032 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10033   echo $ECHO_N "(cached) $ECHO_C" >&6
10034 else
10035   case $OBJDUMP_FOR_TARGET in
10036   [\\/]* | ?:[\\/]*)
10037   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10038   ;;
10039   *)
10040   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10041 for as_dir in $gcc_cv_tool_dirs
10042 do
10043   IFS=$as_save_IFS
10044   test -z "$as_dir" && as_dir=.
10045   for ac_exec_ext in '' $ac_executable_extensions; do
10046   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10047     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10048     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10049     break 2
10050   fi
10051 done
10052 done
10053
10054   ;;
10055 esac
10056 fi
10057 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10058
10059 if test -n "$OBJDUMP_FOR_TARGET"; then
10060   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10061 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10062 else
10063   echo "$as_me:$LINENO: result: no" >&5
10064 echo "${ECHO_T}no" >&6
10065 fi
10066
10067 fi
10068 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10069
10070
10071 if test -n "$OBJDUMP_FOR_TARGET"; then
10072   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10073 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10074   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10075 fi
10076
10077 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10078   for ncn_progname in objdump; do
10079     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10080 set dummy ${ncn_progname}; ac_word=$2
10081 echo "$as_me:$LINENO: checking for $ac_word" >&5
10082 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10083 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10084   echo $ECHO_N "(cached) $ECHO_C" >&6
10085 else
10086   if test -n "$OBJDUMP_FOR_TARGET"; then
10087   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10088 else
10089 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10090 for as_dir in $PATH
10091 do
10092   IFS=$as_save_IFS
10093   test -z "$as_dir" && as_dir=.
10094   for ac_exec_ext in '' $ac_executable_extensions; do
10095   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10096     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10097     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10098     break 2
10099   fi
10100 done
10101 done
10102
10103 fi
10104 fi
10105 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10106 if test -n "$OBJDUMP_FOR_TARGET"; then
10107   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10108 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10109 else
10110   echo "$as_me:$LINENO: result: no" >&5
10111 echo "${ECHO_T}no" >&6
10112 fi
10113
10114   done
10115 fi
10116
10117 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10118   for ncn_progname in objdump; do
10119     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10120 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10121     if test -x $with_build_time_tools/${ncn_progname}; then
10122       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10123       echo "$as_me:$LINENO: result: yes" >&5
10124 echo "${ECHO_T}yes" >&6
10125       break
10126     else
10127       echo "$as_me:$LINENO: result: no" >&5
10128 echo "${ECHO_T}no" >&6
10129     fi
10130   done
10131 fi
10132
10133 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10134   for ncn_progname in objdump; do
10135     if test -n "$ncn_target_tool_prefix"; then
10136       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10137 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10138 echo "$as_me:$LINENO: checking for $ac_word" >&5
10139 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10140 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10141   echo $ECHO_N "(cached) $ECHO_C" >&6
10142 else
10143   if test -n "$OBJDUMP_FOR_TARGET"; then
10144   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10145 else
10146 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10147 for as_dir in $PATH
10148 do
10149   IFS=$as_save_IFS
10150   test -z "$as_dir" && as_dir=.
10151   for ac_exec_ext in '' $ac_executable_extensions; do
10152   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10153     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10154     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10155     break 2
10156   fi
10157 done
10158 done
10159
10160 fi
10161 fi
10162 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10163 if test -n "$OBJDUMP_FOR_TARGET"; then
10164   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10165 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10166 else
10167   echo "$as_me:$LINENO: result: no" >&5
10168 echo "${ECHO_T}no" >&6
10169 fi
10170
10171     fi
10172     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10173       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10174 set dummy ${ncn_progname}; ac_word=$2
10175 echo "$as_me:$LINENO: checking for $ac_word" >&5
10176 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10177 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10178   echo $ECHO_N "(cached) $ECHO_C" >&6
10179 else
10180   if test -n "$OBJDUMP_FOR_TARGET"; then
10181   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10182 else
10183 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10184 for as_dir in $PATH
10185 do
10186   IFS=$as_save_IFS
10187   test -z "$as_dir" && as_dir=.
10188   for ac_exec_ext in '' $ac_executable_extensions; do
10189   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10190     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10191     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10192     break 2
10193   fi
10194 done
10195 done
10196
10197 fi
10198 fi
10199 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10200 if test -n "$OBJDUMP_FOR_TARGET"; then
10201   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10202 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10203 else
10204   echo "$as_me:$LINENO: result: no" >&5
10205 echo "${ECHO_T}no" >&6
10206 fi
10207
10208     fi
10209     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10210   done
10211 fi
10212
10213 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10214   set dummy objdump
10215   if test $build = $target ; then
10216     OBJDUMP_FOR_TARGET="$2"
10217   else
10218     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10219   fi
10220 else
10221   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10222 fi
10223
10224 else
10225   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10226 fi
10227
10228
10229
10230
10231 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10232   if test -n "$with_build_time_tools"; then
10233     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10234 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10235     if test -x $with_build_time_tools/ranlib; then
10236       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10237       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10238       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10239 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10240     else
10241       echo "$as_me:$LINENO: result: no" >&5
10242 echo "${ECHO_T}no" >&6
10243     fi
10244   elif test $build != $host && test $have_gcc_for_target = yes; then
10245     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10246     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10247     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10248   fi
10249 fi
10250 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10251   # Extract the first word of "ranlib", so it can be a program name with args.
10252 set dummy ranlib; ac_word=$2
10253 echo "$as_me:$LINENO: checking for $ac_word" >&5
10254 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10255 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10256   echo $ECHO_N "(cached) $ECHO_C" >&6
10257 else
10258   case $RANLIB_FOR_TARGET in
10259   [\\/]* | ?:[\\/]*)
10260   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10261   ;;
10262   *)
10263   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10264 for as_dir in $gcc_cv_tool_dirs
10265 do
10266   IFS=$as_save_IFS
10267   test -z "$as_dir" && as_dir=.
10268   for ac_exec_ext in '' $ac_executable_extensions; do
10269   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10270     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10271     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10272     break 2
10273   fi
10274 done
10275 done
10276
10277   ;;
10278 esac
10279 fi
10280 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10281
10282 if test -n "$RANLIB_FOR_TARGET"; then
10283   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10284 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10285 else
10286   echo "$as_me:$LINENO: result: no" >&5
10287 echo "${ECHO_T}no" >&6
10288 fi
10289
10290 fi
10291 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10292
10293
10294 if test -n "$RANLIB_FOR_TARGET"; then
10295   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10296 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10297   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10298 fi
10299
10300 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10301   for ncn_progname in ranlib; do
10302     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10303 set dummy ${ncn_progname}; ac_word=$2
10304 echo "$as_me:$LINENO: checking for $ac_word" >&5
10305 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10306 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10307   echo $ECHO_N "(cached) $ECHO_C" >&6
10308 else
10309   if test -n "$RANLIB_FOR_TARGET"; then
10310   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10311 else
10312 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10313 for as_dir in $PATH
10314 do
10315   IFS=$as_save_IFS
10316   test -z "$as_dir" && as_dir=.
10317   for ac_exec_ext in '' $ac_executable_extensions; do
10318   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10319     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10320     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10321     break 2
10322   fi
10323 done
10324 done
10325
10326 fi
10327 fi
10328 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10329 if test -n "$RANLIB_FOR_TARGET"; then
10330   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10331 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10332 else
10333   echo "$as_me:$LINENO: result: no" >&5
10334 echo "${ECHO_T}no" >&6
10335 fi
10336
10337   done
10338 fi
10339
10340 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10341   for ncn_progname in ranlib; do
10342     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10343 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10344     if test -x $with_build_time_tools/${ncn_progname}; then
10345       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10346       echo "$as_me:$LINENO: result: yes" >&5
10347 echo "${ECHO_T}yes" >&6
10348       break
10349     else
10350       echo "$as_me:$LINENO: result: no" >&5
10351 echo "${ECHO_T}no" >&6
10352     fi
10353   done
10354 fi
10355
10356 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10357   for ncn_progname in ranlib; do
10358     if test -n "$ncn_target_tool_prefix"; then
10359       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10360 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10361 echo "$as_me:$LINENO: checking for $ac_word" >&5
10362 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10363 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10364   echo $ECHO_N "(cached) $ECHO_C" >&6
10365 else
10366   if test -n "$RANLIB_FOR_TARGET"; then
10367   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10368 else
10369 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10370 for as_dir in $PATH
10371 do
10372   IFS=$as_save_IFS
10373   test -z "$as_dir" && as_dir=.
10374   for ac_exec_ext in '' $ac_executable_extensions; do
10375   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10376     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10377     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10378     break 2
10379   fi
10380 done
10381 done
10382
10383 fi
10384 fi
10385 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10386 if test -n "$RANLIB_FOR_TARGET"; then
10387   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10388 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10389 else
10390   echo "$as_me:$LINENO: result: no" >&5
10391 echo "${ECHO_T}no" >&6
10392 fi
10393
10394     fi
10395     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10396       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10397 set dummy ${ncn_progname}; ac_word=$2
10398 echo "$as_me:$LINENO: checking for $ac_word" >&5
10399 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10400 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10401   echo $ECHO_N "(cached) $ECHO_C" >&6
10402 else
10403   if test -n "$RANLIB_FOR_TARGET"; then
10404   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10405 else
10406 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10407 for as_dir in $PATH
10408 do
10409   IFS=$as_save_IFS
10410   test -z "$as_dir" && as_dir=.
10411   for ac_exec_ext in '' $ac_executable_extensions; do
10412   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10413     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10414     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10415     break 2
10416   fi
10417 done
10418 done
10419
10420 fi
10421 fi
10422 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10423 if test -n "$RANLIB_FOR_TARGET"; then
10424   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10425 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10426 else
10427   echo "$as_me:$LINENO: result: no" >&5
10428 echo "${ECHO_T}no" >&6
10429 fi
10430
10431     fi
10432     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10433   done
10434 fi
10435
10436 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10437   set dummy ranlib
10438   if test $build = $target ; then
10439     RANLIB_FOR_TARGET="$2"
10440   else
10441     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10442   fi
10443 else
10444   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10445 fi
10446
10447 else
10448   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10449 fi
10450
10451
10452
10453
10454 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10455   if test -n "$with_build_time_tools"; then
10456     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10457 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10458     if test -x $with_build_time_tools/strip; then
10459       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10460       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10461       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10462 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10463     else
10464       echo "$as_me:$LINENO: result: no" >&5
10465 echo "${ECHO_T}no" >&6
10466     fi
10467   elif test $build != $host && test $have_gcc_for_target = yes; then
10468     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10469     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10470     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10471   fi
10472 fi
10473 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10474   # Extract the first word of "strip", so it can be a program name with args.
10475 set dummy strip; ac_word=$2
10476 echo "$as_me:$LINENO: checking for $ac_word" >&5
10477 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10478 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10479   echo $ECHO_N "(cached) $ECHO_C" >&6
10480 else
10481   case $STRIP_FOR_TARGET in
10482   [\\/]* | ?:[\\/]*)
10483   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10484   ;;
10485   *)
10486   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10487 for as_dir in $gcc_cv_tool_dirs
10488 do
10489   IFS=$as_save_IFS
10490   test -z "$as_dir" && as_dir=.
10491   for ac_exec_ext in '' $ac_executable_extensions; do
10492   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10493     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10494     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10495     break 2
10496   fi
10497 done
10498 done
10499
10500   ;;
10501 esac
10502 fi
10503 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10504
10505 if test -n "$STRIP_FOR_TARGET"; then
10506   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10507 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10508 else
10509   echo "$as_me:$LINENO: result: no" >&5
10510 echo "${ECHO_T}no" >&6
10511 fi
10512
10513 fi
10514 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10515
10516
10517 if test -n "$STRIP_FOR_TARGET"; then
10518   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10519 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10520   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10521 fi
10522
10523 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10524   for ncn_progname in strip; do
10525     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10526 set dummy ${ncn_progname}; ac_word=$2
10527 echo "$as_me:$LINENO: checking for $ac_word" >&5
10528 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10529 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10530   echo $ECHO_N "(cached) $ECHO_C" >&6
10531 else
10532   if test -n "$STRIP_FOR_TARGET"; then
10533   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10534 else
10535 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10536 for as_dir in $PATH
10537 do
10538   IFS=$as_save_IFS
10539   test -z "$as_dir" && as_dir=.
10540   for ac_exec_ext in '' $ac_executable_extensions; do
10541   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10542     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10543     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10544     break 2
10545   fi
10546 done
10547 done
10548
10549 fi
10550 fi
10551 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10552 if test -n "$STRIP_FOR_TARGET"; then
10553   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10554 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10555 else
10556   echo "$as_me:$LINENO: result: no" >&5
10557 echo "${ECHO_T}no" >&6
10558 fi
10559
10560   done
10561 fi
10562
10563 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10564   for ncn_progname in strip; do
10565     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10566 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10567     if test -x $with_build_time_tools/${ncn_progname}; then
10568       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10569       echo "$as_me:$LINENO: result: yes" >&5
10570 echo "${ECHO_T}yes" >&6
10571       break
10572     else
10573       echo "$as_me:$LINENO: result: no" >&5
10574 echo "${ECHO_T}no" >&6
10575     fi
10576   done
10577 fi
10578
10579 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10580   for ncn_progname in strip; do
10581     if test -n "$ncn_target_tool_prefix"; then
10582       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10583 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10584 echo "$as_me:$LINENO: checking for $ac_word" >&5
10585 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10586 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10587   echo $ECHO_N "(cached) $ECHO_C" >&6
10588 else
10589   if test -n "$STRIP_FOR_TARGET"; then
10590   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10591 else
10592 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10593 for as_dir in $PATH
10594 do
10595   IFS=$as_save_IFS
10596   test -z "$as_dir" && as_dir=.
10597   for ac_exec_ext in '' $ac_executable_extensions; do
10598   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10599     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10600     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10601     break 2
10602   fi
10603 done
10604 done
10605
10606 fi
10607 fi
10608 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10609 if test -n "$STRIP_FOR_TARGET"; then
10610   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10611 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10612 else
10613   echo "$as_me:$LINENO: result: no" >&5
10614 echo "${ECHO_T}no" >&6
10615 fi
10616
10617     fi
10618     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10619       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10620 set dummy ${ncn_progname}; ac_word=$2
10621 echo "$as_me:$LINENO: checking for $ac_word" >&5
10622 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10623 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10624   echo $ECHO_N "(cached) $ECHO_C" >&6
10625 else
10626   if test -n "$STRIP_FOR_TARGET"; then
10627   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10628 else
10629 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10630 for as_dir in $PATH
10631 do
10632   IFS=$as_save_IFS
10633   test -z "$as_dir" && as_dir=.
10634   for ac_exec_ext in '' $ac_executable_extensions; do
10635   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10636     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10637     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10638     break 2
10639   fi
10640 done
10641 done
10642
10643 fi
10644 fi
10645 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10646 if test -n "$STRIP_FOR_TARGET"; then
10647   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10648 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10649 else
10650   echo "$as_me:$LINENO: result: no" >&5
10651 echo "${ECHO_T}no" >&6
10652 fi
10653
10654     fi
10655     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10656   done
10657 fi
10658
10659 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10660   set dummy strip
10661   if test $build = $target ; then
10662     STRIP_FOR_TARGET="$2"
10663   else
10664     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10665   fi
10666 else
10667   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10668 fi
10669
10670 else
10671   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10672 fi
10673
10674
10675
10676
10677 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10678   if test -n "$with_build_time_tools"; then
10679     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10680 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10681     if test -x $with_build_time_tools/windres; then
10682       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10683       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10684       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10685 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10686     else
10687       echo "$as_me:$LINENO: result: no" >&5
10688 echo "${ECHO_T}no" >&6
10689     fi
10690   elif test $build != $host && test $have_gcc_for_target = yes; then
10691     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10692     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10693     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10694   fi
10695 fi
10696 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10697   # Extract the first word of "windres", so it can be a program name with args.
10698 set dummy windres; ac_word=$2
10699 echo "$as_me:$LINENO: checking for $ac_word" >&5
10700 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10701 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10702   echo $ECHO_N "(cached) $ECHO_C" >&6
10703 else
10704   case $WINDRES_FOR_TARGET in
10705   [\\/]* | ?:[\\/]*)
10706   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10707   ;;
10708   *)
10709   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10710 for as_dir in $gcc_cv_tool_dirs
10711 do
10712   IFS=$as_save_IFS
10713   test -z "$as_dir" && as_dir=.
10714   for ac_exec_ext in '' $ac_executable_extensions; do
10715   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10716     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10717     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10718     break 2
10719   fi
10720 done
10721 done
10722
10723   ;;
10724 esac
10725 fi
10726 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10727
10728 if test -n "$WINDRES_FOR_TARGET"; then
10729   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10730 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10731 else
10732   echo "$as_me:$LINENO: result: no" >&5
10733 echo "${ECHO_T}no" >&6
10734 fi
10735
10736 fi
10737 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10738
10739
10740 if test -n "$WINDRES_FOR_TARGET"; then
10741   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10742 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10743   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10744 fi
10745
10746 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10747   for ncn_progname in windres; do
10748     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10749 set dummy ${ncn_progname}; ac_word=$2
10750 echo "$as_me:$LINENO: checking for $ac_word" >&5
10751 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10752 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10753   echo $ECHO_N "(cached) $ECHO_C" >&6
10754 else
10755   if test -n "$WINDRES_FOR_TARGET"; then
10756   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10757 else
10758 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10759 for as_dir in $PATH
10760 do
10761   IFS=$as_save_IFS
10762   test -z "$as_dir" && as_dir=.
10763   for ac_exec_ext in '' $ac_executable_extensions; do
10764   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10765     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10766     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10767     break 2
10768   fi
10769 done
10770 done
10771
10772 fi
10773 fi
10774 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10775 if test -n "$WINDRES_FOR_TARGET"; then
10776   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10777 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10778 else
10779   echo "$as_me:$LINENO: result: no" >&5
10780 echo "${ECHO_T}no" >&6
10781 fi
10782
10783   done
10784 fi
10785
10786 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10787   for ncn_progname in windres; do
10788     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10789 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10790     if test -x $with_build_time_tools/${ncn_progname}; then
10791       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10792       echo "$as_me:$LINENO: result: yes" >&5
10793 echo "${ECHO_T}yes" >&6
10794       break
10795     else
10796       echo "$as_me:$LINENO: result: no" >&5
10797 echo "${ECHO_T}no" >&6
10798     fi
10799   done
10800 fi
10801
10802 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10803   for ncn_progname in windres; do
10804     if test -n "$ncn_target_tool_prefix"; then
10805       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10806 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10807 echo "$as_me:$LINENO: checking for $ac_word" >&5
10808 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10809 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10810   echo $ECHO_N "(cached) $ECHO_C" >&6
10811 else
10812   if test -n "$WINDRES_FOR_TARGET"; then
10813   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10814 else
10815 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10816 for as_dir in $PATH
10817 do
10818   IFS=$as_save_IFS
10819   test -z "$as_dir" && as_dir=.
10820   for ac_exec_ext in '' $ac_executable_extensions; do
10821   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10822     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10823     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10824     break 2
10825   fi
10826 done
10827 done
10828
10829 fi
10830 fi
10831 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10832 if test -n "$WINDRES_FOR_TARGET"; then
10833   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10834 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10835 else
10836   echo "$as_me:$LINENO: result: no" >&5
10837 echo "${ECHO_T}no" >&6
10838 fi
10839
10840     fi
10841     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10842       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10843 set dummy ${ncn_progname}; ac_word=$2
10844 echo "$as_me:$LINENO: checking for $ac_word" >&5
10845 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10846 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10847   echo $ECHO_N "(cached) $ECHO_C" >&6
10848 else
10849   if test -n "$WINDRES_FOR_TARGET"; then
10850   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10851 else
10852 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10853 for as_dir in $PATH
10854 do
10855   IFS=$as_save_IFS
10856   test -z "$as_dir" && as_dir=.
10857   for ac_exec_ext in '' $ac_executable_extensions; do
10858   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10859     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10860     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10861     break 2
10862   fi
10863 done
10864 done
10865
10866 fi
10867 fi
10868 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10869 if test -n "$WINDRES_FOR_TARGET"; then
10870   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10871 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10872 else
10873   echo "$as_me:$LINENO: result: no" >&5
10874 echo "${ECHO_T}no" >&6
10875 fi
10876
10877     fi
10878     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10879   done
10880 fi
10881
10882 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10883   set dummy windres
10884   if test $build = $target ; then
10885     WINDRES_FOR_TARGET="$2"
10886   else
10887     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10888   fi
10889 else
10890   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
10891 fi
10892
10893 else
10894   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10895 fi
10896
10897
10898
10899
10900 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
10901   if test -n "$with_build_time_tools"; then
10902     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
10903 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
10904     if test -x $with_build_time_tools/windmc; then
10905       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
10906       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10907       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
10908 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
10909     else
10910       echo "$as_me:$LINENO: result: no" >&5
10911 echo "${ECHO_T}no" >&6
10912     fi
10913   elif test $build != $host && test $have_gcc_for_target = yes; then
10914     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
10915     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
10916     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10917   fi
10918 fi
10919 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10920   # Extract the first word of "windmc", so it can be a program name with args.
10921 set dummy windmc; ac_word=$2
10922 echo "$as_me:$LINENO: checking for $ac_word" >&5
10923 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10924 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
10925   echo $ECHO_N "(cached) $ECHO_C" >&6
10926 else
10927   case $WINDMC_FOR_TARGET in
10928   [\\/]* | ?:[\\/]*)
10929   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
10930   ;;
10931   *)
10932   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10933 for as_dir in $gcc_cv_tool_dirs
10934 do
10935   IFS=$as_save_IFS
10936   test -z "$as_dir" && as_dir=.
10937   for ac_exec_ext in '' $ac_executable_extensions; do
10938   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10939     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10940     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10941     break 2
10942   fi
10943 done
10944 done
10945
10946   ;;
10947 esac
10948 fi
10949 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
10950
10951 if test -n "$WINDMC_FOR_TARGET"; then
10952   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
10953 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
10954 else
10955   echo "$as_me:$LINENO: result: no" >&5
10956 echo "${ECHO_T}no" >&6
10957 fi
10958
10959 fi
10960 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
10961
10962
10963 if test -n "$WINDMC_FOR_TARGET"; then
10964   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10965 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
10966   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
10967 fi
10968
10969 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
10970   for ncn_progname in windmc; do
10971     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10972 set dummy ${ncn_progname}; ac_word=$2
10973 echo "$as_me:$LINENO: checking for $ac_word" >&5
10974 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10975 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
10976   echo $ECHO_N "(cached) $ECHO_C" >&6
10977 else
10978   if test -n "$WINDMC_FOR_TARGET"; then
10979   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
10980 else
10981 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10982 for as_dir in $PATH
10983 do
10984   IFS=$as_save_IFS
10985   test -z "$as_dir" && as_dir=.
10986   for ac_exec_ext in '' $ac_executable_extensions; do
10987   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10988     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
10989     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10990     break 2
10991   fi
10992 done
10993 done
10994
10995 fi
10996 fi
10997 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
10998 if test -n "$WINDMC_FOR_TARGET"; then
10999   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11000 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11001 else
11002   echo "$as_me:$LINENO: result: no" >&5
11003 echo "${ECHO_T}no" >&6
11004 fi
11005
11006   done
11007 fi
11008
11009 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11010   for ncn_progname in windmc; do
11011     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11012 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11013     if test -x $with_build_time_tools/${ncn_progname}; then
11014       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11015       echo "$as_me:$LINENO: result: yes" >&5
11016 echo "${ECHO_T}yes" >&6
11017       break
11018     else
11019       echo "$as_me:$LINENO: result: no" >&5
11020 echo "${ECHO_T}no" >&6
11021     fi
11022   done
11023 fi
11024
11025 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11026   for ncn_progname in windmc; do
11027     if test -n "$ncn_target_tool_prefix"; then
11028       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11029 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11030 echo "$as_me:$LINENO: checking for $ac_word" >&5
11031 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11032 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11033   echo $ECHO_N "(cached) $ECHO_C" >&6
11034 else
11035   if test -n "$WINDMC_FOR_TARGET"; then
11036   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11037 else
11038 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11039 for as_dir in $PATH
11040 do
11041   IFS=$as_save_IFS
11042   test -z "$as_dir" && as_dir=.
11043   for ac_exec_ext in '' $ac_executable_extensions; do
11044   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11045     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11046     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11047     break 2
11048   fi
11049 done
11050 done
11051
11052 fi
11053 fi
11054 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11055 if test -n "$WINDMC_FOR_TARGET"; then
11056   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11057 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11058 else
11059   echo "$as_me:$LINENO: result: no" >&5
11060 echo "${ECHO_T}no" >&6
11061 fi
11062
11063     fi
11064     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11065       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11066 set dummy ${ncn_progname}; ac_word=$2
11067 echo "$as_me:$LINENO: checking for $ac_word" >&5
11068 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11069 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11070   echo $ECHO_N "(cached) $ECHO_C" >&6
11071 else
11072   if test -n "$WINDMC_FOR_TARGET"; then
11073   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11074 else
11075 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11076 for as_dir in $PATH
11077 do
11078   IFS=$as_save_IFS
11079   test -z "$as_dir" && as_dir=.
11080   for ac_exec_ext in '' $ac_executable_extensions; do
11081   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11082     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11083     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11084     break 2
11085   fi
11086 done
11087 done
11088
11089 fi
11090 fi
11091 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11092 if test -n "$WINDMC_FOR_TARGET"; then
11093   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11094 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11095 else
11096   echo "$as_me:$LINENO: result: no" >&5
11097 echo "${ECHO_T}no" >&6
11098 fi
11099
11100     fi
11101     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11102   done
11103 fi
11104
11105 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11106   set dummy windmc
11107   if test $build = $target ; then
11108     WINDMC_FOR_TARGET="$2"
11109   else
11110     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11111   fi
11112 else
11113   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11114 fi
11115
11116 else
11117   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11118 fi
11119
11120
11121 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11122
11123 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11124 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11125 if test "x${build}" != "x${host}" ; then
11126   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11127     # We already found the complete path
11128     ac_dir=`dirname $AR_FOR_TARGET`
11129     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11130 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11131   else
11132     # Canadian cross, just use what we found
11133     echo "$as_me:$LINENO: result: pre-installed" >&5
11134 echo "${ECHO_T}pre-installed" >&6
11135   fi
11136 else
11137   ok=yes
11138   case " ${configdirs} " in
11139     *" binutils "*) ;;
11140     *) ok=no ;;
11141   esac
11142
11143   if test $ok = yes; then
11144     # An in-tree tool is available and we can use it
11145     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11146     echo "$as_me:$LINENO: result: just compiled" >&5
11147 echo "${ECHO_T}just compiled" >&6
11148   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11149     # We already found the complete path
11150     ac_dir=`dirname $AR_FOR_TARGET`
11151     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11152 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11153   elif test "x$target" = "x$host"; then
11154     # We can use an host tool
11155     AR_FOR_TARGET='$(AR)'
11156     echo "$as_me:$LINENO: result: host tool" >&5
11157 echo "${ECHO_T}host tool" >&6
11158   else
11159     # We need a cross tool
11160     echo "$as_me:$LINENO: result: pre-installed" >&5
11161 echo "${ECHO_T}pre-installed" >&6
11162   fi
11163 fi
11164
11165 echo "$as_me:$LINENO: checking where to find the target as" >&5
11166 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11167 if test "x${build}" != "x${host}" ; then
11168   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11169     # We already found the complete path
11170     ac_dir=`dirname $AS_FOR_TARGET`
11171     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11172 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11173   else
11174     # Canadian cross, just use what we found
11175     echo "$as_me:$LINENO: result: pre-installed" >&5
11176 echo "${ECHO_T}pre-installed" >&6
11177   fi
11178 else
11179   ok=yes
11180   case " ${configdirs} " in
11181     *" gas "*) ;;
11182     *) ok=no ;;
11183   esac
11184
11185   if test $ok = yes; then
11186     # An in-tree tool is available and we can use it
11187     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11188     echo "$as_me:$LINENO: result: just compiled" >&5
11189 echo "${ECHO_T}just compiled" >&6
11190   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11191     # We already found the complete path
11192     ac_dir=`dirname $AS_FOR_TARGET`
11193     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11194 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11195   elif test "x$target" = "x$host"; then
11196     # We can use an host tool
11197     AS_FOR_TARGET='$(AS)'
11198     echo "$as_me:$LINENO: result: host tool" >&5
11199 echo "${ECHO_T}host tool" >&6
11200   else
11201     # We need a cross tool
11202     echo "$as_me:$LINENO: result: pre-installed" >&5
11203 echo "${ECHO_T}pre-installed" >&6
11204   fi
11205 fi
11206
11207 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11208 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11209 if test "x${build}" != "x${host}" ; then
11210   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11211     # We already found the complete path
11212     ac_dir=`dirname $CC_FOR_TARGET`
11213     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11214 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11215   else
11216     # Canadian cross, just use what we found
11217     echo "$as_me:$LINENO: result: pre-installed" >&5
11218 echo "${ECHO_T}pre-installed" >&6
11219   fi
11220 else
11221   ok=yes
11222   case " ${configdirs} " in
11223     *" gcc "*) ;;
11224     *) ok=no ;;
11225   esac
11226
11227   if test $ok = yes; then
11228     # An in-tree tool is available and we can use it
11229     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11230     echo "$as_me:$LINENO: result: just compiled" >&5
11231 echo "${ECHO_T}just compiled" >&6
11232   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11233     # We already found the complete path
11234     ac_dir=`dirname $CC_FOR_TARGET`
11235     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11236 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11237   elif test "x$target" = "x$host"; then
11238     # We can use an host tool
11239     CC_FOR_TARGET='$(CC)'
11240     echo "$as_me:$LINENO: result: host tool" >&5
11241 echo "${ECHO_T}host tool" >&6
11242   else
11243     # We need a cross tool
11244     echo "$as_me:$LINENO: result: pre-installed" >&5
11245 echo "${ECHO_T}pre-installed" >&6
11246   fi
11247 fi
11248
11249 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11250 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11251 if test "x${build}" != "x${host}" ; then
11252   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11253     # We already found the complete path
11254     ac_dir=`dirname $CXX_FOR_TARGET`
11255     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11256 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11257   else
11258     # Canadian cross, just use what we found
11259     echo "$as_me:$LINENO: result: pre-installed" >&5
11260 echo "${ECHO_T}pre-installed" >&6
11261   fi
11262 else
11263   ok=yes
11264   case " ${configdirs} " in
11265     *" gcc "*) ;;
11266     *) ok=no ;;
11267   esac
11268   case ,${enable_languages}, in
11269     *,c++,*) ;;
11270     *) ok=no ;;
11271   esac
11272   if test $ok = yes; then
11273     # An in-tree tool is available and we can use it
11274     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'
11275     echo "$as_me:$LINENO: result: just compiled" >&5
11276 echo "${ECHO_T}just compiled" >&6
11277   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11278     # We already found the complete path
11279     ac_dir=`dirname $CXX_FOR_TARGET`
11280     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11281 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11282   elif test "x$target" = "x$host"; then
11283     # We can use an host tool
11284     CXX_FOR_TARGET='$(CXX)'
11285     echo "$as_me:$LINENO: result: host tool" >&5
11286 echo "${ECHO_T}host tool" >&6
11287   else
11288     # We need a cross tool
11289     echo "$as_me:$LINENO: result: pre-installed" >&5
11290 echo "${ECHO_T}pre-installed" >&6
11291   fi
11292 fi
11293
11294 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11295 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11296 if test "x${build}" != "x${host}" ; then
11297   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11298     # We already found the complete path
11299     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11300     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11301 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11302   else
11303     # Canadian cross, just use what we found
11304     echo "$as_me:$LINENO: result: pre-installed" >&5
11305 echo "${ECHO_T}pre-installed" >&6
11306   fi
11307 else
11308   ok=yes
11309   case " ${configdirs} " in
11310     *" gcc "*) ;;
11311     *) ok=no ;;
11312   esac
11313   case ,${enable_languages}, in
11314     *,c++,*) ;;
11315     *) ok=no ;;
11316   esac
11317   if test $ok = yes; then
11318     # An in-tree tool is available and we can use it
11319     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'
11320     echo "$as_me:$LINENO: result: just compiled" >&5
11321 echo "${ECHO_T}just compiled" >&6
11322   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11323     # We already found the complete path
11324     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11325     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11326 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11327   elif test "x$target" = "x$host"; then
11328     # We can use an host tool
11329     RAW_CXX_FOR_TARGET='$(CXX)'
11330     echo "$as_me:$LINENO: result: host tool" >&5
11331 echo "${ECHO_T}host tool" >&6
11332   else
11333     # We need a cross tool
11334     echo "$as_me:$LINENO: result: pre-installed" >&5
11335 echo "${ECHO_T}pre-installed" >&6
11336   fi
11337 fi
11338
11339 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11340 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11341 if test "x${build}" != "x${host}" ; then
11342   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11343     # We already found the complete path
11344     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11345     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11346 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11347   else
11348     # Canadian cross, just use what we found
11349     echo "$as_me:$LINENO: result: pre-installed" >&5
11350 echo "${ECHO_T}pre-installed" >&6
11351   fi
11352 else
11353   ok=yes
11354   case " ${configdirs} " in
11355     *" binutils "*) ;;
11356     *) ok=no ;;
11357   esac
11358
11359   if test $ok = yes; then
11360     # An in-tree tool is available and we can use it
11361     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11362     echo "$as_me:$LINENO: result: just compiled" >&5
11363 echo "${ECHO_T}just compiled" >&6
11364   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11365     # We already found the complete path
11366     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11367     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11368 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11369   elif test "x$target" = "x$host"; then
11370     # We can use an host tool
11371     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11372     echo "$as_me:$LINENO: result: host tool" >&5
11373 echo "${ECHO_T}host tool" >&6
11374   else
11375     # We need a cross tool
11376     echo "$as_me:$LINENO: result: pre-installed" >&5
11377 echo "${ECHO_T}pre-installed" >&6
11378   fi
11379 fi
11380
11381 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11382 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11383 if test "x${build}" != "x${host}" ; then
11384   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11385     # We already found the complete path
11386     ac_dir=`dirname $GCC_FOR_TARGET`
11387     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11388 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11389   else
11390     # Canadian cross, just use what we found
11391     echo "$as_me:$LINENO: result: pre-installed" >&5
11392 echo "${ECHO_T}pre-installed" >&6
11393   fi
11394 else
11395   ok=yes
11396   case " ${configdirs} " in
11397     *" gcc "*) ;;
11398     *) ok=no ;;
11399   esac
11400
11401   if test $ok = yes; then
11402     # An in-tree tool is available and we can use it
11403     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11404     echo "$as_me:$LINENO: result: just compiled" >&5
11405 echo "${ECHO_T}just compiled" >&6
11406   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11407     # We already found the complete path
11408     ac_dir=`dirname $GCC_FOR_TARGET`
11409     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11410 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11411   elif test "x$target" = "x$host"; then
11412     # We can use an host tool
11413     GCC_FOR_TARGET='$()'
11414     echo "$as_me:$LINENO: result: host tool" >&5
11415 echo "${ECHO_T}host tool" >&6
11416   else
11417     # We need a cross tool
11418     echo "$as_me:$LINENO: result: pre-installed" >&5
11419 echo "${ECHO_T}pre-installed" >&6
11420   fi
11421 fi
11422
11423 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11424 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11425 if test "x${build}" != "x${host}" ; then
11426   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11427     # We already found the complete path
11428     ac_dir=`dirname $GCJ_FOR_TARGET`
11429     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11430 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11431   else
11432     # Canadian cross, just use what we found
11433     echo "$as_me:$LINENO: result: pre-installed" >&5
11434 echo "${ECHO_T}pre-installed" >&6
11435   fi
11436 else
11437   ok=yes
11438   case " ${configdirs} " in
11439     *" gcc "*) ;;
11440     *) ok=no ;;
11441   esac
11442   case ,${enable_languages}, in
11443     *,java,*) ;;
11444     *) ok=no ;;
11445   esac
11446   if test $ok = yes; then
11447     # An in-tree tool is available and we can use it
11448     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11449     echo "$as_me:$LINENO: result: just compiled" >&5
11450 echo "${ECHO_T}just compiled" >&6
11451   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11452     # We already found the complete path
11453     ac_dir=`dirname $GCJ_FOR_TARGET`
11454     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11455 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11456   elif test "x$target" = "x$host"; then
11457     # We can use an host tool
11458     GCJ_FOR_TARGET='$(GCJ)'
11459     echo "$as_me:$LINENO: result: host tool" >&5
11460 echo "${ECHO_T}host tool" >&6
11461   else
11462     # We need a cross tool
11463     echo "$as_me:$LINENO: result: pre-installed" >&5
11464 echo "${ECHO_T}pre-installed" >&6
11465   fi
11466 fi
11467
11468 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11469 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11470 if test "x${build}" != "x${host}" ; then
11471   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11472     # We already found the complete path
11473     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11474     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11475 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11476   else
11477     # Canadian cross, just use what we found
11478     echo "$as_me:$LINENO: result: pre-installed" >&5
11479 echo "${ECHO_T}pre-installed" >&6
11480   fi
11481 else
11482   ok=yes
11483   case " ${configdirs} " in
11484     *" gcc "*) ;;
11485     *) ok=no ;;
11486   esac
11487   case ,${enable_languages}, in
11488     *,fortran,*) ;;
11489     *) ok=no ;;
11490   esac
11491   if test $ok = yes; then
11492     # An in-tree tool is available and we can use it
11493     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11494     echo "$as_me:$LINENO: result: just compiled" >&5
11495 echo "${ECHO_T}just compiled" >&6
11496   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11497     # We already found the complete path
11498     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11499     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11500 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11501   elif test "x$target" = "x$host"; then
11502     # We can use an host tool
11503     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11504     echo "$as_me:$LINENO: result: host tool" >&5
11505 echo "${ECHO_T}host tool" >&6
11506   else
11507     # We need a cross tool
11508     echo "$as_me:$LINENO: result: pre-installed" >&5
11509 echo "${ECHO_T}pre-installed" >&6
11510   fi
11511 fi
11512
11513 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11514 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11515 if test "x${build}" != "x${host}" ; then
11516   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11517     # We already found the complete path
11518     ac_dir=`dirname $LD_FOR_TARGET`
11519     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11520 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11521   else
11522     # Canadian cross, just use what we found
11523     echo "$as_me:$LINENO: result: pre-installed" >&5
11524 echo "${ECHO_T}pre-installed" >&6
11525   fi
11526 else
11527   ok=yes
11528   case " ${configdirs} " in
11529     *" ld "*) ;;
11530     *) ok=no ;;
11531   esac
11532
11533   if test $ok = yes; then
11534     # An in-tree tool is available and we can use it
11535     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11536     echo "$as_me:$LINENO: result: just compiled" >&5
11537 echo "${ECHO_T}just compiled" >&6
11538   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11539     # We already found the complete path
11540     ac_dir=`dirname $LD_FOR_TARGET`
11541     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11542 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11543   elif test "x$target" = "x$host"; then
11544     # We can use an host tool
11545     LD_FOR_TARGET='$(LD)'
11546     echo "$as_me:$LINENO: result: host tool" >&5
11547 echo "${ECHO_T}host tool" >&6
11548   else
11549     # We need a cross tool
11550     echo "$as_me:$LINENO: result: pre-installed" >&5
11551 echo "${ECHO_T}pre-installed" >&6
11552   fi
11553 fi
11554
11555 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11556 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11557 if test "x${build}" != "x${host}" ; then
11558   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11559     # We already found the complete path
11560     ac_dir=`dirname $LIPO_FOR_TARGET`
11561     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11562 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11563   else
11564     # Canadian cross, just use what we found
11565     echo "$as_me:$LINENO: result: pre-installed" >&5
11566 echo "${ECHO_T}pre-installed" >&6
11567   fi
11568 else
11569   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11570     # We already found the complete path
11571     ac_dir=`dirname $LIPO_FOR_TARGET`
11572     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11573 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11574   elif test "x$target" = "x$host"; then
11575     # We can use an host tool
11576     LIPO_FOR_TARGET='$(LIPO)'
11577     echo "$as_me:$LINENO: result: host tool" >&5
11578 echo "${ECHO_T}host tool" >&6
11579   else
11580     # We need a cross tool
11581     echo "$as_me:$LINENO: result: pre-installed" >&5
11582 echo "${ECHO_T}pre-installed" >&6
11583   fi
11584 fi
11585
11586 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11587 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11588 if test "x${build}" != "x${host}" ; then
11589   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11590     # We already found the complete path
11591     ac_dir=`dirname $NM_FOR_TARGET`
11592     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11593 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11594   else
11595     # Canadian cross, just use what we found
11596     echo "$as_me:$LINENO: result: pre-installed" >&5
11597 echo "${ECHO_T}pre-installed" >&6
11598   fi
11599 else
11600   ok=yes
11601   case " ${configdirs} " in
11602     *" binutils "*) ;;
11603     *) ok=no ;;
11604   esac
11605
11606   if test $ok = yes; then
11607     # An in-tree tool is available and we can use it
11608     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11609     echo "$as_me:$LINENO: result: just compiled" >&5
11610 echo "${ECHO_T}just compiled" >&6
11611   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11612     # We already found the complete path
11613     ac_dir=`dirname $NM_FOR_TARGET`
11614     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11615 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11616   elif test "x$target" = "x$host"; then
11617     # We can use an host tool
11618     NM_FOR_TARGET='$(NM)'
11619     echo "$as_me:$LINENO: result: host tool" >&5
11620 echo "${ECHO_T}host tool" >&6
11621   else
11622     # We need a cross tool
11623     echo "$as_me:$LINENO: result: pre-installed" >&5
11624 echo "${ECHO_T}pre-installed" >&6
11625   fi
11626 fi
11627
11628 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11629 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11630 if test "x${build}" != "x${host}" ; then
11631   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11632     # We already found the complete path
11633     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11634     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11635 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11636   else
11637     # Canadian cross, just use what we found
11638     echo "$as_me:$LINENO: result: pre-installed" >&5
11639 echo "${ECHO_T}pre-installed" >&6
11640   fi
11641 else
11642   ok=yes
11643   case " ${configdirs} " in
11644     *" binutils "*) ;;
11645     *) ok=no ;;
11646   esac
11647
11648   if test $ok = yes; then
11649     # An in-tree tool is available and we can use it
11650     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11651     echo "$as_me:$LINENO: result: just compiled" >&5
11652 echo "${ECHO_T}just compiled" >&6
11653   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11654     # We already found the complete path
11655     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11656     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11657 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11658   elif test "x$target" = "x$host"; then
11659     # We can use an host tool
11660     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11661     echo "$as_me:$LINENO: result: host tool" >&5
11662 echo "${ECHO_T}host tool" >&6
11663   else
11664     # We need a cross tool
11665     echo "$as_me:$LINENO: result: pre-installed" >&5
11666 echo "${ECHO_T}pre-installed" >&6
11667   fi
11668 fi
11669
11670 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11671 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11672 if test "x${build}" != "x${host}" ; then
11673   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11674     # We already found the complete path
11675     ac_dir=`dirname $RANLIB_FOR_TARGET`
11676     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11677 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11678   else
11679     # Canadian cross, just use what we found
11680     echo "$as_me:$LINENO: result: pre-installed" >&5
11681 echo "${ECHO_T}pre-installed" >&6
11682   fi
11683 else
11684   ok=yes
11685   case " ${configdirs} " in
11686     *" binutils "*) ;;
11687     *) ok=no ;;
11688   esac
11689
11690   if test $ok = yes; then
11691     # An in-tree tool is available and we can use it
11692     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11693     echo "$as_me:$LINENO: result: just compiled" >&5
11694 echo "${ECHO_T}just compiled" >&6
11695   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11696     # We already found the complete path
11697     ac_dir=`dirname $RANLIB_FOR_TARGET`
11698     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11699 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11700   elif test "x$target" = "x$host"; then
11701     # We can use an host tool
11702     RANLIB_FOR_TARGET='$(RANLIB)'
11703     echo "$as_me:$LINENO: result: host tool" >&5
11704 echo "${ECHO_T}host tool" >&6
11705   else
11706     # We need a cross tool
11707     echo "$as_me:$LINENO: result: pre-installed" >&5
11708 echo "${ECHO_T}pre-installed" >&6
11709   fi
11710 fi
11711
11712 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11713 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11714 if test "x${build}" != "x${host}" ; then
11715   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11716     # We already found the complete path
11717     ac_dir=`dirname $STRIP_FOR_TARGET`
11718     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11719 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11720   else
11721     # Canadian cross, just use what we found
11722     echo "$as_me:$LINENO: result: pre-installed" >&5
11723 echo "${ECHO_T}pre-installed" >&6
11724   fi
11725 else
11726   ok=yes
11727   case " ${configdirs} " in
11728     *" binutils "*) ;;
11729     *) ok=no ;;
11730   esac
11731
11732   if test $ok = yes; then
11733     # An in-tree tool is available and we can use it
11734     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11735     echo "$as_me:$LINENO: result: just compiled" >&5
11736 echo "${ECHO_T}just compiled" >&6
11737   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11738     # We already found the complete path
11739     ac_dir=`dirname $STRIP_FOR_TARGET`
11740     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11741 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11742   elif test "x$target" = "x$host"; then
11743     # We can use an host tool
11744     STRIP_FOR_TARGET='$(STRIP)'
11745     echo "$as_me:$LINENO: result: host tool" >&5
11746 echo "${ECHO_T}host tool" >&6
11747   else
11748     # We need a cross tool
11749     echo "$as_me:$LINENO: result: pre-installed" >&5
11750 echo "${ECHO_T}pre-installed" >&6
11751   fi
11752 fi
11753
11754 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11755 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11756 if test "x${build}" != "x${host}" ; then
11757   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11758     # We already found the complete path
11759     ac_dir=`dirname $WINDRES_FOR_TARGET`
11760     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11761 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11762   else
11763     # Canadian cross, just use what we found
11764     echo "$as_me:$LINENO: result: pre-installed" >&5
11765 echo "${ECHO_T}pre-installed" >&6
11766   fi
11767 else
11768   ok=yes
11769   case " ${configdirs} " in
11770     *" binutils "*) ;;
11771     *) ok=no ;;
11772   esac
11773
11774   if test $ok = yes; then
11775     # An in-tree tool is available and we can use it
11776     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11777     echo "$as_me:$LINENO: result: just compiled" >&5
11778 echo "${ECHO_T}just compiled" >&6
11779   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11780     # We already found the complete path
11781     ac_dir=`dirname $WINDRES_FOR_TARGET`
11782     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11783 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11784   elif test "x$target" = "x$host"; then
11785     # We can use an host tool
11786     WINDRES_FOR_TARGET='$(WINDRES)'
11787     echo "$as_me:$LINENO: result: host tool" >&5
11788 echo "${ECHO_T}host tool" >&6
11789   else
11790     # We need a cross tool
11791     echo "$as_me:$LINENO: result: pre-installed" >&5
11792 echo "${ECHO_T}pre-installed" >&6
11793   fi
11794 fi
11795
11796 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
11797 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
11798 if test "x${build}" != "x${host}" ; then
11799   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11800     # We already found the complete path
11801     ac_dir=`dirname $WINDMC_FOR_TARGET`
11802     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11803 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11804   else
11805     # Canadian cross, just use what we found
11806     echo "$as_me:$LINENO: result: pre-installed" >&5
11807 echo "${ECHO_T}pre-installed" >&6
11808   fi
11809 else
11810   ok=yes
11811   case " ${configdirs} " in
11812     *" binutils "*) ;;
11813     *) ok=no ;;
11814   esac
11815
11816   if test $ok = yes; then
11817     # An in-tree tool is available and we can use it
11818     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
11819     echo "$as_me:$LINENO: result: just compiled" >&5
11820 echo "${ECHO_T}just compiled" >&6
11821   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11822     # We already found the complete path
11823     ac_dir=`dirname $WINDMC_FOR_TARGET`
11824     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11825 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11826   elif test "x$target" = "x$host"; then
11827     # We can use an host tool
11828     WINDMC_FOR_TARGET='$(WINDMC)'
11829     echo "$as_me:$LINENO: result: host tool" >&5
11830 echo "${ECHO_T}host tool" >&6
11831   else
11832     # We need a cross tool
11833     echo "$as_me:$LINENO: result: pre-installed" >&5
11834 echo "${ECHO_T}pre-installed" >&6
11835   fi
11836 fi
11837
11838
11839
11840
11841
11842 # Certain tools may need extra flags.
11843 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11844 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11845 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11846
11847 # When building target libraries, except in a Canadian cross, we use
11848 # the same toolchain as the compiler we just built.
11849 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11850 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11851 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11852 if test $host = $build; then
11853   case " $configdirs " in
11854     *" gcc "*)
11855       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11856       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11857       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11858       ;;
11859   esac
11860 fi
11861
11862
11863
11864
11865
11866 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11867 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11868 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11869 if test "${enable_maintainer_mode+set}" = set; then
11870   enableval="$enable_maintainer_mode"
11871   USE_MAINTAINER_MODE=$enableval
11872 else
11873   USE_MAINTAINER_MODE=no
11874 fi;
11875 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11876 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11877
11878
11879 if test "$USE_MAINTAINER_MODE" = yes; then
11880   MAINTAINER_MODE_TRUE=
11881   MAINTAINER_MODE_FALSE='#'
11882 else
11883   MAINTAINER_MODE_TRUE='#'
11884   MAINTAINER_MODE_FALSE=
11885 fi
11886 MAINT=$MAINTAINER_MODE_TRUE
11887
11888 # ---------------------
11889 # GCC bootstrap support
11890 # ---------------------
11891
11892 # Stage specific cflags for build.
11893 stage1_cflags="-g"
11894 case $build in
11895   vax-*-*)
11896     case ${GCC} in
11897       yes) stage1_cflags="-g -Wa,-J" ;;
11898       *) stage1_cflags="-g -J" ;;
11899     esac ;;
11900 esac
11901
11902 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
11903 if test "$GCC" = yes; then
11904   saved_CFLAGS="$CFLAGS"
11905
11906   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
11907   CFLAGS="$CFLAGS -fkeep-inline-functions"
11908   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
11909 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
11910   cat >conftest.$ac_ext <<_ACEOF
11911 /* confdefs.h.  */
11912 _ACEOF
11913 cat confdefs.h >>conftest.$ac_ext
11914 cat >>conftest.$ac_ext <<_ACEOF
11915 /* end confdefs.h.  */
11916
11917 #if (__GNUC__ < 3) \
11918     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
11919                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
11920 #error http://gcc.gnu.org/PR29382
11921 #endif
11922
11923 int
11924 main ()
11925 {
11926
11927   ;
11928   return 0;
11929 }
11930 _ACEOF
11931 rm -f conftest.$ac_objext
11932 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11933   (eval $ac_compile) 2>conftest.er1
11934   ac_status=$?
11935   grep -v '^ *+' conftest.er1 >conftest.err
11936   rm -f conftest.er1
11937   cat conftest.err >&5
11938   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11939   (exit $ac_status); } &&
11940          { ac_try='test -z "$ac_c_werror_flag"
11941                          || test ! -s conftest.err'
11942   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11943   (eval $ac_try) 2>&5
11944   ac_status=$?
11945   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11946   (exit $ac_status); }; } &&
11947          { ac_try='test -s conftest.$ac_objext'
11948   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11949   (eval $ac_try) 2>&5
11950   ac_status=$?
11951   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11952   (exit $ac_status); }; }; then
11953   echo "$as_me:$LINENO: result: yes" >&5
11954 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
11955 else
11956   echo "$as_me: failed program was:" >&5
11957 sed 's/^/| /' conftest.$ac_ext >&5
11958
11959 echo "$as_me:$LINENO: result: no" >&5
11960 echo "${ECHO_T}no" >&6
11961 fi
11962 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11963
11964   CFLAGS="$saved_CFLAGS"
11965 fi
11966
11967
11968
11969 # Enable --enable-checking in stage1 of the compiler.
11970 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
11971 if test "${enable_stage1_checking+set}" = set; then
11972   enableval="$enable_stage1_checking"
11973   stage1_checking=--enable-checking=${enable_stage1_checking}
11974 else
11975   if test "x$enable_checking" = xno; then
11976   stage1_checking=--enable-checking
11977 else
11978   stage1_checking=--enable-checking${enable_checking+=}$enable_checking
11979 fi
11980 fi;
11981
11982
11983 # Enable -Werror in bootstrap stage2 and later.
11984 # Check whether --enable-werror or --disable-werror was given.
11985 if test "${enable_werror+set}" = set; then
11986   enableval="$enable_werror"
11987
11988 else
11989   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
11990   enable_werror=yes
11991 else
11992   enable_werror=no
11993 fi
11994 fi;
11995 case ${enable_werror} in
11996   yes) stage2_werror_flag="--enable-werror-always" ;;
11997   *) stage2_werror_flag="" ;;
11998 esac
11999
12000
12001 # Flags needed to enable html installing and building
12002
12003 # Check whether --with-datarootdir or --without-datarootdir was given.
12004 if test "${with_datarootdir+set}" = set; then
12005   withval="$with_datarootdir"
12006   datarootdir="\${prefix}/${withval}"
12007 else
12008   datarootdir="\${prefix}/share"
12009 fi;
12010
12011
12012 # Check whether --with-docdir or --without-docdir was given.
12013 if test "${with_docdir+set}" = set; then
12014   withval="$with_docdir"
12015   docdir="\${prefix}/${withval}"
12016 else
12017   docdir="\${datarootdir}/doc"
12018 fi;
12019
12020
12021 # Check whether --with-pdfdir or --without-pdfdir was given.
12022 if test "${with_pdfdir+set}" = set; then
12023   withval="$with_pdfdir"
12024   pdfdir="\${prefix}/${withval}"
12025 else
12026   pdfdir="\${docdir}"
12027 fi;
12028
12029
12030 # Check whether --with-htmldir or --without-htmldir was given.
12031 if test "${with_htmldir+set}" = set; then
12032   withval="$with_htmldir"
12033   htmldir="\${prefix}/${withval}"
12034 else
12035   htmldir="\${docdir}"
12036 fi;
12037
12038
12039
12040
12041
12042
12043           ac_config_files="$ac_config_files Makefile"
12044 cat >confcache <<\_ACEOF
12045 # This file is a shell script that caches the results of configure
12046 # tests run on this system so they can be shared between configure
12047 # scripts and configure runs, see configure's option --config-cache.
12048 # It is not useful on other systems.  If it contains results you don't
12049 # want to keep, you may remove or edit it.
12050 #
12051 # config.status only pays attention to the cache file if you give it
12052 # the --recheck option to rerun configure.
12053 #
12054 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12055 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12056 # following values.
12057
12058 _ACEOF
12059
12060 # The following way of writing the cache mishandles newlines in values,
12061 # but we know of no workaround that is simple, portable, and efficient.
12062 # So, don't put newlines in cache variables' values.
12063 # Ultrix sh set writes to stderr and can't be redirected directly,
12064 # and sets the high bit in the cache file unless we assign to the vars.
12065 {
12066   (set) 2>&1 |
12067     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12068     *ac_space=\ *)
12069       # `set' does not quote correctly, so add quotes (double-quote
12070       # substitution turns \\\\ into \\, and sed turns \\ into \).
12071       sed -n \
12072         "s/'/'\\\\''/g;
12073           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12074       ;;
12075     *)
12076       # `set' quotes correctly as required by POSIX, so do not add quotes.
12077       sed -n \
12078         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12079       ;;
12080     esac;
12081 } |
12082   sed '
12083      t clear
12084      : clear
12085      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12086      t end
12087      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12088      : end' >>confcache
12089 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12090   if test -w $cache_file; then
12091     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12092     cat confcache >$cache_file
12093   else
12094     echo "not updating unwritable cache $cache_file"
12095   fi
12096 fi
12097 rm -f confcache
12098
12099 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12100 # Let make expand exec_prefix.
12101 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12102
12103 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12104 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12105 # trailing colons and then remove the whole line if VPATH becomes empty
12106 # (actually we leave an empty line to preserve line numbers).
12107 if test "x$srcdir" = x.; then
12108   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12109 s/:*\$(srcdir):*/:/;
12110 s/:*\${srcdir}:*/:/;
12111 s/:*@srcdir@:*/:/;
12112 s/^\([^=]*=[     ]*\):*/\1/;
12113 s/:*$//;
12114 s/^[^=]*=[       ]*$//;
12115 }'
12116 fi
12117
12118 # Transform confdefs.h into DEFS.
12119 # Protect against shell expansion while executing Makefile rules.
12120 # Protect against Makefile macro expansion.
12121 #
12122 # If the first sed substitution is executed (which looks for macros that
12123 # take arguments), then we branch to the quote section.  Otherwise,
12124 # look for a macro that doesn't take arguments.
12125 cat >confdef2opt.sed <<\_ACEOF
12126 t clear
12127 : clear
12128 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12129 t quote
12130 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12131 t quote
12132 d
12133 : quote
12134 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12135 s,\[,\\&,g
12136 s,\],\\&,g
12137 s,\$,$$,g
12138 p
12139 _ACEOF
12140 # We use echo to avoid assuming a particular line-breaking character.
12141 # The extra dot is to prevent the shell from consuming trailing
12142 # line-breaks from the sub-command output.  A line-break within
12143 # single-quotes doesn't work because, if this script is created in a
12144 # platform that uses two characters for line-breaks (e.g., DOS), tr
12145 # would break.
12146 ac_LF_and_DOT=`echo; echo .`
12147 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12148 rm -f confdef2opt.sed
12149
12150
12151 ac_libobjs=
12152 ac_ltlibobjs=
12153 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12154   # 1. Remove the extension, and $U if already installed.
12155   ac_i=`echo "$ac_i" |
12156          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12157   # 2. Add them.
12158   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12159   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12160 done
12161 LIBOBJS=$ac_libobjs
12162
12163 LTLIBOBJS=$ac_ltlibobjs
12164
12165
12166
12167 : ${CONFIG_STATUS=./config.status}
12168 ac_clean_files_save=$ac_clean_files
12169 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12170 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12171 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12172 cat >$CONFIG_STATUS <<_ACEOF
12173 #! $SHELL
12174 # Generated by $as_me.
12175 # Run this file to recreate the current configuration.
12176 # Compiler output produced by configure, useful for debugging
12177 # configure, is in config.log if it exists.
12178
12179 debug=false
12180 ac_cs_recheck=false
12181 ac_cs_silent=false
12182 SHELL=\${CONFIG_SHELL-$SHELL}
12183 _ACEOF
12184
12185 cat >>$CONFIG_STATUS <<\_ACEOF
12186 ## --------------------- ##
12187 ## M4sh Initialization.  ##
12188 ## --------------------- ##
12189
12190 # Be Bourne compatible
12191 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12192   emulate sh
12193   NULLCMD=:
12194   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12195   # is contrary to our usage.  Disable this feature.
12196   alias -g '${1+"$@"}'='"$@"'
12197 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12198   set -o posix
12199 fi
12200 DUALCASE=1; export DUALCASE # for MKS sh
12201
12202 # Support unset when possible.
12203 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12204   as_unset=unset
12205 else
12206   as_unset=false
12207 fi
12208
12209
12210 # Work around bugs in pre-3.0 UWIN ksh.
12211 $as_unset ENV MAIL MAILPATH
12212 PS1='$ '
12213 PS2='> '
12214 PS4='+ '
12215
12216 # NLS nuisances.
12217 for as_var in \
12218   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12219   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12220   LC_TELEPHONE LC_TIME
12221 do
12222   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12223     eval $as_var=C; export $as_var
12224   else
12225     $as_unset $as_var
12226   fi
12227 done
12228
12229 # Required to use basename.
12230 if expr a : '\(a\)' >/dev/null 2>&1; then
12231   as_expr=expr
12232 else
12233   as_expr=false
12234 fi
12235
12236 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12237   as_basename=basename
12238 else
12239   as_basename=false
12240 fi
12241
12242
12243 # Name of the executable.
12244 as_me=`$as_basename "$0" ||
12245 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12246          X"$0" : 'X\(//\)$' \| \
12247          X"$0" : 'X\(/\)$' \| \
12248          .     : '\(.\)' 2>/dev/null ||
12249 echo X/"$0" |
12250     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12251           /^X\/\(\/\/\)$/{ s//\1/; q; }
12252           /^X\/\(\/\).*/{ s//\1/; q; }
12253           s/.*/./; q'`
12254
12255
12256 # PATH needs CR, and LINENO needs CR and PATH.
12257 # Avoid depending upon Character Ranges.
12258 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12259 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12260 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12261 as_cr_digits='0123456789'
12262 as_cr_alnum=$as_cr_Letters$as_cr_digits
12263
12264 # The user is always right.
12265 if test "${PATH_SEPARATOR+set}" != set; then
12266   echo "#! /bin/sh" >conf$$.sh
12267   echo  "exit 0"   >>conf$$.sh
12268   chmod +x conf$$.sh
12269   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12270     PATH_SEPARATOR=';'
12271   else
12272     PATH_SEPARATOR=:
12273   fi
12274   rm -f conf$$.sh
12275 fi
12276
12277
12278   as_lineno_1=$LINENO
12279   as_lineno_2=$LINENO
12280   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12281   test "x$as_lineno_1" != "x$as_lineno_2" &&
12282   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12283   # Find who we are.  Look in the path if we contain no path at all
12284   # relative or not.
12285   case $0 in
12286     *[\\/]* ) as_myself=$0 ;;
12287     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12288 for as_dir in $PATH
12289 do
12290   IFS=$as_save_IFS
12291   test -z "$as_dir" && as_dir=.
12292   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12293 done
12294
12295        ;;
12296   esac
12297   # We did not find ourselves, most probably we were run as `sh COMMAND'
12298   # in which case we are not to be found in the path.
12299   if test "x$as_myself" = x; then
12300     as_myself=$0
12301   fi
12302   if test ! -f "$as_myself"; then
12303     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12304 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12305    { (exit 1); exit 1; }; }
12306   fi
12307   case $CONFIG_SHELL in
12308   '')
12309     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12310 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12311 do
12312   IFS=$as_save_IFS
12313   test -z "$as_dir" && as_dir=.
12314   for as_base in sh bash ksh sh5; do
12315          case $as_dir in
12316          /*)
12317            if ("$as_dir/$as_base" -c '
12318   as_lineno_1=$LINENO
12319   as_lineno_2=$LINENO
12320   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12321   test "x$as_lineno_1" != "x$as_lineno_2" &&
12322   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12323              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12324              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12325              CONFIG_SHELL=$as_dir/$as_base
12326              export CONFIG_SHELL
12327              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12328            fi;;
12329          esac
12330        done
12331 done
12332 ;;
12333   esac
12334
12335   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12336   # uniformly replaced by the line number.  The first 'sed' inserts a
12337   # line-number line before each line; the second 'sed' does the real
12338   # work.  The second script uses 'N' to pair each line-number line
12339   # with the numbered line, and appends trailing '-' during
12340   # substitution so that $LINENO is not a special case at line end.
12341   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12342   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12343   sed '=' <$as_myself |
12344     sed '
12345       N
12346       s,$,-,
12347       : loop
12348       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12349       t loop
12350       s,-$,,
12351       s,^['$as_cr_digits']*\n,,
12352     ' >$as_me.lineno &&
12353   chmod +x $as_me.lineno ||
12354     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12355 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12356    { (exit 1); exit 1; }; }
12357
12358   # Don't try to exec as it changes $[0], causing all sort of problems
12359   # (the dirname of $[0] is not the place where we might find the
12360   # original and so on.  Autoconf is especially sensible to this).
12361   . ./$as_me.lineno
12362   # Exit status is that of the last command.
12363   exit
12364 }
12365
12366
12367 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12368   *c*,-n*) ECHO_N= ECHO_C='
12369 ' ECHO_T='      ' ;;
12370   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12371   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12372 esac
12373
12374 if expr a : '\(a\)' >/dev/null 2>&1; then
12375   as_expr=expr
12376 else
12377   as_expr=false
12378 fi
12379
12380 rm -f conf$$ conf$$.exe conf$$.file
12381 echo >conf$$.file
12382 if ln -s conf$$.file conf$$ 2>/dev/null; then
12383   # We could just check for DJGPP; but this test a) works b) is more generic
12384   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12385   if test -f conf$$.exe; then
12386     # Don't use ln at all; we don't have any links
12387     as_ln_s='cp -p'
12388   else
12389     as_ln_s='ln -s'
12390   fi
12391 elif ln conf$$.file conf$$ 2>/dev/null; then
12392   as_ln_s=ln
12393 else
12394   as_ln_s='cp -p'
12395 fi
12396 rm -f conf$$ conf$$.exe conf$$.file
12397
12398 if mkdir -p . 2>/dev/null; then
12399   as_mkdir_p=:
12400 else
12401   test -d ./-p && rmdir ./-p
12402   as_mkdir_p=false
12403 fi
12404
12405 as_executable_p="test -f"
12406
12407 # Sed expression to map a string onto a valid CPP name.
12408 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12409
12410 # Sed expression to map a string onto a valid variable name.
12411 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12412
12413
12414 # IFS
12415 # We need space, tab and new line, in precisely that order.
12416 as_nl='
12417 '
12418 IFS="   $as_nl"
12419
12420 # CDPATH.
12421 $as_unset CDPATH
12422
12423 exec 6>&1
12424
12425 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12426 # report actual input values of CONFIG_FILES etc. instead of their
12427 # values after options handling.  Logging --version etc. is OK.
12428 exec 5>>config.log
12429 {
12430   echo
12431   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12432 ## Running $as_me. ##
12433 _ASBOX
12434 } >&5
12435 cat >&5 <<_CSEOF
12436
12437 This file was extended by $as_me, which was
12438 generated by GNU Autoconf 2.59.  Invocation command line was
12439
12440   CONFIG_FILES    = $CONFIG_FILES
12441   CONFIG_HEADERS  = $CONFIG_HEADERS
12442   CONFIG_LINKS    = $CONFIG_LINKS
12443   CONFIG_COMMANDS = $CONFIG_COMMANDS
12444   $ $0 $@
12445
12446 _CSEOF
12447 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12448 echo >&5
12449 _ACEOF
12450
12451 # Files that config.status was made for.
12452 if test -n "$ac_config_files"; then
12453   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12454 fi
12455
12456 if test -n "$ac_config_headers"; then
12457   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12458 fi
12459
12460 if test -n "$ac_config_links"; then
12461   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12462 fi
12463
12464 if test -n "$ac_config_commands"; then
12465   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12466 fi
12467
12468 cat >>$CONFIG_STATUS <<\_ACEOF
12469
12470 ac_cs_usage="\
12471 \`$as_me' instantiates files from templates according to the
12472 current configuration.
12473
12474 Usage: $0 [OPTIONS] [FILE]...
12475
12476   -h, --help       print this help, then exit
12477   -V, --version    print version number, then exit
12478   -q, --quiet      do not print progress messages
12479   -d, --debug      don't remove temporary files
12480       --recheck    update $as_me by reconfiguring in the same conditions
12481   --file=FILE[:TEMPLATE]
12482                    instantiate the configuration file FILE
12483
12484 Configuration files:
12485 $config_files
12486
12487 Report bugs to <bug-autoconf@gnu.org>."
12488 _ACEOF
12489
12490 cat >>$CONFIG_STATUS <<_ACEOF
12491 ac_cs_version="\\
12492 config.status
12493 configured by $0, generated by GNU Autoconf 2.59,
12494   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12495
12496 Copyright (C) 2003 Free Software Foundation, Inc.
12497 This config.status script is free software; the Free Software Foundation
12498 gives unlimited permission to copy, distribute and modify it."
12499 srcdir=$srcdir
12500 INSTALL="$INSTALL"
12501 _ACEOF
12502
12503 cat >>$CONFIG_STATUS <<\_ACEOF
12504 # If no file are specified by the user, then we need to provide default
12505 # value.  By we need to know if files were specified by the user.
12506 ac_need_defaults=:
12507 while test $# != 0
12508 do
12509   case $1 in
12510   --*=*)
12511     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12512     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12513     ac_shift=:
12514     ;;
12515   -*)
12516     ac_option=$1
12517     ac_optarg=$2
12518     ac_shift=shift
12519     ;;
12520   *) # This is not an option, so the user has probably given explicit
12521      # arguments.
12522      ac_option=$1
12523      ac_need_defaults=false;;
12524   esac
12525
12526   case $ac_option in
12527   # Handling of the options.
12528 _ACEOF
12529 cat >>$CONFIG_STATUS <<\_ACEOF
12530   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12531     ac_cs_recheck=: ;;
12532   --version | --vers* | -V )
12533     echo "$ac_cs_version"; exit 0 ;;
12534   --he | --h)
12535     # Conflict between --help and --header
12536     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12537 Try \`$0 --help' for more information." >&5
12538 echo "$as_me: error: ambiguous option: $1
12539 Try \`$0 --help' for more information." >&2;}
12540    { (exit 1); exit 1; }; };;
12541   --help | --hel | -h )
12542     echo "$ac_cs_usage"; exit 0 ;;
12543   --debug | --d* | -d )
12544     debug=: ;;
12545   --file | --fil | --fi | --f )
12546     $ac_shift
12547     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12548     ac_need_defaults=false;;
12549   --header | --heade | --head | --hea )
12550     $ac_shift
12551     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12552     ac_need_defaults=false;;
12553   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12554   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12555     ac_cs_silent=: ;;
12556
12557   # This is an error.
12558   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12559 Try \`$0 --help' for more information." >&5
12560 echo "$as_me: error: unrecognized option: $1
12561 Try \`$0 --help' for more information." >&2;}
12562    { (exit 1); exit 1; }; } ;;
12563
12564   *) ac_config_targets="$ac_config_targets $1" ;;
12565
12566   esac
12567   shift
12568 done
12569
12570 ac_configure_extra_args=
12571
12572 if $ac_cs_silent; then
12573   exec 6>/dev/null
12574   ac_configure_extra_args="$ac_configure_extra_args --silent"
12575 fi
12576
12577 _ACEOF
12578 cat >>$CONFIG_STATUS <<_ACEOF
12579 if \$ac_cs_recheck; then
12580   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12581   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12582 fi
12583
12584 _ACEOF
12585
12586
12587
12588
12589
12590 cat >>$CONFIG_STATUS <<\_ACEOF
12591 for ac_config_target in $ac_config_targets
12592 do
12593   case "$ac_config_target" in
12594   # Handling of arguments.
12595   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12596   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12597 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12598    { (exit 1); exit 1; }; };;
12599   esac
12600 done
12601
12602 # If the user did not use the arguments to specify the items to instantiate,
12603 # then the envvar interface is used.  Set only those that are not.
12604 # We use the long form for the default assignment because of an extremely
12605 # bizarre bug on SunOS 4.1.3.
12606 if $ac_need_defaults; then
12607   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12608 fi
12609
12610 # Have a temporary directory for convenience.  Make it in the build tree
12611 # simply because there is no reason to put it here, and in addition,
12612 # creating and moving files from /tmp can sometimes cause problems.
12613 # Create a temporary directory, and hook for its removal unless debugging.
12614 $debug ||
12615 {
12616   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12617   trap '{ (exit 1); exit 1; }' 1 2 13 15
12618 }
12619
12620 # Create a (secure) tmp directory for tmp files.
12621
12622 {
12623   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12624   test -n "$tmp" && test -d "$tmp"
12625 }  ||
12626 {
12627   tmp=./confstat$$-$RANDOM
12628   (umask 077 && mkdir $tmp)
12629 } ||
12630 {
12631    echo "$me: cannot create a temporary directory in ." >&2
12632    { (exit 1); exit 1; }
12633 }
12634
12635 _ACEOF
12636
12637 cat >>$CONFIG_STATUS <<_ACEOF
12638
12639 #
12640 # CONFIG_FILES section.
12641 #
12642
12643 # No need to generate the scripts if there are no CONFIG_FILES.
12644 # This happens for instance when ./config.status config.h
12645 if test -n "\$CONFIG_FILES"; then
12646   # Protect against being on the right side of a sed subst in config.status.
12647   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12648    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12649 s,@SHELL@,$SHELL,;t t
12650 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12651 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12652 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12653 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12654 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12655 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12656 s,@exec_prefix@,$exec_prefix,;t t
12657 s,@prefix@,$prefix,;t t
12658 s,@program_transform_name@,$program_transform_name,;t t
12659 s,@bindir@,$bindir,;t t
12660 s,@sbindir@,$sbindir,;t t
12661 s,@libexecdir@,$libexecdir,;t t
12662 s,@datadir@,$datadir,;t t
12663 s,@sysconfdir@,$sysconfdir,;t t
12664 s,@sharedstatedir@,$sharedstatedir,;t t
12665 s,@localstatedir@,$localstatedir,;t t
12666 s,@libdir@,$libdir,;t t
12667 s,@includedir@,$includedir,;t t
12668 s,@oldincludedir@,$oldincludedir,;t t
12669 s,@infodir@,$infodir,;t t
12670 s,@mandir@,$mandir,;t t
12671 s,@build_alias@,$build_alias,;t t
12672 s,@host_alias@,$host_alias,;t t
12673 s,@target_alias@,$target_alias,;t t
12674 s,@DEFS@,$DEFS,;t t
12675 s,@ECHO_C@,$ECHO_C,;t t
12676 s,@ECHO_N@,$ECHO_N,;t t
12677 s,@ECHO_T@,$ECHO_T,;t t
12678 s,@LIBS@,$LIBS,;t t
12679 s,@build@,$build,;t t
12680 s,@build_cpu@,$build_cpu,;t t
12681 s,@build_vendor@,$build_vendor,;t t
12682 s,@build_os@,$build_os,;t t
12683 s,@build_noncanonical@,$build_noncanonical,;t t
12684 s,@host_noncanonical@,$host_noncanonical,;t t
12685 s,@target_noncanonical@,$target_noncanonical,;t t
12686 s,@host@,$host,;t t
12687 s,@host_cpu@,$host_cpu,;t t
12688 s,@host_vendor@,$host_vendor,;t t
12689 s,@host_os@,$host_os,;t t
12690 s,@target@,$target,;t t
12691 s,@target_cpu@,$target_cpu,;t t
12692 s,@target_vendor@,$target_vendor,;t t
12693 s,@target_os@,$target_os,;t t
12694 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12695 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12696 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12697 s,@LN@,$LN,;t t
12698 s,@LN_S@,$LN_S,;t t
12699 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12700 s,@build_libsubdir@,$build_libsubdir,;t t
12701 s,@build_subdir@,$build_subdir,;t t
12702 s,@host_subdir@,$host_subdir,;t t
12703 s,@target_subdir@,$target_subdir,;t t
12704 s,@CC@,$CC,;t t
12705 s,@CFLAGS@,$CFLAGS,;t t
12706 s,@LDFLAGS@,$LDFLAGS,;t t
12707 s,@CPPFLAGS@,$CPPFLAGS,;t t
12708 s,@ac_ct_CC@,$ac_ct_CC,;t t
12709 s,@EXEEXT@,$EXEEXT,;t t
12710 s,@OBJEXT@,$OBJEXT,;t t
12711 s,@CXX@,$CXX,;t t
12712 s,@CXXFLAGS@,$CXXFLAGS,;t t
12713 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12714 s,@GNATBIND@,$GNATBIND,;t t
12715 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12716 s,@GNATMAKE@,$GNATMAKE,;t t
12717 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12718 s,@do_compare@,$do_compare,;t t
12719 s,@gmplibs@,$gmplibs,;t t
12720 s,@gmpinc@,$gmpinc,;t t
12721 s,@stage1_languages@,$stage1_languages,;t t
12722 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12723 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12724 s,@tooldir@,$tooldir,;t t
12725 s,@build_tooldir@,$build_tooldir,;t t
12726 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12727 s,@GDB_TK@,$GDB_TK,;t t
12728 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12729 s,@build_configargs@,$build_configargs,;t t
12730 s,@build_configdirs@,$build_configdirs,;t t
12731 s,@host_configargs@,$host_configargs,;t t
12732 s,@configdirs@,$configdirs,;t t
12733 s,@target_configargs@,$target_configargs,;t t
12734 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12735 s,@config_shell@,$config_shell,;t t
12736 s,@YACC@,$YACC,;t t
12737 s,@BISON@,$BISON,;t t
12738 s,@M4@,$M4,;t t
12739 s,@LEX@,$LEX,;t t
12740 s,@FLEX@,$FLEX,;t t
12741 s,@MAKEINFO@,$MAKEINFO,;t t
12742 s,@EXPECT@,$EXPECT,;t t
12743 s,@RUNTEST@,$RUNTEST,;t t
12744 s,@AR@,$AR,;t t
12745 s,@AS@,$AS,;t t
12746 s,@DLLTOOL@,$DLLTOOL,;t t
12747 s,@LD@,$LD,;t t
12748 s,@LIPO@,$LIPO,;t t
12749 s,@NM@,$NM,;t t
12750 s,@RANLIB@,$RANLIB,;t t
12751 s,@STRIP@,$STRIP,;t t
12752 s,@WINDRES@,$WINDRES,;t t
12753 s,@WINDMC@,$WINDMC,;t t
12754 s,@OBJCOPY@,$OBJCOPY,;t t
12755 s,@OBJDUMP@,$OBJDUMP,;t t
12756 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12757 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12758 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12759 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12760 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12761 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12762 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12763 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12764 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12765 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12766 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12767 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12768 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12769 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12770 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12771 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12772 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12773 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12774 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12775 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12776 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12777 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12778 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12779 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12780 s,@MAINT@,$MAINT,;t t
12781 s,@stage1_cflags@,$stage1_cflags,;t t
12782 s,@stage1_checking@,$stage1_checking,;t t
12783 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12784 s,@datarootdir@,$datarootdir,;t t
12785 s,@docdir@,$docdir,;t t
12786 s,@pdfdir@,$pdfdir,;t t
12787 s,@htmldir@,$htmldir,;t t
12788 s,@LIBOBJS@,$LIBOBJS,;t t
12789 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12790 /@serialization_dependencies@/r $serialization_dependencies
12791 s,@serialization_dependencies@,,;t t
12792 /@host_makefile_frag@/r $host_makefile_frag
12793 s,@host_makefile_frag@,,;t t
12794 /@target_makefile_frag@/r $target_makefile_frag
12795 s,@target_makefile_frag@,,;t t
12796 /@alphaieee_frag@/r $alphaieee_frag
12797 s,@alphaieee_frag@,,;t t
12798 /@ospace_frag@/r $ospace_frag
12799 s,@ospace_frag@,,;t t
12800 CEOF
12801
12802 _ACEOF
12803
12804   cat >>$CONFIG_STATUS <<\_ACEOF
12805   # Split the substitutions into bite-sized pieces for seds with
12806   # small command number limits, like on Digital OSF/1 and HP-UX.
12807   ac_max_sed_lines=48
12808   ac_sed_frag=1 # Number of current file.
12809   ac_beg=1 # First line for current file.
12810   ac_end=$ac_max_sed_lines # Line after last line for current file.
12811   ac_more_lines=:
12812   ac_sed_cmds=
12813   while $ac_more_lines; do
12814     if test $ac_beg -gt 1; then
12815       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12816     else
12817       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12818     fi
12819     if test ! -s $tmp/subs.frag; then
12820       ac_more_lines=false
12821     else
12822       # The purpose of the label and of the branching condition is to
12823       # speed up the sed processing (if there are no `@' at all, there
12824       # is no need to browse any of the substitutions).
12825       # These are the two extra sed commands mentioned above.
12826       (echo ':t
12827   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12828       if test -z "$ac_sed_cmds"; then
12829         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12830       else
12831         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12832       fi
12833       ac_sed_frag=`expr $ac_sed_frag + 1`
12834       ac_beg=$ac_end
12835       ac_end=`expr $ac_end + $ac_max_sed_lines`
12836     fi
12837   done
12838   if test -z "$ac_sed_cmds"; then
12839     ac_sed_cmds=cat
12840   fi
12841 fi # test -n "$CONFIG_FILES"
12842
12843 _ACEOF
12844 cat >>$CONFIG_STATUS <<\_ACEOF
12845 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12846   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12847   case $ac_file in
12848   - | *:- | *:-:* ) # input from stdin
12849         cat >$tmp/stdin
12850         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12851         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12852   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12853         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12854   * )   ac_file_in=$ac_file.in ;;
12855   esac
12856
12857   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12858   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12859 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12860          X"$ac_file" : 'X\(//\)[^/]' \| \
12861          X"$ac_file" : 'X\(//\)$' \| \
12862          X"$ac_file" : 'X\(/\)' \| \
12863          .     : '\(.\)' 2>/dev/null ||
12864 echo X"$ac_file" |
12865     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12866           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12867           /^X\(\/\/\)$/{ s//\1/; q; }
12868           /^X\(\/\).*/{ s//\1/; q; }
12869           s/.*/./; q'`
12870   { if $as_mkdir_p; then
12871     mkdir -p "$ac_dir"
12872   else
12873     as_dir="$ac_dir"
12874     as_dirs=
12875     while test ! -d "$as_dir"; do
12876       as_dirs="$as_dir $as_dirs"
12877       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12878 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12879          X"$as_dir" : 'X\(//\)[^/]' \| \
12880          X"$as_dir" : 'X\(//\)$' \| \
12881          X"$as_dir" : 'X\(/\)' \| \
12882          .     : '\(.\)' 2>/dev/null ||
12883 echo X"$as_dir" |
12884     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12885           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12886           /^X\(\/\/\)$/{ s//\1/; q; }
12887           /^X\(\/\).*/{ s//\1/; q; }
12888           s/.*/./; q'`
12889     done
12890     test ! -n "$as_dirs" || mkdir $as_dirs
12891   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
12892 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
12893    { (exit 1); exit 1; }; }; }
12894
12895   ac_builddir=.
12896
12897 if test "$ac_dir" != .; then
12898   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
12899   # A "../" for each directory in $ac_dir_suffix.
12900   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
12901 else
12902   ac_dir_suffix= ac_top_builddir=
12903 fi
12904
12905 case $srcdir in
12906   .)  # No --srcdir option.  We are building in place.
12907     ac_srcdir=.
12908     if test -z "$ac_top_builddir"; then
12909        ac_top_srcdir=.
12910     else
12911        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
12912     fi ;;
12913   [\\/]* | ?:[\\/]* )  # Absolute path.
12914     ac_srcdir=$srcdir$ac_dir_suffix;
12915     ac_top_srcdir=$srcdir ;;
12916   *) # Relative path.
12917     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
12918     ac_top_srcdir=$ac_top_builddir$srcdir ;;
12919 esac
12920
12921 # Do not use `cd foo && pwd` to compute absolute paths, because
12922 # the directories may not exist.
12923 case `pwd` in
12924 .) ac_abs_builddir="$ac_dir";;
12925 *)
12926   case "$ac_dir" in
12927   .) ac_abs_builddir=`pwd`;;
12928   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
12929   *) ac_abs_builddir=`pwd`/"$ac_dir";;
12930   esac;;
12931 esac
12932 case $ac_abs_builddir in
12933 .) ac_abs_top_builddir=${ac_top_builddir}.;;
12934 *)
12935   case ${ac_top_builddir}. in
12936   .) ac_abs_top_builddir=$ac_abs_builddir;;
12937   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
12938   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
12939   esac;;
12940 esac
12941 case $ac_abs_builddir in
12942 .) ac_abs_srcdir=$ac_srcdir;;
12943 *)
12944   case $ac_srcdir in
12945   .) ac_abs_srcdir=$ac_abs_builddir;;
12946   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
12947   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
12948   esac;;
12949 esac
12950 case $ac_abs_builddir in
12951 .) ac_abs_top_srcdir=$ac_top_srcdir;;
12952 *)
12953   case $ac_top_srcdir in
12954   .) ac_abs_top_srcdir=$ac_abs_builddir;;
12955   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
12956   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
12957   esac;;
12958 esac
12959
12960
12961   case $INSTALL in
12962   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
12963   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
12964   esac
12965
12966   if test x"$ac_file" != x-; then
12967     { echo "$as_me:$LINENO: creating $ac_file" >&5
12968 echo "$as_me: creating $ac_file" >&6;}
12969     rm -f "$ac_file"
12970   fi
12971   # Let's still pretend it is `configure' which instantiates (i.e., don't
12972   # use $as_me), people would be surprised to read:
12973   #    /* config.h.  Generated by config.status.  */
12974   if test x"$ac_file" = x-; then
12975     configure_input=
12976   else
12977     configure_input="$ac_file.  "
12978   fi
12979   configure_input=$configure_input"Generated from `echo $ac_file_in |
12980                                      sed 's,.*/,,'` by configure."
12981
12982   # First look for the input files in the build tree, otherwise in the
12983   # src tree.
12984   ac_file_inputs=`IFS=:
12985     for f in $ac_file_in; do
12986       case $f in
12987       -) echo $tmp/stdin ;;
12988       [\\/$]*)
12989          # Absolute (can't be DOS-style, as IFS=:)
12990          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
12991 echo "$as_me: error: cannot find input file: $f" >&2;}
12992    { (exit 1); exit 1; }; }
12993          echo "$f";;
12994       *) # Relative
12995          if test -f "$f"; then
12996            # Build tree
12997            echo "$f"
12998          elif test -f "$srcdir/$f"; then
12999            # Source tree
13000            echo "$srcdir/$f"
13001          else
13002            # /dev/null tree
13003            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13004 echo "$as_me: error: cannot find input file: $f" >&2;}
13005    { (exit 1); exit 1; }; }
13006          fi;;
13007       esac
13008     done` || { (exit 1); exit 1; }
13009 _ACEOF
13010 cat >>$CONFIG_STATUS <<_ACEOF
13011   sed "$ac_vpsub
13012 $extrasub
13013 _ACEOF
13014 cat >>$CONFIG_STATUS <<\_ACEOF
13015 :t
13016 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13017 s,@configure_input@,$configure_input,;t t
13018 s,@srcdir@,$ac_srcdir,;t t
13019 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13020 s,@top_srcdir@,$ac_top_srcdir,;t t
13021 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13022 s,@builddir@,$ac_builddir,;t t
13023 s,@abs_builddir@,$ac_abs_builddir,;t t
13024 s,@top_builddir@,$ac_top_builddir,;t t
13025 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13026 s,@INSTALL@,$ac_INSTALL,;t t
13027 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13028   rm -f $tmp/stdin
13029   if test x"$ac_file" != x-; then
13030     mv $tmp/out $ac_file
13031   else
13032     cat $tmp/out
13033     rm -f $tmp/out
13034   fi
13035
13036 done
13037 _ACEOF
13038
13039 cat >>$CONFIG_STATUS <<\_ACEOF
13040
13041 { (exit 0); exit 0; }
13042 _ACEOF
13043 chmod +x $CONFIG_STATUS
13044 ac_clean_files=$ac_clean_files_save
13045
13046
13047 # configure is writing to config.log, and then calls config.status.
13048 # config.status does its own redirection, appending to config.log.
13049 # Unfortunately, on DOS this fails, as config.log is still kept open
13050 # by configure, so config.status won't be able to write to it; its
13051 # output is simply discarded.  So we exec the FD to /dev/null,
13052 # effectively closing config.log, so it can be properly (re)opened and
13053 # appended to by config.status.  When coming back to configure, we
13054 # need to make the FD available again.
13055 if test "$no_create" != yes; then
13056   ac_cs_success=:
13057   ac_config_status_args=
13058   test "$silent" = yes &&
13059     ac_config_status_args="$ac_config_status_args --quiet"
13060   exec 5>/dev/null
13061   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13062   exec 5>>config.log
13063   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13064   # would make configure fail if this is the last instruction.
13065   $ac_cs_success || { (exit 1); exit 1; }
13066 fi
13067