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 # Remove the initial space we just introduced and, as these will be
1792 # expanded by make, quote '$'.
1793 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1794
1795
1796 moveifchange=${srcdir}/move-if-change
1797
1798 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1799
1800 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1801 # a relative path.
1802 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1803   INSTALL="${srcpwd}/install-sh -c"
1804 fi
1805
1806 # Set srcdir to "." if that's what it is.
1807 # This is important for multilib support.
1808 pwd=`${PWDCMD-pwd}`
1809 if test "${pwd}" = "${srcpwd}" ; then
1810   srcdir=.
1811 fi
1812
1813 topsrcdir=$srcpwd
1814
1815 extra_host_args=
1816
1817 ### To add a new directory to the tree, first choose whether it is a target
1818 ### or a host dependent tool.  Then put it into the appropriate list
1819 ### (library or tools, host or target), doing a dependency sort.
1820
1821 # Subdirs will be configured in the order listed in build_configdirs,
1822 # configdirs, or target_configdirs; see the serialization section below.
1823
1824 # Dependency sorting is only needed when *configuration* must be done in
1825 # a particular order.  In all cases a dependency should be specified in
1826 # the Makefile, whether or not it's implicitly specified here.
1827
1828 # Double entries in build_configdirs, configdirs, or target_configdirs may
1829 # cause circular dependencies and break everything horribly.
1830
1831 # these library is used by various programs built for the build
1832 # environment
1833 #
1834 build_libs="build-libiberty"
1835
1836 # these tools are built for the build environment
1837 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1838
1839 # these libraries are used by various programs built for the host environment
1840 #
1841 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1842
1843 # these tools are built for the host environment
1844 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1845 # know that we are building the simulator.
1846 # binutils, gas and ld appear in that order because it makes sense to run
1847 # "make check" in that particular order.
1848 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"
1849
1850 # libgcj represents the runtime libraries only used by gcj.
1851 libgcj="target-libffi \
1852         target-zlib \
1853         target-qthreads \
1854         target-libjava"
1855
1856 # these libraries are built for the target environment, and are built after
1857 # the host libraries and the host tools (which may be a cross compiler)
1858 #
1859 target_libraries="target-libgcc \
1860                 target-libiberty \
1861                 target-libgloss \
1862                 target-newlib \
1863                 target-libstdc++-v3 \
1864                 target-libmudflap \
1865                 target-libssp \
1866                 target-libgfortran \
1867                 target-boehm-gc \
1868                 ${libgcj} \
1869                 target-libobjc \
1870                 target-libada \
1871                 target-libgomp"
1872
1873 # these tools are built using the target libraries, and are intended to
1874 # run only in the target environment
1875 #
1876 # note: any program that *uses* libraries that are in the "target_libraries"
1877 # list belongs in this list.  those programs are also very likely
1878 # candidates for the "native_only" list which follows
1879 #
1880 target_tools="target-examples target-groff target-gperf target-rda"
1881
1882 ################################################################################
1883
1884 ## All tools belong in one of the four categories, and are assigned above
1885 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1886 ## is important because configure will choke if they ever get through.
1887 ## ${configdirs} is directories we build using the host tools.
1888 ## ${target_configdirs} is directories we build using the target tools.
1889 configdirs=`echo ${host_libs} ${host_tools}`
1890 target_configdirs=`echo ${target_libraries} ${target_tools}`
1891 build_configdirs=`echo ${build_libs} ${build_tools}`
1892
1893 ################################################################################
1894
1895 srcname="gnu development package"
1896
1897 # This gets set non-empty for some net releases of packages.
1898 appdirs=""
1899
1900 # Define is_cross_compiler to save on calls to 'test'.
1901 is_cross_compiler=
1902 if test x"${host}" = x"${target}" ; then
1903   is_cross_compiler=no
1904 else
1905   is_cross_compiler=yes
1906 fi
1907
1908 # Find the build and target subdir names.
1909
1910 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1911 # have matching libraries, they should use host libraries: Makefile.tpl
1912 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1913 # However, they still use the build modules, because the corresponding
1914 # host modules (e.g. bison) are only built for the host when bootstrap
1915 # finishes. So:
1916 # - build_subdir is where we find build modules, and never changes.
1917 # - build_libsubdir is where we find build libraries, and can be overridden.
1918
1919 # Prefix 'build-' so this never conflicts with target_subdir.
1920 build_subdir="build-${build_noncanonical}"
1921
1922 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1923 if test "${with_build_libsubdir+set}" = set; then
1924   withval="$with_build_libsubdir"
1925   build_libsubdir="$withval"
1926 else
1927   build_libsubdir="$build_subdir"
1928 fi;
1929 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1930 if ( test $srcdir = . && test -d gcc ) \
1931    || test -d $srcdir/../host-${host_noncanonical}; then
1932   host_subdir="host-${host_noncanonical}"
1933 else
1934   host_subdir=.
1935 fi
1936 # No prefix.
1937 target_subdir=${target_noncanonical}
1938
1939
1940 # Skipdirs are removed silently.
1941 skipdirs=
1942 # Noconfigdirs are removed loudly.
1943 noconfigdirs=""
1944
1945 use_gnu_ld=
1946 # Make sure we don't let GNU ld be added if we didn't want it.
1947 if test x$with_gnu_ld = xno ; then
1948   use_gnu_ld=no
1949   noconfigdirs="$noconfigdirs ld"
1950 fi
1951
1952 use_gnu_as=
1953 # Make sure we don't let GNU as be added if we didn't want it.
1954 if test x$with_gnu_as = xno ; then
1955   use_gnu_as=no
1956   noconfigdirs="$noconfigdirs gas"
1957 fi
1958
1959 # some tools are so dependent upon X11 that if we're not building with X,
1960 # it's not even worth trying to configure, much less build, that tool.
1961
1962 case ${with_x} in
1963   yes | "") ;; # the default value for this tree is that X11 is available
1964   no)
1965     skipdirs="${skipdirs} tk itcl libgui"
1966     # We won't be able to build gdbtk without X.
1967     enable_gdbtk=no
1968     ;;
1969   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1970 esac
1971
1972 # Some tools are only suitable for building in a "native" situation.
1973 # Remove these if host!=target.
1974 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"
1975
1976 # Similarly, some are only suitable for cross toolchains.
1977 # Remove these if host=target.
1978 cross_only="target-libgloss target-newlib target-opcodes"
1979
1980 case $is_cross_compiler in
1981   no) skipdirs="${skipdirs} ${cross_only}" ;;
1982   yes) skipdirs="${skipdirs} ${native_only}" ;;
1983 esac
1984
1985 # If both --with-headers and --with-libs are specified, default to
1986 # --without-newlib.
1987 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
1988    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
1989   if test x"${with_newlib}" = x ; then
1990     with_newlib=no
1991   fi
1992 fi
1993
1994 # Recognize --with-newlib/--without-newlib.
1995 case ${with_newlib} in
1996   no) skipdirs="${skipdirs} target-newlib" ;;
1997   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
1998 esac
1999
2000 # Configure extra directories which are host specific
2001
2002 case "${host}" in
2003   *-cygwin*)
2004     configdirs="$configdirs libtermcap" ;;
2005 esac
2006
2007 # A target can indicate whether a language isn't supported for some reason.
2008 # Only spaces may be used in this macro; not newlines or tabs.
2009 unsupported_languages=
2010
2011 # Remove more programs from consideration, based on the host or
2012 # target this usually means that a port of the program doesn't
2013 # exist yet.
2014
2015 case "${host}" in
2016   hppa*64*-*-*)
2017     noconfigdirs="$noconfigdirs byacc"
2018     ;;
2019   i[3456789]86-*-vsta)
2020     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2021     ;;
2022   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2023     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2024     ;;
2025   x86_64-*-mingw*)
2026     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2027     ;;
2028   i[3456789]86-*-mingw32*)
2029     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2030     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2031     ;;
2032   i[3456789]86-*-beos*)
2033     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2034     ;;
2035   *-*-cygwin*)
2036     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2037     ;;
2038   *-*-netbsd*)
2039     noconfigdirs="$noconfigdirs rcs"
2040     ;;
2041   ppc*-*-pe)
2042     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2043     ;;
2044   powerpc-*-beos*)
2045     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2046     ;;
2047 esac
2048
2049
2050 # Check whether --enable-libada or --disable-libada was given.
2051 if test "${enable_libada+set}" = set; then
2052   enableval="$enable_libada"
2053   ENABLE_LIBADA=$enableval
2054 else
2055   ENABLE_LIBADA=yes
2056 fi;
2057 if test "${ENABLE_LIBADA}" != "yes" ; then
2058   noconfigdirs="$noconfigdirs gnattools"
2059 fi
2060
2061 # Check whether --enable-libssp or --disable-libssp was given.
2062 if test "${enable_libssp+set}" = set; then
2063   enableval="$enable_libssp"
2064   ENABLE_LIBSSP=$enableval
2065 else
2066   ENABLE_LIBSSP=yes
2067 fi;
2068
2069 # Save it here so that, even in case of --enable-libgcj, if the Java
2070 # front-end isn't enabled, we still get libgcj disabled.
2071 libgcj_saved=$libgcj
2072 case $enable_libgcj in
2073 yes)
2074   # If we reset it here, it won't get added to noconfigdirs in the
2075   # target-specific build rules, so it will be forcibly enabled
2076   # (unless the Java language itself isn't enabled).
2077   libgcj=
2078   ;;
2079 no)
2080   # Make sure we get it printed in the list of not supported target libs.
2081   noconfigdirs="$noconfigdirs ${libgcj}"
2082   ;;
2083 esac
2084
2085
2086 # Disable libmudflap on some systems.
2087 if test x$enable_libmudflap = x ; then
2088     case "${target}" in
2089     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2090         # Enable libmudflap by default in GNU and friends.
2091         ;;
2092     *-*-freebsd*)
2093         # Enable libmudflap by default in FreeBSD.
2094         ;;
2095     *)
2096         # Disable it by default everywhere else.
2097         noconfigdirs="$noconfigdirs target-libmudflap"
2098         ;;
2099     esac
2100 fi
2101
2102 # Disable libgomp on non POSIX hosted systems.
2103 if test x$enable_libgomp = x ; then
2104     # Enable libgomp by default on hosted POSIX systems.
2105     case "${target}" in
2106     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2107         ;;
2108     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2109         ;;
2110     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2111         ;;
2112     *-*-darwin* | *-*-aix*)
2113         ;;
2114     *)
2115         noconfigdirs="$noconfigdirs target-libgomp"
2116         ;;
2117     esac
2118 fi
2119
2120
2121 case "${target}" in
2122   *-*-chorusos)
2123     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2124     ;;
2125   powerpc-*-darwin* | i[3456789]86-*-darwin*)
2126     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2127     noconfigdirs="$noconfigdirs sim target-rda"
2128     ;;
2129   *-*-darwin*)
2130     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2131     noconfigdirs="$noconfigdirs sim target-rda"
2132     noconfigdirs="$noconfigdirs ${libgcj}"
2133     ;;
2134   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2135     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2136     ;;
2137   *-*-freebsd*)
2138     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2139     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2140         && test -f /usr/local/include/gmp.h; then
2141       with_gmp=/usr/local
2142     fi
2143
2144     # Skip some stuff that's unsupported on some FreeBSD configurations.
2145     case "${target}" in
2146       i*86-*-*) ;;
2147       alpha*-*-*) ;;
2148       *)
2149         noconfigdirs="$noconfigdirs ${libgcj}"
2150         ;;
2151     esac
2152     ;;
2153   *-*-kaos*)
2154     # Remove unsupported stuff on all kaOS configurations.
2155     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2156     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2157     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2158     noconfigdirs="$noconfigdirs target-libgloss"
2159     ;;
2160   *-*-netbsd*)
2161     # Skip some stuff on all NetBSD configurations.
2162     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2163
2164     # Skip some stuff that's unsupported on some NetBSD configurations.
2165     case "${target}" in
2166       i*86-*-netbsdelf*) ;;
2167       arm*-*-netbsdelf*) ;;
2168       *)
2169         noconfigdirs="$noconfigdirs ${libgcj}"
2170         ;;
2171     esac
2172     ;;
2173   *-*-netware*)
2174     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2175     ;;
2176   *-*-rtems*)
2177     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2178     ;;
2179     # The tpf target doesn't support gdb yet.
2180   *-*-tpf*)
2181     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2182     ;;
2183   *-*-uclinux*)
2184     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2185     ;;
2186   *-*-vxworks*)
2187     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2188     ;;
2189   alpha*-dec-osf*)
2190     # ld works, but does not support shared libraries.
2191     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2192     # gas doesn't generate exception information.
2193     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2194     ;;
2195   alpha*-*-*vms*)
2196     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2197     ;;
2198   alpha*-*-linux*)
2199     # newlib is not 64 bit ready
2200     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2201     ;;
2202   alpha*-*-*)
2203     # newlib is not 64 bit ready
2204     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2205     ;;
2206   am33_2.0-*-linux*)
2207     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2208     ;;
2209   sh-*-linux*)
2210     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2211     ;;
2212   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2213     noconfigdirs="$noconfigdirs ${libgcj}"
2214     noconfigdirs="$noconfigdirs target-examples"
2215     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2216     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2217     noconfigdirs="$noconfigdirs expect dejagnu"
2218     # the C++ libraries don't build on top of CE's C libraries
2219     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2220     noconfigdirs="$noconfigdirs target-newlib"
2221     case "${host}" in
2222       *-*-cygwin*) ;; # keep gdb and readline
2223       *) noconfigdirs="$noconfigdirs gdb readline"
2224          ;;
2225     esac
2226     ;;
2227   arc-*-*)
2228     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2229     ;;
2230   arm-semi-aof )
2231     ;;
2232   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2233     noconfigdirs="$noconfigdirs ${libgcj}"
2234     ;;
2235   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2236     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2237     ;;
2238   arm*-*-linux-gnueabi)
2239     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2240     noconfigdirs="$noconfigdirs target-libjava target-libobjc"
2241     case ${with_newlib} in
2242       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2243     esac
2244     ;;
2245   arm*-*-symbianelf*)
2246     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2247     ;;
2248   arm-*-pe*)
2249     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2250     ;;
2251   thumb-*-coff)
2252     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2253     ;;
2254   thumb-*-elf)
2255     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2256     ;;
2257   thumb-*-pe)
2258     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2259     ;;
2260   arm-*-riscix*)
2261     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2262     ;;
2263   avr-*-*)
2264     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2265     ;;
2266   bfin-*-*)
2267     noconfigdirs="$noconfigdirs gdb"
2268     if test x${is_cross_compiler} != xno ; then
2269       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2270     fi
2271     ;;
2272   c4x-*-* | tic4x-*-*)
2273     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2274     ;;
2275   c54x*-*-* | tic54x-*-*)
2276     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2277     ;;
2278   cris-*-* | crisv32-*-*)
2279     unsupported_languages="$unsupported_languages java"
2280     case "${target}" in
2281       *-*-aout)
2282         unsupported_languages="$unsupported_languages fortran"
2283         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2284       *-*-elf)
2285         unsupported_languages="$unsupported_languages fortran"
2286         noconfigdirs="$noconfigdirs target-boehm-gc";;
2287       *-*-linux*)
2288         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2289       *)
2290         unsupported_languages="$unsupported_languages fortran"
2291         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2292     esac
2293     ;;
2294   crx-*-*)
2295     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2296     ;;
2297   d10v-*-*)
2298     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2299     ;;
2300   d30v-*-*)
2301     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2302     ;;
2303   fr30-*-elf*)
2304     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2305     ;;
2306   frv-*-*)
2307     noconfigdirs="$noconfigdirs ${libgcj}"
2308     ;;
2309   h8300*-*-*)
2310     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2311     ;;
2312   h8500-*-*)
2313     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2314     ;;
2315   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2316     ;;
2317   hppa*64*-*-linux* | parisc*64*-*-linux*)
2318     # In this case, it's because the hppa64-linux target is for
2319     # the kernel only at this point and has no libc, and thus no
2320     # headers, crt*.o, etc., all of which are needed by these.
2321     noconfigdirs="$noconfigdirs target-zlib"
2322     ;;
2323   parisc*-*-linux* | hppa*-*-linux*)
2324     ;;
2325   hppa*-*-*elf* | \
2326   hppa*-*-lites* | \
2327   hppa*-*-openbsd* | \
2328   hppa*64*-*-*)
2329     noconfigdirs="$noconfigdirs ${libgcj}"
2330     ;;
2331   hppa*-hp-hpux11*)
2332     noconfigdirs="$noconfigdirs ld shellutils"
2333     ;;
2334   hppa*-*-*)
2335     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2336     # build on HP-UX 10.20.
2337     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2338     ;;
2339   i960-*-*)
2340     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2341     ;;
2342   ia64*-*-elf*)
2343     # No gdb support yet.
2344     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2345     ;;
2346   ia64*-**-hpux*)
2347     # No gdb or ld support yet.
2348     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2349     ;;
2350   i370-*-opened*)
2351     ;;
2352   i[3456789]86-*-coff | i[3456789]86-*-elf)
2353     noconfigdirs="$noconfigdirs ${libgcj}"
2354     ;;
2355   i[3456789]86-*-linux*)
2356     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2357     # not build java stuff by default.
2358     case "${target}" in
2359       *-*-*libc1*)
2360         noconfigdirs="$noconfigdirs ${libgcj}";;
2361     esac
2362
2363     # This section makes it possible to build newlib natively on linux.
2364     # If we are using a cross compiler then don't configure newlib.
2365     if test x${is_cross_compiler} != xno ; then
2366       noconfigdirs="$noconfigdirs target-newlib"
2367     fi
2368     noconfigdirs="$noconfigdirs target-libgloss"
2369     # If we are not using a cross compiler, do configure newlib.
2370     # Note however, that newlib will only be configured in this situation
2371     # if the --with-newlib option has been given, because otherwise
2372     # 'target-newlib' will appear in skipdirs.
2373     ;;
2374   i[3456789]86-*-mingw32*)
2375     target_configdirs="$target_configdirs target-winsup"
2376     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2377     ;;
2378   x86_64-*-mingw*)
2379     target_configdirs="$target_configdirs target-winsup"
2380     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2381     ;;
2382   *-*-cygwin*)
2383     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2384     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2385     # always build newlib if winsup directory is present.
2386     if test -d "$srcdir/winsup/cygwin"; then
2387       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2388     elif test -d "$srcdir/newlib"; then
2389       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2390     fi
2391     ;;
2392   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2393   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2394     ;;
2395   i[3456789]86-*-pe)
2396     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2397     ;;
2398   i[3456789]86-*-sco3.2v5*)
2399     # The linker does not yet know about weak symbols in COFF,
2400     # and is not configured to handle mixed ELF and COFF.
2401     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2402     ;;
2403   i[3456789]86-*-sco*)
2404     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2405     ;;
2406   i[3456789]86-*-solaris2*)
2407     noconfigdirs="$noconfigdirs target-libgloss"
2408     ;;
2409   i[3456789]86-*-sysv4*)
2410     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2411     ;;
2412   i[3456789]86-*-beos*)
2413     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2414     ;;
2415   i[3456789]86-*-rdos*)
2416     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2417     ;;
2418   m32r-*-*)
2419     noconfigdirs="$noconfigdirs ${libgcj}"
2420     ;;
2421   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2422     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2423     ;;
2424   m68k-*-elf*)
2425     noconfigdirs="$noconfigdirs ${libgcj}"
2426     ;;
2427   m68k-*-coff*)
2428     noconfigdirs="$noconfigdirs ${libgcj}"
2429     ;;
2430   mcore-*-pe*)
2431   # The EPOC C++ environment does not support exceptions or rtti,
2432   # and so building libstdc++-v3 tends not to always work.
2433     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2434     ;;
2435   mmix-*-*)
2436     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2437     unsupported_languages="$unsupported_languages fortran java"
2438     ;;
2439   mn10200-*-*)
2440     noconfigdirs="$noconfigdirs ${libgcj}"
2441     ;;
2442   mn10300-*-*)
2443     noconfigdirs="$noconfigdirs ${libgcj}"
2444     ;;
2445   mt-*-*)
2446     noconfigdirs="$noconfigdirs sim"
2447     ;;
2448   powerpc-*-aix*)
2449     # copied from rs6000-*-* entry
2450     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2451     ;;
2452   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2453     target_configdirs="$target_configdirs target-winsup"
2454     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2455     # always build newlib.
2456     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2457     ;;
2458     # This is temporary until we can link against shared libraries
2459   powerpcle-*-solaris*)
2460     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2461     ;;
2462   powerpc-*-beos*)
2463     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2464     ;;
2465   powerpc-*-eabi)
2466     noconfigdirs="$noconfigdirs ${libgcj}"
2467     ;;
2468   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2469     ;;
2470   rs6000-*-lynxos*)
2471     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2472     ;;
2473   rs6000-*-aix*)
2474     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2475     ;;
2476   rs6000-*-*)
2477     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2478     ;;
2479   m68k-apollo-*)
2480     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2481     ;;
2482   mips*-*-irix5*)
2483     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2484     ;;
2485   mips*-*-irix6*)
2486     # Linking libjava exceeds command-line length limits on at least
2487     # IRIX 6.2, but not on IRIX 6.5.
2488     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2489     # <oldham@codesourcery.com>
2490     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2491     ;;
2492   mips*-*-bsd*)
2493     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2494     ;;
2495   mips64*-*-linux*)
2496     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2497     ;;
2498   mips*-*-linux*)
2499     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2500     ;;
2501   mips*-*-*)
2502     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2503     ;;
2504   romp-*-*)
2505     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2506     ;;
2507   sh-*-* | sh64-*-*)
2508     case "${host}" in
2509       i[3456789]86-*-vsta) ;; # don't add gprof back in
2510       i[3456789]86-*-go32*) ;; # don't add gprof back in
2511       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2512       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2513     esac
2514     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2515     ;;
2516   sparc-*-elf*)
2517     noconfigdirs="$noconfigdirs ${libgcj}"
2518     ;;
2519   sparc64-*-elf*)
2520     noconfigdirs="$noconfigdirs ${libgcj}"
2521     ;;
2522   sparclite-*-*)
2523     noconfigdirs="$noconfigdirs ${libgcj}"
2524     ;;
2525   sparc-*-sunos4*)
2526     noconfigdirs="$noconfigdirs ${libgcj}"
2527     if test x${is_cross_compiler} != xno ; then
2528            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2529     else
2530            use_gnu_ld=no
2531     fi
2532     ;;
2533   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2534     noconfigdirs="$noconfigdirs ${libgcj}"
2535     ;;
2536   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2537     ;;
2538   spu-*-*)
2539     skipdirs="target-libssp"
2540     ;;
2541   v810-*-*)
2542     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2543     ;;
2544   v850-*-*)
2545     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2546     ;;
2547   v850e-*-*)
2548     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2549     ;;
2550   v850ea-*-*)
2551     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2552     ;;
2553   vax-*-vms)
2554     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2555     ;;
2556   vax-*-*)
2557     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2558     ;;
2559   xtensa-*-*)
2560     noconfigdirs="$noconfigdirs ${libgcj}"
2561     ;;
2562   ip2k-*-*)
2563     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2564     ;;
2565   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2566     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2567     ;;
2568   *-*-lynxos*)
2569     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2570     ;;
2571   *-*-*)
2572     noconfigdirs="$noconfigdirs ${libgcj}"
2573     ;;
2574 esac
2575
2576 # If we aren't building newlib, then don't build libgloss, since libgloss
2577 # depends upon some newlib header files.
2578 case "${noconfigdirs}" in
2579   *target-libgloss*) ;;
2580   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2581 esac
2582
2583 # Work in distributions that contain no compiler tools, like Autoconf.
2584 tentative_cc=""
2585 host_makefile_frag=/dev/null
2586 if test -d ${srcdir}/config ; then
2587 case "${host}" in
2588   m68k-hp-hpux*)
2589     # Avoid "too much defining" errors from HPUX compiler.
2590     tentative_cc="cc -Wp,-H256000"
2591     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2592     # If it's HP/UX ar, this should be harmless.
2593     RANLIB="ar ts"
2594     ;;
2595   m68k-apollo-sysv*)
2596     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2597     ;;
2598   m68k-apollo-bsd*)
2599     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2600     # chokes on bfd, the compiler won't let you assign integers to enums, and
2601     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2602     # the apollo compiler" (the preferred version of GCC could be called cc,
2603     # or whatever), but I'm not sure leaving CC as cc is any better...
2604     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2605     # Used to have BISON=yacc.
2606     tentative_cc=gcc
2607     ;;
2608   m88k-dg-dgux*)
2609     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2610     ;;
2611   m88k-harris-cxux*)
2612     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2613     tentative_cc="cc -Xa"
2614     host_makefile_frag="config/mh-cxux"
2615     ;;
2616   m88k-motorola-sysv*)
2617     ;;
2618   mips*-dec-ultrix*)
2619     tentative_cc="cc -Wf,-XNg1000"
2620     host_makefile_frag="config/mh-decstation"
2621     ;;
2622   mips*-nec-sysv4*)
2623     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2624     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2625     host_makefile_frag="config/mh-necv4"
2626     ;;
2627   mips*-sgi-irix4*)
2628     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2629     # environment.  Also bump switch table size so that cp-parse will
2630     # compile.  Bump string length limit so linker builds.
2631     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2632     ;;
2633   mips*-*-sysv4*)
2634     host_makefile_frag="config/mh-sysv4"
2635     ;;
2636   mips*-*-sysv*)
2637     # This is for a MIPS running RISC/os 4.52C.
2638
2639     # This is needed for GDB, but needs to be in the top-level make because
2640     # if a library is compiled with the bsd headers and gets linked with the
2641     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2642     # a different size).
2643     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2644     # known except to select the sysv environment.  Could we use /proc instead?
2645     # These "sysv environments" and "bsd environments" often end up being a pain.
2646     #
2647     # This is not part of CFLAGS because perhaps not all C compilers have this
2648     # option.
2649     tentative_cc="cc -systype sysv"
2650     ;;
2651   i370-ibm-opened*)
2652     tentative_cc="c89"
2653     ;;
2654   i[3456789]86-*-sysv5*)
2655     host_makefile_frag="config/mh-sysv5"
2656     ;;
2657   i[3456789]86-*-dgux*)
2658     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2659     host_makefile_frag="config/mh-dgux386"
2660     ;;
2661   i[3456789]86-ncr-sysv4.3*)
2662     # The MetaWare compiler will generate a copyright message unless you
2663     # turn it off by adding the -Hnocopyr flag.
2664     tentative_cc="cc -Hnocopyr"
2665     ;;
2666   i[3456789]86-ncr-sysv4*)
2667     # for an NCR 3000 (i486/SVR4) system.
2668     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2669     # This compiler not only emits obnoxious copyright messages every time
2670     # you run it, but it chokes and dies on a whole bunch of GNU source
2671     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2672     tentative_cc="/usr/ccs/ATT/cc"
2673     host_makefile_frag="config/mh-ncr3000"
2674     ;;
2675   i[3456789]86-*-sco3.2v5*)
2676     ;;
2677   i[3456789]86-*-sco*)
2678     # The native C compiler botches some simple uses of const.  Unfortunately,
2679     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2680     tentative_cc="cc -Dconst="
2681     host_makefile_frag="config/mh-sco"
2682     ;;
2683   i[3456789]86-*-udk*)
2684     host_makefile_frag="config/mh-sysv5"
2685     ;;
2686   i[3456789]86-*-solaris2*)
2687     host_makefile_frag="config/mh-sysv4"
2688     ;;
2689   i[3456789]86-*-msdosdjgpp*)
2690     host_makefile_frag="config/mh-djgpp"
2691     ;;
2692   *-cygwin*)
2693     host_makefile_frag="config/mh-cygwin"
2694     ;;
2695   *-mingw32*)
2696     ;;
2697   *-mingw64*)
2698     ;;
2699   *-interix*)
2700     host_makefile_frag="config/mh-interix"
2701     ;;
2702   vax-*-ultrix2*)
2703     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2704     tentative_cc=gcc
2705     ;;
2706   *-*-solaris2*)
2707     host_makefile_frag="config/mh-solaris"
2708     ;;
2709   m68k-sun-sunos*)
2710     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2711     # without overflowing the jump tables (-J says to use a 32 bit table)
2712     tentative_cc="cc -J"
2713     ;;
2714   *-hp-hpux*)
2715     tentative_cc="cc -Wp,-H256000"
2716     ;;
2717   *-*-hiux*)
2718     tentative_cc="cc -Wp,-H256000"
2719     ;;
2720   rs6000-*-lynxos*)
2721     # /bin/cc is less than useful for our purposes.  Always use GCC
2722     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2723     host_makefile_frag="config/mh-lynxrs6k"
2724     ;;
2725   powerpc-*-darwin*)
2726     host_makefile_frag="config/mh-ppc-darwin"
2727     ;;
2728   powerpc-*-aix*)
2729     host_makefile_frag="config/mh-ppc-aix"
2730     ;;
2731   rs6000-*-aix*)
2732     host_makefile_frag="config/mh-ppc-aix"
2733     ;;
2734   *-*-lynxos*)
2735     # /bin/cc is less than useful for our purposes.  Always use GCC
2736     tentative_cc="/bin/gcc"
2737     ;;
2738   *-*-sysv4*)
2739     host_makefile_frag="config/mh-sysv4"
2740     ;;
2741   # This is placed last to prevent interfering with the cases above.
2742   i[3456789]86-*-*)
2743     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2744     host_makefile_frag="config/mh-x86omitfp"
2745     ;;
2746 esac
2747 fi
2748
2749 # If we aren't going to be using gcc, see if we can extract a definition
2750 # of CC from the fragment.
2751 # Actually, use the 'pre-extracted' version above.
2752 if test -z "${CC}" && test "${build}" = "${host}" ; then
2753   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2754   found=
2755   for dir in $PATH; do
2756     test -z "$dir" && dir=.
2757     if test -f $dir/gcc; then
2758       found=yes
2759       break
2760     fi
2761   done
2762   IFS="$save_ifs"
2763   if test -z "${found}" && test -n "${tentative_cc}" ; then
2764     CC=$tentative_cc
2765   fi
2766 fi
2767
2768 if test "${build}" != "${host}" ; then
2769   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2770 else
2771   CC_FOR_BUILD="\$(CC)"
2772 fi
2773
2774 ac_ext=c
2775 ac_cpp='$CPP $CPPFLAGS'
2776 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2777 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2778 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2779 if test -n "$ac_tool_prefix"; then
2780   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2781 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2782 echo "$as_me:$LINENO: checking for $ac_word" >&5
2783 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2784 if test "${ac_cv_prog_CC+set}" = set; then
2785   echo $ECHO_N "(cached) $ECHO_C" >&6
2786 else
2787   if test -n "$CC"; then
2788   ac_cv_prog_CC="$CC" # Let the user override the test.
2789 else
2790 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2791 for as_dir in $PATH
2792 do
2793   IFS=$as_save_IFS
2794   test -z "$as_dir" && as_dir=.
2795   for ac_exec_ext in '' $ac_executable_extensions; do
2796   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2797     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2798     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2799     break 2
2800   fi
2801 done
2802 done
2803
2804 fi
2805 fi
2806 CC=$ac_cv_prog_CC
2807 if test -n "$CC"; then
2808   echo "$as_me:$LINENO: result: $CC" >&5
2809 echo "${ECHO_T}$CC" >&6
2810 else
2811   echo "$as_me:$LINENO: result: no" >&5
2812 echo "${ECHO_T}no" >&6
2813 fi
2814
2815 fi
2816 if test -z "$ac_cv_prog_CC"; then
2817   ac_ct_CC=$CC
2818   # Extract the first word of "gcc", so it can be a program name with args.
2819 set dummy gcc; ac_word=$2
2820 echo "$as_me:$LINENO: checking for $ac_word" >&5
2821 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2822 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2823   echo $ECHO_N "(cached) $ECHO_C" >&6
2824 else
2825   if test -n "$ac_ct_CC"; then
2826   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2827 else
2828 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2829 for as_dir in $PATH
2830 do
2831   IFS=$as_save_IFS
2832   test -z "$as_dir" && as_dir=.
2833   for ac_exec_ext in '' $ac_executable_extensions; do
2834   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2835     ac_cv_prog_ac_ct_CC="gcc"
2836     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2837     break 2
2838   fi
2839 done
2840 done
2841
2842 fi
2843 fi
2844 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2845 if test -n "$ac_ct_CC"; then
2846   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2847 echo "${ECHO_T}$ac_ct_CC" >&6
2848 else
2849   echo "$as_me:$LINENO: result: no" >&5
2850 echo "${ECHO_T}no" >&6
2851 fi
2852
2853   CC=$ac_ct_CC
2854 else
2855   CC="$ac_cv_prog_CC"
2856 fi
2857
2858 if test -z "$CC"; then
2859   if test -n "$ac_tool_prefix"; then
2860   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2861 set dummy ${ac_tool_prefix}cc; ac_word=$2
2862 echo "$as_me:$LINENO: checking for $ac_word" >&5
2863 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2864 if test "${ac_cv_prog_CC+set}" = set; then
2865   echo $ECHO_N "(cached) $ECHO_C" >&6
2866 else
2867   if test -n "$CC"; then
2868   ac_cv_prog_CC="$CC" # Let the user override the test.
2869 else
2870 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2871 for as_dir in $PATH
2872 do
2873   IFS=$as_save_IFS
2874   test -z "$as_dir" && as_dir=.
2875   for ac_exec_ext in '' $ac_executable_extensions; do
2876   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2877     ac_cv_prog_CC="${ac_tool_prefix}cc"
2878     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2879     break 2
2880   fi
2881 done
2882 done
2883
2884 fi
2885 fi
2886 CC=$ac_cv_prog_CC
2887 if test -n "$CC"; then
2888   echo "$as_me:$LINENO: result: $CC" >&5
2889 echo "${ECHO_T}$CC" >&6
2890 else
2891   echo "$as_me:$LINENO: result: no" >&5
2892 echo "${ECHO_T}no" >&6
2893 fi
2894
2895 fi
2896 if test -z "$ac_cv_prog_CC"; then
2897   ac_ct_CC=$CC
2898   # Extract the first word of "cc", so it can be a program name with args.
2899 set dummy cc; ac_word=$2
2900 echo "$as_me:$LINENO: checking for $ac_word" >&5
2901 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2902 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2903   echo $ECHO_N "(cached) $ECHO_C" >&6
2904 else
2905   if test -n "$ac_ct_CC"; then
2906   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2907 else
2908 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2909 for as_dir in $PATH
2910 do
2911   IFS=$as_save_IFS
2912   test -z "$as_dir" && as_dir=.
2913   for ac_exec_ext in '' $ac_executable_extensions; do
2914   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2915     ac_cv_prog_ac_ct_CC="cc"
2916     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2917     break 2
2918   fi
2919 done
2920 done
2921
2922 fi
2923 fi
2924 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2925 if test -n "$ac_ct_CC"; then
2926   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2927 echo "${ECHO_T}$ac_ct_CC" >&6
2928 else
2929   echo "$as_me:$LINENO: result: no" >&5
2930 echo "${ECHO_T}no" >&6
2931 fi
2932
2933   CC=$ac_ct_CC
2934 else
2935   CC="$ac_cv_prog_CC"
2936 fi
2937
2938 fi
2939 if test -z "$CC"; then
2940   # Extract the first word of "cc", so it can be a program name with args.
2941 set dummy cc; ac_word=$2
2942 echo "$as_me:$LINENO: checking for $ac_word" >&5
2943 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2944 if test "${ac_cv_prog_CC+set}" = set; then
2945   echo $ECHO_N "(cached) $ECHO_C" >&6
2946 else
2947   if test -n "$CC"; then
2948   ac_cv_prog_CC="$CC" # Let the user override the test.
2949 else
2950   ac_prog_rejected=no
2951 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2952 for as_dir in $PATH
2953 do
2954   IFS=$as_save_IFS
2955   test -z "$as_dir" && as_dir=.
2956   for ac_exec_ext in '' $ac_executable_extensions; do
2957   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2958     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2959        ac_prog_rejected=yes
2960        continue
2961      fi
2962     ac_cv_prog_CC="cc"
2963     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2964     break 2
2965   fi
2966 done
2967 done
2968
2969 if test $ac_prog_rejected = yes; then
2970   # We found a bogon in the path, so make sure we never use it.
2971   set dummy $ac_cv_prog_CC
2972   shift
2973   if test $# != 0; then
2974     # We chose a different compiler from the bogus one.
2975     # However, it has the same basename, so the bogon will be chosen
2976     # first if we set CC to just the basename; use the full file name.
2977     shift
2978     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
2979   fi
2980 fi
2981 fi
2982 fi
2983 CC=$ac_cv_prog_CC
2984 if test -n "$CC"; then
2985   echo "$as_me:$LINENO: result: $CC" >&5
2986 echo "${ECHO_T}$CC" >&6
2987 else
2988   echo "$as_me:$LINENO: result: no" >&5
2989 echo "${ECHO_T}no" >&6
2990 fi
2991
2992 fi
2993 if test -z "$CC"; then
2994   if test -n "$ac_tool_prefix"; then
2995   for ac_prog in cl
2996   do
2997     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2998 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2999 echo "$as_me:$LINENO: checking for $ac_word" >&5
3000 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3001 if test "${ac_cv_prog_CC+set}" = set; then
3002   echo $ECHO_N "(cached) $ECHO_C" >&6
3003 else
3004   if test -n "$CC"; then
3005   ac_cv_prog_CC="$CC" # Let the user override the test.
3006 else
3007 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3008 for as_dir in $PATH
3009 do
3010   IFS=$as_save_IFS
3011   test -z "$as_dir" && as_dir=.
3012   for ac_exec_ext in '' $ac_executable_extensions; do
3013   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3014     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3015     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3016     break 2
3017   fi
3018 done
3019 done
3020
3021 fi
3022 fi
3023 CC=$ac_cv_prog_CC
3024 if test -n "$CC"; then
3025   echo "$as_me:$LINENO: result: $CC" >&5
3026 echo "${ECHO_T}$CC" >&6
3027 else
3028   echo "$as_me:$LINENO: result: no" >&5
3029 echo "${ECHO_T}no" >&6
3030 fi
3031
3032     test -n "$CC" && break
3033   done
3034 fi
3035 if test -z "$CC"; then
3036   ac_ct_CC=$CC
3037   for ac_prog in cl
3038 do
3039   # Extract the first word of "$ac_prog", so it can be a program name with args.
3040 set dummy $ac_prog; ac_word=$2
3041 echo "$as_me:$LINENO: checking for $ac_word" >&5
3042 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3043 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3044   echo $ECHO_N "(cached) $ECHO_C" >&6
3045 else
3046   if test -n "$ac_ct_CC"; then
3047   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3048 else
3049 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3050 for as_dir in $PATH
3051 do
3052   IFS=$as_save_IFS
3053   test -z "$as_dir" && as_dir=.
3054   for ac_exec_ext in '' $ac_executable_extensions; do
3055   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3056     ac_cv_prog_ac_ct_CC="$ac_prog"
3057     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3058     break 2
3059   fi
3060 done
3061 done
3062
3063 fi
3064 fi
3065 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3066 if test -n "$ac_ct_CC"; then
3067   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3068 echo "${ECHO_T}$ac_ct_CC" >&6
3069 else
3070   echo "$as_me:$LINENO: result: no" >&5
3071 echo "${ECHO_T}no" >&6
3072 fi
3073
3074   test -n "$ac_ct_CC" && break
3075 done
3076
3077   CC=$ac_ct_CC
3078 fi
3079
3080 fi
3081
3082
3083 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3084 See \`config.log' for more details." >&5
3085 echo "$as_me: error: no acceptable C compiler found in \$PATH
3086 See \`config.log' for more details." >&2;}
3087    { (exit 1); exit 1; }; }
3088
3089 # Provide some information about the compiler.
3090 echo "$as_me:$LINENO:" \
3091      "checking for C compiler version" >&5
3092 ac_compiler=`set X $ac_compile; echo $2`
3093 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3094   (eval $ac_compiler --version </dev/null >&5) 2>&5
3095   ac_status=$?
3096   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3097   (exit $ac_status); }
3098 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3099   (eval $ac_compiler -v </dev/null >&5) 2>&5
3100   ac_status=$?
3101   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3102   (exit $ac_status); }
3103 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3104   (eval $ac_compiler -V </dev/null >&5) 2>&5
3105   ac_status=$?
3106   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3107   (exit $ac_status); }
3108
3109 cat >conftest.$ac_ext <<_ACEOF
3110 /* confdefs.h.  */
3111 _ACEOF
3112 cat confdefs.h >>conftest.$ac_ext
3113 cat >>conftest.$ac_ext <<_ACEOF
3114 /* end confdefs.h.  */
3115
3116 int
3117 main ()
3118 {
3119
3120   ;
3121   return 0;
3122 }
3123 _ACEOF
3124 ac_clean_files_save=$ac_clean_files
3125 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3126 # Try to create an executable without -o first, disregard a.out.
3127 # It will help us diagnose broken compilers, and finding out an intuition
3128 # of exeext.
3129 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3130 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3131 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3132 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3133   (eval $ac_link_default) 2>&5
3134   ac_status=$?
3135   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3136   (exit $ac_status); }; then
3137   # Find the output, starting from the most likely.  This scheme is
3138 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3139 # resort.
3140
3141 # Be careful to initialize this variable, since it used to be cached.
3142 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3143 ac_cv_exeext=
3144 # b.out is created by i960 compilers.
3145 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3146 do
3147   test -f "$ac_file" || continue
3148   case $ac_file in
3149     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3150         ;;
3151     conftest.$ac_ext )
3152         # This is the source file.
3153         ;;
3154     [ab].out )
3155         # We found the default executable, but exeext='' is most
3156         # certainly right.
3157         break;;
3158     *.* )
3159         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3160         # FIXME: I believe we export ac_cv_exeext for Libtool,
3161         # but it would be cool to find out if it's true.  Does anybody
3162         # maintain Libtool? --akim.
3163         export ac_cv_exeext
3164         break;;
3165     * )
3166         break;;
3167   esac
3168 done
3169 else
3170   echo "$as_me: failed program was:" >&5
3171 sed 's/^/| /' conftest.$ac_ext >&5
3172
3173 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3174 See \`config.log' for more details." >&5
3175 echo "$as_me: error: C compiler cannot create executables
3176 See \`config.log' for more details." >&2;}
3177    { (exit 77); exit 77; }; }
3178 fi
3179
3180 ac_exeext=$ac_cv_exeext
3181 echo "$as_me:$LINENO: result: $ac_file" >&5
3182 echo "${ECHO_T}$ac_file" >&6
3183
3184 # Check the compiler produces executables we can run.  If not, either
3185 # the compiler is broken, or we cross compile.
3186 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3187 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3188 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3189 # If not cross compiling, check that we can run a simple program.
3190 if test "$cross_compiling" != yes; then
3191   if { ac_try='./$ac_file'
3192   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3193   (eval $ac_try) 2>&5
3194   ac_status=$?
3195   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3196   (exit $ac_status); }; }; then
3197     cross_compiling=no
3198   else
3199     if test "$cross_compiling" = maybe; then
3200         cross_compiling=yes
3201     else
3202         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3203 If you meant to cross compile, use \`--host'.
3204 See \`config.log' for more details." >&5
3205 echo "$as_me: error: cannot run C compiled programs.
3206 If you meant to cross compile, use \`--host'.
3207 See \`config.log' for more details." >&2;}
3208    { (exit 1); exit 1; }; }
3209     fi
3210   fi
3211 fi
3212 echo "$as_me:$LINENO: result: yes" >&5
3213 echo "${ECHO_T}yes" >&6
3214
3215 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3216 ac_clean_files=$ac_clean_files_save
3217 # Check the compiler produces executables we can run.  If not, either
3218 # the compiler is broken, or we cross compile.
3219 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3220 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3221 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3222 echo "${ECHO_T}$cross_compiling" >&6
3223
3224 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3225 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3226 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3227   (eval $ac_link) 2>&5
3228   ac_status=$?
3229   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3230   (exit $ac_status); }; then
3231   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3232 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3233 # work properly (i.e., refer to `conftest.exe'), while it won't with
3234 # `rm'.
3235 for ac_file in conftest.exe conftest conftest.*; do
3236   test -f "$ac_file" || continue
3237   case $ac_file in
3238     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3239     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3240           export ac_cv_exeext
3241           break;;
3242     * ) break;;
3243   esac
3244 done
3245 else
3246   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3247 See \`config.log' for more details." >&5
3248 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3249 See \`config.log' for more details." >&2;}
3250    { (exit 1); exit 1; }; }
3251 fi
3252
3253 rm -f conftest$ac_cv_exeext
3254 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3255 echo "${ECHO_T}$ac_cv_exeext" >&6
3256
3257 rm -f conftest.$ac_ext
3258 EXEEXT=$ac_cv_exeext
3259 ac_exeext=$EXEEXT
3260 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3261 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3262 if test "${ac_cv_objext+set}" = set; then
3263   echo $ECHO_N "(cached) $ECHO_C" >&6
3264 else
3265   cat >conftest.$ac_ext <<_ACEOF
3266 /* confdefs.h.  */
3267 _ACEOF
3268 cat confdefs.h >>conftest.$ac_ext
3269 cat >>conftest.$ac_ext <<_ACEOF
3270 /* end confdefs.h.  */
3271
3272 int
3273 main ()
3274 {
3275
3276   ;
3277   return 0;
3278 }
3279 _ACEOF
3280 rm -f conftest.o conftest.obj
3281 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3282   (eval $ac_compile) 2>&5
3283   ac_status=$?
3284   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3285   (exit $ac_status); }; then
3286   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3287   case $ac_file in
3288     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3289     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3290        break;;
3291   esac
3292 done
3293 else
3294   echo "$as_me: failed program was:" >&5
3295 sed 's/^/| /' conftest.$ac_ext >&5
3296
3297 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3298 See \`config.log' for more details." >&5
3299 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3300 See \`config.log' for more details." >&2;}
3301    { (exit 1); exit 1; }; }
3302 fi
3303
3304 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3305 fi
3306 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3307 echo "${ECHO_T}$ac_cv_objext" >&6
3308 OBJEXT=$ac_cv_objext
3309 ac_objext=$OBJEXT
3310 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3311 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3312 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3313   echo $ECHO_N "(cached) $ECHO_C" >&6
3314 else
3315   cat >conftest.$ac_ext <<_ACEOF
3316 /* confdefs.h.  */
3317 _ACEOF
3318 cat confdefs.h >>conftest.$ac_ext
3319 cat >>conftest.$ac_ext <<_ACEOF
3320 /* end confdefs.h.  */
3321
3322 int
3323 main ()
3324 {
3325 #ifndef __GNUC__
3326        choke me
3327 #endif
3328
3329   ;
3330   return 0;
3331 }
3332 _ACEOF
3333 rm -f conftest.$ac_objext
3334 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3335   (eval $ac_compile) 2>conftest.er1
3336   ac_status=$?
3337   grep -v '^ *+' conftest.er1 >conftest.err
3338   rm -f conftest.er1
3339   cat conftest.err >&5
3340   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3341   (exit $ac_status); } &&
3342          { ac_try='test -z "$ac_c_werror_flag"
3343                          || test ! -s conftest.err'
3344   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3345   (eval $ac_try) 2>&5
3346   ac_status=$?
3347   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3348   (exit $ac_status); }; } &&
3349          { ac_try='test -s conftest.$ac_objext'
3350   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3351   (eval $ac_try) 2>&5
3352   ac_status=$?
3353   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3354   (exit $ac_status); }; }; then
3355   ac_compiler_gnu=yes
3356 else
3357   echo "$as_me: failed program was:" >&5
3358 sed 's/^/| /' conftest.$ac_ext >&5
3359
3360 ac_compiler_gnu=no
3361 fi
3362 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3363 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3364
3365 fi
3366 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3367 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3368 GCC=`test $ac_compiler_gnu = yes && echo yes`
3369 ac_test_CFLAGS=${CFLAGS+set}
3370 ac_save_CFLAGS=$CFLAGS
3371 CFLAGS="-g"
3372 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3373 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3374 if test "${ac_cv_prog_cc_g+set}" = set; then
3375   echo $ECHO_N "(cached) $ECHO_C" >&6
3376 else
3377   cat >conftest.$ac_ext <<_ACEOF
3378 /* confdefs.h.  */
3379 _ACEOF
3380 cat confdefs.h >>conftest.$ac_ext
3381 cat >>conftest.$ac_ext <<_ACEOF
3382 /* end confdefs.h.  */
3383
3384 int
3385 main ()
3386 {
3387
3388   ;
3389   return 0;
3390 }
3391 _ACEOF
3392 rm -f conftest.$ac_objext
3393 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3394   (eval $ac_compile) 2>conftest.er1
3395   ac_status=$?
3396   grep -v '^ *+' conftest.er1 >conftest.err
3397   rm -f conftest.er1
3398   cat conftest.err >&5
3399   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3400   (exit $ac_status); } &&
3401          { ac_try='test -z "$ac_c_werror_flag"
3402                          || test ! -s conftest.err'
3403   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3404   (eval $ac_try) 2>&5
3405   ac_status=$?
3406   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3407   (exit $ac_status); }; } &&
3408          { ac_try='test -s conftest.$ac_objext'
3409   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3410   (eval $ac_try) 2>&5
3411   ac_status=$?
3412   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3413   (exit $ac_status); }; }; then
3414   ac_cv_prog_cc_g=yes
3415 else
3416   echo "$as_me: failed program was:" >&5
3417 sed 's/^/| /' conftest.$ac_ext >&5
3418
3419 ac_cv_prog_cc_g=no
3420 fi
3421 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3422 fi
3423 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3424 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3425 if test "$ac_test_CFLAGS" = set; then
3426   CFLAGS=$ac_save_CFLAGS
3427 elif test $ac_cv_prog_cc_g = yes; then
3428   if test "$GCC" = yes; then
3429     CFLAGS="-g -O2"
3430   else
3431     CFLAGS="-g"
3432   fi
3433 else
3434   if test "$GCC" = yes; then
3435     CFLAGS="-O2"
3436   else
3437     CFLAGS=
3438   fi
3439 fi
3440 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3441 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3442 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3443   echo $ECHO_N "(cached) $ECHO_C" >&6
3444 else
3445   ac_cv_prog_cc_stdc=no
3446 ac_save_CC=$CC
3447 cat >conftest.$ac_ext <<_ACEOF
3448 /* confdefs.h.  */
3449 _ACEOF
3450 cat confdefs.h >>conftest.$ac_ext
3451 cat >>conftest.$ac_ext <<_ACEOF
3452 /* end confdefs.h.  */
3453 #include <stdarg.h>
3454 #include <stdio.h>
3455 #include <sys/types.h>
3456 #include <sys/stat.h>
3457 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3458 struct buf { int x; };
3459 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3460 static char *e (p, i)
3461      char **p;
3462      int i;
3463 {
3464   return p[i];
3465 }
3466 static char *f (char * (*g) (char **, int), char **p, ...)
3467 {
3468   char *s;
3469   va_list v;
3470   va_start (v,p);
3471   s = g (p, va_arg (v,int));
3472   va_end (v);
3473   return s;
3474 }
3475
3476 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3477    function prototypes and stuff, but not '\xHH' hex character constants.
3478    These don't provoke an error unfortunately, instead are silently treated
3479    as 'x'.  The following induces an error, until -std1 is added to get
3480    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3481    array size at least.  It's necessary to write '\x00'==0 to get something
3482    that's true only with -std1.  */
3483 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3484
3485 int test (int i, double x);
3486 struct s1 {int (*f) (int a);};
3487 struct s2 {int (*f) (double a);};
3488 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3489 int argc;
3490 char **argv;
3491 int
3492 main ()
3493 {
3494 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3495   ;
3496   return 0;
3497 }
3498 _ACEOF
3499 # Don't try gcc -ansi; that turns off useful extensions and
3500 # breaks some systems' header files.
3501 # AIX                   -qlanglvl=ansi
3502 # Ultrix and OSF/1      -std1
3503 # HP-UX 10.20 and later -Ae
3504 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3505 # SVR4                  -Xc -D__EXTENSIONS__
3506 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3507 do
3508   CC="$ac_save_CC $ac_arg"
3509   rm -f conftest.$ac_objext
3510 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3511   (eval $ac_compile) 2>conftest.er1
3512   ac_status=$?
3513   grep -v '^ *+' conftest.er1 >conftest.err
3514   rm -f conftest.er1
3515   cat conftest.err >&5
3516   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3517   (exit $ac_status); } &&
3518          { ac_try='test -z "$ac_c_werror_flag"
3519                          || test ! -s conftest.err'
3520   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3521   (eval $ac_try) 2>&5
3522   ac_status=$?
3523   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3524   (exit $ac_status); }; } &&
3525          { ac_try='test -s conftest.$ac_objext'
3526   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3527   (eval $ac_try) 2>&5
3528   ac_status=$?
3529   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3530   (exit $ac_status); }; }; then
3531   ac_cv_prog_cc_stdc=$ac_arg
3532 break
3533 else
3534   echo "$as_me: failed program was:" >&5
3535 sed 's/^/| /' conftest.$ac_ext >&5
3536
3537 fi
3538 rm -f conftest.err conftest.$ac_objext
3539 done
3540 rm -f conftest.$ac_ext conftest.$ac_objext
3541 CC=$ac_save_CC
3542
3543 fi
3544
3545 case "x$ac_cv_prog_cc_stdc" in
3546   x|xno)
3547     echo "$as_me:$LINENO: result: none needed" >&5
3548 echo "${ECHO_T}none needed" >&6 ;;
3549   *)
3550     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3551 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3552     CC="$CC $ac_cv_prog_cc_stdc" ;;
3553 esac
3554
3555 # Some people use a C++ compiler to compile C.  Since we use `exit',
3556 # in C++ we need to declare it.  In case someone uses the same compiler
3557 # for both compiling C and C++ we need to have the C++ compiler decide
3558 # the declaration of exit, since it's the most demanding environment.
3559 cat >conftest.$ac_ext <<_ACEOF
3560 #ifndef __cplusplus
3561   choke me
3562 #endif
3563 _ACEOF
3564 rm -f conftest.$ac_objext
3565 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3566   (eval $ac_compile) 2>conftest.er1
3567   ac_status=$?
3568   grep -v '^ *+' conftest.er1 >conftest.err
3569   rm -f conftest.er1
3570   cat conftest.err >&5
3571   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3572   (exit $ac_status); } &&
3573          { ac_try='test -z "$ac_c_werror_flag"
3574                          || test ! -s conftest.err'
3575   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3576   (eval $ac_try) 2>&5
3577   ac_status=$?
3578   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3579   (exit $ac_status); }; } &&
3580          { ac_try='test -s conftest.$ac_objext'
3581   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3582   (eval $ac_try) 2>&5
3583   ac_status=$?
3584   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3585   (exit $ac_status); }; }; then
3586   for ac_declaration in \
3587    '' \
3588    'extern "C" void std::exit (int) throw (); using std::exit;' \
3589    'extern "C" void std::exit (int); using std::exit;' \
3590    'extern "C" void exit (int) throw ();' \
3591    'extern "C" void exit (int);' \
3592    'void exit (int);'
3593 do
3594   cat >conftest.$ac_ext <<_ACEOF
3595 /* confdefs.h.  */
3596 _ACEOF
3597 cat confdefs.h >>conftest.$ac_ext
3598 cat >>conftest.$ac_ext <<_ACEOF
3599 /* end confdefs.h.  */
3600 $ac_declaration
3601 #include <stdlib.h>
3602 int
3603 main ()
3604 {
3605 exit (42);
3606   ;
3607   return 0;
3608 }
3609 _ACEOF
3610 rm -f conftest.$ac_objext
3611 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3612   (eval $ac_compile) 2>conftest.er1
3613   ac_status=$?
3614   grep -v '^ *+' conftest.er1 >conftest.err
3615   rm -f conftest.er1
3616   cat conftest.err >&5
3617   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3618   (exit $ac_status); } &&
3619          { ac_try='test -z "$ac_c_werror_flag"
3620                          || test ! -s conftest.err'
3621   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3622   (eval $ac_try) 2>&5
3623   ac_status=$?
3624   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3625   (exit $ac_status); }; } &&
3626          { ac_try='test -s conftest.$ac_objext'
3627   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3628   (eval $ac_try) 2>&5
3629   ac_status=$?
3630   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3631   (exit $ac_status); }; }; then
3632   :
3633 else
3634   echo "$as_me: failed program was:" >&5
3635 sed 's/^/| /' conftest.$ac_ext >&5
3636
3637 continue
3638 fi
3639 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3640   cat >conftest.$ac_ext <<_ACEOF
3641 /* confdefs.h.  */
3642 _ACEOF
3643 cat confdefs.h >>conftest.$ac_ext
3644 cat >>conftest.$ac_ext <<_ACEOF
3645 /* end confdefs.h.  */
3646 $ac_declaration
3647 int
3648 main ()
3649 {
3650 exit (42);
3651   ;
3652   return 0;
3653 }
3654 _ACEOF
3655 rm -f conftest.$ac_objext
3656 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3657   (eval $ac_compile) 2>conftest.er1
3658   ac_status=$?
3659   grep -v '^ *+' conftest.er1 >conftest.err
3660   rm -f conftest.er1
3661   cat conftest.err >&5
3662   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3663   (exit $ac_status); } &&
3664          { ac_try='test -z "$ac_c_werror_flag"
3665                          || test ! -s conftest.err'
3666   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3667   (eval $ac_try) 2>&5
3668   ac_status=$?
3669   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3670   (exit $ac_status); }; } &&
3671          { ac_try='test -s conftest.$ac_objext'
3672   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3673   (eval $ac_try) 2>&5
3674   ac_status=$?
3675   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3676   (exit $ac_status); }; }; then
3677   break
3678 else
3679   echo "$as_me: failed program was:" >&5
3680 sed 's/^/| /' conftest.$ac_ext >&5
3681
3682 fi
3683 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3684 done
3685 rm -f conftest*
3686 if test -n "$ac_declaration"; then
3687   echo '#ifdef __cplusplus' >>confdefs.h
3688   echo $ac_declaration      >>confdefs.h
3689   echo '#endif'             >>confdefs.h
3690 fi
3691
3692 else
3693   echo "$as_me: failed program was:" >&5
3694 sed 's/^/| /' conftest.$ac_ext >&5
3695
3696 fi
3697 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3698 ac_ext=c
3699 ac_cpp='$CPP $CPPFLAGS'
3700 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3701 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3702 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3703
3704 ac_ext=cc
3705 ac_cpp='$CXXCPP $CPPFLAGS'
3706 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3707 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3708 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3709 if test -n "$ac_tool_prefix"; then
3710   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3711   do
3712     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3713 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3714 echo "$as_me:$LINENO: checking for $ac_word" >&5
3715 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3716 if test "${ac_cv_prog_CXX+set}" = set; then
3717   echo $ECHO_N "(cached) $ECHO_C" >&6
3718 else
3719   if test -n "$CXX"; then
3720   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3721 else
3722 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3723 for as_dir in $PATH
3724 do
3725   IFS=$as_save_IFS
3726   test -z "$as_dir" && as_dir=.
3727   for ac_exec_ext in '' $ac_executable_extensions; do
3728   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3729     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3730     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3731     break 2
3732   fi
3733 done
3734 done
3735
3736 fi
3737 fi
3738 CXX=$ac_cv_prog_CXX
3739 if test -n "$CXX"; then
3740   echo "$as_me:$LINENO: result: $CXX" >&5
3741 echo "${ECHO_T}$CXX" >&6
3742 else
3743   echo "$as_me:$LINENO: result: no" >&5
3744 echo "${ECHO_T}no" >&6
3745 fi
3746
3747     test -n "$CXX" && break
3748   done
3749 fi
3750 if test -z "$CXX"; then
3751   ac_ct_CXX=$CXX
3752   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3753 do
3754   # Extract the first word of "$ac_prog", so it can be a program name with args.
3755 set dummy $ac_prog; ac_word=$2
3756 echo "$as_me:$LINENO: checking for $ac_word" >&5
3757 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3758 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3759   echo $ECHO_N "(cached) $ECHO_C" >&6
3760 else
3761   if test -n "$ac_ct_CXX"; then
3762   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3763 else
3764 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3765 for as_dir in $PATH
3766 do
3767   IFS=$as_save_IFS
3768   test -z "$as_dir" && as_dir=.
3769   for ac_exec_ext in '' $ac_executable_extensions; do
3770   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3771     ac_cv_prog_ac_ct_CXX="$ac_prog"
3772     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3773     break 2
3774   fi
3775 done
3776 done
3777
3778 fi
3779 fi
3780 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3781 if test -n "$ac_ct_CXX"; then
3782   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3783 echo "${ECHO_T}$ac_ct_CXX" >&6
3784 else
3785   echo "$as_me:$LINENO: result: no" >&5
3786 echo "${ECHO_T}no" >&6
3787 fi
3788
3789   test -n "$ac_ct_CXX" && break
3790 done
3791 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3792
3793   CXX=$ac_ct_CXX
3794 fi
3795
3796
3797 # Provide some information about the compiler.
3798 echo "$as_me:$LINENO:" \
3799      "checking for C++ compiler version" >&5
3800 ac_compiler=`set X $ac_compile; echo $2`
3801 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3802   (eval $ac_compiler --version </dev/null >&5) 2>&5
3803   ac_status=$?
3804   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3805   (exit $ac_status); }
3806 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3807   (eval $ac_compiler -v </dev/null >&5) 2>&5
3808   ac_status=$?
3809   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3810   (exit $ac_status); }
3811 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3812   (eval $ac_compiler -V </dev/null >&5) 2>&5
3813   ac_status=$?
3814   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3815   (exit $ac_status); }
3816
3817 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3818 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3819 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3820   echo $ECHO_N "(cached) $ECHO_C" >&6
3821 else
3822   cat >conftest.$ac_ext <<_ACEOF
3823 /* confdefs.h.  */
3824 _ACEOF
3825 cat confdefs.h >>conftest.$ac_ext
3826 cat >>conftest.$ac_ext <<_ACEOF
3827 /* end confdefs.h.  */
3828
3829 int
3830 main ()
3831 {
3832 #ifndef __GNUC__
3833        choke me
3834 #endif
3835
3836   ;
3837   return 0;
3838 }
3839 _ACEOF
3840 rm -f conftest.$ac_objext
3841 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3842   (eval $ac_compile) 2>conftest.er1
3843   ac_status=$?
3844   grep -v '^ *+' conftest.er1 >conftest.err
3845   rm -f conftest.er1
3846   cat conftest.err >&5
3847   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3848   (exit $ac_status); } &&
3849          { ac_try='test -z "$ac_cxx_werror_flag"
3850                          || test ! -s conftest.err'
3851   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3852   (eval $ac_try) 2>&5
3853   ac_status=$?
3854   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3855   (exit $ac_status); }; } &&
3856          { ac_try='test -s conftest.$ac_objext'
3857   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3858   (eval $ac_try) 2>&5
3859   ac_status=$?
3860   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3861   (exit $ac_status); }; }; then
3862   ac_compiler_gnu=yes
3863 else
3864   echo "$as_me: failed program was:" >&5
3865 sed 's/^/| /' conftest.$ac_ext >&5
3866
3867 ac_compiler_gnu=no
3868 fi
3869 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3870 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3871
3872 fi
3873 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3874 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3875 GXX=`test $ac_compiler_gnu = yes && echo yes`
3876 ac_test_CXXFLAGS=${CXXFLAGS+set}
3877 ac_save_CXXFLAGS=$CXXFLAGS
3878 CXXFLAGS="-g"
3879 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3880 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3881 if test "${ac_cv_prog_cxx_g+set}" = set; then
3882   echo $ECHO_N "(cached) $ECHO_C" >&6
3883 else
3884   cat >conftest.$ac_ext <<_ACEOF
3885 /* confdefs.h.  */
3886 _ACEOF
3887 cat confdefs.h >>conftest.$ac_ext
3888 cat >>conftest.$ac_ext <<_ACEOF
3889 /* end confdefs.h.  */
3890
3891 int
3892 main ()
3893 {
3894
3895   ;
3896   return 0;
3897 }
3898 _ACEOF
3899 rm -f conftest.$ac_objext
3900 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3901   (eval $ac_compile) 2>conftest.er1
3902   ac_status=$?
3903   grep -v '^ *+' conftest.er1 >conftest.err
3904   rm -f conftest.er1
3905   cat conftest.err >&5
3906   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3907   (exit $ac_status); } &&
3908          { ac_try='test -z "$ac_cxx_werror_flag"
3909                          || test ! -s conftest.err'
3910   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3911   (eval $ac_try) 2>&5
3912   ac_status=$?
3913   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3914   (exit $ac_status); }; } &&
3915          { ac_try='test -s conftest.$ac_objext'
3916   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3917   (eval $ac_try) 2>&5
3918   ac_status=$?
3919   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3920   (exit $ac_status); }; }; then
3921   ac_cv_prog_cxx_g=yes
3922 else
3923   echo "$as_me: failed program was:" >&5
3924 sed 's/^/| /' conftest.$ac_ext >&5
3925
3926 ac_cv_prog_cxx_g=no
3927 fi
3928 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3929 fi
3930 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3931 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
3932 if test "$ac_test_CXXFLAGS" = set; then
3933   CXXFLAGS=$ac_save_CXXFLAGS
3934 elif test $ac_cv_prog_cxx_g = yes; then
3935   if test "$GXX" = yes; then
3936     CXXFLAGS="-g -O2"
3937   else
3938     CXXFLAGS="-g"
3939   fi
3940 else
3941   if test "$GXX" = yes; then
3942     CXXFLAGS="-O2"
3943   else
3944     CXXFLAGS=
3945   fi
3946 fi
3947 for ac_declaration in \
3948    '' \
3949    'extern "C" void std::exit (int) throw (); using std::exit;' \
3950    'extern "C" void std::exit (int); using std::exit;' \
3951    'extern "C" void exit (int) throw ();' \
3952    'extern "C" void exit (int);' \
3953    'void exit (int);'
3954 do
3955   cat >conftest.$ac_ext <<_ACEOF
3956 /* confdefs.h.  */
3957 _ACEOF
3958 cat confdefs.h >>conftest.$ac_ext
3959 cat >>conftest.$ac_ext <<_ACEOF
3960 /* end confdefs.h.  */
3961 $ac_declaration
3962 #include <stdlib.h>
3963 int
3964 main ()
3965 {
3966 exit (42);
3967   ;
3968   return 0;
3969 }
3970 _ACEOF
3971 rm -f conftest.$ac_objext
3972 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3973   (eval $ac_compile) 2>conftest.er1
3974   ac_status=$?
3975   grep -v '^ *+' conftest.er1 >conftest.err
3976   rm -f conftest.er1
3977   cat conftest.err >&5
3978   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3979   (exit $ac_status); } &&
3980          { ac_try='test -z "$ac_cxx_werror_flag"
3981                          || test ! -s conftest.err'
3982   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3983   (eval $ac_try) 2>&5
3984   ac_status=$?
3985   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3986   (exit $ac_status); }; } &&
3987          { ac_try='test -s conftest.$ac_objext'
3988   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3989   (eval $ac_try) 2>&5
3990   ac_status=$?
3991   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3992   (exit $ac_status); }; }; then
3993   :
3994 else
3995   echo "$as_me: failed program was:" >&5
3996 sed 's/^/| /' conftest.$ac_ext >&5
3997
3998 continue
3999 fi
4000 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4001   cat >conftest.$ac_ext <<_ACEOF
4002 /* confdefs.h.  */
4003 _ACEOF
4004 cat confdefs.h >>conftest.$ac_ext
4005 cat >>conftest.$ac_ext <<_ACEOF
4006 /* end confdefs.h.  */
4007 $ac_declaration
4008 int
4009 main ()
4010 {
4011 exit (42);
4012   ;
4013   return 0;
4014 }
4015 _ACEOF
4016 rm -f conftest.$ac_objext
4017 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4018   (eval $ac_compile) 2>conftest.er1
4019   ac_status=$?
4020   grep -v '^ *+' conftest.er1 >conftest.err
4021   rm -f conftest.er1
4022   cat conftest.err >&5
4023   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4024   (exit $ac_status); } &&
4025          { ac_try='test -z "$ac_cxx_werror_flag"
4026                          || test ! -s conftest.err'
4027   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4028   (eval $ac_try) 2>&5
4029   ac_status=$?
4030   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4031   (exit $ac_status); }; } &&
4032          { ac_try='test -s conftest.$ac_objext'
4033   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4034   (eval $ac_try) 2>&5
4035   ac_status=$?
4036   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4037   (exit $ac_status); }; }; then
4038   break
4039 else
4040   echo "$as_me: failed program was:" >&5
4041 sed 's/^/| /' conftest.$ac_ext >&5
4042
4043 fi
4044 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4045 done
4046 rm -f conftest*
4047 if test -n "$ac_declaration"; then
4048   echo '#ifdef __cplusplus' >>confdefs.h
4049   echo $ac_declaration      >>confdefs.h
4050   echo '#endif'             >>confdefs.h
4051 fi
4052
4053 ac_ext=c
4054 ac_cpp='$CPP $CPPFLAGS'
4055 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4056 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4057 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4058
4059
4060 # We must set the default linker to the linker used by gcc for the correct
4061 # operation of libtool.  If LD is not defined and we are using gcc, try to
4062 # set the LD default to the ld used by gcc.
4063 if test -z "$LD"; then
4064   if test "$GCC" = yes; then
4065     case $build in
4066     *-*-mingw*)
4067       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4068     *)
4069       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4070     esac
4071     case $gcc_prog_ld in
4072     # Accept absolute paths.
4073     [\\/]* | [A-Za-z]:[\\/]*)
4074       LD="$gcc_prog_ld" ;;
4075     esac
4076   fi
4077 fi
4078
4079
4080
4081
4082 if test -n "$ac_tool_prefix"; then
4083   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4084 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4085 echo "$as_me:$LINENO: checking for $ac_word" >&5
4086 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4087 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4088   echo $ECHO_N "(cached) $ECHO_C" >&6
4089 else
4090   if test -n "$GNATBIND"; then
4091   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4092 else
4093 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4094 for as_dir in $PATH
4095 do
4096   IFS=$as_save_IFS
4097   test -z "$as_dir" && as_dir=.
4098   for ac_exec_ext in '' $ac_executable_extensions; do
4099   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4100     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4101     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4102     break 2
4103   fi
4104 done
4105 done
4106
4107 fi
4108 fi
4109 GNATBIND=$ac_cv_prog_GNATBIND
4110 if test -n "$GNATBIND"; then
4111   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4112 echo "${ECHO_T}$GNATBIND" >&6
4113 else
4114   echo "$as_me:$LINENO: result: no" >&5
4115 echo "${ECHO_T}no" >&6
4116 fi
4117
4118 fi
4119 if test -z "$ac_cv_prog_GNATBIND"; then
4120   ac_ct_GNATBIND=$GNATBIND
4121   # Extract the first word of "gnatbind", so it can be a program name with args.
4122 set dummy gnatbind; ac_word=$2
4123 echo "$as_me:$LINENO: checking for $ac_word" >&5
4124 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4125 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4126   echo $ECHO_N "(cached) $ECHO_C" >&6
4127 else
4128   if test -n "$ac_ct_GNATBIND"; then
4129   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4130 else
4131 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4132 for as_dir in $PATH
4133 do
4134   IFS=$as_save_IFS
4135   test -z "$as_dir" && as_dir=.
4136   for ac_exec_ext in '' $ac_executable_extensions; do
4137   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4138     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4139     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4140     break 2
4141   fi
4142 done
4143 done
4144
4145   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4146 fi
4147 fi
4148 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4149 if test -n "$ac_ct_GNATBIND"; then
4150   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4151 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4152 else
4153   echo "$as_me:$LINENO: result: no" >&5
4154 echo "${ECHO_T}no" >&6
4155 fi
4156
4157   GNATBIND=$ac_ct_GNATBIND
4158 else
4159   GNATBIND="$ac_cv_prog_GNATBIND"
4160 fi
4161
4162 if test -n "$ac_tool_prefix"; then
4163   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4164 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4165 echo "$as_me:$LINENO: checking for $ac_word" >&5
4166 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4167 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4168   echo $ECHO_N "(cached) $ECHO_C" >&6
4169 else
4170   if test -n "$GNATMAKE"; then
4171   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4172 else
4173 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4174 for as_dir in $PATH
4175 do
4176   IFS=$as_save_IFS
4177   test -z "$as_dir" && as_dir=.
4178   for ac_exec_ext in '' $ac_executable_extensions; do
4179   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4180     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4181     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4182     break 2
4183   fi
4184 done
4185 done
4186
4187 fi
4188 fi
4189 GNATMAKE=$ac_cv_prog_GNATMAKE
4190 if test -n "$GNATMAKE"; then
4191   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4192 echo "${ECHO_T}$GNATMAKE" >&6
4193 else
4194   echo "$as_me:$LINENO: result: no" >&5
4195 echo "${ECHO_T}no" >&6
4196 fi
4197
4198 fi
4199 if test -z "$ac_cv_prog_GNATMAKE"; then
4200   ac_ct_GNATMAKE=$GNATMAKE
4201   # Extract the first word of "gnatmake", so it can be a program name with args.
4202 set dummy gnatmake; ac_word=$2
4203 echo "$as_me:$LINENO: checking for $ac_word" >&5
4204 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4205 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4206   echo $ECHO_N "(cached) $ECHO_C" >&6
4207 else
4208   if test -n "$ac_ct_GNATMAKE"; then
4209   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4210 else
4211 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4212 for as_dir in $PATH
4213 do
4214   IFS=$as_save_IFS
4215   test -z "$as_dir" && as_dir=.
4216   for ac_exec_ext in '' $ac_executable_extensions; do
4217   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4218     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4219     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4220     break 2
4221   fi
4222 done
4223 done
4224
4225   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4226 fi
4227 fi
4228 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4229 if test -n "$ac_ct_GNATMAKE"; then
4230   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4231 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4232 else
4233   echo "$as_me:$LINENO: result: no" >&5
4234 echo "${ECHO_T}no" >&6
4235 fi
4236
4237   GNATMAKE=$ac_ct_GNATMAKE
4238 else
4239   GNATMAKE="$ac_cv_prog_GNATMAKE"
4240 fi
4241
4242 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4243 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4244 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4245   echo $ECHO_N "(cached) $ECHO_C" >&6
4246 else
4247   cat >conftest.adb <<EOF
4248 procedure conftest is begin null; end conftest;
4249 EOF
4250 acx_cv_cc_gcc_supports_ada=no
4251 # There is a bug in old released versions of GCC which causes the
4252 # driver to exit successfully when the appropriate language module
4253 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4254 # Therefore we must check for the error message as well as an
4255 # unsuccessful exit.
4256 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4257 # given a .adb file, but produce no object file.  So we must check
4258 # if an object file was really produced to guard against this.
4259 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4260 if test x"$errors" = x && test -f conftest.$ac_objext; then
4261   acx_cv_cc_gcc_supports_ada=yes
4262 fi
4263 rm -f conftest.*
4264 fi
4265 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4266 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4267
4268 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4269   have_gnat=yes
4270 else
4271   have_gnat=no
4272 fi
4273
4274 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4275 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4276 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4277   echo $ECHO_N "(cached) $ECHO_C" >&6
4278 else
4279    echo abfoo >t1
4280   echo cdfoo >t2
4281   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4282   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4283     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4284       :
4285     else
4286       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4287     fi
4288   fi
4289   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4290     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4291       :
4292     else
4293       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4294     fi
4295   fi
4296   rm t1 t2
4297
4298 fi
4299 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4300 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4301 do_compare="$gcc_cv_prog_cmp_skip"
4302
4303
4304
4305 # Check for GMP and MPFR
4306 gmplibs="-lmpfr -lgmp"
4307 gmpinc=
4308 have_gmp=no
4309
4310 # Specify a location for mpfr
4311 # check for this first so it ends up on the link line before gmp.
4312
4313 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4314 if test "${with_mpfr_dir+set}" = set; then
4315   withval="$with_mpfr_dir"
4316   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4317 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4318 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4319 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4320    { (exit 1); exit 1; }; }
4321 fi;
4322
4323
4324 # Check whether --with-mpfr or --without-mpfr was given.
4325 if test "${with_mpfr+set}" = set; then
4326   withval="$with_mpfr"
4327
4328 fi;
4329
4330 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4331 if test "${with_mpfr_include+set}" = set; then
4332   withval="$with_mpfr_include"
4333
4334 fi;
4335
4336 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4337 if test "${with_mpfr_lib+set}" = set; then
4338   withval="$with_mpfr_lib"
4339
4340 fi;
4341
4342 if test "x$with_mpfr" != x; then
4343   gmplibs="-L$with_mpfr/lib $gmplibs"
4344   gmpinc="-I$with_mpfr/include"
4345 fi
4346 if test "x$with_mpfr_include" != x; then
4347   gmpinc="-I$with_mpfr_include"
4348 fi
4349 if test "x$with_mpfr_lib" != x; then
4350   gmplibs="-L$with_mpfr_lib $gmplibs"
4351 fi
4352 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4353   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4354   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4355   # Do not test the mpfr version.  Assume that it is sufficient, since
4356   # it is in the source tree, and the library has not been built yet
4357   # but it would be included on the link line in the version check below
4358   # hence making the test fail.
4359   have_gmp=yes
4360 fi
4361
4362 # Specify a location for gmp
4363
4364 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4365 if test "${with_gmp_dir+set}" = set; then
4366   withval="$with_gmp_dir"
4367   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4368 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4369 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4370 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4371    { (exit 1); exit 1; }; }
4372 fi;
4373
4374
4375 # Check whether --with-gmp or --without-gmp was given.
4376 if test "${with_gmp+set}" = set; then
4377   withval="$with_gmp"
4378
4379 fi;
4380
4381 # Check whether --with-gmp_include or --without-gmp_include was given.
4382 if test "${with_gmp_include+set}" = set; then
4383   withval="$with_gmp_include"
4384
4385 fi;
4386
4387 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4388 if test "${with_gmp_lib+set}" = set; then
4389   withval="$with_gmp_lib"
4390
4391 fi;
4392
4393
4394 if test "x$with_gmp" != x; then
4395   gmplibs="-L$with_gmp/lib $gmplibs"
4396   gmpinc="-I$with_gmp/include $gmpinc"
4397 fi
4398 if test "x$with_gmp_include" != x; then
4399   gmpinc="-I$with_gmp_include $gmpinc"
4400 fi
4401 if test "x$with_gmp_lib" != x; then
4402   gmplibs="-L$with_gmp_lib $gmplibs"
4403 fi
4404 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4405   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4406   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4407   # Do not test the gmp version.  Assume that it is sufficient, since
4408   # it is in the source tree, and the library has not been built yet
4409   # but it would be included on the link line in the version check below
4410   # hence making the test fail.
4411   have_gmp=yes
4412 fi
4413
4414 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4415   have_gmp=yes
4416   saved_CFLAGS="$CFLAGS"
4417   CFLAGS="$CFLAGS $gmpinc"
4418   # Check GMP actually works
4419   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4420 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4421
4422 cat >conftest.$ac_ext <<_ACEOF
4423 /* confdefs.h.  */
4424 _ACEOF
4425 cat confdefs.h >>conftest.$ac_ext
4426 cat >>conftest.$ac_ext <<_ACEOF
4427 /* end confdefs.h.  */
4428 #include "gmp.h"
4429 int
4430 main ()
4431 {
4432
4433   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4434   choke me
4435   #endif
4436
4437   ;
4438   return 0;
4439 }
4440 _ACEOF
4441 rm -f conftest.$ac_objext
4442 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4443   (eval $ac_compile) 2>conftest.er1
4444   ac_status=$?
4445   grep -v '^ *+' conftest.er1 >conftest.err
4446   rm -f conftest.er1
4447   cat conftest.err >&5
4448   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4449   (exit $ac_status); } &&
4450          { ac_try='test -z "$ac_c_werror_flag"
4451                          || test ! -s conftest.err'
4452   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4453   (eval $ac_try) 2>&5
4454   ac_status=$?
4455   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4456   (exit $ac_status); }; } &&
4457          { ac_try='test -s conftest.$ac_objext'
4458   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4459   (eval $ac_try) 2>&5
4460   ac_status=$?
4461   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4462   (exit $ac_status); }; }; then
4463   echo "$as_me:$LINENO: result: yes" >&5
4464 echo "${ECHO_T}yes" >&6
4465 else
4466   echo "$as_me: failed program was:" >&5
4467 sed 's/^/| /' conftest.$ac_ext >&5
4468
4469 echo "$as_me:$LINENO: result: no" >&5
4470 echo "${ECHO_T}no" >&6; have_gmp=no
4471 fi
4472 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4473
4474   if test x"$have_gmp" = xyes; then
4475     saved_LIBS="$LIBS"
4476     LIBS="$LIBS $gmplibs"
4477         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4478 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4479     cat >conftest.$ac_ext <<_ACEOF
4480 /* confdefs.h.  */
4481 _ACEOF
4482 cat confdefs.h >>conftest.$ac_ext
4483 cat >>conftest.$ac_ext <<_ACEOF
4484 /* end confdefs.h.  */
4485 #include <gmp.h>
4486     #include <mpfr.h>
4487 int
4488 main ()
4489 {
4490
4491     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,0)
4492     choke me
4493     #endif
4494     mpfr_t n;
4495     mpfr_t x;
4496     int t;
4497     mpfr_init (n);
4498     mpfr_init (x);
4499     mpfr_atan2 (n, n, x, GMP_RNDN);
4500     mpfr_erfc (n, x, GMP_RNDN);
4501     mpfr_subnormalize (x, t, GMP_RNDN);
4502
4503   ;
4504   return 0;
4505 }
4506 _ACEOF
4507 rm -f conftest.$ac_objext conftest$ac_exeext
4508 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4509   (eval $ac_link) 2>conftest.er1
4510   ac_status=$?
4511   grep -v '^ *+' conftest.er1 >conftest.err
4512   rm -f conftest.er1
4513   cat conftest.err >&5
4514   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4515   (exit $ac_status); } &&
4516          { ac_try='test -z "$ac_c_werror_flag"
4517                          || test ! -s conftest.err'
4518   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4519   (eval $ac_try) 2>&5
4520   ac_status=$?
4521   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4522   (exit $ac_status); }; } &&
4523          { ac_try='test -s conftest$ac_exeext'
4524   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4525   (eval $ac_try) 2>&5
4526   ac_status=$?
4527   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4528   (exit $ac_status); }; }; then
4529   cat >conftest.$ac_ext <<_ACEOF
4530 /* confdefs.h.  */
4531 _ACEOF
4532 cat confdefs.h >>conftest.$ac_ext
4533 cat >>conftest.$ac_ext <<_ACEOF
4534 /* end confdefs.h.  */
4535 #include <gmp.h>
4536     #include <mpfr.h>
4537 int
4538 main ()
4539 {
4540
4541     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4542     choke me
4543     #endif
4544     mpfr_t n; mpfr_init(n);
4545
4546   ;
4547   return 0;
4548 }
4549 _ACEOF
4550 rm -f conftest.$ac_objext conftest$ac_exeext
4551 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4552   (eval $ac_link) 2>conftest.er1
4553   ac_status=$?
4554   grep -v '^ *+' conftest.er1 >conftest.err
4555   rm -f conftest.er1
4556   cat conftest.err >&5
4557   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4558   (exit $ac_status); } &&
4559          { ac_try='test -z "$ac_c_werror_flag"
4560                          || test ! -s conftest.err'
4561   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4562   (eval $ac_try) 2>&5
4563   ac_status=$?
4564   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4565   (exit $ac_status); }; } &&
4566          { ac_try='test -s conftest$ac_exeext'
4567   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4568   (eval $ac_try) 2>&5
4569   ac_status=$?
4570   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4571   (exit $ac_status); }; }; then
4572   echo "$as_me:$LINENO: result: yes" >&5
4573 echo "${ECHO_T}yes" >&6
4574 else
4575   echo "$as_me: failed program was:" >&5
4576 sed 's/^/| /' conftest.$ac_ext >&5
4577
4578 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4579 echo "${ECHO_T}buggy but acceptable" >&6
4580 fi
4581 rm -f conftest.err conftest.$ac_objext \
4582       conftest$ac_exeext conftest.$ac_ext
4583 else
4584   echo "$as_me: failed program was:" >&5
4585 sed 's/^/| /' conftest.$ac_ext >&5
4586
4587 echo "$as_me:$LINENO: result: no" >&5
4588 echo "${ECHO_T}no" >&6; have_gmp=no
4589 fi
4590 rm -f conftest.err conftest.$ac_objext \
4591       conftest$ac_exeext conftest.$ac_ext
4592       LIBS="$saved_LIBS"
4593   fi
4594   CFLAGS="$saved_CFLAGS"
4595
4596   if test x$have_gmp != xyes; then
4597     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4598 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4599 Copies of these libraries' source code can be found at their respective
4600 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4601 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4602 If you obtained GMP and/or MPFR from a vendor distribution package, make
4603 sure that you have installed both the libraries and the header files.
4604 They may be located in separate packages." >&5
4605 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4606 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4607 Copies of these libraries' source code can be found at their respective
4608 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4609 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4610 If you obtained GMP and/or MPFR from a vendor distribution package, make
4611 sure that you have installed both the libraries and the header files.
4612 They may be located in separate packages." >&2;}
4613    { (exit 1); exit 1; }; }
4614   fi
4615 fi
4616
4617 # Flags needed for both GMP and/or MPFR
4618
4619
4620
4621 # By default, C is the only stage 1 language.
4622 stage1_languages=,c,
4623
4624 # Figure out what language subdirectories are present.
4625 # Look if the user specified --enable-languages="..."; if not, use
4626 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4627 # go away some day.
4628 # NB:  embedded tabs in this IF block -- do not untabify
4629 if test -d ${srcdir}/gcc; then
4630   if test x"${enable_languages+set}" != xset; then
4631     if test x"${LANGUAGES+set}" = xset; then
4632       enable_languages="${LANGUAGES}"
4633         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4634     else
4635       enable_languages=all
4636     fi
4637   else
4638     if test x"${enable_languages}" = x ||
4639        test x"${enable_languages}" = xyes;
4640        then
4641       echo configure.in: --enable-languages needs at least one language argument 1>&2
4642       exit 1
4643     fi
4644   fi
4645   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4646
4647   # 'f95' is the old name for the 'fortran' language. We issue a warning
4648   # and make the substitution.
4649   case ,${enable_languages}, in
4650     *,f95,*)
4651       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4652       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4653       ;;
4654   esac
4655
4656   # First scan to see if an enabled language requires some other language.
4657   # We assume that a given config-lang.in will list all the language
4658   # front ends it requires, even if some are required indirectly.
4659   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4660     case ${lang_frag} in
4661       ..) ;;
4662       # The odd quoting in the next line works around
4663       # an apparent bug in bash 1.12 on linux.
4664       ${srcdir}/gcc/[*]/config-lang.in) ;;
4665       *)
4666         # From the config-lang.in, get $language, $lang_requires
4667         language=
4668         lang_requires=
4669         . ${lang_frag}
4670         for other in ${lang_requires} ; do
4671           case ,${enable_languages}, in
4672             *,$other,*) ;;
4673             *,all,*) ;;
4674             *,$language,*)
4675               echo " \`$other' language required by \`$language'; enabling" 1>&2
4676               enable_languages="${enable_languages},${other}"
4677               ;;
4678           esac
4679         done
4680         ;;
4681     esac
4682   done
4683
4684   new_enable_languages=,c,
4685   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4686   potential_languages=,c,
4687
4688   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4689     case ${lang_frag} in
4690       ..) ;;
4691       # The odd quoting in the next line works around
4692       # an apparent bug in bash 1.12 on linux.
4693       ${srcdir}/gcc/[*]/config-lang.in) ;;
4694       *)
4695         # From the config-lang.in, get $language, $target_libs,
4696         # $lang_dirs, $boot_language, and $build_by_default
4697         language=
4698         target_libs=
4699         lang_dirs=
4700         subdir_requires=
4701         boot_language=no
4702         build_by_default=yes
4703         . ${lang_frag}
4704         if test x${language} = x; then
4705           echo "${lang_frag} doesn't set \$language." 1>&2
4706           exit 1
4707         fi
4708
4709         case ,${enable_languages}, in
4710           *,${language},*)
4711             # Language was explicitly selected; include it.
4712             add_this_lang=yes
4713             ;;
4714           *,all,*)
4715             # 'all' was selected, select it if it is a default language
4716             add_this_lang=${build_by_default}
4717             ;;
4718           *)
4719             add_this_lang=no
4720             ;;
4721         esac
4722
4723         # Disable languages that need other directories if these aren't available.
4724         for i in $subdir_requires; do
4725           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4726           case ,${enable_languages}, in
4727             *,${language},*)
4728               # Specifically requested language; tell them.
4729               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4730 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4731    { (exit 1); exit 1; }; }
4732               ;;
4733             *)
4734               # Silently disable.
4735               add_this_lang=unsupported
4736               ;;
4737           esac
4738         done
4739
4740         # Disable Ada if no preexisting GNAT is available.
4741         case ,${enable_languages},:${language}:${have_gnat} in
4742           *,${language},*:ada:no)
4743             # Specifically requested language; tell them.
4744             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4745 echo "$as_me: error: GNAT is required to build $language" >&2;}
4746    { (exit 1); exit 1; }; }
4747             ;;
4748           *:ada:no)
4749             # Silently disable.
4750             add_this_lang=unsupported
4751             ;;
4752         esac
4753
4754         # Disable a language that is unsupported by the target.
4755         case " $unsupported_languages " in
4756           *" $language "*)
4757             add_this_lang=unsupported
4758             ;;
4759         esac
4760
4761         case $add_this_lang in
4762           unsupported)
4763             # Remove language-dependent dirs.
4764             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4765             ;;
4766           no)
4767             # Remove language-dependent dirs; still show language as supported.
4768             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4769             potential_languages="${potential_languages}${language},"
4770             ;;
4771           yes)
4772             new_enable_languages="${new_enable_languages}${language},"
4773             potential_languages="${potential_languages}${language},"
4774             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4775             case ${boot_language} in
4776               yes)
4777                 # Add to (comma-separated) list of stage 1 languages.
4778                 stage1_languages="${stage1_languages}${language},"
4779                 ;;
4780             esac
4781             ;;
4782         esac
4783         ;;
4784     esac
4785   done
4786
4787   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4788 if test "${enable_stage1_languages+set}" = set; then
4789   enableval="$enable_stage1_languages"
4790   case ,${enable_stage1_languages}, in
4791     ,no,|,,)
4792       # Set it to something that will have no effect in the loop below
4793       enable_stage1_languages=c ;;
4794     ,yes,)
4795       enable_stage1_languages=`echo $new_enable_languages | \
4796         sed -e "s/^,//" -e "s/,$//" ` ;;
4797     *,all,*)
4798       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4799         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4800   esac
4801
4802   # Add "good" languages from enable_stage1_languages to stage1_languages,
4803   # while "bad" languages go in missing_languages.  Leave no duplicates.
4804   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4805     case $potential_languages in
4806       *,$i,*)
4807         case $stage1_languages in
4808           *,$i,*) ;;
4809           *) stage1_languages="$stage1_languages$i," ;;
4810         esac ;;
4811       *)
4812         case $missing_languages in
4813           *,$i,*) ;;
4814           *) missing_languages="$missing_languages$i," ;;
4815         esac ;;
4816      esac
4817   done
4818 fi;
4819
4820   # Remove leading/trailing commas that were added for simplicity
4821   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4822   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4823   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4824   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4825
4826   if test "x$missing_languages" != x; then
4827     { { echo "$as_me:$LINENO: error:
4828 The following requested languages could not be built: ${missing_languages}
4829 Supported languages are: ${potential_languages}" >&5
4830 echo "$as_me: error:
4831 The following requested languages could not be built: ${missing_languages}
4832 Supported languages are: ${potential_languages}" >&2;}
4833    { (exit 1); exit 1; }; }
4834   fi
4835   if test "x$new_enable_languages" != "x$enable_languages"; then
4836     echo The following languages will be built: ${new_enable_languages}
4837     enable_languages="$new_enable_languages"
4838   fi
4839
4840
4841   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4842 fi
4843
4844 # Handle --disable-<component> generically.
4845 for dir in $configdirs $build_configdirs $target_configdirs ; do
4846   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4847   if eval test x\${enable_${dirname}} "=" xno ; then
4848     noconfigdirs="$noconfigdirs $dir"
4849   fi
4850 done
4851
4852 # Check for Boehm's garbage collector
4853 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4854 if test "${enable_objc_gc+set}" = set; then
4855   enableval="$enable_objc_gc"
4856   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4857   *,objc,*:*:yes:*target-boehm-gc*)
4858     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4859 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4860    { (exit 1); exit 1; }; }
4861     ;;
4862 esac
4863 fi;
4864
4865 # Make sure we only build Boehm's garbage collector if required.
4866 case ,${enable_languages},:${enable_objc_gc} in
4867   *,objc,*:yes)
4868     # Keep target-boehm-gc if requested for Objective-C.
4869     ;;
4870   *)
4871     # Otherwise remove target-boehm-gc depending on target-libjava.
4872     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4873       noconfigdirs="$noconfigdirs target-boehm-gc"
4874     fi
4875     ;;
4876 esac
4877
4878 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4879 # $build_configdirs and $target_configdirs.
4880 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4881
4882 notsupp=""
4883 for dir in . $skipdirs $noconfigdirs ; do
4884   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4885   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4886     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4887     if test -r $srcdir/$dirname/configure ; then
4888       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4889         true
4890       else
4891         notsupp="$notsupp $dir"
4892       fi
4893     fi
4894   fi
4895   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4896     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4897     if test -r $srcdir/$dirname/configure ; then
4898       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4899         true
4900       else
4901         notsupp="$notsupp $dir"
4902       fi
4903     fi
4904   fi
4905   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4906     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4907     if test -r $srcdir/$dirname/configure ; then
4908       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4909         true
4910       else
4911         notsupp="$notsupp $dir"
4912       fi
4913     fi
4914   fi
4915 done
4916
4917 # Sometimes the tools are distributed with libiberty but with no other
4918 # libraries.  In that case, we don't want to build target-libiberty.
4919 # Don't let libgcc imply libiberty either.
4920 if test -n "${target_configdirs}" ; then
4921   libgcc=
4922   others=
4923   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
4924     if test "$i" = "libgcc"; then
4925       libgcc=target-libgcc
4926     elif test "$i" != "libiberty" ; then
4927       if test -r $srcdir/$i/configure ; then
4928         others=yes;
4929         break;
4930       fi
4931     fi
4932   done
4933   if test -z "${others}" ; then
4934     target_configdirs=$libgcc
4935   fi
4936 fi
4937
4938 # Quietly strip out all directories which aren't configurable in this tree.
4939 # This relies on all configurable subdirectories being autoconfiscated, which
4940 # is now the case.
4941 build_configdirs_all="$build_configdirs"
4942 build_configdirs=
4943 for i in ${build_configdirs_all} ; do
4944   j=`echo $i | sed -e s/build-//g`
4945   if test -f ${srcdir}/$j/configure ; then
4946     build_configdirs="${build_configdirs} $i"
4947   fi
4948 done
4949
4950 configdirs_all="$configdirs"
4951 configdirs=
4952 for i in ${configdirs_all} ; do
4953   if test -f ${srcdir}/$i/configure ; then
4954     configdirs="${configdirs} $i"
4955   fi
4956 done
4957
4958 target_configdirs_all="$target_configdirs"
4959 target_configdirs=
4960 for i in ${target_configdirs_all} ; do
4961   j=`echo $i | sed -e s/target-//g`
4962   if test -f ${srcdir}/$j/configure ; then
4963     target_configdirs="${target_configdirs} $i"
4964   fi
4965 done
4966
4967 # Produce a warning message for the subdirs we can't configure.
4968 # This isn't especially interesting in the Cygnus tree, but in the individual
4969 # FSF releases, it's important to let people know when their machine isn't
4970 # supported by the one or two programs in a package.
4971
4972 if test -n "${notsupp}" && test -z "${norecursion}" ; then
4973   # If $appdirs is non-empty, at least one of those directories must still
4974   # be configured, or we error out.  (E.g., if the gas release supports a
4975   # specified target in some subdirs but not the gas subdir, we shouldn't
4976   # pretend that all is well.)
4977   if test -n "$appdirs" ; then
4978     for dir in $appdirs ; do
4979       if test -r $dir/Makefile.in ; then
4980         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4981           appdirs=""
4982           break
4983         fi
4984         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
4985           appdirs=""
4986           break
4987         fi
4988       fi
4989     done
4990     if test -n "$appdirs" ; then
4991       echo "*** This configuration is not supported by this package." 1>&2
4992       exit 1
4993     fi
4994   fi
4995   # Okay, some application will build, or we don't care to check.  Still
4996   # notify of subdirs not getting built.
4997   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
4998   echo "    ${notsupp}" 1>&2
4999   echo "    (Any other directories should still work fine.)" 1>&2
5000 fi
5001
5002 case "$host" in
5003   *msdosdjgpp*)
5004     enable_gdbtk=no ;;
5005 esac
5006
5007 # To find our prefix, in gcc_cv_tool_prefix.
5008
5009 # The user is always right.
5010 if test "${PATH_SEPARATOR+set}" != set; then
5011   echo "#! /bin/sh" >conf$$.sh
5012   echo  "exit 0"   >>conf$$.sh
5013   chmod +x conf$$.sh
5014   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5015     PATH_SEPARATOR=';'
5016   else
5017     PATH_SEPARATOR=:
5018   fi
5019   rm -f conf$$.sh
5020 fi
5021
5022
5023
5024 if test "x$exec_prefix" = xNONE; then
5025         if test "x$prefix" = xNONE; then
5026                 gcc_cv_tool_prefix=$ac_default_prefix
5027         else
5028                 gcc_cv_tool_prefix=$prefix
5029         fi
5030 else
5031         gcc_cv_tool_prefix=$exec_prefix
5032 fi
5033
5034 # If there is no compiler in the tree, use the PATH only.  In any
5035 # case, if there is no compiler in the tree nobody should use
5036 # AS_FOR_TARGET and LD_FOR_TARGET.
5037 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5038     gcc_version=`cat $srcdir/gcc/BASE-VER`
5039     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5040     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5041     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5042     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5043     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5044     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5045 else
5046     gcc_cv_tool_dirs=
5047 fi
5048
5049 if test x$build = x$target && test -n "$md_exec_prefix"; then
5050         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5051 fi
5052
5053
5054
5055 copy_dirs=
5056
5057
5058 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5059 if test "${with_build_sysroot+set}" = set; then
5060   withval="$with_build_sysroot"
5061   if test x"$withval" != x ; then
5062      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5063    fi
5064 else
5065   SYSROOT_CFLAGS_FOR_TARGET=
5066 fi;
5067
5068
5069 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5070 # the named directory are copied to $(tooldir)/sys-include.
5071 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5072   if test x${is_cross_compiler} = xno ; then
5073     echo 1>&2 '***' --with-headers is only supported when cross compiling
5074     exit 1
5075   fi
5076   if test x"${with_headers}" != xyes ; then
5077     x=${gcc_cv_tool_prefix}
5078     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5079   fi
5080 fi
5081
5082 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5083 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5084 # are permitted.
5085 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5086   if test x${is_cross_compiler} = xno ; then
5087     echo 1>&2 '***' --with-libs is only supported when cross compiling
5088     exit 1
5089   fi
5090   if test x"${with_libs}" != xyes ; then
5091     # Copy the libraries in reverse order, so that files in the first named
5092     # library override files in subsequent libraries.
5093     x=${gcc_cv_tool_prefix}
5094     for l in ${with_libs}; do
5095       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5096     done
5097   fi
5098 fi
5099
5100 # Set with_gnu_as and with_gnu_ld as appropriate.
5101 #
5102 # This is done by determining whether or not the appropriate directory
5103 # is available, and by checking whether or not specific configurations
5104 # have requested that this magic not happen.
5105 #
5106 # The command line options always override the explicit settings in
5107 # configure.in, and the settings in configure.in override this magic.
5108 #
5109 # If the default for a toolchain is to use GNU as and ld, and you don't
5110 # want to do that, then you should use the --without-gnu-as and
5111 # --without-gnu-ld options for the configure script.
5112
5113 if test x${use_gnu_as} = x &&
5114    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5115   with_gnu_as=yes
5116   extra_host_args="$extra_host_args --with-gnu-as"
5117 fi
5118
5119 if test x${use_gnu_ld} = x &&
5120    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5121   with_gnu_ld=yes
5122   extra_host_args="$extra_host_args --with-gnu-ld"
5123 fi
5124
5125 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5126 # can detect this case.
5127
5128 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5129   with_newlib=yes
5130   extra_host_args="$extra_host_args --with-newlib"
5131 fi
5132
5133 # Handle ${copy_dirs}
5134 set fnord ${copy_dirs}
5135 shift
5136 while test $# != 0 ; do
5137   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5138     :
5139   else
5140     echo Copying $1 to $2
5141
5142     # Use the install script to create the directory and all required
5143     # parent directories.
5144     if test -d $2 ; then
5145       :
5146     else
5147       echo >config.temp
5148       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5149     fi
5150
5151     # Copy the directory, assuming we have tar.
5152     # FIXME: Should we use B in the second tar?  Not all systems support it.
5153     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5154
5155     # It is the responsibility of the user to correctly adjust all
5156     # symlinks.  If somebody can figure out how to handle them correctly
5157     # here, feel free to add the code.
5158
5159     echo $1 > $2/COPIED
5160   fi
5161   shift; shift
5162 done
5163
5164 # Determine a target-dependent exec_prefix that the installed
5165 # gcc will search in.  Keep this list sorted by triplet, with
5166 # the *-*-osname triplets last.
5167 md_exec_prefix=
5168 case "${target}" in
5169   alpha*-*-*vms*)
5170     md_exec_prefix=/gnu/lib/gcc-lib
5171     ;;
5172   i[34567]86-pc-msdosdjgpp*)
5173     md_exec_prefix=/dev/env/DJDIR/bin
5174     ;;
5175   i[34567]86-*-sco3.2v5*)
5176     if test $with_gnu_as = yes; then
5177       md_exec_prefix=/usr/gnu/bin
5178     else
5179       md_exec_prefix=/usr/ccs/bin/elf
5180     fi
5181     ;;
5182
5183   mn10300-*-* | \
5184   powerpc-*-chorusos* | \
5185   powerpc*-*-eabi* | \
5186   powerpc*-*-sysv* | \
5187   powerpc*-*-kaos* | \
5188   s390x-ibm-tpf*)
5189     md_exec_prefix=/usr/ccs/bin
5190     ;;
5191   sparc64-*-elf*)
5192     ;;
5193   v850*-*-*)
5194     md_exec_prefix=/usr/ccs/bin
5195     ;;
5196   xtensa-*-elf*)
5197     ;;
5198
5199   *-*-beos* | \
5200   *-*-elf* | \
5201   *-*-hpux* | \
5202   *-*-netware* | \
5203   *-*-nto-qnx* | \
5204   *-*-rtems* | \
5205   *-*-solaris2* | \
5206   *-*-sysv[45]* | \
5207   *-*-vxworks* | \
5208   *-wrs-windiss)
5209     md_exec_prefix=/usr/ccs/bin
5210     ;;
5211 esac
5212
5213 extra_arflags_for_target=
5214 extra_nmflags_for_target=
5215 extra_ranlibflags_for_target=
5216 target_makefile_frag=/dev/null
5217 case "${target}" in
5218   mep*-*-*)
5219     target_makefile_frag="config/mt-mep"
5220     ;;
5221   spu-*-*)
5222     target_makefile_frag="config/mt-spu"
5223     ;;
5224   *-*-netware*)
5225     target_makefile_frag="config/mt-netware"
5226     ;;
5227   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5228     target_makefile_frag="config/mt-gnu"
5229     ;;
5230   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5231     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5232     # commands to handle both 32-bit and 64-bit objects.  These flags are
5233     # harmless if we're using GNU nm or ar.
5234     extra_arflags_for_target=" -X32_64"
5235     extra_nmflags_for_target=" -B -X32_64"
5236     ;;
5237   *-*-darwin*)
5238     # ranlib from Darwin requires the -c flag to look at common symbols.
5239     extra_ranlibflags_for_target=" -c"
5240     ;;
5241   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5242     target_makefile_frag="config/mt-wince"
5243     ;;
5244 esac
5245
5246 alphaieee_frag=/dev/null
5247 case $target in
5248   alpha*-*-*)
5249     # This just makes sure to use the -mieee option to build target libs.
5250     # This should probably be set individually by each library.
5251     alphaieee_frag="config/mt-alphaieee"
5252     ;;
5253 esac
5254
5255 # If --enable-target-optspace always use -Os instead of -O2 to build
5256 # the target libraries, similarly if it is not specified, use -Os
5257 # on selected platforms.
5258 ospace_frag=/dev/null
5259 case "${enable_target_optspace}:${target}" in
5260   yes:*)
5261     ospace_frag="config/mt-ospace"
5262     ;;
5263   :d30v-*)
5264     ospace_frag="config/mt-d30v"
5265     ;;
5266   :m32r-* | :d10v-* | :fr30-*)
5267     ospace_frag="config/mt-ospace"
5268     ;;
5269   no:* | :*)
5270     ;;
5271   *)
5272     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5273     ;;
5274 esac
5275
5276 # Default to using --with-stabs for certain targets.
5277 if test x${with_stabs} = x ; then
5278   case "${target}" in
5279   mips*-*-irix[56]*)
5280     ;;
5281   mips*-*-* | alpha*-*-osf*)
5282     with_stabs=yes;
5283     extra_host_args="${extra_host_args} --with-stabs"
5284     ;;
5285   esac
5286 fi
5287
5288 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5289 # them automatically.
5290 case "${host}" in
5291   hppa*64*-*-hpux11*)
5292     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5293     ;;
5294 esac
5295
5296 # Some systems (e.g., one of the i386-aix systems the gas testers are
5297 # using) don't handle "\$" correctly, so don't use it here.
5298 tooldir='${exec_prefix}'/${target_noncanonical}
5299 build_tooldir=${tooldir}
5300
5301 # Create a .gdbinit file which runs the one in srcdir
5302 # and tells GDB to look there for source files.
5303
5304 if test -r ${srcdir}/.gdbinit ; then
5305   case ${srcdir} in
5306     .) ;;
5307     *) cat > ./.gdbinit <<EOF
5308 # ${NO_EDIT}
5309 dir ${srcdir}
5310 dir .
5311 source ${srcdir}/.gdbinit
5312 EOF
5313     ;;
5314   esac
5315 fi
5316
5317 # Make sure that the compiler is able to generate an executable.  If it
5318 # can't, we are probably in trouble.  We don't care whether we can run the
5319 # executable--we might be using a cross compiler--we only care whether it
5320 # can be created.  At this point the main configure script has set CC.
5321 we_are_ok=no
5322 echo "int main () { return 0; }" > conftest.c
5323 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5324 if test $? = 0 ; then
5325   if test -s conftest || test -s conftest.exe ; then
5326     we_are_ok=yes
5327   fi
5328 fi
5329 case $we_are_ok in
5330   no)
5331     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5332     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5333     rm -f conftest*
5334     exit 1
5335     ;;
5336 esac
5337 rm -f conftest*
5338
5339 # The Solaris /usr/ucb/cc compiler does not appear to work.
5340 case "${host}" in
5341   sparc-sun-solaris2*)
5342       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5343       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5344           could_use=
5345           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5346           if test -d /opt/cygnus/bin ; then
5347               if test "$could_use" = "" ; then
5348                   could_use="/opt/cygnus/bin"
5349               else
5350                   could_use="$could_use or /opt/cygnus/bin"
5351               fi
5352           fi
5353         if test "$could_use" = "" ; then
5354             echo "Warning: compilation may fail because you're using"
5355             echo "/usr/ucb/cc.  You should change your PATH or CC "
5356             echo "variable and rerun configure."
5357         else
5358             echo "Warning: compilation may fail because you're using"
5359             echo "/usr/ucb/cc, when you should use the C compiler from"
5360             echo "$could_use.  You should change your"
5361             echo "PATH or CC variable and rerun configure."
5362         fi
5363       fi
5364   ;;
5365 esac
5366
5367 case "${host}" in
5368   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5369   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5370   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5371 esac
5372
5373 # Record target_configdirs and the configure arguments for target and
5374 # build configuration in Makefile.
5375 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5376 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5377
5378 # Determine whether gdb needs tk/tcl or not.
5379 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5380 # and in that case we want gdb to be built without tk.  Ugh!
5381 # In fact I believe gdb is the *only* package directly dependent on tk,
5382 # so we should be able to put the 'maybe's in unconditionally and
5383 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5384 # 100% sure that that's safe though.
5385
5386 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5387 case "$enable_gdbtk" in
5388   no)
5389     GDB_TK="" ;;
5390   yes)
5391     GDB_TK="${gdb_tk}" ;;
5392   *)
5393     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5394     # distro.  Eventually someone will fix this and move Insight, nee
5395     # gdbtk to a separate directory.
5396     if test -d ${srcdir}/gdb/gdbtk ; then
5397       GDB_TK="${gdb_tk}"
5398     else
5399       GDB_TK=""
5400     fi
5401     ;;
5402 esac
5403 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5404 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5405
5406 # Strip out unwanted targets.
5407
5408 # While at that, we remove Makefiles if we were started for recursive
5409 # configuration, so that the top-level Makefile reconfigures them,
5410 # like we used to do when configure itself was recursive.
5411
5412 # Loop over modules.  $extrasub must be used with care, limiting as
5413 # much as possible the usage of range addresses.  That's because autoconf
5414 # splits the sed script to overcome limits in the number of commands,
5415 # and relying on carefully-timed sed passes may turn out to be very hard
5416 # to maintain later.  In this particular case, you just have to be careful
5417 # not to nest @if/@endif pairs, because configure will not warn you at all.
5418
5419 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5420 if test "${enable_bootstrap+set}" = set; then
5421   enableval="$enable_bootstrap"
5422
5423 else
5424   enable_bootstrap=default
5425 fi;
5426
5427 # Issue errors and warnings for invalid/strange bootstrap combinations.
5428 case "$configdirs" in
5429   *gcc*) have_compiler=yes ;;
5430   *) have_compiler=no ;;
5431 esac
5432
5433 case "$have_compiler:$host:$target:$enable_bootstrap" in
5434   *:*:*:no) ;;
5435
5436   # Default behavior.  Enable bootstrap if we have a compiler
5437   # and we are in a native configuration.
5438   yes:$build:$build:default)
5439     enable_bootstrap=yes ;;
5440
5441   *:*:*:default)
5442     enable_bootstrap=no ;;
5443
5444   # We have a compiler and we are in a native configuration, bootstrap is ok
5445   yes:$build:$build:yes)
5446     ;;
5447
5448   # Other configurations, but we have a compiler.  Assume the user knows
5449   # what he's doing.
5450   yes:*:*:yes)
5451     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5452 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5453     ;;
5454
5455   # No compiler: if they passed --enable-bootstrap explicitly, fail
5456   no:*:*:yes)
5457     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5458 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5459    { (exit 1); exit 1; }; } ;;
5460
5461   # Fail if wrong command line
5462   *)
5463     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5464 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5465    { (exit 1); exit 1; }; }
5466     ;;
5467 esac
5468
5469 # Adjust the toplevel makefile according to whether bootstrap was selected.
5470 case "$enable_bootstrap" in
5471   yes)
5472     bootstrap_suffix=bootstrap ;;
5473   no)
5474     bootstrap_suffix=no-bootstrap ;;
5475 esac
5476
5477 for module in ${build_configdirs} ; do
5478   if test -z "${no_recursion}" \
5479      && test -f ${build_subdir}/${module}/Makefile; then
5480     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5481     rm -f ${build_subdir}/${module}/Makefile
5482   fi
5483   extrasub="$extrasub
5484 /^@if build-$module\$/d
5485 /^@endif build-$module\$/d
5486 /^@if build-$module-$bootstrap_suffix\$/d
5487 /^@endif build-$module-$bootstrap_suffix\$/d"
5488 done
5489 for module in ${configdirs} ; do
5490   if test -z "${no_recursion}"; then
5491     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5492       if test -f ${file}; then
5493         echo 1>&2 "*** removing ${file} to force reconfigure"
5494         rm -f ${file}
5495       fi
5496     done
5497   fi
5498   extrasub="$extrasub
5499 /^@if $module\$/d
5500 /^@endif $module\$/d
5501 /^@if $module-$bootstrap_suffix\$/d
5502 /^@endif $module-$bootstrap_suffix\$/d"
5503 done
5504 for module in ${target_configdirs} ; do
5505   if test -z "${no_recursion}" \
5506      && test -f ${target_subdir}/${module}/Makefile; then
5507     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5508     rm -f ${target_subdir}/${module}/Makefile
5509   fi
5510   extrasub="$extrasub
5511 /^@if target-$module\$/d
5512 /^@endif target-$module\$/d
5513 /^@if target-$module-$bootstrap_suffix\$/d
5514 /^@endif target-$module-$bootstrap_suffix\$/d"
5515 done
5516
5517 extrasub="$extrasub
5518 /^@if /,/^@endif /d"
5519
5520 # Create the serialization dependencies.  This uses a temporary file.
5521
5522 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5523 if test "${enable_serial_configure+set}" = set; then
5524   enableval="$enable_serial_configure"
5525
5526 fi;
5527
5528 case ${enable_serial_configure} in
5529   yes)
5530     enable_serial_build_configure=yes
5531     enable_serial_host_configure=yes
5532     enable_serial_target_configure=yes
5533     ;;
5534 esac
5535
5536 # These force 'configure's to be done one at a time, to avoid problems
5537 # with contention over a shared config.cache.
5538 rm -f serdep.tmp
5539 echo '# serdep.tmp' > serdep.tmp
5540 olditem=
5541 test "x${enable_serial_build_configure}" = xyes &&
5542 for item in ${build_configdirs} ; do
5543   case ${olditem} in
5544     "") ;;
5545     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5546   esac
5547   olditem=${item}
5548 done
5549 olditem=
5550 test "x${enable_serial_host_configure}" = xyes &&
5551 for item in ${configdirs} ; do
5552   case ${olditem} in
5553     "") ;;
5554     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5555   esac
5556   olditem=${item}
5557 done
5558 olditem=
5559 test "x${enable_serial_target_configure}" = xyes &&
5560 for item in ${target_configdirs} ; do
5561   case ${olditem} in
5562     "") ;;
5563     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5564   esac
5565   olditem=${item}
5566 done
5567 serialization_dependencies=serdep.tmp
5568
5569
5570 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5571 # target, nonopt, and variable assignments.  These are the ones we
5572 # might not want to pass down to subconfigures.  Also strip
5573 # program-prefix, program-suffix, and program-transform-name, so that
5574 # we can pass down a consistent program-transform-name.
5575 baseargs=
5576 keep_next=no
5577 skip_next=no
5578 eval "set -- $ac_configure_args"
5579 for ac_arg
5580 do
5581   if test X"$skip_next" = X"yes"; then
5582     skip_next=no
5583     continue
5584   fi
5585   if test X"$keep_next" = X"yes"; then
5586     case $ac_arg in
5587       *\'*)
5588         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5589     esac
5590     baseargs="$baseargs '$ac_arg'"
5591     keep_next=no
5592     continue
5593   fi
5594
5595   # Handle separated arguments.  Based on the logic generated by
5596   # autoconf 2.59.
5597   case $ac_arg in
5598     *=* | --config-cache | -C | -disable-* | --disable-* \
5599       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5600       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5601       | -with-* | --with-* | -without-* | --without-* | --x)
5602       separate_arg=no
5603       ;;
5604     -*)
5605       separate_arg=yes
5606       ;;
5607     *)
5608       separate_arg=no
5609       ;;
5610   esac
5611
5612   case "$ac_arg" in
5613     --no*)
5614       continue
5615       ;;
5616     --c* | \
5617     --sr* | \
5618     --ho* | \
5619     --bu* | \
5620     --t* | \
5621     --program-* | \
5622     -cache_file* | \
5623     -srcdir* | \
5624     -host* | \
5625     -build* | \
5626     -target* | \
5627     -program-prefix* | \
5628     -program-suffix* | \
5629     -program-transform-name* )
5630       skip_next=$separate_arg
5631       continue
5632       ;;
5633     -*)
5634       # An option.  Add it.
5635       case $ac_arg in
5636         *\'*)
5637           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5638       esac
5639       baseargs="$baseargs '$ac_arg'"
5640       keep_next=$separate_arg
5641       ;;
5642     *)
5643       # Either a variable assignment, or a nonopt (triplet).  Don't
5644       # pass it down; let the Makefile handle this.
5645       continue
5646       ;;
5647   esac
5648 done
5649 # Remove the initial space we just introduced and, as these will be
5650 # expanded by make, quote '$'.
5651 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5652
5653 # Add in --program-transform-name, after --program-prefix and
5654 # --program-suffix have been applied to it.  Autoconf has already
5655 # doubled dollar signs and backslashes in program_transform_name; we want
5656 # the backslashes un-doubled, and then the entire thing wrapped in single
5657 # quotes, because this will be expanded first by make and then by the shell.
5658 # Also, because we want to override the logic in subdir configure scripts to
5659 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5660 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5661 ${program_transform_name}
5662 EOF_SED
5663 gcc_transform_name=`cat conftestsed.out`
5664 rm -f conftestsed.out
5665 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5666
5667 # For the build-side libraries, we just need to pretend we're native,
5668 # and not use the same cache file.  Multilibs are neither needed nor
5669 # desired.
5670 build_configargs="--cache-file=../config.cache ${baseargs}"
5671
5672 # For host modules, accept cache file option, or specification as blank.
5673 case "${cache_file}" in
5674 "") # empty
5675   cache_file_option="" ;;
5676 /* | [A-Za-z]:[\\/]* ) # absolute path
5677   cache_file_option="--cache-file=${cache_file}" ;;
5678 *) # relative path
5679   cache_file_option="--cache-file=../${cache_file}" ;;
5680 esac
5681
5682 # Host dirs don't like to share a cache file either, horribly enough.
5683 # This seems to be due to autoconf 2.5x stupidity.
5684 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5685
5686 target_configargs=${baseargs}
5687
5688 # Passing a --with-cross-host argument lets the target libraries know
5689 # whether they are being built with a cross-compiler or being built
5690 # native.  However, it would be better to use other mechanisms to make the
5691 # sorts of decisions they want to make on this basis.  Please consider
5692 # this option to be deprecated.  FIXME.
5693 if test x${is_cross_compiler} = xyes ; then
5694   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5695 fi
5696
5697 # Default to --enable-multilib.
5698 if test x${enable_multilib} = x ; then
5699   target_configargs="--enable-multilib ${target_configargs}"
5700 fi
5701
5702 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5703 # changed from the earlier setting of with_newlib.
5704 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5705   target_configargs="--with-newlib ${target_configargs}"
5706 fi
5707
5708 # Different target subdirs use different values of certain variables
5709 # (notably CXX).  Worse, multilibs use *lots* of different values.
5710 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5711 # it doesn't automatically accept command-line overrides of them.
5712 # This means it's not safe for target subdirs to share a cache file,
5713 # which is disgusting, but there you have it.  Hopefully this can be
5714 # fixed in future.  It's still worthwhile to use a cache file for each
5715 # directory.  I think.
5716
5717 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5718 # We need to pass --target, as newer autoconf's requires consistency
5719 # for target_alias and gcc doesn't manage it consistently.
5720 target_configargs="--cache-file=./config.cache ${target_configargs}"
5721
5722 FLAGS_FOR_TARGET=
5723 case " $target_configdirs " in
5724  *" newlib "*)
5725   case " $target_configargs " in
5726   *" --with-newlib "*)
5727    case "$target" in
5728    *-cygwin*)
5729      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' ;;
5730    esac
5731
5732    # If we're not building GCC, don't discard standard headers.
5733    if test -d ${srcdir}/gcc; then
5734      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5735
5736      if test "${build}" != "${host}"; then
5737        # On Canadian crosses, CC_FOR_TARGET will have already been set
5738        # by `configure', so we won't have an opportunity to add -Bgcc/
5739        # to it.  This is right: we don't want to search that directory
5740        # for binaries, but we want the header files in there, so add
5741        # them explicitly.
5742        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5743
5744        # Someone might think of using the pre-installed headers on
5745        # Canadian crosses, in case the installed compiler is not fully
5746        # compatible with the compiler being built.  In this case, it
5747        # would be better to flag an error than risking having
5748        # incompatible object files being constructed.  We can't
5749        # guarantee that an error will be flagged, but let's hope the
5750        # compiler will do it, when presented with incompatible header
5751        # files.
5752      fi
5753    fi
5754
5755    case "${target}-${is_cross_compiler}" in
5756    i[3456789]86-*-linux*-no)
5757       # Here host == target, so we don't need to build gcc,
5758       # so we don't want to discard standard headers.
5759       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5760       ;;
5761    *)
5762       # If we're building newlib, use its generic headers last, but search
5763       # for any libc-related directories first (so make it the last -B
5764       # switch).
5765       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5766       ;;
5767    esac
5768    ;;
5769   esac
5770   ;;
5771 esac
5772 case "$target" in
5773 *-mingw*)
5774   # Can't be handled as Cygwin above since Mingw does not use newlib.
5775   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' ;;
5776 esac
5777
5778 # Allow the user to override the flags for
5779 # our build compiler if desired.
5780 CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5781
5782 # On Canadian crosses, we'll be searching the right directories for
5783 # the previously-installed cross compiler, so don't bother to add
5784 # flags for directories within the install tree of the compiler
5785 # being built; programs in there won't even run.
5786 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5787   # Search for pre-installed headers if nothing else fits.
5788   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5789 fi
5790
5791 if test "x${use_gnu_ld}" = x &&
5792    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5793   # Arrange for us to find uninstalled linker scripts.
5794   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5795 fi
5796
5797 # Search for other target-specific linker scripts and such.
5798 case "${target}" in
5799   m32c-*-* )
5800     if test -d ${srcdir}/libgloss/m32c; then
5801       # This is for crt0.o
5802       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5803       # This is for r8c.ld
5804       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5805       # This is for libnosys.a
5806       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5807     fi
5808     ;;
5809   mep*)
5810     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5811     ;;
5812 esac
5813
5814 # Makefile fragments.
5815 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5816 do
5817   eval fragval=\$$frag
5818   if test $fragval != /dev/null; then
5819     eval $frag=${srcdir}/$fragval
5820   fi
5821 done
5822
5823
5824
5825
5826
5827 # Miscellanea: directories, flags, etc.
5828
5829
5830
5831
5832
5833
5834
5835 # Build module lists & subconfigure args.
5836
5837
5838
5839 # Host module lists & subconfigure args.
5840
5841
5842
5843 # Target module lists & subconfigure args.
5844
5845
5846
5847 # Build tools.
5848
5849
5850
5851 # Generate default definitions for YACC, M4, LEX and other programs that run
5852 # on the build machine.  These are used if the Makefile can't locate these
5853 # programs in objdir.
5854 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5855
5856 for ac_prog in 'bison -y' byacc yacc
5857 do
5858   # Extract the first word of "$ac_prog", so it can be a program name with args.
5859 set dummy $ac_prog; ac_word=$2
5860 echo "$as_me:$LINENO: checking for $ac_word" >&5
5861 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5862 if test "${ac_cv_prog_YACC+set}" = set; then
5863   echo $ECHO_N "(cached) $ECHO_C" >&6
5864 else
5865   if test -n "$YACC"; then
5866   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5867 else
5868 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5869 for as_dir in $PATH
5870 do
5871   IFS=$as_save_IFS
5872   test -z "$as_dir" && as_dir=.
5873   for ac_exec_ext in '' $ac_executable_extensions; do
5874   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5875     ac_cv_prog_YACC="$ac_prog"
5876     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5877     break 2
5878   fi
5879 done
5880 done
5881
5882 fi
5883 fi
5884 YACC=$ac_cv_prog_YACC
5885 if test -n "$YACC"; then
5886   echo "$as_me:$LINENO: result: $YACC" >&5
5887 echo "${ECHO_T}$YACC" >&6
5888 else
5889   echo "$as_me:$LINENO: result: no" >&5
5890 echo "${ECHO_T}no" >&6
5891 fi
5892
5893   test -n "$YACC" && break
5894 done
5895 test -n "$YACC" || YACC="$MISSING bison -y"
5896
5897 case " $build_configdirs " in
5898   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
5899   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
5900 esac
5901
5902 for ac_prog in bison
5903 do
5904   # Extract the first word of "$ac_prog", so it can be a program name with args.
5905 set dummy $ac_prog; ac_word=$2
5906 echo "$as_me:$LINENO: checking for $ac_word" >&5
5907 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5908 if test "${ac_cv_prog_BISON+set}" = set; then
5909   echo $ECHO_N "(cached) $ECHO_C" >&6
5910 else
5911   if test -n "$BISON"; then
5912   ac_cv_prog_BISON="$BISON" # Let the user override the test.
5913 else
5914 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5915 for as_dir in $PATH
5916 do
5917   IFS=$as_save_IFS
5918   test -z "$as_dir" && as_dir=.
5919   for ac_exec_ext in '' $ac_executable_extensions; do
5920   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5921     ac_cv_prog_BISON="$ac_prog"
5922     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5923     break 2
5924   fi
5925 done
5926 done
5927
5928 fi
5929 fi
5930 BISON=$ac_cv_prog_BISON
5931 if test -n "$BISON"; then
5932   echo "$as_me:$LINENO: result: $BISON" >&5
5933 echo "${ECHO_T}$BISON" >&6
5934 else
5935   echo "$as_me:$LINENO: result: no" >&5
5936 echo "${ECHO_T}no" >&6
5937 fi
5938
5939   test -n "$BISON" && break
5940 done
5941 test -n "$BISON" || BISON="$MISSING bison"
5942
5943 case " $build_configdirs " in
5944   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
5945 esac
5946
5947 for ac_prog in gm4 gnum4 m4
5948 do
5949   # Extract the first word of "$ac_prog", so it can be a program name with args.
5950 set dummy $ac_prog; ac_word=$2
5951 echo "$as_me:$LINENO: checking for $ac_word" >&5
5952 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5953 if test "${ac_cv_prog_M4+set}" = set; then
5954   echo $ECHO_N "(cached) $ECHO_C" >&6
5955 else
5956   if test -n "$M4"; then
5957   ac_cv_prog_M4="$M4" # Let the user override the test.
5958 else
5959 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5960 for as_dir in $PATH
5961 do
5962   IFS=$as_save_IFS
5963   test -z "$as_dir" && as_dir=.
5964   for ac_exec_ext in '' $ac_executable_extensions; do
5965   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5966     ac_cv_prog_M4="$ac_prog"
5967     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5968     break 2
5969   fi
5970 done
5971 done
5972
5973 fi
5974 fi
5975 M4=$ac_cv_prog_M4
5976 if test -n "$M4"; then
5977   echo "$as_me:$LINENO: result: $M4" >&5
5978 echo "${ECHO_T}$M4" >&6
5979 else
5980   echo "$as_me:$LINENO: result: no" >&5
5981 echo "${ECHO_T}no" >&6
5982 fi
5983
5984   test -n "$M4" && break
5985 done
5986 test -n "$M4" || M4="$MISSING m4"
5987
5988 case " $build_configdirs " in
5989   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
5990 esac
5991
5992 for ac_prog in flex lex
5993 do
5994   # Extract the first word of "$ac_prog", so it can be a program name with args.
5995 set dummy $ac_prog; ac_word=$2
5996 echo "$as_me:$LINENO: checking for $ac_word" >&5
5997 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5998 if test "${ac_cv_prog_LEX+set}" = set; then
5999   echo $ECHO_N "(cached) $ECHO_C" >&6
6000 else
6001   if test -n "$LEX"; then
6002   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6003 else
6004 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6005 for as_dir in $PATH
6006 do
6007   IFS=$as_save_IFS
6008   test -z "$as_dir" && as_dir=.
6009   for ac_exec_ext in '' $ac_executable_extensions; do
6010   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6011     ac_cv_prog_LEX="$ac_prog"
6012     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6013     break 2
6014   fi
6015 done
6016 done
6017
6018 fi
6019 fi
6020 LEX=$ac_cv_prog_LEX
6021 if test -n "$LEX"; then
6022   echo "$as_me:$LINENO: result: $LEX" >&5
6023 echo "${ECHO_T}$LEX" >&6
6024 else
6025   echo "$as_me:$LINENO: result: no" >&5
6026 echo "${ECHO_T}no" >&6
6027 fi
6028
6029   test -n "$LEX" && break
6030 done
6031 test -n "$LEX" || LEX="$MISSING flex"
6032
6033 case " $build_configdirs " in
6034   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6035   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6036 esac
6037
6038 for ac_prog in flex
6039 do
6040   # Extract the first word of "$ac_prog", so it can be a program name with args.
6041 set dummy $ac_prog; ac_word=$2
6042 echo "$as_me:$LINENO: checking for $ac_word" >&5
6043 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6044 if test "${ac_cv_prog_FLEX+set}" = set; then
6045   echo $ECHO_N "(cached) $ECHO_C" >&6
6046 else
6047   if test -n "$FLEX"; then
6048   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6049 else
6050 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6051 for as_dir in $PATH
6052 do
6053   IFS=$as_save_IFS
6054   test -z "$as_dir" && as_dir=.
6055   for ac_exec_ext in '' $ac_executable_extensions; do
6056   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6057     ac_cv_prog_FLEX="$ac_prog"
6058     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6059     break 2
6060   fi
6061 done
6062 done
6063
6064 fi
6065 fi
6066 FLEX=$ac_cv_prog_FLEX
6067 if test -n "$FLEX"; then
6068   echo "$as_me:$LINENO: result: $FLEX" >&5
6069 echo "${ECHO_T}$FLEX" >&6
6070 else
6071   echo "$as_me:$LINENO: result: no" >&5
6072 echo "${ECHO_T}no" >&6
6073 fi
6074
6075   test -n "$FLEX" && break
6076 done
6077 test -n "$FLEX" || FLEX="$MISSING flex"
6078
6079 case " $build_configdirs " in
6080   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6081 esac
6082
6083 for ac_prog in makeinfo
6084 do
6085   # Extract the first word of "$ac_prog", so it can be a program name with args.
6086 set dummy $ac_prog; ac_word=$2
6087 echo "$as_me:$LINENO: checking for $ac_word" >&5
6088 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6089 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6090   echo $ECHO_N "(cached) $ECHO_C" >&6
6091 else
6092   if test -n "$MAKEINFO"; then
6093   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6094 else
6095 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6096 for as_dir in $PATH
6097 do
6098   IFS=$as_save_IFS
6099   test -z "$as_dir" && as_dir=.
6100   for ac_exec_ext in '' $ac_executable_extensions; do
6101   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6102     ac_cv_prog_MAKEINFO="$ac_prog"
6103     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6104     break 2
6105   fi
6106 done
6107 done
6108
6109 fi
6110 fi
6111 MAKEINFO=$ac_cv_prog_MAKEINFO
6112 if test -n "$MAKEINFO"; then
6113   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6114 echo "${ECHO_T}$MAKEINFO" >&6
6115 else
6116   echo "$as_me:$LINENO: result: no" >&5
6117 echo "${ECHO_T}no" >&6
6118 fi
6119
6120   test -n "$MAKEINFO" && break
6121 done
6122 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6123
6124 case " $build_configdirs " in
6125   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6126   *)
6127
6128     # For an installed makeinfo, we require it to be from texinfo 4.4 or
6129     # higher, else we use the "missing" dummy.
6130     if ${MAKEINFO} --version \
6131        | egrep 'texinfo[^0-9]*([1-3][0-9]|4\.[4-9]|[5-9])' >/dev/null 2>&1; then
6132       :
6133     else
6134       MAKEINFO="$MISSING makeinfo"
6135     fi
6136     ;;
6137
6138 esac
6139
6140 # FIXME: expect and dejagnu may become build tools?
6141
6142 for ac_prog in expect
6143 do
6144   # Extract the first word of "$ac_prog", so it can be a program name with args.
6145 set dummy $ac_prog; ac_word=$2
6146 echo "$as_me:$LINENO: checking for $ac_word" >&5
6147 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6148 if test "${ac_cv_prog_EXPECT+set}" = set; then
6149   echo $ECHO_N "(cached) $ECHO_C" >&6
6150 else
6151   if test -n "$EXPECT"; then
6152   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6153 else
6154 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6155 for as_dir in $PATH
6156 do
6157   IFS=$as_save_IFS
6158   test -z "$as_dir" && as_dir=.
6159   for ac_exec_ext in '' $ac_executable_extensions; do
6160   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6161     ac_cv_prog_EXPECT="$ac_prog"
6162     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6163     break 2
6164   fi
6165 done
6166 done
6167
6168 fi
6169 fi
6170 EXPECT=$ac_cv_prog_EXPECT
6171 if test -n "$EXPECT"; then
6172   echo "$as_me:$LINENO: result: $EXPECT" >&5
6173 echo "${ECHO_T}$EXPECT" >&6
6174 else
6175   echo "$as_me:$LINENO: result: no" >&5
6176 echo "${ECHO_T}no" >&6
6177 fi
6178
6179   test -n "$EXPECT" && break
6180 done
6181 test -n "$EXPECT" || EXPECT="expect"
6182
6183 case " $configdirs " in
6184   *" expect "*)
6185     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6186     ;;
6187 esac
6188
6189 for ac_prog in runtest
6190 do
6191   # Extract the first word of "$ac_prog", so it can be a program name with args.
6192 set dummy $ac_prog; ac_word=$2
6193 echo "$as_me:$LINENO: checking for $ac_word" >&5
6194 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6195 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6196   echo $ECHO_N "(cached) $ECHO_C" >&6
6197 else
6198   if test -n "$RUNTEST"; then
6199   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6200 else
6201 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6202 for as_dir in $PATH
6203 do
6204   IFS=$as_save_IFS
6205   test -z "$as_dir" && as_dir=.
6206   for ac_exec_ext in '' $ac_executable_extensions; do
6207   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6208     ac_cv_prog_RUNTEST="$ac_prog"
6209     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6210     break 2
6211   fi
6212 done
6213 done
6214
6215 fi
6216 fi
6217 RUNTEST=$ac_cv_prog_RUNTEST
6218 if test -n "$RUNTEST"; then
6219   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6220 echo "${ECHO_T}$RUNTEST" >&6
6221 else
6222   echo "$as_me:$LINENO: result: no" >&5
6223 echo "${ECHO_T}no" >&6
6224 fi
6225
6226   test -n "$RUNTEST" && break
6227 done
6228 test -n "$RUNTEST" || RUNTEST="runtest"
6229
6230 case " $configdirs " in
6231   *" dejagnu "*)
6232     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6233     ;;
6234 esac
6235
6236
6237 # Host tools.
6238 ncn_tool_prefix=
6239 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6240 ncn_target_tool_prefix=
6241 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6242
6243
6244
6245 if test -n "$AR"; then
6246   ac_cv_prog_AR=$AR
6247 elif test -n "$ac_cv_prog_AR"; then
6248   AR=$ac_cv_prog_AR
6249 fi
6250
6251 if test -n "$ac_cv_prog_AR"; then
6252   for ncn_progname in ar; do
6253     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6254 set dummy ${ncn_progname}; ac_word=$2
6255 echo "$as_me:$LINENO: checking for $ac_word" >&5
6256 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6257 if test "${ac_cv_prog_AR+set}" = set; then
6258   echo $ECHO_N "(cached) $ECHO_C" >&6
6259 else
6260   if test -n "$AR"; then
6261   ac_cv_prog_AR="$AR" # Let the user override the test.
6262 else
6263 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6264 for as_dir in $PATH
6265 do
6266   IFS=$as_save_IFS
6267   test -z "$as_dir" && as_dir=.
6268   for ac_exec_ext in '' $ac_executable_extensions; do
6269   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6270     ac_cv_prog_AR="${ncn_progname}"
6271     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6272     break 2
6273   fi
6274 done
6275 done
6276
6277 fi
6278 fi
6279 AR=$ac_cv_prog_AR
6280 if test -n "$AR"; then
6281   echo "$as_me:$LINENO: result: $AR" >&5
6282 echo "${ECHO_T}$AR" >&6
6283 else
6284   echo "$as_me:$LINENO: result: no" >&5
6285 echo "${ECHO_T}no" >&6
6286 fi
6287
6288   done
6289 fi
6290
6291 for ncn_progname in ar; do
6292   if test -n "$ncn_tool_prefix"; then
6293     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6294 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6295 echo "$as_me:$LINENO: checking for $ac_word" >&5
6296 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6297 if test "${ac_cv_prog_AR+set}" = set; then
6298   echo $ECHO_N "(cached) $ECHO_C" >&6
6299 else
6300   if test -n "$AR"; then
6301   ac_cv_prog_AR="$AR" # Let the user override the test.
6302 else
6303 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6304 for as_dir in $PATH
6305 do
6306   IFS=$as_save_IFS
6307   test -z "$as_dir" && as_dir=.
6308   for ac_exec_ext in '' $ac_executable_extensions; do
6309   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6310     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6311     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6312     break 2
6313   fi
6314 done
6315 done
6316
6317 fi
6318 fi
6319 AR=$ac_cv_prog_AR
6320 if test -n "$AR"; then
6321   echo "$as_me:$LINENO: result: $AR" >&5
6322 echo "${ECHO_T}$AR" >&6
6323 else
6324   echo "$as_me:$LINENO: result: no" >&5
6325 echo "${ECHO_T}no" >&6
6326 fi
6327
6328   fi
6329   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6330     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6331 set dummy ${ncn_progname}; ac_word=$2
6332 echo "$as_me:$LINENO: checking for $ac_word" >&5
6333 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6334 if test "${ac_cv_prog_AR+set}" = set; then
6335   echo $ECHO_N "(cached) $ECHO_C" >&6
6336 else
6337   if test -n "$AR"; then
6338   ac_cv_prog_AR="$AR" # Let the user override the test.
6339 else
6340 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6341 for as_dir in $PATH
6342 do
6343   IFS=$as_save_IFS
6344   test -z "$as_dir" && as_dir=.
6345   for ac_exec_ext in '' $ac_executable_extensions; do
6346   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6347     ac_cv_prog_AR="${ncn_progname}"
6348     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6349     break 2
6350   fi
6351 done
6352 done
6353
6354 fi
6355 fi
6356 AR=$ac_cv_prog_AR
6357 if test -n "$AR"; then
6358   echo "$as_me:$LINENO: result: $AR" >&5
6359 echo "${ECHO_T}$AR" >&6
6360 else
6361   echo "$as_me:$LINENO: result: no" >&5
6362 echo "${ECHO_T}no" >&6
6363 fi
6364
6365   fi
6366   test -n "$ac_cv_prog_AR" && break
6367 done
6368
6369 if test -z "$ac_cv_prog_AR" ; then
6370   set dummy ar
6371   if test $build = $host ; then
6372     AR="$2"
6373   else
6374     AR="${ncn_tool_prefix}$2"
6375   fi
6376 fi
6377
6378
6379
6380 if test -n "$AS"; then
6381   ac_cv_prog_AS=$AS
6382 elif test -n "$ac_cv_prog_AS"; then
6383   AS=$ac_cv_prog_AS
6384 fi
6385
6386 if test -n "$ac_cv_prog_AS"; then
6387   for ncn_progname in as; do
6388     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6389 set dummy ${ncn_progname}; ac_word=$2
6390 echo "$as_me:$LINENO: checking for $ac_word" >&5
6391 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6392 if test "${ac_cv_prog_AS+set}" = set; then
6393   echo $ECHO_N "(cached) $ECHO_C" >&6
6394 else
6395   if test -n "$AS"; then
6396   ac_cv_prog_AS="$AS" # Let the user override the test.
6397 else
6398 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6399 for as_dir in $PATH
6400 do
6401   IFS=$as_save_IFS
6402   test -z "$as_dir" && as_dir=.
6403   for ac_exec_ext in '' $ac_executable_extensions; do
6404   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6405     ac_cv_prog_AS="${ncn_progname}"
6406     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6407     break 2
6408   fi
6409 done
6410 done
6411
6412 fi
6413 fi
6414 AS=$ac_cv_prog_AS
6415 if test -n "$AS"; then
6416   echo "$as_me:$LINENO: result: $AS" >&5
6417 echo "${ECHO_T}$AS" >&6
6418 else
6419   echo "$as_me:$LINENO: result: no" >&5
6420 echo "${ECHO_T}no" >&6
6421 fi
6422
6423   done
6424 fi
6425
6426 for ncn_progname in as; do
6427   if test -n "$ncn_tool_prefix"; then
6428     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6429 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6430 echo "$as_me:$LINENO: checking for $ac_word" >&5
6431 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6432 if test "${ac_cv_prog_AS+set}" = set; then
6433   echo $ECHO_N "(cached) $ECHO_C" >&6
6434 else
6435   if test -n "$AS"; then
6436   ac_cv_prog_AS="$AS" # Let the user override the test.
6437 else
6438 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6439 for as_dir in $PATH
6440 do
6441   IFS=$as_save_IFS
6442   test -z "$as_dir" && as_dir=.
6443   for ac_exec_ext in '' $ac_executable_extensions; do
6444   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6445     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6446     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6447     break 2
6448   fi
6449 done
6450 done
6451
6452 fi
6453 fi
6454 AS=$ac_cv_prog_AS
6455 if test -n "$AS"; then
6456   echo "$as_me:$LINENO: result: $AS" >&5
6457 echo "${ECHO_T}$AS" >&6
6458 else
6459   echo "$as_me:$LINENO: result: no" >&5
6460 echo "${ECHO_T}no" >&6
6461 fi
6462
6463   fi
6464   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6465     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6466 set dummy ${ncn_progname}; ac_word=$2
6467 echo "$as_me:$LINENO: checking for $ac_word" >&5
6468 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6469 if test "${ac_cv_prog_AS+set}" = set; then
6470   echo $ECHO_N "(cached) $ECHO_C" >&6
6471 else
6472   if test -n "$AS"; then
6473   ac_cv_prog_AS="$AS" # Let the user override the test.
6474 else
6475 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6476 for as_dir in $PATH
6477 do
6478   IFS=$as_save_IFS
6479   test -z "$as_dir" && as_dir=.
6480   for ac_exec_ext in '' $ac_executable_extensions; do
6481   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6482     ac_cv_prog_AS="${ncn_progname}"
6483     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6484     break 2
6485   fi
6486 done
6487 done
6488
6489 fi
6490 fi
6491 AS=$ac_cv_prog_AS
6492 if test -n "$AS"; then
6493   echo "$as_me:$LINENO: result: $AS" >&5
6494 echo "${ECHO_T}$AS" >&6
6495 else
6496   echo "$as_me:$LINENO: result: no" >&5
6497 echo "${ECHO_T}no" >&6
6498 fi
6499
6500   fi
6501   test -n "$ac_cv_prog_AS" && break
6502 done
6503
6504 if test -z "$ac_cv_prog_AS" ; then
6505   set dummy as
6506   if test $build = $host ; then
6507     AS="$2"
6508   else
6509     AS="${ncn_tool_prefix}$2"
6510   fi
6511 fi
6512
6513
6514
6515 if test -n "$DLLTOOL"; then
6516   ac_cv_prog_DLLTOOL=$DLLTOOL
6517 elif test -n "$ac_cv_prog_DLLTOOL"; then
6518   DLLTOOL=$ac_cv_prog_DLLTOOL
6519 fi
6520
6521 if test -n "$ac_cv_prog_DLLTOOL"; then
6522   for ncn_progname in dlltool; do
6523     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6524 set dummy ${ncn_progname}; ac_word=$2
6525 echo "$as_me:$LINENO: checking for $ac_word" >&5
6526 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6527 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6528   echo $ECHO_N "(cached) $ECHO_C" >&6
6529 else
6530   if test -n "$DLLTOOL"; then
6531   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6532 else
6533 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6534 for as_dir in $PATH
6535 do
6536   IFS=$as_save_IFS
6537   test -z "$as_dir" && as_dir=.
6538   for ac_exec_ext in '' $ac_executable_extensions; do
6539   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6540     ac_cv_prog_DLLTOOL="${ncn_progname}"
6541     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6542     break 2
6543   fi
6544 done
6545 done
6546
6547 fi
6548 fi
6549 DLLTOOL=$ac_cv_prog_DLLTOOL
6550 if test -n "$DLLTOOL"; then
6551   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6552 echo "${ECHO_T}$DLLTOOL" >&6
6553 else
6554   echo "$as_me:$LINENO: result: no" >&5
6555 echo "${ECHO_T}no" >&6
6556 fi
6557
6558   done
6559 fi
6560
6561 for ncn_progname in dlltool; do
6562   if test -n "$ncn_tool_prefix"; then
6563     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6564 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6565 echo "$as_me:$LINENO: checking for $ac_word" >&5
6566 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6567 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6568   echo $ECHO_N "(cached) $ECHO_C" >&6
6569 else
6570   if test -n "$DLLTOOL"; then
6571   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6572 else
6573 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6574 for as_dir in $PATH
6575 do
6576   IFS=$as_save_IFS
6577   test -z "$as_dir" && as_dir=.
6578   for ac_exec_ext in '' $ac_executable_extensions; do
6579   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6580     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6581     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6582     break 2
6583   fi
6584 done
6585 done
6586
6587 fi
6588 fi
6589 DLLTOOL=$ac_cv_prog_DLLTOOL
6590 if test -n "$DLLTOOL"; then
6591   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6592 echo "${ECHO_T}$DLLTOOL" >&6
6593 else
6594   echo "$as_me:$LINENO: result: no" >&5
6595 echo "${ECHO_T}no" >&6
6596 fi
6597
6598   fi
6599   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6600     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6601 set dummy ${ncn_progname}; ac_word=$2
6602 echo "$as_me:$LINENO: checking for $ac_word" >&5
6603 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6604 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6605   echo $ECHO_N "(cached) $ECHO_C" >&6
6606 else
6607   if test -n "$DLLTOOL"; then
6608   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6609 else
6610 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6611 for as_dir in $PATH
6612 do
6613   IFS=$as_save_IFS
6614   test -z "$as_dir" && as_dir=.
6615   for ac_exec_ext in '' $ac_executable_extensions; do
6616   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6617     ac_cv_prog_DLLTOOL="${ncn_progname}"
6618     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6619     break 2
6620   fi
6621 done
6622 done
6623
6624 fi
6625 fi
6626 DLLTOOL=$ac_cv_prog_DLLTOOL
6627 if test -n "$DLLTOOL"; then
6628   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6629 echo "${ECHO_T}$DLLTOOL" >&6
6630 else
6631   echo "$as_me:$LINENO: result: no" >&5
6632 echo "${ECHO_T}no" >&6
6633 fi
6634
6635   fi
6636   test -n "$ac_cv_prog_DLLTOOL" && break
6637 done
6638
6639 if test -z "$ac_cv_prog_DLLTOOL" ; then
6640   set dummy dlltool
6641   if test $build = $host ; then
6642     DLLTOOL="$2"
6643   else
6644     DLLTOOL="${ncn_tool_prefix}$2"
6645   fi
6646 fi
6647
6648
6649
6650 if test -n "$LD"; then
6651   ac_cv_prog_LD=$LD
6652 elif test -n "$ac_cv_prog_LD"; then
6653   LD=$ac_cv_prog_LD
6654 fi
6655
6656 if test -n "$ac_cv_prog_LD"; then
6657   for ncn_progname in ld; do
6658     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6659 set dummy ${ncn_progname}; ac_word=$2
6660 echo "$as_me:$LINENO: checking for $ac_word" >&5
6661 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6662 if test "${ac_cv_prog_LD+set}" = set; then
6663   echo $ECHO_N "(cached) $ECHO_C" >&6
6664 else
6665   if test -n "$LD"; then
6666   ac_cv_prog_LD="$LD" # Let the user override the test.
6667 else
6668 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6669 for as_dir in $PATH
6670 do
6671   IFS=$as_save_IFS
6672   test -z "$as_dir" && as_dir=.
6673   for ac_exec_ext in '' $ac_executable_extensions; do
6674   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6675     ac_cv_prog_LD="${ncn_progname}"
6676     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6677     break 2
6678   fi
6679 done
6680 done
6681
6682 fi
6683 fi
6684 LD=$ac_cv_prog_LD
6685 if test -n "$LD"; then
6686   echo "$as_me:$LINENO: result: $LD" >&5
6687 echo "${ECHO_T}$LD" >&6
6688 else
6689   echo "$as_me:$LINENO: result: no" >&5
6690 echo "${ECHO_T}no" >&6
6691 fi
6692
6693   done
6694 fi
6695
6696 for ncn_progname in ld; do
6697   if test -n "$ncn_tool_prefix"; then
6698     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6699 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6700 echo "$as_me:$LINENO: checking for $ac_word" >&5
6701 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6702 if test "${ac_cv_prog_LD+set}" = set; then
6703   echo $ECHO_N "(cached) $ECHO_C" >&6
6704 else
6705   if test -n "$LD"; then
6706   ac_cv_prog_LD="$LD" # Let the user override the test.
6707 else
6708 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6709 for as_dir in $PATH
6710 do
6711   IFS=$as_save_IFS
6712   test -z "$as_dir" && as_dir=.
6713   for ac_exec_ext in '' $ac_executable_extensions; do
6714   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6715     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6716     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6717     break 2
6718   fi
6719 done
6720 done
6721
6722 fi
6723 fi
6724 LD=$ac_cv_prog_LD
6725 if test -n "$LD"; then
6726   echo "$as_me:$LINENO: result: $LD" >&5
6727 echo "${ECHO_T}$LD" >&6
6728 else
6729   echo "$as_me:$LINENO: result: no" >&5
6730 echo "${ECHO_T}no" >&6
6731 fi
6732
6733   fi
6734   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6735     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6736 set dummy ${ncn_progname}; ac_word=$2
6737 echo "$as_me:$LINENO: checking for $ac_word" >&5
6738 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6739 if test "${ac_cv_prog_LD+set}" = set; then
6740   echo $ECHO_N "(cached) $ECHO_C" >&6
6741 else
6742   if test -n "$LD"; then
6743   ac_cv_prog_LD="$LD" # Let the user override the test.
6744 else
6745 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6746 for as_dir in $PATH
6747 do
6748   IFS=$as_save_IFS
6749   test -z "$as_dir" && as_dir=.
6750   for ac_exec_ext in '' $ac_executable_extensions; do
6751   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6752     ac_cv_prog_LD="${ncn_progname}"
6753     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6754     break 2
6755   fi
6756 done
6757 done
6758
6759 fi
6760 fi
6761 LD=$ac_cv_prog_LD
6762 if test -n "$LD"; then
6763   echo "$as_me:$LINENO: result: $LD" >&5
6764 echo "${ECHO_T}$LD" >&6
6765 else
6766   echo "$as_me:$LINENO: result: no" >&5
6767 echo "${ECHO_T}no" >&6
6768 fi
6769
6770   fi
6771   test -n "$ac_cv_prog_LD" && break
6772 done
6773
6774 if test -z "$ac_cv_prog_LD" ; then
6775   set dummy ld
6776   if test $build = $host ; then
6777     LD="$2"
6778   else
6779     LD="${ncn_tool_prefix}$2"
6780   fi
6781 fi
6782
6783
6784
6785 if test -n "$LIPO"; then
6786   ac_cv_prog_LIPO=$LIPO
6787 elif test -n "$ac_cv_prog_LIPO"; then
6788   LIPO=$ac_cv_prog_LIPO
6789 fi
6790
6791 if test -n "$ac_cv_prog_LIPO"; then
6792   for ncn_progname in lipo; do
6793     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6794 set dummy ${ncn_progname}; ac_word=$2
6795 echo "$as_me:$LINENO: checking for $ac_word" >&5
6796 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6797 if test "${ac_cv_prog_LIPO+set}" = set; then
6798   echo $ECHO_N "(cached) $ECHO_C" >&6
6799 else
6800   if test -n "$LIPO"; then
6801   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6802 else
6803 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6804 for as_dir in $PATH
6805 do
6806   IFS=$as_save_IFS
6807   test -z "$as_dir" && as_dir=.
6808   for ac_exec_ext in '' $ac_executable_extensions; do
6809   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6810     ac_cv_prog_LIPO="${ncn_progname}"
6811     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6812     break 2
6813   fi
6814 done
6815 done
6816
6817 fi
6818 fi
6819 LIPO=$ac_cv_prog_LIPO
6820 if test -n "$LIPO"; then
6821   echo "$as_me:$LINENO: result: $LIPO" >&5
6822 echo "${ECHO_T}$LIPO" >&6
6823 else
6824   echo "$as_me:$LINENO: result: no" >&5
6825 echo "${ECHO_T}no" >&6
6826 fi
6827
6828   done
6829 fi
6830
6831 for ncn_progname in lipo; do
6832   if test -n "$ncn_tool_prefix"; then
6833     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6834 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6835 echo "$as_me:$LINENO: checking for $ac_word" >&5
6836 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6837 if test "${ac_cv_prog_LIPO+set}" = set; then
6838   echo $ECHO_N "(cached) $ECHO_C" >&6
6839 else
6840   if test -n "$LIPO"; then
6841   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6842 else
6843 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6844 for as_dir in $PATH
6845 do
6846   IFS=$as_save_IFS
6847   test -z "$as_dir" && as_dir=.
6848   for ac_exec_ext in '' $ac_executable_extensions; do
6849   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6850     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6851     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6852     break 2
6853   fi
6854 done
6855 done
6856
6857 fi
6858 fi
6859 LIPO=$ac_cv_prog_LIPO
6860 if test -n "$LIPO"; then
6861   echo "$as_me:$LINENO: result: $LIPO" >&5
6862 echo "${ECHO_T}$LIPO" >&6
6863 else
6864   echo "$as_me:$LINENO: result: no" >&5
6865 echo "${ECHO_T}no" >&6
6866 fi
6867
6868   fi
6869   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6870     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6871 set dummy ${ncn_progname}; ac_word=$2
6872 echo "$as_me:$LINENO: checking for $ac_word" >&5
6873 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6874 if test "${ac_cv_prog_LIPO+set}" = set; then
6875   echo $ECHO_N "(cached) $ECHO_C" >&6
6876 else
6877   if test -n "$LIPO"; then
6878   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6879 else
6880 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6881 for as_dir in $PATH
6882 do
6883   IFS=$as_save_IFS
6884   test -z "$as_dir" && as_dir=.
6885   for ac_exec_ext in '' $ac_executable_extensions; do
6886   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6887     ac_cv_prog_LIPO="${ncn_progname}"
6888     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6889     break 2
6890   fi
6891 done
6892 done
6893
6894 fi
6895 fi
6896 LIPO=$ac_cv_prog_LIPO
6897 if test -n "$LIPO"; then
6898   echo "$as_me:$LINENO: result: $LIPO" >&5
6899 echo "${ECHO_T}$LIPO" >&6
6900 else
6901   echo "$as_me:$LINENO: result: no" >&5
6902 echo "${ECHO_T}no" >&6
6903 fi
6904
6905   fi
6906   test -n "$ac_cv_prog_LIPO" && break
6907 done
6908
6909 if test -z "$ac_cv_prog_LIPO" ; then
6910   set dummy lipo
6911   if test $build = $host ; then
6912     LIPO="$2"
6913   else
6914     LIPO="${ncn_tool_prefix}$2"
6915   fi
6916 fi
6917
6918
6919
6920 if test -n "$NM"; then
6921   ac_cv_prog_NM=$NM
6922 elif test -n "$ac_cv_prog_NM"; then
6923   NM=$ac_cv_prog_NM
6924 fi
6925
6926 if test -n "$ac_cv_prog_NM"; then
6927   for ncn_progname in nm; do
6928     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6929 set dummy ${ncn_progname}; ac_word=$2
6930 echo "$as_me:$LINENO: checking for $ac_word" >&5
6931 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6932 if test "${ac_cv_prog_NM+set}" = set; then
6933   echo $ECHO_N "(cached) $ECHO_C" >&6
6934 else
6935   if test -n "$NM"; then
6936   ac_cv_prog_NM="$NM" # Let the user override the test.
6937 else
6938 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6939 for as_dir in $PATH
6940 do
6941   IFS=$as_save_IFS
6942   test -z "$as_dir" && as_dir=.
6943   for ac_exec_ext in '' $ac_executable_extensions; do
6944   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6945     ac_cv_prog_NM="${ncn_progname}"
6946     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6947     break 2
6948   fi
6949 done
6950 done
6951
6952 fi
6953 fi
6954 NM=$ac_cv_prog_NM
6955 if test -n "$NM"; then
6956   echo "$as_me:$LINENO: result: $NM" >&5
6957 echo "${ECHO_T}$NM" >&6
6958 else
6959   echo "$as_me:$LINENO: result: no" >&5
6960 echo "${ECHO_T}no" >&6
6961 fi
6962
6963   done
6964 fi
6965
6966 for ncn_progname in nm; do
6967   if test -n "$ncn_tool_prefix"; then
6968     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6969 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6970 echo "$as_me:$LINENO: checking for $ac_word" >&5
6971 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6972 if test "${ac_cv_prog_NM+set}" = set; then
6973   echo $ECHO_N "(cached) $ECHO_C" >&6
6974 else
6975   if test -n "$NM"; then
6976   ac_cv_prog_NM="$NM" # Let the user override the test.
6977 else
6978 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6979 for as_dir in $PATH
6980 do
6981   IFS=$as_save_IFS
6982   test -z "$as_dir" && as_dir=.
6983   for ac_exec_ext in '' $ac_executable_extensions; do
6984   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6985     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
6986     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6987     break 2
6988   fi
6989 done
6990 done
6991
6992 fi
6993 fi
6994 NM=$ac_cv_prog_NM
6995 if test -n "$NM"; then
6996   echo "$as_me:$LINENO: result: $NM" >&5
6997 echo "${ECHO_T}$NM" >&6
6998 else
6999   echo "$as_me:$LINENO: result: no" >&5
7000 echo "${ECHO_T}no" >&6
7001 fi
7002
7003   fi
7004   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7005     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7006 set dummy ${ncn_progname}; ac_word=$2
7007 echo "$as_me:$LINENO: checking for $ac_word" >&5
7008 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7009 if test "${ac_cv_prog_NM+set}" = set; then
7010   echo $ECHO_N "(cached) $ECHO_C" >&6
7011 else
7012   if test -n "$NM"; then
7013   ac_cv_prog_NM="$NM" # Let the user override the test.
7014 else
7015 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7016 for as_dir in $PATH
7017 do
7018   IFS=$as_save_IFS
7019   test -z "$as_dir" && as_dir=.
7020   for ac_exec_ext in '' $ac_executable_extensions; do
7021   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7022     ac_cv_prog_NM="${ncn_progname}"
7023     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7024     break 2
7025   fi
7026 done
7027 done
7028
7029 fi
7030 fi
7031 NM=$ac_cv_prog_NM
7032 if test -n "$NM"; then
7033   echo "$as_me:$LINENO: result: $NM" >&5
7034 echo "${ECHO_T}$NM" >&6
7035 else
7036   echo "$as_me:$LINENO: result: no" >&5
7037 echo "${ECHO_T}no" >&6
7038 fi
7039
7040   fi
7041   test -n "$ac_cv_prog_NM" && break
7042 done
7043
7044 if test -z "$ac_cv_prog_NM" ; then
7045   set dummy nm
7046   if test $build = $host ; then
7047     NM="$2"
7048   else
7049     NM="${ncn_tool_prefix}$2"
7050   fi
7051 fi
7052
7053
7054
7055 if test -n "$RANLIB"; then
7056   ac_cv_prog_RANLIB=$RANLIB
7057 elif test -n "$ac_cv_prog_RANLIB"; then
7058   RANLIB=$ac_cv_prog_RANLIB
7059 fi
7060
7061 if test -n "$ac_cv_prog_RANLIB"; then
7062   for ncn_progname in ranlib; do
7063     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7064 set dummy ${ncn_progname}; ac_word=$2
7065 echo "$as_me:$LINENO: checking for $ac_word" >&5
7066 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7067 if test "${ac_cv_prog_RANLIB+set}" = set; then
7068   echo $ECHO_N "(cached) $ECHO_C" >&6
7069 else
7070   if test -n "$RANLIB"; then
7071   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7072 else
7073 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7074 for as_dir in $PATH
7075 do
7076   IFS=$as_save_IFS
7077   test -z "$as_dir" && as_dir=.
7078   for ac_exec_ext in '' $ac_executable_extensions; do
7079   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7080     ac_cv_prog_RANLIB="${ncn_progname}"
7081     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7082     break 2
7083   fi
7084 done
7085 done
7086
7087 fi
7088 fi
7089 RANLIB=$ac_cv_prog_RANLIB
7090 if test -n "$RANLIB"; then
7091   echo "$as_me:$LINENO: result: $RANLIB" >&5
7092 echo "${ECHO_T}$RANLIB" >&6
7093 else
7094   echo "$as_me:$LINENO: result: no" >&5
7095 echo "${ECHO_T}no" >&6
7096 fi
7097
7098   done
7099 fi
7100
7101 for ncn_progname in ranlib; do
7102   if test -n "$ncn_tool_prefix"; then
7103     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7104 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7105 echo "$as_me:$LINENO: checking for $ac_word" >&5
7106 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7107 if test "${ac_cv_prog_RANLIB+set}" = set; then
7108   echo $ECHO_N "(cached) $ECHO_C" >&6
7109 else
7110   if test -n "$RANLIB"; then
7111   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7112 else
7113 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7114 for as_dir in $PATH
7115 do
7116   IFS=$as_save_IFS
7117   test -z "$as_dir" && as_dir=.
7118   for ac_exec_ext in '' $ac_executable_extensions; do
7119   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7120     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7121     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7122     break 2
7123   fi
7124 done
7125 done
7126
7127 fi
7128 fi
7129 RANLIB=$ac_cv_prog_RANLIB
7130 if test -n "$RANLIB"; then
7131   echo "$as_me:$LINENO: result: $RANLIB" >&5
7132 echo "${ECHO_T}$RANLIB" >&6
7133 else
7134   echo "$as_me:$LINENO: result: no" >&5
7135 echo "${ECHO_T}no" >&6
7136 fi
7137
7138   fi
7139   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7140     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7141 set dummy ${ncn_progname}; ac_word=$2
7142 echo "$as_me:$LINENO: checking for $ac_word" >&5
7143 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7144 if test "${ac_cv_prog_RANLIB+set}" = set; then
7145   echo $ECHO_N "(cached) $ECHO_C" >&6
7146 else
7147   if test -n "$RANLIB"; then
7148   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7149 else
7150 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7151 for as_dir in $PATH
7152 do
7153   IFS=$as_save_IFS
7154   test -z "$as_dir" && as_dir=.
7155   for ac_exec_ext in '' $ac_executable_extensions; do
7156   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7157     ac_cv_prog_RANLIB="${ncn_progname}"
7158     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7159     break 2
7160   fi
7161 done
7162 done
7163
7164 fi
7165 fi
7166 RANLIB=$ac_cv_prog_RANLIB
7167 if test -n "$RANLIB"; then
7168   echo "$as_me:$LINENO: result: $RANLIB" >&5
7169 echo "${ECHO_T}$RANLIB" >&6
7170 else
7171   echo "$as_me:$LINENO: result: no" >&5
7172 echo "${ECHO_T}no" >&6
7173 fi
7174
7175   fi
7176   test -n "$ac_cv_prog_RANLIB" && break
7177 done
7178
7179 if test -z "$ac_cv_prog_RANLIB" ; then
7180   RANLIB=":"
7181 fi
7182
7183
7184
7185 if test -n "$STRIP"; then
7186   ac_cv_prog_STRIP=$STRIP
7187 elif test -n "$ac_cv_prog_STRIP"; then
7188   STRIP=$ac_cv_prog_STRIP
7189 fi
7190
7191 if test -n "$ac_cv_prog_STRIP"; then
7192   for ncn_progname in strip; do
7193     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7194 set dummy ${ncn_progname}; ac_word=$2
7195 echo "$as_me:$LINENO: checking for $ac_word" >&5
7196 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7197 if test "${ac_cv_prog_STRIP+set}" = set; then
7198   echo $ECHO_N "(cached) $ECHO_C" >&6
7199 else
7200   if test -n "$STRIP"; then
7201   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7202 else
7203 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7204 for as_dir in $PATH
7205 do
7206   IFS=$as_save_IFS
7207   test -z "$as_dir" && as_dir=.
7208   for ac_exec_ext in '' $ac_executable_extensions; do
7209   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7210     ac_cv_prog_STRIP="${ncn_progname}"
7211     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7212     break 2
7213   fi
7214 done
7215 done
7216
7217 fi
7218 fi
7219 STRIP=$ac_cv_prog_STRIP
7220 if test -n "$STRIP"; then
7221   echo "$as_me:$LINENO: result: $STRIP" >&5
7222 echo "${ECHO_T}$STRIP" >&6
7223 else
7224   echo "$as_me:$LINENO: result: no" >&5
7225 echo "${ECHO_T}no" >&6
7226 fi
7227
7228   done
7229 fi
7230
7231 for ncn_progname in strip; do
7232   if test -n "$ncn_tool_prefix"; then
7233     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7234 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7235 echo "$as_me:$LINENO: checking for $ac_word" >&5
7236 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7237 if test "${ac_cv_prog_STRIP+set}" = set; then
7238   echo $ECHO_N "(cached) $ECHO_C" >&6
7239 else
7240   if test -n "$STRIP"; then
7241   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7242 else
7243 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7244 for as_dir in $PATH
7245 do
7246   IFS=$as_save_IFS
7247   test -z "$as_dir" && as_dir=.
7248   for ac_exec_ext in '' $ac_executable_extensions; do
7249   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7250     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7251     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7252     break 2
7253   fi
7254 done
7255 done
7256
7257 fi
7258 fi
7259 STRIP=$ac_cv_prog_STRIP
7260 if test -n "$STRIP"; then
7261   echo "$as_me:$LINENO: result: $STRIP" >&5
7262 echo "${ECHO_T}$STRIP" >&6
7263 else
7264   echo "$as_me:$LINENO: result: no" >&5
7265 echo "${ECHO_T}no" >&6
7266 fi
7267
7268   fi
7269   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7270     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7271 set dummy ${ncn_progname}; ac_word=$2
7272 echo "$as_me:$LINENO: checking for $ac_word" >&5
7273 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7274 if test "${ac_cv_prog_STRIP+set}" = set; then
7275   echo $ECHO_N "(cached) $ECHO_C" >&6
7276 else
7277   if test -n "$STRIP"; then
7278   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7279 else
7280 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7281 for as_dir in $PATH
7282 do
7283   IFS=$as_save_IFS
7284   test -z "$as_dir" && as_dir=.
7285   for ac_exec_ext in '' $ac_executable_extensions; do
7286   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7287     ac_cv_prog_STRIP="${ncn_progname}"
7288     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7289     break 2
7290   fi
7291 done
7292 done
7293
7294 fi
7295 fi
7296 STRIP=$ac_cv_prog_STRIP
7297 if test -n "$STRIP"; then
7298   echo "$as_me:$LINENO: result: $STRIP" >&5
7299 echo "${ECHO_T}$STRIP" >&6
7300 else
7301   echo "$as_me:$LINENO: result: no" >&5
7302 echo "${ECHO_T}no" >&6
7303 fi
7304
7305   fi
7306   test -n "$ac_cv_prog_STRIP" && break
7307 done
7308
7309 if test -z "$ac_cv_prog_STRIP" ; then
7310   STRIP=":"
7311 fi
7312
7313
7314
7315 if test -n "$WINDRES"; then
7316   ac_cv_prog_WINDRES=$WINDRES
7317 elif test -n "$ac_cv_prog_WINDRES"; then
7318   WINDRES=$ac_cv_prog_WINDRES
7319 fi
7320
7321 if test -n "$ac_cv_prog_WINDRES"; then
7322   for ncn_progname in windres; do
7323     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7324 set dummy ${ncn_progname}; ac_word=$2
7325 echo "$as_me:$LINENO: checking for $ac_word" >&5
7326 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7327 if test "${ac_cv_prog_WINDRES+set}" = set; then
7328   echo $ECHO_N "(cached) $ECHO_C" >&6
7329 else
7330   if test -n "$WINDRES"; then
7331   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7332 else
7333 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7334 for as_dir in $PATH
7335 do
7336   IFS=$as_save_IFS
7337   test -z "$as_dir" && as_dir=.
7338   for ac_exec_ext in '' $ac_executable_extensions; do
7339   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7340     ac_cv_prog_WINDRES="${ncn_progname}"
7341     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7342     break 2
7343   fi
7344 done
7345 done
7346
7347 fi
7348 fi
7349 WINDRES=$ac_cv_prog_WINDRES
7350 if test -n "$WINDRES"; then
7351   echo "$as_me:$LINENO: result: $WINDRES" >&5
7352 echo "${ECHO_T}$WINDRES" >&6
7353 else
7354   echo "$as_me:$LINENO: result: no" >&5
7355 echo "${ECHO_T}no" >&6
7356 fi
7357
7358   done
7359 fi
7360
7361 for ncn_progname in windres; do
7362   if test -n "$ncn_tool_prefix"; then
7363     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7364 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7365 echo "$as_me:$LINENO: checking for $ac_word" >&5
7366 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7367 if test "${ac_cv_prog_WINDRES+set}" = set; then
7368   echo $ECHO_N "(cached) $ECHO_C" >&6
7369 else
7370   if test -n "$WINDRES"; then
7371   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7372 else
7373 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7374 for as_dir in $PATH
7375 do
7376   IFS=$as_save_IFS
7377   test -z "$as_dir" && as_dir=.
7378   for ac_exec_ext in '' $ac_executable_extensions; do
7379   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7380     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7381     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7382     break 2
7383   fi
7384 done
7385 done
7386
7387 fi
7388 fi
7389 WINDRES=$ac_cv_prog_WINDRES
7390 if test -n "$WINDRES"; then
7391   echo "$as_me:$LINENO: result: $WINDRES" >&5
7392 echo "${ECHO_T}$WINDRES" >&6
7393 else
7394   echo "$as_me:$LINENO: result: no" >&5
7395 echo "${ECHO_T}no" >&6
7396 fi
7397
7398   fi
7399   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7400     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7401 set dummy ${ncn_progname}; ac_word=$2
7402 echo "$as_me:$LINENO: checking for $ac_word" >&5
7403 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7404 if test "${ac_cv_prog_WINDRES+set}" = set; then
7405   echo $ECHO_N "(cached) $ECHO_C" >&6
7406 else
7407   if test -n "$WINDRES"; then
7408   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7409 else
7410 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7411 for as_dir in $PATH
7412 do
7413   IFS=$as_save_IFS
7414   test -z "$as_dir" && as_dir=.
7415   for ac_exec_ext in '' $ac_executable_extensions; do
7416   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7417     ac_cv_prog_WINDRES="${ncn_progname}"
7418     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7419     break 2
7420   fi
7421 done
7422 done
7423
7424 fi
7425 fi
7426 WINDRES=$ac_cv_prog_WINDRES
7427 if test -n "$WINDRES"; then
7428   echo "$as_me:$LINENO: result: $WINDRES" >&5
7429 echo "${ECHO_T}$WINDRES" >&6
7430 else
7431   echo "$as_me:$LINENO: result: no" >&5
7432 echo "${ECHO_T}no" >&6
7433 fi
7434
7435   fi
7436   test -n "$ac_cv_prog_WINDRES" && break
7437 done
7438
7439 if test -z "$ac_cv_prog_WINDRES" ; then
7440   set dummy windres
7441   if test $build = $host ; then
7442     WINDRES="$2"
7443   else
7444     WINDRES="${ncn_tool_prefix}$2"
7445   fi
7446 fi
7447
7448
7449
7450 if test -n "$WINDMC"; then
7451   ac_cv_prog_WINDMC=$WINDMC
7452 elif test -n "$ac_cv_prog_WINDMC"; then
7453   WINDMC=$ac_cv_prog_WINDMC
7454 fi
7455
7456 if test -n "$ac_cv_prog_WINDMC"; then
7457   for ncn_progname in windmc; do
7458     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7459 set dummy ${ncn_progname}; ac_word=$2
7460 echo "$as_me:$LINENO: checking for $ac_word" >&5
7461 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7462 if test "${ac_cv_prog_WINDMC+set}" = set; then
7463   echo $ECHO_N "(cached) $ECHO_C" >&6
7464 else
7465   if test -n "$WINDMC"; then
7466   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7467 else
7468 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7469 for as_dir in $PATH
7470 do
7471   IFS=$as_save_IFS
7472   test -z "$as_dir" && as_dir=.
7473   for ac_exec_ext in '' $ac_executable_extensions; do
7474   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7475     ac_cv_prog_WINDMC="${ncn_progname}"
7476     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7477     break 2
7478   fi
7479 done
7480 done
7481
7482 fi
7483 fi
7484 WINDMC=$ac_cv_prog_WINDMC
7485 if test -n "$WINDMC"; then
7486   echo "$as_me:$LINENO: result: $WINDMC" >&5
7487 echo "${ECHO_T}$WINDMC" >&6
7488 else
7489   echo "$as_me:$LINENO: result: no" >&5
7490 echo "${ECHO_T}no" >&6
7491 fi
7492
7493   done
7494 fi
7495
7496 for ncn_progname in windmc; do
7497   if test -n "$ncn_tool_prefix"; then
7498     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7499 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7500 echo "$as_me:$LINENO: checking for $ac_word" >&5
7501 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7502 if test "${ac_cv_prog_WINDMC+set}" = set; then
7503   echo $ECHO_N "(cached) $ECHO_C" >&6
7504 else
7505   if test -n "$WINDMC"; then
7506   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7507 else
7508 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7509 for as_dir in $PATH
7510 do
7511   IFS=$as_save_IFS
7512   test -z "$as_dir" && as_dir=.
7513   for ac_exec_ext in '' $ac_executable_extensions; do
7514   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7515     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7516     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7517     break 2
7518   fi
7519 done
7520 done
7521
7522 fi
7523 fi
7524 WINDMC=$ac_cv_prog_WINDMC
7525 if test -n "$WINDMC"; then
7526   echo "$as_me:$LINENO: result: $WINDMC" >&5
7527 echo "${ECHO_T}$WINDMC" >&6
7528 else
7529   echo "$as_me:$LINENO: result: no" >&5
7530 echo "${ECHO_T}no" >&6
7531 fi
7532
7533   fi
7534   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7535     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7536 set dummy ${ncn_progname}; ac_word=$2
7537 echo "$as_me:$LINENO: checking for $ac_word" >&5
7538 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7539 if test "${ac_cv_prog_WINDMC+set}" = set; then
7540   echo $ECHO_N "(cached) $ECHO_C" >&6
7541 else
7542   if test -n "$WINDMC"; then
7543   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7544 else
7545 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7546 for as_dir in $PATH
7547 do
7548   IFS=$as_save_IFS
7549   test -z "$as_dir" && as_dir=.
7550   for ac_exec_ext in '' $ac_executable_extensions; do
7551   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7552     ac_cv_prog_WINDMC="${ncn_progname}"
7553     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7554     break 2
7555   fi
7556 done
7557 done
7558
7559 fi
7560 fi
7561 WINDMC=$ac_cv_prog_WINDMC
7562 if test -n "$WINDMC"; then
7563   echo "$as_me:$LINENO: result: $WINDMC" >&5
7564 echo "${ECHO_T}$WINDMC" >&6
7565 else
7566   echo "$as_me:$LINENO: result: no" >&5
7567 echo "${ECHO_T}no" >&6
7568 fi
7569
7570   fi
7571   test -n "$ac_cv_prog_WINDMC" && break
7572 done
7573
7574 if test -z "$ac_cv_prog_WINDMC" ; then
7575   set dummy windmc
7576   if test $build = $host ; then
7577     WINDMC="$2"
7578   else
7579     WINDMC="${ncn_tool_prefix}$2"
7580   fi
7581 fi
7582
7583
7584
7585 if test -n "$OBJCOPY"; then
7586   ac_cv_prog_OBJCOPY=$OBJCOPY
7587 elif test -n "$ac_cv_prog_OBJCOPY"; then
7588   OBJCOPY=$ac_cv_prog_OBJCOPY
7589 fi
7590
7591 if test -n "$ac_cv_prog_OBJCOPY"; then
7592   for ncn_progname in objcopy; do
7593     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7594 set dummy ${ncn_progname}; ac_word=$2
7595 echo "$as_me:$LINENO: checking for $ac_word" >&5
7596 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7597 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7598   echo $ECHO_N "(cached) $ECHO_C" >&6
7599 else
7600   if test -n "$OBJCOPY"; then
7601   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7602 else
7603 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7604 for as_dir in $PATH
7605 do
7606   IFS=$as_save_IFS
7607   test -z "$as_dir" && as_dir=.
7608   for ac_exec_ext in '' $ac_executable_extensions; do
7609   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7610     ac_cv_prog_OBJCOPY="${ncn_progname}"
7611     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7612     break 2
7613   fi
7614 done
7615 done
7616
7617 fi
7618 fi
7619 OBJCOPY=$ac_cv_prog_OBJCOPY
7620 if test -n "$OBJCOPY"; then
7621   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7622 echo "${ECHO_T}$OBJCOPY" >&6
7623 else
7624   echo "$as_me:$LINENO: result: no" >&5
7625 echo "${ECHO_T}no" >&6
7626 fi
7627
7628   done
7629 fi
7630
7631 for ncn_progname in objcopy; do
7632   if test -n "$ncn_tool_prefix"; then
7633     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7634 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7635 echo "$as_me:$LINENO: checking for $ac_word" >&5
7636 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7637 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7638   echo $ECHO_N "(cached) $ECHO_C" >&6
7639 else
7640   if test -n "$OBJCOPY"; then
7641   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7642 else
7643 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7644 for as_dir in $PATH
7645 do
7646   IFS=$as_save_IFS
7647   test -z "$as_dir" && as_dir=.
7648   for ac_exec_ext in '' $ac_executable_extensions; do
7649   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7650     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7651     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7652     break 2
7653   fi
7654 done
7655 done
7656
7657 fi
7658 fi
7659 OBJCOPY=$ac_cv_prog_OBJCOPY
7660 if test -n "$OBJCOPY"; then
7661   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7662 echo "${ECHO_T}$OBJCOPY" >&6
7663 else
7664   echo "$as_me:$LINENO: result: no" >&5
7665 echo "${ECHO_T}no" >&6
7666 fi
7667
7668   fi
7669   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7670     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7671 set dummy ${ncn_progname}; ac_word=$2
7672 echo "$as_me:$LINENO: checking for $ac_word" >&5
7673 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7674 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7675   echo $ECHO_N "(cached) $ECHO_C" >&6
7676 else
7677   if test -n "$OBJCOPY"; then
7678   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7679 else
7680 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7681 for as_dir in $PATH
7682 do
7683   IFS=$as_save_IFS
7684   test -z "$as_dir" && as_dir=.
7685   for ac_exec_ext in '' $ac_executable_extensions; do
7686   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7687     ac_cv_prog_OBJCOPY="${ncn_progname}"
7688     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7689     break 2
7690   fi
7691 done
7692 done
7693
7694 fi
7695 fi
7696 OBJCOPY=$ac_cv_prog_OBJCOPY
7697 if test -n "$OBJCOPY"; then
7698   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7699 echo "${ECHO_T}$OBJCOPY" >&6
7700 else
7701   echo "$as_me:$LINENO: result: no" >&5
7702 echo "${ECHO_T}no" >&6
7703 fi
7704
7705   fi
7706   test -n "$ac_cv_prog_OBJCOPY" && break
7707 done
7708
7709 if test -z "$ac_cv_prog_OBJCOPY" ; then
7710   set dummy objcopy
7711   if test $build = $host ; then
7712     OBJCOPY="$2"
7713   else
7714     OBJCOPY="${ncn_tool_prefix}$2"
7715   fi
7716 fi
7717
7718
7719
7720 if test -n "$OBJDUMP"; then
7721   ac_cv_prog_OBJDUMP=$OBJDUMP
7722 elif test -n "$ac_cv_prog_OBJDUMP"; then
7723   OBJDUMP=$ac_cv_prog_OBJDUMP
7724 fi
7725
7726 if test -n "$ac_cv_prog_OBJDUMP"; then
7727   for ncn_progname in objdump; do
7728     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7729 set dummy ${ncn_progname}; ac_word=$2
7730 echo "$as_me:$LINENO: checking for $ac_word" >&5
7731 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7732 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7733   echo $ECHO_N "(cached) $ECHO_C" >&6
7734 else
7735   if test -n "$OBJDUMP"; then
7736   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7737 else
7738 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7739 for as_dir in $PATH
7740 do
7741   IFS=$as_save_IFS
7742   test -z "$as_dir" && as_dir=.
7743   for ac_exec_ext in '' $ac_executable_extensions; do
7744   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7745     ac_cv_prog_OBJDUMP="${ncn_progname}"
7746     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7747     break 2
7748   fi
7749 done
7750 done
7751
7752 fi
7753 fi
7754 OBJDUMP=$ac_cv_prog_OBJDUMP
7755 if test -n "$OBJDUMP"; then
7756   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7757 echo "${ECHO_T}$OBJDUMP" >&6
7758 else
7759   echo "$as_me:$LINENO: result: no" >&5
7760 echo "${ECHO_T}no" >&6
7761 fi
7762
7763   done
7764 fi
7765
7766 for ncn_progname in objdump; do
7767   if test -n "$ncn_tool_prefix"; then
7768     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7769 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7770 echo "$as_me:$LINENO: checking for $ac_word" >&5
7771 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7772 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7773   echo $ECHO_N "(cached) $ECHO_C" >&6
7774 else
7775   if test -n "$OBJDUMP"; then
7776   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7777 else
7778 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7779 for as_dir in $PATH
7780 do
7781   IFS=$as_save_IFS
7782   test -z "$as_dir" && as_dir=.
7783   for ac_exec_ext in '' $ac_executable_extensions; do
7784   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7785     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7786     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7787     break 2
7788   fi
7789 done
7790 done
7791
7792 fi
7793 fi
7794 OBJDUMP=$ac_cv_prog_OBJDUMP
7795 if test -n "$OBJDUMP"; then
7796   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7797 echo "${ECHO_T}$OBJDUMP" >&6
7798 else
7799   echo "$as_me:$LINENO: result: no" >&5
7800 echo "${ECHO_T}no" >&6
7801 fi
7802
7803   fi
7804   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7805     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7806 set dummy ${ncn_progname}; ac_word=$2
7807 echo "$as_me:$LINENO: checking for $ac_word" >&5
7808 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7809 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7810   echo $ECHO_N "(cached) $ECHO_C" >&6
7811 else
7812   if test -n "$OBJDUMP"; then
7813   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7814 else
7815 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7816 for as_dir in $PATH
7817 do
7818   IFS=$as_save_IFS
7819   test -z "$as_dir" && as_dir=.
7820   for ac_exec_ext in '' $ac_executable_extensions; do
7821   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7822     ac_cv_prog_OBJDUMP="${ncn_progname}"
7823     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7824     break 2
7825   fi
7826 done
7827 done
7828
7829 fi
7830 fi
7831 OBJDUMP=$ac_cv_prog_OBJDUMP
7832 if test -n "$OBJDUMP"; then
7833   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7834 echo "${ECHO_T}$OBJDUMP" >&6
7835 else
7836   echo "$as_me:$LINENO: result: no" >&5
7837 echo "${ECHO_T}no" >&6
7838 fi
7839
7840   fi
7841   test -n "$ac_cv_prog_OBJDUMP" && break
7842 done
7843
7844 if test -z "$ac_cv_prog_OBJDUMP" ; then
7845   set dummy objdump
7846   if test $build = $host ; then
7847     OBJDUMP="$2"
7848   else
7849     OBJDUMP="${ncn_tool_prefix}$2"
7850   fi
7851 fi
7852
7853
7854
7855
7856
7857
7858
7859 # Target tools.
7860
7861 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7862 if test "${with_build_time_tools+set}" = set; then
7863   withval="$with_build_time_tools"
7864   case x"$withval" in
7865      x/*) ;;
7866      *)
7867        with_build_time_tools=
7868        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7869 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7870        ;;
7871    esac
7872 else
7873   with_build_time_tools=
7874 fi;
7875
7876
7877
7878 if test -n "$CC_FOR_TARGET"; then
7879   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7880 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7881   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7882 fi
7883
7884 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7885   for ncn_progname in cc gcc; do
7886     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7887 set dummy ${ncn_progname}; ac_word=$2
7888 echo "$as_me:$LINENO: checking for $ac_word" >&5
7889 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7890 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7891   echo $ECHO_N "(cached) $ECHO_C" >&6
7892 else
7893   if test -n "$CC_FOR_TARGET"; then
7894   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7895 else
7896 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7897 for as_dir in $PATH
7898 do
7899   IFS=$as_save_IFS
7900   test -z "$as_dir" && as_dir=.
7901   for ac_exec_ext in '' $ac_executable_extensions; do
7902   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7903     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7904     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7905     break 2
7906   fi
7907 done
7908 done
7909
7910 fi
7911 fi
7912 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7913 if test -n "$CC_FOR_TARGET"; then
7914   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7915 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7916 else
7917   echo "$as_me:$LINENO: result: no" >&5
7918 echo "${ECHO_T}no" >&6
7919 fi
7920
7921   done
7922 fi
7923
7924 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
7925   for ncn_progname in cc gcc; do
7926     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7927 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7928     if test -x $with_build_time_tools/${ncn_progname}; then
7929       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7930       echo "$as_me:$LINENO: result: yes" >&5
7931 echo "${ECHO_T}yes" >&6
7932       break
7933     else
7934       echo "$as_me:$LINENO: result: no" >&5
7935 echo "${ECHO_T}no" >&6
7936     fi
7937   done
7938 fi
7939
7940 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
7941   for ncn_progname in cc gcc; do
7942     if test -n "$ncn_target_tool_prefix"; then
7943       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
7944 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
7945 echo "$as_me:$LINENO: checking for $ac_word" >&5
7946 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7947 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7948   echo $ECHO_N "(cached) $ECHO_C" >&6
7949 else
7950   if test -n "$CC_FOR_TARGET"; then
7951   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7952 else
7953 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7954 for as_dir in $PATH
7955 do
7956   IFS=$as_save_IFS
7957   test -z "$as_dir" && as_dir=.
7958   for ac_exec_ext in '' $ac_executable_extensions; do
7959   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7960     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
7961     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7962     break 2
7963   fi
7964 done
7965 done
7966
7967 fi
7968 fi
7969 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7970 if test -n "$CC_FOR_TARGET"; then
7971   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7972 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7973 else
7974   echo "$as_me:$LINENO: result: no" >&5
7975 echo "${ECHO_T}no" >&6
7976 fi
7977
7978     fi
7979     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
7980       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7981 set dummy ${ncn_progname}; ac_word=$2
7982 echo "$as_me:$LINENO: checking for $ac_word" >&5
7983 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7984 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7985   echo $ECHO_N "(cached) $ECHO_C" >&6
7986 else
7987   if test -n "$CC_FOR_TARGET"; then
7988   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7989 else
7990 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7991 for as_dir in $PATH
7992 do
7993   IFS=$as_save_IFS
7994   test -z "$as_dir" && as_dir=.
7995   for ac_exec_ext in '' $ac_executable_extensions; do
7996   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7997     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7998     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7999     break 2
8000   fi
8001 done
8002 done
8003
8004 fi
8005 fi
8006 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8007 if test -n "$CC_FOR_TARGET"; then
8008   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8009 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8010 else
8011   echo "$as_me:$LINENO: result: no" >&5
8012 echo "${ECHO_T}no" >&6
8013 fi
8014
8015     fi
8016     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8017   done
8018 fi
8019
8020 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8021   set dummy cc gcc
8022   if test $build = $target ; then
8023     CC_FOR_TARGET="$2"
8024   else
8025     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8026   fi
8027 else
8028   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8029 fi
8030
8031
8032
8033 if test -n "$CXX_FOR_TARGET"; then
8034   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8035 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8036   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8037 fi
8038
8039 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8040   for ncn_progname in c++ g++ cxx gxx; do
8041     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8042 set dummy ${ncn_progname}; ac_word=$2
8043 echo "$as_me:$LINENO: checking for $ac_word" >&5
8044 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8045 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8046   echo $ECHO_N "(cached) $ECHO_C" >&6
8047 else
8048   if test -n "$CXX_FOR_TARGET"; then
8049   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8050 else
8051 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8052 for as_dir in $PATH
8053 do
8054   IFS=$as_save_IFS
8055   test -z "$as_dir" && as_dir=.
8056   for ac_exec_ext in '' $ac_executable_extensions; do
8057   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8058     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8059     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8060     break 2
8061   fi
8062 done
8063 done
8064
8065 fi
8066 fi
8067 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8068 if test -n "$CXX_FOR_TARGET"; then
8069   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8070 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8071 else
8072   echo "$as_me:$LINENO: result: no" >&5
8073 echo "${ECHO_T}no" >&6
8074 fi
8075
8076   done
8077 fi
8078
8079 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8080   for ncn_progname in c++ g++ cxx gxx; do
8081     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8082 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8083     if test -x $with_build_time_tools/${ncn_progname}; then
8084       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8085       echo "$as_me:$LINENO: result: yes" >&5
8086 echo "${ECHO_T}yes" >&6
8087       break
8088     else
8089       echo "$as_me:$LINENO: result: no" >&5
8090 echo "${ECHO_T}no" >&6
8091     fi
8092   done
8093 fi
8094
8095 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8096   for ncn_progname in c++ g++ cxx gxx; do
8097     if test -n "$ncn_target_tool_prefix"; then
8098       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8099 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8100 echo "$as_me:$LINENO: checking for $ac_word" >&5
8101 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8102 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8103   echo $ECHO_N "(cached) $ECHO_C" >&6
8104 else
8105   if test -n "$CXX_FOR_TARGET"; then
8106   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8107 else
8108 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8109 for as_dir in $PATH
8110 do
8111   IFS=$as_save_IFS
8112   test -z "$as_dir" && as_dir=.
8113   for ac_exec_ext in '' $ac_executable_extensions; do
8114   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8115     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8116     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8117     break 2
8118   fi
8119 done
8120 done
8121
8122 fi
8123 fi
8124 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8125 if test -n "$CXX_FOR_TARGET"; then
8126   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8127 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8128 else
8129   echo "$as_me:$LINENO: result: no" >&5
8130 echo "${ECHO_T}no" >&6
8131 fi
8132
8133     fi
8134     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8135       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8136 set dummy ${ncn_progname}; ac_word=$2
8137 echo "$as_me:$LINENO: checking for $ac_word" >&5
8138 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8139 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8140   echo $ECHO_N "(cached) $ECHO_C" >&6
8141 else
8142   if test -n "$CXX_FOR_TARGET"; then
8143   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8144 else
8145 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8146 for as_dir in $PATH
8147 do
8148   IFS=$as_save_IFS
8149   test -z "$as_dir" && as_dir=.
8150   for ac_exec_ext in '' $ac_executable_extensions; do
8151   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8152     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8153     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8154     break 2
8155   fi
8156 done
8157 done
8158
8159 fi
8160 fi
8161 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8162 if test -n "$CXX_FOR_TARGET"; then
8163   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8164 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8165 else
8166   echo "$as_me:$LINENO: result: no" >&5
8167 echo "${ECHO_T}no" >&6
8168 fi
8169
8170     fi
8171     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8172   done
8173 fi
8174
8175 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8176   set dummy c++ g++ cxx gxx
8177   if test $build = $target ; then
8178     CXX_FOR_TARGET="$2"
8179   else
8180     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8181   fi
8182 else
8183   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8184 fi
8185
8186
8187
8188 if test -n "$GCC_FOR_TARGET"; then
8189   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8190 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8191   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8192 fi
8193
8194 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8195   for ncn_progname in gcc; do
8196     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8197 set dummy ${ncn_progname}; ac_word=$2
8198 echo "$as_me:$LINENO: checking for $ac_word" >&5
8199 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8200 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8201   echo $ECHO_N "(cached) $ECHO_C" >&6
8202 else
8203   if test -n "$GCC_FOR_TARGET"; then
8204   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8205 else
8206 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8207 for as_dir in $PATH
8208 do
8209   IFS=$as_save_IFS
8210   test -z "$as_dir" && as_dir=.
8211   for ac_exec_ext in '' $ac_executable_extensions; do
8212   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8213     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8214     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8215     break 2
8216   fi
8217 done
8218 done
8219
8220 fi
8221 fi
8222 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8223 if test -n "$GCC_FOR_TARGET"; then
8224   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8225 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8226 else
8227   echo "$as_me:$LINENO: result: no" >&5
8228 echo "${ECHO_T}no" >&6
8229 fi
8230
8231   done
8232 fi
8233
8234 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8235   for ncn_progname in gcc; do
8236     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8237 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8238     if test -x $with_build_time_tools/${ncn_progname}; then
8239       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8240       echo "$as_me:$LINENO: result: yes" >&5
8241 echo "${ECHO_T}yes" >&6
8242       break
8243     else
8244       echo "$as_me:$LINENO: result: no" >&5
8245 echo "${ECHO_T}no" >&6
8246     fi
8247   done
8248 fi
8249
8250 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8251   for ncn_progname in gcc; do
8252     if test -n "$ncn_target_tool_prefix"; then
8253       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8254 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8255 echo "$as_me:$LINENO: checking for $ac_word" >&5
8256 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8257 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8258   echo $ECHO_N "(cached) $ECHO_C" >&6
8259 else
8260   if test -n "$GCC_FOR_TARGET"; then
8261   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8262 else
8263 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8264 for as_dir in $PATH
8265 do
8266   IFS=$as_save_IFS
8267   test -z "$as_dir" && as_dir=.
8268   for ac_exec_ext in '' $ac_executable_extensions; do
8269   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8270     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8271     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8272     break 2
8273   fi
8274 done
8275 done
8276
8277 fi
8278 fi
8279 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8280 if test -n "$GCC_FOR_TARGET"; then
8281   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8282 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8283 else
8284   echo "$as_me:$LINENO: result: no" >&5
8285 echo "${ECHO_T}no" >&6
8286 fi
8287
8288     fi
8289     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8290       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8291 set dummy ${ncn_progname}; ac_word=$2
8292 echo "$as_me:$LINENO: checking for $ac_word" >&5
8293 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8294 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8295   echo $ECHO_N "(cached) $ECHO_C" >&6
8296 else
8297   if test -n "$GCC_FOR_TARGET"; then
8298   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8299 else
8300 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8301 for as_dir in $PATH
8302 do
8303   IFS=$as_save_IFS
8304   test -z "$as_dir" && as_dir=.
8305   for ac_exec_ext in '' $ac_executable_extensions; do
8306   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8307     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8308     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8309     break 2
8310   fi
8311 done
8312 done
8313
8314 fi
8315 fi
8316 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8317 if test -n "$GCC_FOR_TARGET"; then
8318   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8319 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8320 else
8321   echo "$as_me:$LINENO: result: no" >&5
8322 echo "${ECHO_T}no" >&6
8323 fi
8324
8325     fi
8326     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8327   done
8328 fi
8329
8330 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8331   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8332 else
8333   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8334 fi
8335
8336
8337
8338 if test -n "$GCJ_FOR_TARGET"; then
8339   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8340 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8341   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8342 fi
8343
8344 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8345   for ncn_progname in gcj; do
8346     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8347 set dummy ${ncn_progname}; ac_word=$2
8348 echo "$as_me:$LINENO: checking for $ac_word" >&5
8349 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8350 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8351   echo $ECHO_N "(cached) $ECHO_C" >&6
8352 else
8353   if test -n "$GCJ_FOR_TARGET"; then
8354   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8355 else
8356 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8357 for as_dir in $PATH
8358 do
8359   IFS=$as_save_IFS
8360   test -z "$as_dir" && as_dir=.
8361   for ac_exec_ext in '' $ac_executable_extensions; do
8362   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8363     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8364     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8365     break 2
8366   fi
8367 done
8368 done
8369
8370 fi
8371 fi
8372 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8373 if test -n "$GCJ_FOR_TARGET"; then
8374   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8375 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8376 else
8377   echo "$as_me:$LINENO: result: no" >&5
8378 echo "${ECHO_T}no" >&6
8379 fi
8380
8381   done
8382 fi
8383
8384 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8385   for ncn_progname in gcj; do
8386     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8387 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8388     if test -x $with_build_time_tools/${ncn_progname}; then
8389       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8390       echo "$as_me:$LINENO: result: yes" >&5
8391 echo "${ECHO_T}yes" >&6
8392       break
8393     else
8394       echo "$as_me:$LINENO: result: no" >&5
8395 echo "${ECHO_T}no" >&6
8396     fi
8397   done
8398 fi
8399
8400 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8401   for ncn_progname in gcj; do
8402     if test -n "$ncn_target_tool_prefix"; then
8403       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8404 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8405 echo "$as_me:$LINENO: checking for $ac_word" >&5
8406 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8407 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8408   echo $ECHO_N "(cached) $ECHO_C" >&6
8409 else
8410   if test -n "$GCJ_FOR_TARGET"; then
8411   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8412 else
8413 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8414 for as_dir in $PATH
8415 do
8416   IFS=$as_save_IFS
8417   test -z "$as_dir" && as_dir=.
8418   for ac_exec_ext in '' $ac_executable_extensions; do
8419   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8420     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8421     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8422     break 2
8423   fi
8424 done
8425 done
8426
8427 fi
8428 fi
8429 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8430 if test -n "$GCJ_FOR_TARGET"; then
8431   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8432 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8433 else
8434   echo "$as_me:$LINENO: result: no" >&5
8435 echo "${ECHO_T}no" >&6
8436 fi
8437
8438     fi
8439     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8440       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8441 set dummy ${ncn_progname}; ac_word=$2
8442 echo "$as_me:$LINENO: checking for $ac_word" >&5
8443 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8444 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8445   echo $ECHO_N "(cached) $ECHO_C" >&6
8446 else
8447   if test -n "$GCJ_FOR_TARGET"; then
8448   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8449 else
8450 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8451 for as_dir in $PATH
8452 do
8453   IFS=$as_save_IFS
8454   test -z "$as_dir" && as_dir=.
8455   for ac_exec_ext in '' $ac_executable_extensions; do
8456   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8457     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8458     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8459     break 2
8460   fi
8461 done
8462 done
8463
8464 fi
8465 fi
8466 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8467 if test -n "$GCJ_FOR_TARGET"; then
8468   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8469 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8470 else
8471   echo "$as_me:$LINENO: result: no" >&5
8472 echo "${ECHO_T}no" >&6
8473 fi
8474
8475     fi
8476     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8477   done
8478 fi
8479
8480 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8481   set dummy gcj
8482   if test $build = $target ; then
8483     GCJ_FOR_TARGET="$2"
8484   else
8485     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8486   fi
8487 else
8488   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8489 fi
8490
8491
8492
8493 if test -n "$GFORTRAN_FOR_TARGET"; then
8494   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8495 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8496   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8497 fi
8498
8499 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8500   for ncn_progname in gfortran; do
8501     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8502 set dummy ${ncn_progname}; ac_word=$2
8503 echo "$as_me:$LINENO: checking for $ac_word" >&5
8504 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8505 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8506   echo $ECHO_N "(cached) $ECHO_C" >&6
8507 else
8508   if test -n "$GFORTRAN_FOR_TARGET"; then
8509   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8510 else
8511 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8512 for as_dir in $PATH
8513 do
8514   IFS=$as_save_IFS
8515   test -z "$as_dir" && as_dir=.
8516   for ac_exec_ext in '' $ac_executable_extensions; do
8517   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8518     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8519     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8520     break 2
8521   fi
8522 done
8523 done
8524
8525 fi
8526 fi
8527 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8528 if test -n "$GFORTRAN_FOR_TARGET"; then
8529   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8530 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8531 else
8532   echo "$as_me:$LINENO: result: no" >&5
8533 echo "${ECHO_T}no" >&6
8534 fi
8535
8536   done
8537 fi
8538
8539 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8540   for ncn_progname in gfortran; do
8541     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8542 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8543     if test -x $with_build_time_tools/${ncn_progname}; then
8544       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8545       echo "$as_me:$LINENO: result: yes" >&5
8546 echo "${ECHO_T}yes" >&6
8547       break
8548     else
8549       echo "$as_me:$LINENO: result: no" >&5
8550 echo "${ECHO_T}no" >&6
8551     fi
8552   done
8553 fi
8554
8555 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8556   for ncn_progname in gfortran; do
8557     if test -n "$ncn_target_tool_prefix"; then
8558       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8559 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8560 echo "$as_me:$LINENO: checking for $ac_word" >&5
8561 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8562 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8563   echo $ECHO_N "(cached) $ECHO_C" >&6
8564 else
8565   if test -n "$GFORTRAN_FOR_TARGET"; then
8566   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8567 else
8568 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8569 for as_dir in $PATH
8570 do
8571   IFS=$as_save_IFS
8572   test -z "$as_dir" && as_dir=.
8573   for ac_exec_ext in '' $ac_executable_extensions; do
8574   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8575     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8576     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8577     break 2
8578   fi
8579 done
8580 done
8581
8582 fi
8583 fi
8584 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8585 if test -n "$GFORTRAN_FOR_TARGET"; then
8586   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8587 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8588 else
8589   echo "$as_me:$LINENO: result: no" >&5
8590 echo "${ECHO_T}no" >&6
8591 fi
8592
8593     fi
8594     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8595       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8596 set dummy ${ncn_progname}; ac_word=$2
8597 echo "$as_me:$LINENO: checking for $ac_word" >&5
8598 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8599 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8600   echo $ECHO_N "(cached) $ECHO_C" >&6
8601 else
8602   if test -n "$GFORTRAN_FOR_TARGET"; then
8603   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8604 else
8605 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8606 for as_dir in $PATH
8607 do
8608   IFS=$as_save_IFS
8609   test -z "$as_dir" && as_dir=.
8610   for ac_exec_ext in '' $ac_executable_extensions; do
8611   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8612     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8613     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8614     break 2
8615   fi
8616 done
8617 done
8618
8619 fi
8620 fi
8621 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8622 if test -n "$GFORTRAN_FOR_TARGET"; then
8623   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8624 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8625 else
8626   echo "$as_me:$LINENO: result: no" >&5
8627 echo "${ECHO_T}no" >&6
8628 fi
8629
8630     fi
8631     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8632   done
8633 fi
8634
8635 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8636   set dummy gfortran
8637   if test $build = $target ; then
8638     GFORTRAN_FOR_TARGET="$2"
8639   else
8640     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8641   fi
8642 else
8643   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8644 fi
8645
8646
8647
8648 cat > conftest.c << \EOF
8649 #ifdef __GNUC__
8650   gcc_yay;
8651 #endif
8652 EOF
8653 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8654   have_gcc_for_target=yes
8655 else
8656   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8657   have_gcc_for_target=no
8658 fi
8659 rm conftest.c
8660
8661
8662
8663
8664 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8665   if test -n "$with_build_time_tools"; then
8666     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8667 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8668     if test -x $with_build_time_tools/ar; then
8669       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8670       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8671       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8672 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8673     else
8674       echo "$as_me:$LINENO: result: no" >&5
8675 echo "${ECHO_T}no" >&6
8676     fi
8677   elif test $build != $host && test $have_gcc_for_target = yes; then
8678     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8679     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8680     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8681   fi
8682 fi
8683 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8684   # Extract the first word of "ar", so it can be a program name with args.
8685 set dummy ar; ac_word=$2
8686 echo "$as_me:$LINENO: checking for $ac_word" >&5
8687 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8688 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8689   echo $ECHO_N "(cached) $ECHO_C" >&6
8690 else
8691   case $AR_FOR_TARGET in
8692   [\\/]* | ?:[\\/]*)
8693   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8694   ;;
8695   *)
8696   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8697 for as_dir in $gcc_cv_tool_dirs
8698 do
8699   IFS=$as_save_IFS
8700   test -z "$as_dir" && as_dir=.
8701   for ac_exec_ext in '' $ac_executable_extensions; do
8702   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8703     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8704     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8705     break 2
8706   fi
8707 done
8708 done
8709
8710   ;;
8711 esac
8712 fi
8713 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8714
8715 if test -n "$AR_FOR_TARGET"; then
8716   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8717 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8718 else
8719   echo "$as_me:$LINENO: result: no" >&5
8720 echo "${ECHO_T}no" >&6
8721 fi
8722
8723 fi
8724 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8725
8726
8727 if test -n "$AR_FOR_TARGET"; then
8728   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8729 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8730   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8731 fi
8732
8733 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8734   for ncn_progname in ar; do
8735     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8736 set dummy ${ncn_progname}; ac_word=$2
8737 echo "$as_me:$LINENO: checking for $ac_word" >&5
8738 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8739 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8740   echo $ECHO_N "(cached) $ECHO_C" >&6
8741 else
8742   if test -n "$AR_FOR_TARGET"; then
8743   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8744 else
8745 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8746 for as_dir in $PATH
8747 do
8748   IFS=$as_save_IFS
8749   test -z "$as_dir" && as_dir=.
8750   for ac_exec_ext in '' $ac_executable_extensions; do
8751   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8752     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8753     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8754     break 2
8755   fi
8756 done
8757 done
8758
8759 fi
8760 fi
8761 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8762 if test -n "$AR_FOR_TARGET"; then
8763   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8764 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8765 else
8766   echo "$as_me:$LINENO: result: no" >&5
8767 echo "${ECHO_T}no" >&6
8768 fi
8769
8770   done
8771 fi
8772
8773 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8774   for ncn_progname in ar; do
8775     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8776 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8777     if test -x $with_build_time_tools/${ncn_progname}; then
8778       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8779       echo "$as_me:$LINENO: result: yes" >&5
8780 echo "${ECHO_T}yes" >&6
8781       break
8782     else
8783       echo "$as_me:$LINENO: result: no" >&5
8784 echo "${ECHO_T}no" >&6
8785     fi
8786   done
8787 fi
8788
8789 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8790   for ncn_progname in ar; do
8791     if test -n "$ncn_target_tool_prefix"; then
8792       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8793 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8794 echo "$as_me:$LINENO: checking for $ac_word" >&5
8795 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8796 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8797   echo $ECHO_N "(cached) $ECHO_C" >&6
8798 else
8799   if test -n "$AR_FOR_TARGET"; then
8800   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8801 else
8802 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8803 for as_dir in $PATH
8804 do
8805   IFS=$as_save_IFS
8806   test -z "$as_dir" && as_dir=.
8807   for ac_exec_ext in '' $ac_executable_extensions; do
8808   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8809     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8810     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8811     break 2
8812   fi
8813 done
8814 done
8815
8816 fi
8817 fi
8818 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8819 if test -n "$AR_FOR_TARGET"; then
8820   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8821 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8822 else
8823   echo "$as_me:$LINENO: result: no" >&5
8824 echo "${ECHO_T}no" >&6
8825 fi
8826
8827     fi
8828     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8829       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8830 set dummy ${ncn_progname}; ac_word=$2
8831 echo "$as_me:$LINENO: checking for $ac_word" >&5
8832 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8833 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8834   echo $ECHO_N "(cached) $ECHO_C" >&6
8835 else
8836   if test -n "$AR_FOR_TARGET"; then
8837   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8838 else
8839 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8840 for as_dir in $PATH
8841 do
8842   IFS=$as_save_IFS
8843   test -z "$as_dir" && as_dir=.
8844   for ac_exec_ext in '' $ac_executable_extensions; do
8845   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8846     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8847     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8848     break 2
8849   fi
8850 done
8851 done
8852
8853 fi
8854 fi
8855 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8856 if test -n "$AR_FOR_TARGET"; then
8857   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8858 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8859 else
8860   echo "$as_me:$LINENO: result: no" >&5
8861 echo "${ECHO_T}no" >&6
8862 fi
8863
8864     fi
8865     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8866   done
8867 fi
8868
8869 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8870   set dummy ar
8871   if test $build = $target ; then
8872     AR_FOR_TARGET="$2"
8873   else
8874     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8875   fi
8876 else
8877   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
8878 fi
8879
8880 else
8881   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8882 fi
8883
8884
8885
8886
8887 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8888   if test -n "$with_build_time_tools"; then
8889     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
8890 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
8891     if test -x $with_build_time_tools/as; then
8892       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
8893       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8894       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
8895 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
8896     else
8897       echo "$as_me:$LINENO: result: no" >&5
8898 echo "${ECHO_T}no" >&6
8899     fi
8900   elif test $build != $host && test $have_gcc_for_target = yes; then
8901     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
8902     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
8903     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8904   fi
8905 fi
8906 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8907   # Extract the first word of "as", so it can be a program name with args.
8908 set dummy as; ac_word=$2
8909 echo "$as_me:$LINENO: checking for $ac_word" >&5
8910 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8911 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
8912   echo $ECHO_N "(cached) $ECHO_C" >&6
8913 else
8914   case $AS_FOR_TARGET in
8915   [\\/]* | ?:[\\/]*)
8916   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
8917   ;;
8918   *)
8919   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8920 for as_dir in $gcc_cv_tool_dirs
8921 do
8922   IFS=$as_save_IFS
8923   test -z "$as_dir" && as_dir=.
8924   for ac_exec_ext in '' $ac_executable_extensions; do
8925   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8926     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8927     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8928     break 2
8929   fi
8930 done
8931 done
8932
8933   ;;
8934 esac
8935 fi
8936 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8937
8938 if test -n "$AS_FOR_TARGET"; then
8939   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8940 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8941 else
8942   echo "$as_me:$LINENO: result: no" >&5
8943 echo "${ECHO_T}no" >&6
8944 fi
8945
8946 fi
8947 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8948
8949
8950 if test -n "$AS_FOR_TARGET"; then
8951   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
8952 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8953   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8954 fi
8955
8956 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8957   for ncn_progname in as; do
8958     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8959 set dummy ${ncn_progname}; ac_word=$2
8960 echo "$as_me:$LINENO: checking for $ac_word" >&5
8961 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8962 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8963   echo $ECHO_N "(cached) $ECHO_C" >&6
8964 else
8965   if test -n "$AS_FOR_TARGET"; then
8966   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8967 else
8968 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8969 for as_dir in $PATH
8970 do
8971   IFS=$as_save_IFS
8972   test -z "$as_dir" && as_dir=.
8973   for ac_exec_ext in '' $ac_executable_extensions; do
8974   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8975     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
8976     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8977     break 2
8978   fi
8979 done
8980 done
8981
8982 fi
8983 fi
8984 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8985 if test -n "$AS_FOR_TARGET"; then
8986   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8987 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8988 else
8989   echo "$as_me:$LINENO: result: no" >&5
8990 echo "${ECHO_T}no" >&6
8991 fi
8992
8993   done
8994 fi
8995
8996 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
8997   for ncn_progname in as; do
8998     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8999 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9000     if test -x $with_build_time_tools/${ncn_progname}; then
9001       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9002       echo "$as_me:$LINENO: result: yes" >&5
9003 echo "${ECHO_T}yes" >&6
9004       break
9005     else
9006       echo "$as_me:$LINENO: result: no" >&5
9007 echo "${ECHO_T}no" >&6
9008     fi
9009   done
9010 fi
9011
9012 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9013   for ncn_progname in as; do
9014     if test -n "$ncn_target_tool_prefix"; then
9015       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9016 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9017 echo "$as_me:$LINENO: checking for $ac_word" >&5
9018 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9019 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9020   echo $ECHO_N "(cached) $ECHO_C" >&6
9021 else
9022   if test -n "$AS_FOR_TARGET"; then
9023   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9024 else
9025 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9026 for as_dir in $PATH
9027 do
9028   IFS=$as_save_IFS
9029   test -z "$as_dir" && as_dir=.
9030   for ac_exec_ext in '' $ac_executable_extensions; do
9031   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9032     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9033     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9034     break 2
9035   fi
9036 done
9037 done
9038
9039 fi
9040 fi
9041 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9042 if test -n "$AS_FOR_TARGET"; then
9043   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9044 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9045 else
9046   echo "$as_me:$LINENO: result: no" >&5
9047 echo "${ECHO_T}no" >&6
9048 fi
9049
9050     fi
9051     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9052       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9053 set dummy ${ncn_progname}; ac_word=$2
9054 echo "$as_me:$LINENO: checking for $ac_word" >&5
9055 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9056 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9057   echo $ECHO_N "(cached) $ECHO_C" >&6
9058 else
9059   if test -n "$AS_FOR_TARGET"; then
9060   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9061 else
9062 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9063 for as_dir in $PATH
9064 do
9065   IFS=$as_save_IFS
9066   test -z "$as_dir" && as_dir=.
9067   for ac_exec_ext in '' $ac_executable_extensions; do
9068   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9069     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9070     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9071     break 2
9072   fi
9073 done
9074 done
9075
9076 fi
9077 fi
9078 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9079 if test -n "$AS_FOR_TARGET"; then
9080   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9081 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9082 else
9083   echo "$as_me:$LINENO: result: no" >&5
9084 echo "${ECHO_T}no" >&6
9085 fi
9086
9087     fi
9088     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9089   done
9090 fi
9091
9092 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9093   set dummy as
9094   if test $build = $target ; then
9095     AS_FOR_TARGET="$2"
9096   else
9097     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9098   fi
9099 else
9100   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9101 fi
9102
9103 else
9104   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9105 fi
9106
9107
9108
9109
9110 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9111   if test -n "$with_build_time_tools"; then
9112     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9113 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9114     if test -x $with_build_time_tools/dlltool; then
9115       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9116       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9117       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9118 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9119     else
9120       echo "$as_me:$LINENO: result: no" >&5
9121 echo "${ECHO_T}no" >&6
9122     fi
9123   elif test $build != $host && test $have_gcc_for_target = yes; then
9124     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9125     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9126     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9127   fi
9128 fi
9129 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9130   # Extract the first word of "dlltool", so it can be a program name with args.
9131 set dummy dlltool; ac_word=$2
9132 echo "$as_me:$LINENO: checking for $ac_word" >&5
9133 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9134 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9135   echo $ECHO_N "(cached) $ECHO_C" >&6
9136 else
9137   case $DLLTOOL_FOR_TARGET in
9138   [\\/]* | ?:[\\/]*)
9139   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9140   ;;
9141   *)
9142   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9143 for as_dir in $gcc_cv_tool_dirs
9144 do
9145   IFS=$as_save_IFS
9146   test -z "$as_dir" && as_dir=.
9147   for ac_exec_ext in '' $ac_executable_extensions; do
9148   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9149     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9150     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9151     break 2
9152   fi
9153 done
9154 done
9155
9156   ;;
9157 esac
9158 fi
9159 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9160
9161 if test -n "$DLLTOOL_FOR_TARGET"; then
9162   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9163 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9164 else
9165   echo "$as_me:$LINENO: result: no" >&5
9166 echo "${ECHO_T}no" >&6
9167 fi
9168
9169 fi
9170 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9171
9172
9173 if test -n "$DLLTOOL_FOR_TARGET"; then
9174   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9175 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9176   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9177 fi
9178
9179 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9180   for ncn_progname in dlltool; do
9181     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9182 set dummy ${ncn_progname}; ac_word=$2
9183 echo "$as_me:$LINENO: checking for $ac_word" >&5
9184 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9185 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9186   echo $ECHO_N "(cached) $ECHO_C" >&6
9187 else
9188   if test -n "$DLLTOOL_FOR_TARGET"; then
9189   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9190 else
9191 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9192 for as_dir in $PATH
9193 do
9194   IFS=$as_save_IFS
9195   test -z "$as_dir" && as_dir=.
9196   for ac_exec_ext in '' $ac_executable_extensions; do
9197   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9198     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9199     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9200     break 2
9201   fi
9202 done
9203 done
9204
9205 fi
9206 fi
9207 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9208 if test -n "$DLLTOOL_FOR_TARGET"; then
9209   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9210 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9211 else
9212   echo "$as_me:$LINENO: result: no" >&5
9213 echo "${ECHO_T}no" >&6
9214 fi
9215
9216   done
9217 fi
9218
9219 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9220   for ncn_progname in dlltool; do
9221     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9222 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9223     if test -x $with_build_time_tools/${ncn_progname}; then
9224       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9225       echo "$as_me:$LINENO: result: yes" >&5
9226 echo "${ECHO_T}yes" >&6
9227       break
9228     else
9229       echo "$as_me:$LINENO: result: no" >&5
9230 echo "${ECHO_T}no" >&6
9231     fi
9232   done
9233 fi
9234
9235 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9236   for ncn_progname in dlltool; do
9237     if test -n "$ncn_target_tool_prefix"; then
9238       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9239 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9240 echo "$as_me:$LINENO: checking for $ac_word" >&5
9241 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9242 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9243   echo $ECHO_N "(cached) $ECHO_C" >&6
9244 else
9245   if test -n "$DLLTOOL_FOR_TARGET"; then
9246   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9247 else
9248 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9249 for as_dir in $PATH
9250 do
9251   IFS=$as_save_IFS
9252   test -z "$as_dir" && as_dir=.
9253   for ac_exec_ext in '' $ac_executable_extensions; do
9254   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9255     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9256     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9257     break 2
9258   fi
9259 done
9260 done
9261
9262 fi
9263 fi
9264 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9265 if test -n "$DLLTOOL_FOR_TARGET"; then
9266   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9267 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9268 else
9269   echo "$as_me:$LINENO: result: no" >&5
9270 echo "${ECHO_T}no" >&6
9271 fi
9272
9273     fi
9274     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9275       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9276 set dummy ${ncn_progname}; ac_word=$2
9277 echo "$as_me:$LINENO: checking for $ac_word" >&5
9278 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9279 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9280   echo $ECHO_N "(cached) $ECHO_C" >&6
9281 else
9282   if test -n "$DLLTOOL_FOR_TARGET"; then
9283   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9284 else
9285 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9286 for as_dir in $PATH
9287 do
9288   IFS=$as_save_IFS
9289   test -z "$as_dir" && as_dir=.
9290   for ac_exec_ext in '' $ac_executable_extensions; do
9291   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9292     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9293     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9294     break 2
9295   fi
9296 done
9297 done
9298
9299 fi
9300 fi
9301 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9302 if test -n "$DLLTOOL_FOR_TARGET"; then
9303   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9304 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9305 else
9306   echo "$as_me:$LINENO: result: no" >&5
9307 echo "${ECHO_T}no" >&6
9308 fi
9309
9310     fi
9311     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9312   done
9313 fi
9314
9315 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9316   set dummy dlltool
9317   if test $build = $target ; then
9318     DLLTOOL_FOR_TARGET="$2"
9319   else
9320     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9321   fi
9322 else
9323   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9324 fi
9325
9326 else
9327   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9328 fi
9329
9330
9331
9332
9333 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9334   if test -n "$with_build_time_tools"; then
9335     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9336 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9337     if test -x $with_build_time_tools/ld; then
9338       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9339       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9340       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9341 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9342     else
9343       echo "$as_me:$LINENO: result: no" >&5
9344 echo "${ECHO_T}no" >&6
9345     fi
9346   elif test $build != $host && test $have_gcc_for_target = yes; then
9347     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9348     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9349     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9350   fi
9351 fi
9352 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9353   # Extract the first word of "ld", so it can be a program name with args.
9354 set dummy ld; ac_word=$2
9355 echo "$as_me:$LINENO: checking for $ac_word" >&5
9356 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9357 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9358   echo $ECHO_N "(cached) $ECHO_C" >&6
9359 else
9360   case $LD_FOR_TARGET in
9361   [\\/]* | ?:[\\/]*)
9362   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9363   ;;
9364   *)
9365   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9366 for as_dir in $gcc_cv_tool_dirs
9367 do
9368   IFS=$as_save_IFS
9369   test -z "$as_dir" && as_dir=.
9370   for ac_exec_ext in '' $ac_executable_extensions; do
9371   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9372     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9373     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9374     break 2
9375   fi
9376 done
9377 done
9378
9379   ;;
9380 esac
9381 fi
9382 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9383
9384 if test -n "$LD_FOR_TARGET"; then
9385   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9386 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9387 else
9388   echo "$as_me:$LINENO: result: no" >&5
9389 echo "${ECHO_T}no" >&6
9390 fi
9391
9392 fi
9393 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9394
9395
9396 if test -n "$LD_FOR_TARGET"; then
9397   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9398 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9399   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9400 fi
9401
9402 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9403   for ncn_progname in ld; do
9404     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9405 set dummy ${ncn_progname}; ac_word=$2
9406 echo "$as_me:$LINENO: checking for $ac_word" >&5
9407 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9408 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9409   echo $ECHO_N "(cached) $ECHO_C" >&6
9410 else
9411   if test -n "$LD_FOR_TARGET"; then
9412   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9413 else
9414 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9415 for as_dir in $PATH
9416 do
9417   IFS=$as_save_IFS
9418   test -z "$as_dir" && as_dir=.
9419   for ac_exec_ext in '' $ac_executable_extensions; do
9420   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9421     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9422     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9423     break 2
9424   fi
9425 done
9426 done
9427
9428 fi
9429 fi
9430 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9431 if test -n "$LD_FOR_TARGET"; then
9432   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9433 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9434 else
9435   echo "$as_me:$LINENO: result: no" >&5
9436 echo "${ECHO_T}no" >&6
9437 fi
9438
9439   done
9440 fi
9441
9442 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9443   for ncn_progname in ld; do
9444     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9445 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9446     if test -x $with_build_time_tools/${ncn_progname}; then
9447       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9448       echo "$as_me:$LINENO: result: yes" >&5
9449 echo "${ECHO_T}yes" >&6
9450       break
9451     else
9452       echo "$as_me:$LINENO: result: no" >&5
9453 echo "${ECHO_T}no" >&6
9454     fi
9455   done
9456 fi
9457
9458 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9459   for ncn_progname in ld; do
9460     if test -n "$ncn_target_tool_prefix"; then
9461       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9462 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9463 echo "$as_me:$LINENO: checking for $ac_word" >&5
9464 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9465 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9466   echo $ECHO_N "(cached) $ECHO_C" >&6
9467 else
9468   if test -n "$LD_FOR_TARGET"; then
9469   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9470 else
9471 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9472 for as_dir in $PATH
9473 do
9474   IFS=$as_save_IFS
9475   test -z "$as_dir" && as_dir=.
9476   for ac_exec_ext in '' $ac_executable_extensions; do
9477   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9478     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9479     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9480     break 2
9481   fi
9482 done
9483 done
9484
9485 fi
9486 fi
9487 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9488 if test -n "$LD_FOR_TARGET"; then
9489   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9490 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9491 else
9492   echo "$as_me:$LINENO: result: no" >&5
9493 echo "${ECHO_T}no" >&6
9494 fi
9495
9496     fi
9497     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9498       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9499 set dummy ${ncn_progname}; ac_word=$2
9500 echo "$as_me:$LINENO: checking for $ac_word" >&5
9501 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9502 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9503   echo $ECHO_N "(cached) $ECHO_C" >&6
9504 else
9505   if test -n "$LD_FOR_TARGET"; then
9506   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9507 else
9508 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9509 for as_dir in $PATH
9510 do
9511   IFS=$as_save_IFS
9512   test -z "$as_dir" && as_dir=.
9513   for ac_exec_ext in '' $ac_executable_extensions; do
9514   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9515     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9516     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9517     break 2
9518   fi
9519 done
9520 done
9521
9522 fi
9523 fi
9524 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9525 if test -n "$LD_FOR_TARGET"; then
9526   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9527 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9528 else
9529   echo "$as_me:$LINENO: result: no" >&5
9530 echo "${ECHO_T}no" >&6
9531 fi
9532
9533     fi
9534     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9535   done
9536 fi
9537
9538 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9539   set dummy ld
9540   if test $build = $target ; then
9541     LD_FOR_TARGET="$2"
9542   else
9543     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9544   fi
9545 else
9546   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9547 fi
9548
9549 else
9550   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9551 fi
9552
9553
9554
9555
9556 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9557   if test -n "$with_build_time_tools"; then
9558     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9559 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9560     if test -x $with_build_time_tools/lipo; then
9561       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9562       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9563       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9564 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9565     else
9566       echo "$as_me:$LINENO: result: no" >&5
9567 echo "${ECHO_T}no" >&6
9568     fi
9569   elif test $build != $host && test $have_gcc_for_target = yes; then
9570     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9571     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9572     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9573   fi
9574 fi
9575 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9576   # Extract the first word of "lipo", so it can be a program name with args.
9577 set dummy lipo; ac_word=$2
9578 echo "$as_me:$LINENO: checking for $ac_word" >&5
9579 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9580 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9581   echo $ECHO_N "(cached) $ECHO_C" >&6
9582 else
9583   case $LIPO_FOR_TARGET in
9584   [\\/]* | ?:[\\/]*)
9585   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9586   ;;
9587   *)
9588   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9589 for as_dir in $gcc_cv_tool_dirs
9590 do
9591   IFS=$as_save_IFS
9592   test -z "$as_dir" && as_dir=.
9593   for ac_exec_ext in '' $ac_executable_extensions; do
9594   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9595     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9596     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9597     break 2
9598   fi
9599 done
9600 done
9601
9602   ;;
9603 esac
9604 fi
9605 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9606
9607 if test -n "$LIPO_FOR_TARGET"; then
9608   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9609 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9610 else
9611   echo "$as_me:$LINENO: result: no" >&5
9612 echo "${ECHO_T}no" >&6
9613 fi
9614
9615 fi
9616 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9617
9618
9619 if test -n "$LIPO_FOR_TARGET"; then
9620   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9621 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9622   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9623 fi
9624
9625 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9626   for ncn_progname in lipo; do
9627     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9628 set dummy ${ncn_progname}; ac_word=$2
9629 echo "$as_me:$LINENO: checking for $ac_word" >&5
9630 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9631 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9632   echo $ECHO_N "(cached) $ECHO_C" >&6
9633 else
9634   if test -n "$LIPO_FOR_TARGET"; then
9635   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9636 else
9637 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9638 for as_dir in $PATH
9639 do
9640   IFS=$as_save_IFS
9641   test -z "$as_dir" && as_dir=.
9642   for ac_exec_ext in '' $ac_executable_extensions; do
9643   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9644     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9645     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9646     break 2
9647   fi
9648 done
9649 done
9650
9651 fi
9652 fi
9653 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9654 if test -n "$LIPO_FOR_TARGET"; then
9655   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9656 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9657 else
9658   echo "$as_me:$LINENO: result: no" >&5
9659 echo "${ECHO_T}no" >&6
9660 fi
9661
9662   done
9663 fi
9664
9665 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9666   for ncn_progname in lipo; do
9667     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9668 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9669     if test -x $with_build_time_tools/${ncn_progname}; then
9670       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9671       echo "$as_me:$LINENO: result: yes" >&5
9672 echo "${ECHO_T}yes" >&6
9673       break
9674     else
9675       echo "$as_me:$LINENO: result: no" >&5
9676 echo "${ECHO_T}no" >&6
9677     fi
9678   done
9679 fi
9680
9681 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9682   for ncn_progname in lipo; do
9683     if test -n "$ncn_target_tool_prefix"; then
9684       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9685 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9686 echo "$as_me:$LINENO: checking for $ac_word" >&5
9687 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9688 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9689   echo $ECHO_N "(cached) $ECHO_C" >&6
9690 else
9691   if test -n "$LIPO_FOR_TARGET"; then
9692   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9693 else
9694 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9695 for as_dir in $PATH
9696 do
9697   IFS=$as_save_IFS
9698   test -z "$as_dir" && as_dir=.
9699   for ac_exec_ext in '' $ac_executable_extensions; do
9700   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9701     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9702     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9703     break 2
9704   fi
9705 done
9706 done
9707
9708 fi
9709 fi
9710 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9711 if test -n "$LIPO_FOR_TARGET"; then
9712   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9713 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9714 else
9715   echo "$as_me:$LINENO: result: no" >&5
9716 echo "${ECHO_T}no" >&6
9717 fi
9718
9719     fi
9720     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9721       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9722 set dummy ${ncn_progname}; ac_word=$2
9723 echo "$as_me:$LINENO: checking for $ac_word" >&5
9724 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9725 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9726   echo $ECHO_N "(cached) $ECHO_C" >&6
9727 else
9728   if test -n "$LIPO_FOR_TARGET"; then
9729   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9730 else
9731 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9732 for as_dir in $PATH
9733 do
9734   IFS=$as_save_IFS
9735   test -z "$as_dir" && as_dir=.
9736   for ac_exec_ext in '' $ac_executable_extensions; do
9737   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9738     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9739     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9740     break 2
9741   fi
9742 done
9743 done
9744
9745 fi
9746 fi
9747 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9748 if test -n "$LIPO_FOR_TARGET"; then
9749   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9750 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9751 else
9752   echo "$as_me:$LINENO: result: no" >&5
9753 echo "${ECHO_T}no" >&6
9754 fi
9755
9756     fi
9757     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9758   done
9759 fi
9760
9761 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9762   set dummy lipo
9763   if test $build = $target ; then
9764     LIPO_FOR_TARGET="$2"
9765   else
9766     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9767   fi
9768 else
9769   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9770 fi
9771
9772 else
9773   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9774 fi
9775
9776
9777
9778
9779 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9780   if test -n "$with_build_time_tools"; then
9781     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9782 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9783     if test -x $with_build_time_tools/nm; then
9784       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9785       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9786       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9787 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9788     else
9789       echo "$as_me:$LINENO: result: no" >&5
9790 echo "${ECHO_T}no" >&6
9791     fi
9792   elif test $build != $host && test $have_gcc_for_target = yes; then
9793     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9794     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9795     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9796   fi
9797 fi
9798 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9799   # Extract the first word of "nm", so it can be a program name with args.
9800 set dummy nm; ac_word=$2
9801 echo "$as_me:$LINENO: checking for $ac_word" >&5
9802 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9803 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9804   echo $ECHO_N "(cached) $ECHO_C" >&6
9805 else
9806   case $NM_FOR_TARGET in
9807   [\\/]* | ?:[\\/]*)
9808   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9809   ;;
9810   *)
9811   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9812 for as_dir in $gcc_cv_tool_dirs
9813 do
9814   IFS=$as_save_IFS
9815   test -z "$as_dir" && as_dir=.
9816   for ac_exec_ext in '' $ac_executable_extensions; do
9817   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9818     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9819     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9820     break 2
9821   fi
9822 done
9823 done
9824
9825   ;;
9826 esac
9827 fi
9828 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9829
9830 if test -n "$NM_FOR_TARGET"; then
9831   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9832 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9833 else
9834   echo "$as_me:$LINENO: result: no" >&5
9835 echo "${ECHO_T}no" >&6
9836 fi
9837
9838 fi
9839 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9840
9841
9842 if test -n "$NM_FOR_TARGET"; then
9843   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9844 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9845   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9846 fi
9847
9848 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9849   for ncn_progname in nm; do
9850     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9851 set dummy ${ncn_progname}; ac_word=$2
9852 echo "$as_me:$LINENO: checking for $ac_word" >&5
9853 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9854 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9855   echo $ECHO_N "(cached) $ECHO_C" >&6
9856 else
9857   if test -n "$NM_FOR_TARGET"; then
9858   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9859 else
9860 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9861 for as_dir in $PATH
9862 do
9863   IFS=$as_save_IFS
9864   test -z "$as_dir" && as_dir=.
9865   for ac_exec_ext in '' $ac_executable_extensions; do
9866   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9867     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9868     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9869     break 2
9870   fi
9871 done
9872 done
9873
9874 fi
9875 fi
9876 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9877 if test -n "$NM_FOR_TARGET"; then
9878   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9879 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9880 else
9881   echo "$as_me:$LINENO: result: no" >&5
9882 echo "${ECHO_T}no" >&6
9883 fi
9884
9885   done
9886 fi
9887
9888 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
9889   for ncn_progname in nm; do
9890     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9891 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9892     if test -x $with_build_time_tools/${ncn_progname}; then
9893       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9894       echo "$as_me:$LINENO: result: yes" >&5
9895 echo "${ECHO_T}yes" >&6
9896       break
9897     else
9898       echo "$as_me:$LINENO: result: no" >&5
9899 echo "${ECHO_T}no" >&6
9900     fi
9901   done
9902 fi
9903
9904 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
9905   for ncn_progname in nm; do
9906     if test -n "$ncn_target_tool_prefix"; then
9907       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9908 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9909 echo "$as_me:$LINENO: checking for $ac_word" >&5
9910 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9911 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9912   echo $ECHO_N "(cached) $ECHO_C" >&6
9913 else
9914   if test -n "$NM_FOR_TARGET"; then
9915   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9916 else
9917 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9918 for as_dir in $PATH
9919 do
9920   IFS=$as_save_IFS
9921   test -z "$as_dir" && as_dir=.
9922   for ac_exec_ext in '' $ac_executable_extensions; do
9923   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9924     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9925     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9926     break 2
9927   fi
9928 done
9929 done
9930
9931 fi
9932 fi
9933 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9934 if test -n "$NM_FOR_TARGET"; then
9935   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9936 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9937 else
9938   echo "$as_me:$LINENO: result: no" >&5
9939 echo "${ECHO_T}no" >&6
9940 fi
9941
9942     fi
9943     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
9944       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9945 set dummy ${ncn_progname}; ac_word=$2
9946 echo "$as_me:$LINENO: checking for $ac_word" >&5
9947 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9948 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9949   echo $ECHO_N "(cached) $ECHO_C" >&6
9950 else
9951   if test -n "$NM_FOR_TARGET"; then
9952   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9953 else
9954 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9955 for as_dir in $PATH
9956 do
9957   IFS=$as_save_IFS
9958   test -z "$as_dir" && as_dir=.
9959   for ac_exec_ext in '' $ac_executable_extensions; do
9960   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9961     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9962     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9963     break 2
9964   fi
9965 done
9966 done
9967
9968 fi
9969 fi
9970 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9971 if test -n "$NM_FOR_TARGET"; then
9972   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9973 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9974 else
9975   echo "$as_me:$LINENO: result: no" >&5
9976 echo "${ECHO_T}no" >&6
9977 fi
9978
9979     fi
9980     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
9981   done
9982 fi
9983
9984 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
9985   set dummy nm
9986   if test $build = $target ; then
9987     NM_FOR_TARGET="$2"
9988   else
9989     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
9990   fi
9991 else
9992   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
9993 fi
9994
9995 else
9996   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9997 fi
9998
9999
10000
10001
10002 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10003   if test -n "$with_build_time_tools"; then
10004     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10005 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10006     if test -x $with_build_time_tools/objdump; then
10007       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10008       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10009       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10010 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10011     else
10012       echo "$as_me:$LINENO: result: no" >&5
10013 echo "${ECHO_T}no" >&6
10014     fi
10015   elif test $build != $host && test $have_gcc_for_target = yes; then
10016     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10017     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10018     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10019   fi
10020 fi
10021 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10022   # Extract the first word of "objdump", so it can be a program name with args.
10023 set dummy objdump; ac_word=$2
10024 echo "$as_me:$LINENO: checking for $ac_word" >&5
10025 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10026 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10027   echo $ECHO_N "(cached) $ECHO_C" >&6
10028 else
10029   case $OBJDUMP_FOR_TARGET in
10030   [\\/]* | ?:[\\/]*)
10031   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10032   ;;
10033   *)
10034   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10035 for as_dir in $gcc_cv_tool_dirs
10036 do
10037   IFS=$as_save_IFS
10038   test -z "$as_dir" && as_dir=.
10039   for ac_exec_ext in '' $ac_executable_extensions; do
10040   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10041     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10042     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10043     break 2
10044   fi
10045 done
10046 done
10047
10048   ;;
10049 esac
10050 fi
10051 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10052
10053 if test -n "$OBJDUMP_FOR_TARGET"; then
10054   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10055 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10056 else
10057   echo "$as_me:$LINENO: result: no" >&5
10058 echo "${ECHO_T}no" >&6
10059 fi
10060
10061 fi
10062 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10063
10064
10065 if test -n "$OBJDUMP_FOR_TARGET"; then
10066   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10067 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10068   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10069 fi
10070
10071 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10072   for ncn_progname in objdump; do
10073     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10074 set dummy ${ncn_progname}; ac_word=$2
10075 echo "$as_me:$LINENO: checking for $ac_word" >&5
10076 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10077 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10078   echo $ECHO_N "(cached) $ECHO_C" >&6
10079 else
10080   if test -n "$OBJDUMP_FOR_TARGET"; then
10081   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10082 else
10083 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10084 for as_dir in $PATH
10085 do
10086   IFS=$as_save_IFS
10087   test -z "$as_dir" && as_dir=.
10088   for ac_exec_ext in '' $ac_executable_extensions; do
10089   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10090     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10091     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10092     break 2
10093   fi
10094 done
10095 done
10096
10097 fi
10098 fi
10099 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10100 if test -n "$OBJDUMP_FOR_TARGET"; then
10101   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10102 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10103 else
10104   echo "$as_me:$LINENO: result: no" >&5
10105 echo "${ECHO_T}no" >&6
10106 fi
10107
10108   done
10109 fi
10110
10111 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10112   for ncn_progname in objdump; do
10113     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10114 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10115     if test -x $with_build_time_tools/${ncn_progname}; then
10116       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10117       echo "$as_me:$LINENO: result: yes" >&5
10118 echo "${ECHO_T}yes" >&6
10119       break
10120     else
10121       echo "$as_me:$LINENO: result: no" >&5
10122 echo "${ECHO_T}no" >&6
10123     fi
10124   done
10125 fi
10126
10127 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10128   for ncn_progname in objdump; do
10129     if test -n "$ncn_target_tool_prefix"; then
10130       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10131 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10132 echo "$as_me:$LINENO: checking for $ac_word" >&5
10133 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10134 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10135   echo $ECHO_N "(cached) $ECHO_C" >&6
10136 else
10137   if test -n "$OBJDUMP_FOR_TARGET"; then
10138   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10139 else
10140 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10141 for as_dir in $PATH
10142 do
10143   IFS=$as_save_IFS
10144   test -z "$as_dir" && as_dir=.
10145   for ac_exec_ext in '' $ac_executable_extensions; do
10146   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10147     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10148     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10149     break 2
10150   fi
10151 done
10152 done
10153
10154 fi
10155 fi
10156 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10157 if test -n "$OBJDUMP_FOR_TARGET"; then
10158   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10159 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10160 else
10161   echo "$as_me:$LINENO: result: no" >&5
10162 echo "${ECHO_T}no" >&6
10163 fi
10164
10165     fi
10166     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10167       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10168 set dummy ${ncn_progname}; ac_word=$2
10169 echo "$as_me:$LINENO: checking for $ac_word" >&5
10170 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10171 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10172   echo $ECHO_N "(cached) $ECHO_C" >&6
10173 else
10174   if test -n "$OBJDUMP_FOR_TARGET"; then
10175   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10176 else
10177 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10178 for as_dir in $PATH
10179 do
10180   IFS=$as_save_IFS
10181   test -z "$as_dir" && as_dir=.
10182   for ac_exec_ext in '' $ac_executable_extensions; do
10183   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10184     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10185     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10186     break 2
10187   fi
10188 done
10189 done
10190
10191 fi
10192 fi
10193 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10194 if test -n "$OBJDUMP_FOR_TARGET"; then
10195   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10196 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10197 else
10198   echo "$as_me:$LINENO: result: no" >&5
10199 echo "${ECHO_T}no" >&6
10200 fi
10201
10202     fi
10203     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10204   done
10205 fi
10206
10207 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10208   set dummy objdump
10209   if test $build = $target ; then
10210     OBJDUMP_FOR_TARGET="$2"
10211   else
10212     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10213   fi
10214 else
10215   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10216 fi
10217
10218 else
10219   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10220 fi
10221
10222
10223
10224
10225 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10226   if test -n "$with_build_time_tools"; then
10227     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10228 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10229     if test -x $with_build_time_tools/ranlib; then
10230       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10231       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10232       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10233 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10234     else
10235       echo "$as_me:$LINENO: result: no" >&5
10236 echo "${ECHO_T}no" >&6
10237     fi
10238   elif test $build != $host && test $have_gcc_for_target = yes; then
10239     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10240     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10241     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10242   fi
10243 fi
10244 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10245   # Extract the first word of "ranlib", so it can be a program name with args.
10246 set dummy ranlib; ac_word=$2
10247 echo "$as_me:$LINENO: checking for $ac_word" >&5
10248 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10249 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10250   echo $ECHO_N "(cached) $ECHO_C" >&6
10251 else
10252   case $RANLIB_FOR_TARGET in
10253   [\\/]* | ?:[\\/]*)
10254   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10255   ;;
10256   *)
10257   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10258 for as_dir in $gcc_cv_tool_dirs
10259 do
10260   IFS=$as_save_IFS
10261   test -z "$as_dir" && as_dir=.
10262   for ac_exec_ext in '' $ac_executable_extensions; do
10263   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10264     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10265     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10266     break 2
10267   fi
10268 done
10269 done
10270
10271   ;;
10272 esac
10273 fi
10274 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10275
10276 if test -n "$RANLIB_FOR_TARGET"; then
10277   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10278 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10279 else
10280   echo "$as_me:$LINENO: result: no" >&5
10281 echo "${ECHO_T}no" >&6
10282 fi
10283
10284 fi
10285 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10286
10287
10288 if test -n "$RANLIB_FOR_TARGET"; then
10289   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10290 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10291   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10292 fi
10293
10294 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10295   for ncn_progname in ranlib; do
10296     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10297 set dummy ${ncn_progname}; ac_word=$2
10298 echo "$as_me:$LINENO: checking for $ac_word" >&5
10299 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10300 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10301   echo $ECHO_N "(cached) $ECHO_C" >&6
10302 else
10303   if test -n "$RANLIB_FOR_TARGET"; then
10304   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10305 else
10306 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10307 for as_dir in $PATH
10308 do
10309   IFS=$as_save_IFS
10310   test -z "$as_dir" && as_dir=.
10311   for ac_exec_ext in '' $ac_executable_extensions; do
10312   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10313     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10314     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10315     break 2
10316   fi
10317 done
10318 done
10319
10320 fi
10321 fi
10322 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10323 if test -n "$RANLIB_FOR_TARGET"; then
10324   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10325 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10326 else
10327   echo "$as_me:$LINENO: result: no" >&5
10328 echo "${ECHO_T}no" >&6
10329 fi
10330
10331   done
10332 fi
10333
10334 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10335   for ncn_progname in ranlib; do
10336     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10337 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10338     if test -x $with_build_time_tools/${ncn_progname}; then
10339       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10340       echo "$as_me:$LINENO: result: yes" >&5
10341 echo "${ECHO_T}yes" >&6
10342       break
10343     else
10344       echo "$as_me:$LINENO: result: no" >&5
10345 echo "${ECHO_T}no" >&6
10346     fi
10347   done
10348 fi
10349
10350 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10351   for ncn_progname in ranlib; do
10352     if test -n "$ncn_target_tool_prefix"; then
10353       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10354 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10355 echo "$as_me:$LINENO: checking for $ac_word" >&5
10356 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10357 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10358   echo $ECHO_N "(cached) $ECHO_C" >&6
10359 else
10360   if test -n "$RANLIB_FOR_TARGET"; then
10361   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10362 else
10363 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10364 for as_dir in $PATH
10365 do
10366   IFS=$as_save_IFS
10367   test -z "$as_dir" && as_dir=.
10368   for ac_exec_ext in '' $ac_executable_extensions; do
10369   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10370     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10371     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10372     break 2
10373   fi
10374 done
10375 done
10376
10377 fi
10378 fi
10379 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10380 if test -n "$RANLIB_FOR_TARGET"; then
10381   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10382 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10383 else
10384   echo "$as_me:$LINENO: result: no" >&5
10385 echo "${ECHO_T}no" >&6
10386 fi
10387
10388     fi
10389     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10390       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10391 set dummy ${ncn_progname}; ac_word=$2
10392 echo "$as_me:$LINENO: checking for $ac_word" >&5
10393 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10394 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10395   echo $ECHO_N "(cached) $ECHO_C" >&6
10396 else
10397   if test -n "$RANLIB_FOR_TARGET"; then
10398   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10399 else
10400 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10401 for as_dir in $PATH
10402 do
10403   IFS=$as_save_IFS
10404   test -z "$as_dir" && as_dir=.
10405   for ac_exec_ext in '' $ac_executable_extensions; do
10406   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10407     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10408     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10409     break 2
10410   fi
10411 done
10412 done
10413
10414 fi
10415 fi
10416 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10417 if test -n "$RANLIB_FOR_TARGET"; then
10418   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10419 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10420 else
10421   echo "$as_me:$LINENO: result: no" >&5
10422 echo "${ECHO_T}no" >&6
10423 fi
10424
10425     fi
10426     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10427   done
10428 fi
10429
10430 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10431   set dummy ranlib
10432   if test $build = $target ; then
10433     RANLIB_FOR_TARGET="$2"
10434   else
10435     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10436   fi
10437 else
10438   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10439 fi
10440
10441 else
10442   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10443 fi
10444
10445
10446
10447
10448 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10449   if test -n "$with_build_time_tools"; then
10450     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10451 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10452     if test -x $with_build_time_tools/strip; then
10453       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10454       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10455       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10456 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10457     else
10458       echo "$as_me:$LINENO: result: no" >&5
10459 echo "${ECHO_T}no" >&6
10460     fi
10461   elif test $build != $host && test $have_gcc_for_target = yes; then
10462     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10463     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10464     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10465   fi
10466 fi
10467 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10468   # Extract the first word of "strip", so it can be a program name with args.
10469 set dummy strip; ac_word=$2
10470 echo "$as_me:$LINENO: checking for $ac_word" >&5
10471 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10472 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10473   echo $ECHO_N "(cached) $ECHO_C" >&6
10474 else
10475   case $STRIP_FOR_TARGET in
10476   [\\/]* | ?:[\\/]*)
10477   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10478   ;;
10479   *)
10480   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10481 for as_dir in $gcc_cv_tool_dirs
10482 do
10483   IFS=$as_save_IFS
10484   test -z "$as_dir" && as_dir=.
10485   for ac_exec_ext in '' $ac_executable_extensions; do
10486   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10487     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10488     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10489     break 2
10490   fi
10491 done
10492 done
10493
10494   ;;
10495 esac
10496 fi
10497 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10498
10499 if test -n "$STRIP_FOR_TARGET"; then
10500   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10501 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10502 else
10503   echo "$as_me:$LINENO: result: no" >&5
10504 echo "${ECHO_T}no" >&6
10505 fi
10506
10507 fi
10508 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10509
10510
10511 if test -n "$STRIP_FOR_TARGET"; then
10512   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10513 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10514   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10515 fi
10516
10517 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10518   for ncn_progname in strip; do
10519     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10520 set dummy ${ncn_progname}; ac_word=$2
10521 echo "$as_me:$LINENO: checking for $ac_word" >&5
10522 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10523 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10524   echo $ECHO_N "(cached) $ECHO_C" >&6
10525 else
10526   if test -n "$STRIP_FOR_TARGET"; then
10527   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10528 else
10529 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10530 for as_dir in $PATH
10531 do
10532   IFS=$as_save_IFS
10533   test -z "$as_dir" && as_dir=.
10534   for ac_exec_ext in '' $ac_executable_extensions; do
10535   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10536     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10537     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10538     break 2
10539   fi
10540 done
10541 done
10542
10543 fi
10544 fi
10545 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10546 if test -n "$STRIP_FOR_TARGET"; then
10547   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10548 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10549 else
10550   echo "$as_me:$LINENO: result: no" >&5
10551 echo "${ECHO_T}no" >&6
10552 fi
10553
10554   done
10555 fi
10556
10557 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10558   for ncn_progname in strip; do
10559     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10560 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10561     if test -x $with_build_time_tools/${ncn_progname}; then
10562       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10563       echo "$as_me:$LINENO: result: yes" >&5
10564 echo "${ECHO_T}yes" >&6
10565       break
10566     else
10567       echo "$as_me:$LINENO: result: no" >&5
10568 echo "${ECHO_T}no" >&6
10569     fi
10570   done
10571 fi
10572
10573 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10574   for ncn_progname in strip; do
10575     if test -n "$ncn_target_tool_prefix"; then
10576       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10577 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10578 echo "$as_me:$LINENO: checking for $ac_word" >&5
10579 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10580 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10581   echo $ECHO_N "(cached) $ECHO_C" >&6
10582 else
10583   if test -n "$STRIP_FOR_TARGET"; then
10584   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10585 else
10586 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10587 for as_dir in $PATH
10588 do
10589   IFS=$as_save_IFS
10590   test -z "$as_dir" && as_dir=.
10591   for ac_exec_ext in '' $ac_executable_extensions; do
10592   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10593     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10594     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10595     break 2
10596   fi
10597 done
10598 done
10599
10600 fi
10601 fi
10602 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10603 if test -n "$STRIP_FOR_TARGET"; then
10604   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10605 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10606 else
10607   echo "$as_me:$LINENO: result: no" >&5
10608 echo "${ECHO_T}no" >&6
10609 fi
10610
10611     fi
10612     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10613       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10614 set dummy ${ncn_progname}; ac_word=$2
10615 echo "$as_me:$LINENO: checking for $ac_word" >&5
10616 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10617 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10618   echo $ECHO_N "(cached) $ECHO_C" >&6
10619 else
10620   if test -n "$STRIP_FOR_TARGET"; then
10621   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10622 else
10623 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10624 for as_dir in $PATH
10625 do
10626   IFS=$as_save_IFS
10627   test -z "$as_dir" && as_dir=.
10628   for ac_exec_ext in '' $ac_executable_extensions; do
10629   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10630     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10631     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10632     break 2
10633   fi
10634 done
10635 done
10636
10637 fi
10638 fi
10639 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10640 if test -n "$STRIP_FOR_TARGET"; then
10641   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10642 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10643 else
10644   echo "$as_me:$LINENO: result: no" >&5
10645 echo "${ECHO_T}no" >&6
10646 fi
10647
10648     fi
10649     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10650   done
10651 fi
10652
10653 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10654   set dummy strip
10655   if test $build = $target ; then
10656     STRIP_FOR_TARGET="$2"
10657   else
10658     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10659   fi
10660 else
10661   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10662 fi
10663
10664 else
10665   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10666 fi
10667
10668
10669
10670
10671 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10672   if test -n "$with_build_time_tools"; then
10673     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10674 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10675     if test -x $with_build_time_tools/windres; then
10676       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10677       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10678       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10679 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10680     else
10681       echo "$as_me:$LINENO: result: no" >&5
10682 echo "${ECHO_T}no" >&6
10683     fi
10684   elif test $build != $host && test $have_gcc_for_target = yes; then
10685     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10686     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10687     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10688   fi
10689 fi
10690 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10691   # Extract the first word of "windres", so it can be a program name with args.
10692 set dummy windres; ac_word=$2
10693 echo "$as_me:$LINENO: checking for $ac_word" >&5
10694 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10695 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10696   echo $ECHO_N "(cached) $ECHO_C" >&6
10697 else
10698   case $WINDRES_FOR_TARGET in
10699   [\\/]* | ?:[\\/]*)
10700   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10701   ;;
10702   *)
10703   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10704 for as_dir in $gcc_cv_tool_dirs
10705 do
10706   IFS=$as_save_IFS
10707   test -z "$as_dir" && as_dir=.
10708   for ac_exec_ext in '' $ac_executable_extensions; do
10709   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10710     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10711     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10712     break 2
10713   fi
10714 done
10715 done
10716
10717   ;;
10718 esac
10719 fi
10720 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10721
10722 if test -n "$WINDRES_FOR_TARGET"; then
10723   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10724 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10725 else
10726   echo "$as_me:$LINENO: result: no" >&5
10727 echo "${ECHO_T}no" >&6
10728 fi
10729
10730 fi
10731 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10732
10733
10734 if test -n "$WINDRES_FOR_TARGET"; then
10735   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10736 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10737   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10738 fi
10739
10740 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10741   for ncn_progname in windres; do
10742     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10743 set dummy ${ncn_progname}; ac_word=$2
10744 echo "$as_me:$LINENO: checking for $ac_word" >&5
10745 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10746 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10747   echo $ECHO_N "(cached) $ECHO_C" >&6
10748 else
10749   if test -n "$WINDRES_FOR_TARGET"; then
10750   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10751 else
10752 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10753 for as_dir in $PATH
10754 do
10755   IFS=$as_save_IFS
10756   test -z "$as_dir" && as_dir=.
10757   for ac_exec_ext in '' $ac_executable_extensions; do
10758   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10759     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10760     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10761     break 2
10762   fi
10763 done
10764 done
10765
10766 fi
10767 fi
10768 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10769 if test -n "$WINDRES_FOR_TARGET"; then
10770   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10771 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10772 else
10773   echo "$as_me:$LINENO: result: no" >&5
10774 echo "${ECHO_T}no" >&6
10775 fi
10776
10777   done
10778 fi
10779
10780 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10781   for ncn_progname in windres; do
10782     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10783 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10784     if test -x $with_build_time_tools/${ncn_progname}; then
10785       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10786       echo "$as_me:$LINENO: result: yes" >&5
10787 echo "${ECHO_T}yes" >&6
10788       break
10789     else
10790       echo "$as_me:$LINENO: result: no" >&5
10791 echo "${ECHO_T}no" >&6
10792     fi
10793   done
10794 fi
10795
10796 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10797   for ncn_progname in windres; do
10798     if test -n "$ncn_target_tool_prefix"; then
10799       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10800 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10801 echo "$as_me:$LINENO: checking for $ac_word" >&5
10802 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10803 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10804   echo $ECHO_N "(cached) $ECHO_C" >&6
10805 else
10806   if test -n "$WINDRES_FOR_TARGET"; then
10807   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10808 else
10809 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10810 for as_dir in $PATH
10811 do
10812   IFS=$as_save_IFS
10813   test -z "$as_dir" && as_dir=.
10814   for ac_exec_ext in '' $ac_executable_extensions; do
10815   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10816     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10817     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10818     break 2
10819   fi
10820 done
10821 done
10822
10823 fi
10824 fi
10825 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10826 if test -n "$WINDRES_FOR_TARGET"; then
10827   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10828 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10829 else
10830   echo "$as_me:$LINENO: result: no" >&5
10831 echo "${ECHO_T}no" >&6
10832 fi
10833
10834     fi
10835     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10836       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10837 set dummy ${ncn_progname}; ac_word=$2
10838 echo "$as_me:$LINENO: checking for $ac_word" >&5
10839 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10840 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10841   echo $ECHO_N "(cached) $ECHO_C" >&6
10842 else
10843   if test -n "$WINDRES_FOR_TARGET"; then
10844   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10845 else
10846 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10847 for as_dir in $PATH
10848 do
10849   IFS=$as_save_IFS
10850   test -z "$as_dir" && as_dir=.
10851   for ac_exec_ext in '' $ac_executable_extensions; do
10852   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10853     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10854     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10855     break 2
10856   fi
10857 done
10858 done
10859
10860 fi
10861 fi
10862 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10863 if test -n "$WINDRES_FOR_TARGET"; then
10864   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10865 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10866 else
10867   echo "$as_me:$LINENO: result: no" >&5
10868 echo "${ECHO_T}no" >&6
10869 fi
10870
10871     fi
10872     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10873   done
10874 fi
10875
10876 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10877   set dummy windres
10878   if test $build = $target ; then
10879     WINDRES_FOR_TARGET="$2"
10880   else
10881     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10882   fi
10883 else
10884   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
10885 fi
10886
10887 else
10888   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10889 fi
10890
10891
10892
10893
10894 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
10895   if test -n "$with_build_time_tools"; then
10896     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
10897 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
10898     if test -x $with_build_time_tools/windmc; then
10899       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
10900       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10901       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
10902 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
10903     else
10904       echo "$as_me:$LINENO: result: no" >&5
10905 echo "${ECHO_T}no" >&6
10906     fi
10907   elif test $build != $host && test $have_gcc_for_target = yes; then
10908     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
10909     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
10910     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10911   fi
10912 fi
10913 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10914   # Extract the first word of "windmc", so it can be a program name with args.
10915 set dummy windmc; ac_word=$2
10916 echo "$as_me:$LINENO: checking for $ac_word" >&5
10917 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10918 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
10919   echo $ECHO_N "(cached) $ECHO_C" >&6
10920 else
10921   case $WINDMC_FOR_TARGET in
10922   [\\/]* | ?:[\\/]*)
10923   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
10924   ;;
10925   *)
10926   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10927 for as_dir in $gcc_cv_tool_dirs
10928 do
10929   IFS=$as_save_IFS
10930   test -z "$as_dir" && as_dir=.
10931   for ac_exec_ext in '' $ac_executable_extensions; do
10932   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10933     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10934     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10935     break 2
10936   fi
10937 done
10938 done
10939
10940   ;;
10941 esac
10942 fi
10943 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
10944
10945 if test -n "$WINDMC_FOR_TARGET"; then
10946   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
10947 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
10948 else
10949   echo "$as_me:$LINENO: result: no" >&5
10950 echo "${ECHO_T}no" >&6
10951 fi
10952
10953 fi
10954 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
10955
10956
10957 if test -n "$WINDMC_FOR_TARGET"; then
10958   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10959 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
10960   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
10961 fi
10962
10963 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
10964   for ncn_progname in windmc; do
10965     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10966 set dummy ${ncn_progname}; ac_word=$2
10967 echo "$as_me:$LINENO: checking for $ac_word" >&5
10968 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10969 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
10970   echo $ECHO_N "(cached) $ECHO_C" >&6
10971 else
10972   if test -n "$WINDMC_FOR_TARGET"; then
10973   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
10974 else
10975 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10976 for as_dir in $PATH
10977 do
10978   IFS=$as_save_IFS
10979   test -z "$as_dir" && as_dir=.
10980   for ac_exec_ext in '' $ac_executable_extensions; do
10981   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10982     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
10983     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10984     break 2
10985   fi
10986 done
10987 done
10988
10989 fi
10990 fi
10991 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
10992 if test -n "$WINDMC_FOR_TARGET"; then
10993   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
10994 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
10995 else
10996   echo "$as_me:$LINENO: result: no" >&5
10997 echo "${ECHO_T}no" >&6
10998 fi
10999
11000   done
11001 fi
11002
11003 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11004   for ncn_progname in windmc; do
11005     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11006 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11007     if test -x $with_build_time_tools/${ncn_progname}; then
11008       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11009       echo "$as_me:$LINENO: result: yes" >&5
11010 echo "${ECHO_T}yes" >&6
11011       break
11012     else
11013       echo "$as_me:$LINENO: result: no" >&5
11014 echo "${ECHO_T}no" >&6
11015     fi
11016   done
11017 fi
11018
11019 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11020   for ncn_progname in windmc; do
11021     if test -n "$ncn_target_tool_prefix"; then
11022       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11023 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11024 echo "$as_me:$LINENO: checking for $ac_word" >&5
11025 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11026 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11027   echo $ECHO_N "(cached) $ECHO_C" >&6
11028 else
11029   if test -n "$WINDMC_FOR_TARGET"; then
11030   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11031 else
11032 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11033 for as_dir in $PATH
11034 do
11035   IFS=$as_save_IFS
11036   test -z "$as_dir" && as_dir=.
11037   for ac_exec_ext in '' $ac_executable_extensions; do
11038   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11039     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11040     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11041     break 2
11042   fi
11043 done
11044 done
11045
11046 fi
11047 fi
11048 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11049 if test -n "$WINDMC_FOR_TARGET"; then
11050   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11051 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11052 else
11053   echo "$as_me:$LINENO: result: no" >&5
11054 echo "${ECHO_T}no" >&6
11055 fi
11056
11057     fi
11058     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11059       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11060 set dummy ${ncn_progname}; ac_word=$2
11061 echo "$as_me:$LINENO: checking for $ac_word" >&5
11062 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11063 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11064   echo $ECHO_N "(cached) $ECHO_C" >&6
11065 else
11066   if test -n "$WINDMC_FOR_TARGET"; then
11067   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11068 else
11069 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11070 for as_dir in $PATH
11071 do
11072   IFS=$as_save_IFS
11073   test -z "$as_dir" && as_dir=.
11074   for ac_exec_ext in '' $ac_executable_extensions; do
11075   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11076     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11077     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11078     break 2
11079   fi
11080 done
11081 done
11082
11083 fi
11084 fi
11085 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11086 if test -n "$WINDMC_FOR_TARGET"; then
11087   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11088 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11089 else
11090   echo "$as_me:$LINENO: result: no" >&5
11091 echo "${ECHO_T}no" >&6
11092 fi
11093
11094     fi
11095     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11096   done
11097 fi
11098
11099 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11100   set dummy windmc
11101   if test $build = $target ; then
11102     WINDMC_FOR_TARGET="$2"
11103   else
11104     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11105   fi
11106 else
11107   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11108 fi
11109
11110 else
11111   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11112 fi
11113
11114
11115 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11116
11117 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11118 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11119 if test "x${build}" != "x${host}" ; then
11120   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11121     # We already found the complete path
11122     ac_dir=`dirname $AR_FOR_TARGET`
11123     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11124 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11125   else
11126     # Canadian cross, just use what we found
11127     echo "$as_me:$LINENO: result: pre-installed" >&5
11128 echo "${ECHO_T}pre-installed" >&6
11129   fi
11130 else
11131   ok=yes
11132   case " ${configdirs} " in
11133     *" binutils "*) ;;
11134     *) ok=no ;;
11135   esac
11136
11137   if test $ok = yes; then
11138     # An in-tree tool is available and we can use it
11139     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11140     echo "$as_me:$LINENO: result: just compiled" >&5
11141 echo "${ECHO_T}just compiled" >&6
11142   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11143     # We already found the complete path
11144     ac_dir=`dirname $AR_FOR_TARGET`
11145     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11146 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11147   elif test "x$target" = "x$host"; then
11148     # We can use an host tool
11149     AR_FOR_TARGET='$(AR)'
11150     echo "$as_me:$LINENO: result: host tool" >&5
11151 echo "${ECHO_T}host tool" >&6
11152   else
11153     # We need a cross tool
11154     echo "$as_me:$LINENO: result: pre-installed" >&5
11155 echo "${ECHO_T}pre-installed" >&6
11156   fi
11157 fi
11158
11159 echo "$as_me:$LINENO: checking where to find the target as" >&5
11160 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11161 if test "x${build}" != "x${host}" ; then
11162   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11163     # We already found the complete path
11164     ac_dir=`dirname $AS_FOR_TARGET`
11165     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11166 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11167   else
11168     # Canadian cross, just use what we found
11169     echo "$as_me:$LINENO: result: pre-installed" >&5
11170 echo "${ECHO_T}pre-installed" >&6
11171   fi
11172 else
11173   ok=yes
11174   case " ${configdirs} " in
11175     *" gas "*) ;;
11176     *) ok=no ;;
11177   esac
11178
11179   if test $ok = yes; then
11180     # An in-tree tool is available and we can use it
11181     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11182     echo "$as_me:$LINENO: result: just compiled" >&5
11183 echo "${ECHO_T}just compiled" >&6
11184   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11185     # We already found the complete path
11186     ac_dir=`dirname $AS_FOR_TARGET`
11187     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11188 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11189   elif test "x$target" = "x$host"; then
11190     # We can use an host tool
11191     AS_FOR_TARGET='$(AS)'
11192     echo "$as_me:$LINENO: result: host tool" >&5
11193 echo "${ECHO_T}host tool" >&6
11194   else
11195     # We need a cross tool
11196     echo "$as_me:$LINENO: result: pre-installed" >&5
11197 echo "${ECHO_T}pre-installed" >&6
11198   fi
11199 fi
11200
11201 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11202 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11203 if test "x${build}" != "x${host}" ; then
11204   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11205     # We already found the complete path
11206     ac_dir=`dirname $CC_FOR_TARGET`
11207     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11208 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11209   else
11210     # Canadian cross, just use what we found
11211     echo "$as_me:$LINENO: result: pre-installed" >&5
11212 echo "${ECHO_T}pre-installed" >&6
11213   fi
11214 else
11215   ok=yes
11216   case " ${configdirs} " in
11217     *" gcc "*) ;;
11218     *) ok=no ;;
11219   esac
11220
11221   if test $ok = yes; then
11222     # An in-tree tool is available and we can use it
11223     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11224     echo "$as_me:$LINENO: result: just compiled" >&5
11225 echo "${ECHO_T}just compiled" >&6
11226   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11227     # We already found the complete path
11228     ac_dir=`dirname $CC_FOR_TARGET`
11229     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11230 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11231   elif test "x$target" = "x$host"; then
11232     # We can use an host tool
11233     CC_FOR_TARGET='$(CC)'
11234     echo "$as_me:$LINENO: result: host tool" >&5
11235 echo "${ECHO_T}host tool" >&6
11236   else
11237     # We need a cross tool
11238     echo "$as_me:$LINENO: result: pre-installed" >&5
11239 echo "${ECHO_T}pre-installed" >&6
11240   fi
11241 fi
11242
11243 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11244 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11245 if test "x${build}" != "x${host}" ; then
11246   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11247     # We already found the complete path
11248     ac_dir=`dirname $CXX_FOR_TARGET`
11249     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11250 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11251   else
11252     # Canadian cross, just use what we found
11253     echo "$as_me:$LINENO: result: pre-installed" >&5
11254 echo "${ECHO_T}pre-installed" >&6
11255   fi
11256 else
11257   ok=yes
11258   case " ${configdirs} " in
11259     *" gcc "*) ;;
11260     *) ok=no ;;
11261   esac
11262   case ,${enable_languages}, in
11263     *,c++,*) ;;
11264     *) ok=no ;;
11265   esac
11266   if test $ok = yes; then
11267     # An in-tree tool is available and we can use it
11268     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'
11269     echo "$as_me:$LINENO: result: just compiled" >&5
11270 echo "${ECHO_T}just compiled" >&6
11271   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11272     # We already found the complete path
11273     ac_dir=`dirname $CXX_FOR_TARGET`
11274     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11275 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11276   elif test "x$target" = "x$host"; then
11277     # We can use an host tool
11278     CXX_FOR_TARGET='$(CXX)'
11279     echo "$as_me:$LINENO: result: host tool" >&5
11280 echo "${ECHO_T}host tool" >&6
11281   else
11282     # We need a cross tool
11283     echo "$as_me:$LINENO: result: pre-installed" >&5
11284 echo "${ECHO_T}pre-installed" >&6
11285   fi
11286 fi
11287
11288 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11289 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11290 if test "x${build}" != "x${host}" ; then
11291   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11292     # We already found the complete path
11293     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11294     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11295 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11296   else
11297     # Canadian cross, just use what we found
11298     echo "$as_me:$LINENO: result: pre-installed" >&5
11299 echo "${ECHO_T}pre-installed" >&6
11300   fi
11301 else
11302   ok=yes
11303   case " ${configdirs} " in
11304     *" gcc "*) ;;
11305     *) ok=no ;;
11306   esac
11307   case ,${enable_languages}, in
11308     *,c++,*) ;;
11309     *) ok=no ;;
11310   esac
11311   if test $ok = yes; then
11312     # An in-tree tool is available and we can use it
11313     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'
11314     echo "$as_me:$LINENO: result: just compiled" >&5
11315 echo "${ECHO_T}just compiled" >&6
11316   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11317     # We already found the complete path
11318     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11319     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11320 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11321   elif test "x$target" = "x$host"; then
11322     # We can use an host tool
11323     RAW_CXX_FOR_TARGET='$(CXX)'
11324     echo "$as_me:$LINENO: result: host tool" >&5
11325 echo "${ECHO_T}host tool" >&6
11326   else
11327     # We need a cross tool
11328     echo "$as_me:$LINENO: result: pre-installed" >&5
11329 echo "${ECHO_T}pre-installed" >&6
11330   fi
11331 fi
11332
11333 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11334 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11335 if test "x${build}" != "x${host}" ; then
11336   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11337     # We already found the complete path
11338     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11339     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11340 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11341   else
11342     # Canadian cross, just use what we found
11343     echo "$as_me:$LINENO: result: pre-installed" >&5
11344 echo "${ECHO_T}pre-installed" >&6
11345   fi
11346 else
11347   ok=yes
11348   case " ${configdirs} " in
11349     *" binutils "*) ;;
11350     *) ok=no ;;
11351   esac
11352
11353   if test $ok = yes; then
11354     # An in-tree tool is available and we can use it
11355     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11356     echo "$as_me:$LINENO: result: just compiled" >&5
11357 echo "${ECHO_T}just compiled" >&6
11358   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11359     # We already found the complete path
11360     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11361     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11362 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11363   elif test "x$target" = "x$host"; then
11364     # We can use an host tool
11365     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11366     echo "$as_me:$LINENO: result: host tool" >&5
11367 echo "${ECHO_T}host tool" >&6
11368   else
11369     # We need a cross tool
11370     echo "$as_me:$LINENO: result: pre-installed" >&5
11371 echo "${ECHO_T}pre-installed" >&6
11372   fi
11373 fi
11374
11375 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11376 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11377 if test "x${build}" != "x${host}" ; then
11378   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11379     # We already found the complete path
11380     ac_dir=`dirname $GCC_FOR_TARGET`
11381     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11382 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11383   else
11384     # Canadian cross, just use what we found
11385     echo "$as_me:$LINENO: result: pre-installed" >&5
11386 echo "${ECHO_T}pre-installed" >&6
11387   fi
11388 else
11389   ok=yes
11390   case " ${configdirs} " in
11391     *" gcc "*) ;;
11392     *) ok=no ;;
11393   esac
11394
11395   if test $ok = yes; then
11396     # An in-tree tool is available and we can use it
11397     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11398     echo "$as_me:$LINENO: result: just compiled" >&5
11399 echo "${ECHO_T}just compiled" >&6
11400   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11401     # We already found the complete path
11402     ac_dir=`dirname $GCC_FOR_TARGET`
11403     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11404 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11405   elif test "x$target" = "x$host"; then
11406     # We can use an host tool
11407     GCC_FOR_TARGET='$()'
11408     echo "$as_me:$LINENO: result: host tool" >&5
11409 echo "${ECHO_T}host tool" >&6
11410   else
11411     # We need a cross tool
11412     echo "$as_me:$LINENO: result: pre-installed" >&5
11413 echo "${ECHO_T}pre-installed" >&6
11414   fi
11415 fi
11416
11417 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11418 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11419 if test "x${build}" != "x${host}" ; then
11420   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11421     # We already found the complete path
11422     ac_dir=`dirname $GCJ_FOR_TARGET`
11423     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11424 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11425   else
11426     # Canadian cross, just use what we found
11427     echo "$as_me:$LINENO: result: pre-installed" >&5
11428 echo "${ECHO_T}pre-installed" >&6
11429   fi
11430 else
11431   ok=yes
11432   case " ${configdirs} " in
11433     *" gcc "*) ;;
11434     *) ok=no ;;
11435   esac
11436   case ,${enable_languages}, in
11437     *,java,*) ;;
11438     *) ok=no ;;
11439   esac
11440   if test $ok = yes; then
11441     # An in-tree tool is available and we can use it
11442     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11443     echo "$as_me:$LINENO: result: just compiled" >&5
11444 echo "${ECHO_T}just compiled" >&6
11445   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11446     # We already found the complete path
11447     ac_dir=`dirname $GCJ_FOR_TARGET`
11448     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11449 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11450   elif test "x$target" = "x$host"; then
11451     # We can use an host tool
11452     GCJ_FOR_TARGET='$(GCJ)'
11453     echo "$as_me:$LINENO: result: host tool" >&5
11454 echo "${ECHO_T}host tool" >&6
11455   else
11456     # We need a cross tool
11457     echo "$as_me:$LINENO: result: pre-installed" >&5
11458 echo "${ECHO_T}pre-installed" >&6
11459   fi
11460 fi
11461
11462 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11463 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11464 if test "x${build}" != "x${host}" ; then
11465   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11466     # We already found the complete path
11467     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11468     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11469 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11470   else
11471     # Canadian cross, just use what we found
11472     echo "$as_me:$LINENO: result: pre-installed" >&5
11473 echo "${ECHO_T}pre-installed" >&6
11474   fi
11475 else
11476   ok=yes
11477   case " ${configdirs} " in
11478     *" gcc "*) ;;
11479     *) ok=no ;;
11480   esac
11481   case ,${enable_languages}, in
11482     *,fortran,*) ;;
11483     *) ok=no ;;
11484   esac
11485   if test $ok = yes; then
11486     # An in-tree tool is available and we can use it
11487     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11488     echo "$as_me:$LINENO: result: just compiled" >&5
11489 echo "${ECHO_T}just compiled" >&6
11490   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11491     # We already found the complete path
11492     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11493     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11494 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11495   elif test "x$target" = "x$host"; then
11496     # We can use an host tool
11497     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11498     echo "$as_me:$LINENO: result: host tool" >&5
11499 echo "${ECHO_T}host tool" >&6
11500   else
11501     # We need a cross tool
11502     echo "$as_me:$LINENO: result: pre-installed" >&5
11503 echo "${ECHO_T}pre-installed" >&6
11504   fi
11505 fi
11506
11507 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11508 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11509 if test "x${build}" != "x${host}" ; then
11510   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11511     # We already found the complete path
11512     ac_dir=`dirname $LD_FOR_TARGET`
11513     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11514 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11515   else
11516     # Canadian cross, just use what we found
11517     echo "$as_me:$LINENO: result: pre-installed" >&5
11518 echo "${ECHO_T}pre-installed" >&6
11519   fi
11520 else
11521   ok=yes
11522   case " ${configdirs} " in
11523     *" ld "*) ;;
11524     *) ok=no ;;
11525   esac
11526
11527   if test $ok = yes; then
11528     # An in-tree tool is available and we can use it
11529     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11530     echo "$as_me:$LINENO: result: just compiled" >&5
11531 echo "${ECHO_T}just compiled" >&6
11532   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11533     # We already found the complete path
11534     ac_dir=`dirname $LD_FOR_TARGET`
11535     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11536 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11537   elif test "x$target" = "x$host"; then
11538     # We can use an host tool
11539     LD_FOR_TARGET='$(LD)'
11540     echo "$as_me:$LINENO: result: host tool" >&5
11541 echo "${ECHO_T}host tool" >&6
11542   else
11543     # We need a cross tool
11544     echo "$as_me:$LINENO: result: pre-installed" >&5
11545 echo "${ECHO_T}pre-installed" >&6
11546   fi
11547 fi
11548
11549 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11550 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11551 if test "x${build}" != "x${host}" ; then
11552   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11553     # We already found the complete path
11554     ac_dir=`dirname $LIPO_FOR_TARGET`
11555     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11556 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11557   else
11558     # Canadian cross, just use what we found
11559     echo "$as_me:$LINENO: result: pre-installed" >&5
11560 echo "${ECHO_T}pre-installed" >&6
11561   fi
11562 else
11563   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11564     # We already found the complete path
11565     ac_dir=`dirname $LIPO_FOR_TARGET`
11566     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11567 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11568   elif test "x$target" = "x$host"; then
11569     # We can use an host tool
11570     LIPO_FOR_TARGET='$(LIPO)'
11571     echo "$as_me:$LINENO: result: host tool" >&5
11572 echo "${ECHO_T}host tool" >&6
11573   else
11574     # We need a cross tool
11575     echo "$as_me:$LINENO: result: pre-installed" >&5
11576 echo "${ECHO_T}pre-installed" >&6
11577   fi
11578 fi
11579
11580 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11581 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11582 if test "x${build}" != "x${host}" ; then
11583   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11584     # We already found the complete path
11585     ac_dir=`dirname $NM_FOR_TARGET`
11586     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11587 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11588   else
11589     # Canadian cross, just use what we found
11590     echo "$as_me:$LINENO: result: pre-installed" >&5
11591 echo "${ECHO_T}pre-installed" >&6
11592   fi
11593 else
11594   ok=yes
11595   case " ${configdirs} " in
11596     *" binutils "*) ;;
11597     *) ok=no ;;
11598   esac
11599
11600   if test $ok = yes; then
11601     # An in-tree tool is available and we can use it
11602     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11603     echo "$as_me:$LINENO: result: just compiled" >&5
11604 echo "${ECHO_T}just compiled" >&6
11605   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11606     # We already found the complete path
11607     ac_dir=`dirname $NM_FOR_TARGET`
11608     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11609 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11610   elif test "x$target" = "x$host"; then
11611     # We can use an host tool
11612     NM_FOR_TARGET='$(NM)'
11613     echo "$as_me:$LINENO: result: host tool" >&5
11614 echo "${ECHO_T}host tool" >&6
11615   else
11616     # We need a cross tool
11617     echo "$as_me:$LINENO: result: pre-installed" >&5
11618 echo "${ECHO_T}pre-installed" >&6
11619   fi
11620 fi
11621
11622 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11623 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11624 if test "x${build}" != "x${host}" ; then
11625   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11626     # We already found the complete path
11627     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11628     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11629 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11630   else
11631     # Canadian cross, just use what we found
11632     echo "$as_me:$LINENO: result: pre-installed" >&5
11633 echo "${ECHO_T}pre-installed" >&6
11634   fi
11635 else
11636   ok=yes
11637   case " ${configdirs} " in
11638     *" binutils "*) ;;
11639     *) ok=no ;;
11640   esac
11641
11642   if test $ok = yes; then
11643     # An in-tree tool is available and we can use it
11644     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11645     echo "$as_me:$LINENO: result: just compiled" >&5
11646 echo "${ECHO_T}just compiled" >&6
11647   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11648     # We already found the complete path
11649     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11650     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11651 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11652   elif test "x$target" = "x$host"; then
11653     # We can use an host tool
11654     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11655     echo "$as_me:$LINENO: result: host tool" >&5
11656 echo "${ECHO_T}host tool" >&6
11657   else
11658     # We need a cross tool
11659     echo "$as_me:$LINENO: result: pre-installed" >&5
11660 echo "${ECHO_T}pre-installed" >&6
11661   fi
11662 fi
11663
11664 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11665 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11666 if test "x${build}" != "x${host}" ; then
11667   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11668     # We already found the complete path
11669     ac_dir=`dirname $RANLIB_FOR_TARGET`
11670     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11671 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11672   else
11673     # Canadian cross, just use what we found
11674     echo "$as_me:$LINENO: result: pre-installed" >&5
11675 echo "${ECHO_T}pre-installed" >&6
11676   fi
11677 else
11678   ok=yes
11679   case " ${configdirs} " in
11680     *" binutils "*) ;;
11681     *) ok=no ;;
11682   esac
11683
11684   if test $ok = yes; then
11685     # An in-tree tool is available and we can use it
11686     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11687     echo "$as_me:$LINENO: result: just compiled" >&5
11688 echo "${ECHO_T}just compiled" >&6
11689   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11690     # We already found the complete path
11691     ac_dir=`dirname $RANLIB_FOR_TARGET`
11692     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11693 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11694   elif test "x$target" = "x$host"; then
11695     # We can use an host tool
11696     RANLIB_FOR_TARGET='$(RANLIB)'
11697     echo "$as_me:$LINENO: result: host tool" >&5
11698 echo "${ECHO_T}host tool" >&6
11699   else
11700     # We need a cross tool
11701     echo "$as_me:$LINENO: result: pre-installed" >&5
11702 echo "${ECHO_T}pre-installed" >&6
11703   fi
11704 fi
11705
11706 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11707 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11708 if test "x${build}" != "x${host}" ; then
11709   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11710     # We already found the complete path
11711     ac_dir=`dirname $STRIP_FOR_TARGET`
11712     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11713 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11714   else
11715     # Canadian cross, just use what we found
11716     echo "$as_me:$LINENO: result: pre-installed" >&5
11717 echo "${ECHO_T}pre-installed" >&6
11718   fi
11719 else
11720   ok=yes
11721   case " ${configdirs} " in
11722     *" binutils "*) ;;
11723     *) ok=no ;;
11724   esac
11725
11726   if test $ok = yes; then
11727     # An in-tree tool is available and we can use it
11728     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11729     echo "$as_me:$LINENO: result: just compiled" >&5
11730 echo "${ECHO_T}just compiled" >&6
11731   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11732     # We already found the complete path
11733     ac_dir=`dirname $STRIP_FOR_TARGET`
11734     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11735 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11736   elif test "x$target" = "x$host"; then
11737     # We can use an host tool
11738     STRIP_FOR_TARGET='$(STRIP)'
11739     echo "$as_me:$LINENO: result: host tool" >&5
11740 echo "${ECHO_T}host tool" >&6
11741   else
11742     # We need a cross tool
11743     echo "$as_me:$LINENO: result: pre-installed" >&5
11744 echo "${ECHO_T}pre-installed" >&6
11745   fi
11746 fi
11747
11748 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11749 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11750 if test "x${build}" != "x${host}" ; then
11751   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11752     # We already found the complete path
11753     ac_dir=`dirname $WINDRES_FOR_TARGET`
11754     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11755 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11756   else
11757     # Canadian cross, just use what we found
11758     echo "$as_me:$LINENO: result: pre-installed" >&5
11759 echo "${ECHO_T}pre-installed" >&6
11760   fi
11761 else
11762   ok=yes
11763   case " ${configdirs} " in
11764     *" binutils "*) ;;
11765     *) ok=no ;;
11766   esac
11767
11768   if test $ok = yes; then
11769     # An in-tree tool is available and we can use it
11770     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11771     echo "$as_me:$LINENO: result: just compiled" >&5
11772 echo "${ECHO_T}just compiled" >&6
11773   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11774     # We already found the complete path
11775     ac_dir=`dirname $WINDRES_FOR_TARGET`
11776     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11777 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11778   elif test "x$target" = "x$host"; then
11779     # We can use an host tool
11780     WINDRES_FOR_TARGET='$(WINDRES)'
11781     echo "$as_me:$LINENO: result: host tool" >&5
11782 echo "${ECHO_T}host tool" >&6
11783   else
11784     # We need a cross tool
11785     echo "$as_me:$LINENO: result: pre-installed" >&5
11786 echo "${ECHO_T}pre-installed" >&6
11787   fi
11788 fi
11789
11790 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
11791 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
11792 if test "x${build}" != "x${host}" ; then
11793   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11794     # We already found the complete path
11795     ac_dir=`dirname $WINDMC_FOR_TARGET`
11796     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11797 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11798   else
11799     # Canadian cross, just use what we found
11800     echo "$as_me:$LINENO: result: pre-installed" >&5
11801 echo "${ECHO_T}pre-installed" >&6
11802   fi
11803 else
11804   ok=yes
11805   case " ${configdirs} " in
11806     *" binutils "*) ;;
11807     *) ok=no ;;
11808   esac
11809
11810   if test $ok = yes; then
11811     # An in-tree tool is available and we can use it
11812     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
11813     echo "$as_me:$LINENO: result: just compiled" >&5
11814 echo "${ECHO_T}just compiled" >&6
11815   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11816     # We already found the complete path
11817     ac_dir=`dirname $WINDMC_FOR_TARGET`
11818     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11819 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11820   elif test "x$target" = "x$host"; then
11821     # We can use an host tool
11822     WINDMC_FOR_TARGET='$(WINDMC)'
11823     echo "$as_me:$LINENO: result: host tool" >&5
11824 echo "${ECHO_T}host tool" >&6
11825   else
11826     # We need a cross tool
11827     echo "$as_me:$LINENO: result: pre-installed" >&5
11828 echo "${ECHO_T}pre-installed" >&6
11829   fi
11830 fi
11831
11832
11833
11834
11835
11836 # Certain tools may need extra flags.
11837 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11838 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11839 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11840
11841 # When building target libraries, except in a Canadian cross, we use
11842 # the same toolchain as the compiler we just built.
11843 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11844 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11845 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11846 if test $host = $build; then
11847   case " $configdirs " in
11848     *" gcc "*)
11849       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11850       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11851       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11852       ;;
11853   esac
11854 fi
11855
11856
11857
11858
11859
11860 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11861 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11862 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11863 if test "${enable_maintainer_mode+set}" = set; then
11864   enableval="$enable_maintainer_mode"
11865   USE_MAINTAINER_MODE=$enableval
11866 else
11867   USE_MAINTAINER_MODE=no
11868 fi;
11869 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11870 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11871
11872
11873 if test "$USE_MAINTAINER_MODE" = yes; then
11874   MAINTAINER_MODE_TRUE=
11875   MAINTAINER_MODE_FALSE='#'
11876 else
11877   MAINTAINER_MODE_TRUE='#'
11878   MAINTAINER_MODE_FALSE=
11879 fi
11880 MAINT=$MAINTAINER_MODE_TRUE
11881
11882 # ---------------------
11883 # GCC bootstrap support
11884 # ---------------------
11885
11886 # Stage specific cflags for build.
11887 stage1_cflags="-g"
11888 case $build in
11889   vax-*-*)
11890     case ${GCC} in
11891       yes) stage1_cflags="-g -Wa,-J" ;;
11892       *) stage1_cflags="-g -J" ;;
11893     esac ;;
11894 esac
11895
11896 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
11897 if test "$GCC" = yes; then
11898   saved_CFLAGS="$CFLAGS"
11899
11900   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
11901   CFLAGS="$CFLAGS -fkeep-inline-functions"
11902   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
11903 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
11904   cat >conftest.$ac_ext <<_ACEOF
11905 /* confdefs.h.  */
11906 _ACEOF
11907 cat confdefs.h >>conftest.$ac_ext
11908 cat >>conftest.$ac_ext <<_ACEOF
11909 /* end confdefs.h.  */
11910
11911 #if (__GNUC__ < 3) \
11912     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
11913                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
11914 #error http://gcc.gnu.org/PR29382
11915 #endif
11916
11917 int
11918 main ()
11919 {
11920
11921   ;
11922   return 0;
11923 }
11924 _ACEOF
11925 rm -f conftest.$ac_objext
11926 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11927   (eval $ac_compile) 2>conftest.er1
11928   ac_status=$?
11929   grep -v '^ *+' conftest.er1 >conftest.err
11930   rm -f conftest.er1
11931   cat conftest.err >&5
11932   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11933   (exit $ac_status); } &&
11934          { ac_try='test -z "$ac_c_werror_flag"
11935                          || test ! -s conftest.err'
11936   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11937   (eval $ac_try) 2>&5
11938   ac_status=$?
11939   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11940   (exit $ac_status); }; } &&
11941          { ac_try='test -s conftest.$ac_objext'
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); }; }; then
11947   echo "$as_me:$LINENO: result: yes" >&5
11948 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
11949 else
11950   echo "$as_me: failed program was:" >&5
11951 sed 's/^/| /' conftest.$ac_ext >&5
11952
11953 echo "$as_me:$LINENO: result: no" >&5
11954 echo "${ECHO_T}no" >&6
11955 fi
11956 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11957
11958   CFLAGS="$saved_CFLAGS"
11959 fi
11960
11961
11962
11963 # Enable --enable-checking in stage1 of the compiler.
11964 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
11965 if test "${enable_stage1_checking+set}" = set; then
11966   enableval="$enable_stage1_checking"
11967   stage1_checking=--enable-checking=${enable_stage1_checking}
11968 else
11969   if test "x$enable_checking" = xno; then
11970   stage1_checking=--enable-checking=yes,types
11971 else
11972   stage1_checking=--enable-checking=types${enable_checking+,}$enable_checking
11973 fi
11974 fi;
11975
11976
11977 # Enable -Werror in bootstrap stage2 and later.
11978 # Check whether --enable-werror or --disable-werror was given.
11979 if test "${enable_werror+set}" = set; then
11980   enableval="$enable_werror"
11981
11982 else
11983   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
11984   enable_werror=yes
11985 else
11986   enable_werror=no
11987 fi
11988 fi;
11989 case ${enable_werror} in
11990   yes) stage2_werror_flag="--enable-werror-always" ;;
11991   *) stage2_werror_flag="" ;;
11992 esac
11993
11994
11995 # Flags needed to enable html installing and building
11996
11997 # Check whether --with-datarootdir or --without-datarootdir was given.
11998 if test "${with_datarootdir+set}" = set; then
11999   withval="$with_datarootdir"
12000   datarootdir="\${prefix}/${withval}"
12001 else
12002   datarootdir="\${prefix}/share"
12003 fi;
12004
12005
12006 # Check whether --with-docdir or --without-docdir was given.
12007 if test "${with_docdir+set}" = set; then
12008   withval="$with_docdir"
12009   docdir="\${prefix}/${withval}"
12010 else
12011   docdir="\${datarootdir}/doc"
12012 fi;
12013
12014
12015 # Check whether --with-pdfdir or --without-pdfdir was given.
12016 if test "${with_pdfdir+set}" = set; then
12017   withval="$with_pdfdir"
12018   pdfdir="\${prefix}/${withval}"
12019 else
12020   pdfdir="\${docdir}"
12021 fi;
12022
12023
12024 # Check whether --with-htmldir or --without-htmldir was given.
12025 if test "${with_htmldir+set}" = set; then
12026   withval="$with_htmldir"
12027   htmldir="\${prefix}/${withval}"
12028 else
12029   htmldir="\${docdir}"
12030 fi;
12031
12032
12033
12034
12035
12036
12037           ac_config_files="$ac_config_files Makefile"
12038 cat >confcache <<\_ACEOF
12039 # This file is a shell script that caches the results of configure
12040 # tests run on this system so they can be shared between configure
12041 # scripts and configure runs, see configure's option --config-cache.
12042 # It is not useful on other systems.  If it contains results you don't
12043 # want to keep, you may remove or edit it.
12044 #
12045 # config.status only pays attention to the cache file if you give it
12046 # the --recheck option to rerun configure.
12047 #
12048 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12049 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12050 # following values.
12051
12052 _ACEOF
12053
12054 # The following way of writing the cache mishandles newlines in values,
12055 # but we know of no workaround that is simple, portable, and efficient.
12056 # So, don't put newlines in cache variables' values.
12057 # Ultrix sh set writes to stderr and can't be redirected directly,
12058 # and sets the high bit in the cache file unless we assign to the vars.
12059 {
12060   (set) 2>&1 |
12061     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12062     *ac_space=\ *)
12063       # `set' does not quote correctly, so add quotes (double-quote
12064       # substitution turns \\\\ into \\, and sed turns \\ into \).
12065       sed -n \
12066         "s/'/'\\\\''/g;
12067           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12068       ;;
12069     *)
12070       # `set' quotes correctly as required by POSIX, so do not add quotes.
12071       sed -n \
12072         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12073       ;;
12074     esac;
12075 } |
12076   sed '
12077      t clear
12078      : clear
12079      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12080      t end
12081      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12082      : end' >>confcache
12083 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12084   if test -w $cache_file; then
12085     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12086     cat confcache >$cache_file
12087   else
12088     echo "not updating unwritable cache $cache_file"
12089   fi
12090 fi
12091 rm -f confcache
12092
12093 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12094 # Let make expand exec_prefix.
12095 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12096
12097 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12098 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12099 # trailing colons and then remove the whole line if VPATH becomes empty
12100 # (actually we leave an empty line to preserve line numbers).
12101 if test "x$srcdir" = x.; then
12102   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12103 s/:*\$(srcdir):*/:/;
12104 s/:*\${srcdir}:*/:/;
12105 s/:*@srcdir@:*/:/;
12106 s/^\([^=]*=[     ]*\):*/\1/;
12107 s/:*$//;
12108 s/^[^=]*=[       ]*$//;
12109 }'
12110 fi
12111
12112 # Transform confdefs.h into DEFS.
12113 # Protect against shell expansion while executing Makefile rules.
12114 # Protect against Makefile macro expansion.
12115 #
12116 # If the first sed substitution is executed (which looks for macros that
12117 # take arguments), then we branch to the quote section.  Otherwise,
12118 # look for a macro that doesn't take arguments.
12119 cat >confdef2opt.sed <<\_ACEOF
12120 t clear
12121 : clear
12122 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12123 t quote
12124 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12125 t quote
12126 d
12127 : quote
12128 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12129 s,\[,\\&,g
12130 s,\],\\&,g
12131 s,\$,$$,g
12132 p
12133 _ACEOF
12134 # We use echo to avoid assuming a particular line-breaking character.
12135 # The extra dot is to prevent the shell from consuming trailing
12136 # line-breaks from the sub-command output.  A line-break within
12137 # single-quotes doesn't work because, if this script is created in a
12138 # platform that uses two characters for line-breaks (e.g., DOS), tr
12139 # would break.
12140 ac_LF_and_DOT=`echo; echo .`
12141 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12142 rm -f confdef2opt.sed
12143
12144
12145 ac_libobjs=
12146 ac_ltlibobjs=
12147 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12148   # 1. Remove the extension, and $U if already installed.
12149   ac_i=`echo "$ac_i" |
12150          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12151   # 2. Add them.
12152   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12153   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12154 done
12155 LIBOBJS=$ac_libobjs
12156
12157 LTLIBOBJS=$ac_ltlibobjs
12158
12159
12160
12161 : ${CONFIG_STATUS=./config.status}
12162 ac_clean_files_save=$ac_clean_files
12163 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12164 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12165 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12166 cat >$CONFIG_STATUS <<_ACEOF
12167 #! $SHELL
12168 # Generated by $as_me.
12169 # Run this file to recreate the current configuration.
12170 # Compiler output produced by configure, useful for debugging
12171 # configure, is in config.log if it exists.
12172
12173 debug=false
12174 ac_cs_recheck=false
12175 ac_cs_silent=false
12176 SHELL=\${CONFIG_SHELL-$SHELL}
12177 _ACEOF
12178
12179 cat >>$CONFIG_STATUS <<\_ACEOF
12180 ## --------------------- ##
12181 ## M4sh Initialization.  ##
12182 ## --------------------- ##
12183
12184 # Be Bourne compatible
12185 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12186   emulate sh
12187   NULLCMD=:
12188   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12189   # is contrary to our usage.  Disable this feature.
12190   alias -g '${1+"$@"}'='"$@"'
12191 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12192   set -o posix
12193 fi
12194 DUALCASE=1; export DUALCASE # for MKS sh
12195
12196 # Support unset when possible.
12197 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12198   as_unset=unset
12199 else
12200   as_unset=false
12201 fi
12202
12203
12204 # Work around bugs in pre-3.0 UWIN ksh.
12205 $as_unset ENV MAIL MAILPATH
12206 PS1='$ '
12207 PS2='> '
12208 PS4='+ '
12209
12210 # NLS nuisances.
12211 for as_var in \
12212   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12213   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12214   LC_TELEPHONE LC_TIME
12215 do
12216   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12217     eval $as_var=C; export $as_var
12218   else
12219     $as_unset $as_var
12220   fi
12221 done
12222
12223 # Required to use basename.
12224 if expr a : '\(a\)' >/dev/null 2>&1; then
12225   as_expr=expr
12226 else
12227   as_expr=false
12228 fi
12229
12230 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12231   as_basename=basename
12232 else
12233   as_basename=false
12234 fi
12235
12236
12237 # Name of the executable.
12238 as_me=`$as_basename "$0" ||
12239 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12240          X"$0" : 'X\(//\)$' \| \
12241          X"$0" : 'X\(/\)$' \| \
12242          .     : '\(.\)' 2>/dev/null ||
12243 echo X/"$0" |
12244     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12245           /^X\/\(\/\/\)$/{ s//\1/; q; }
12246           /^X\/\(\/\).*/{ s//\1/; q; }
12247           s/.*/./; q'`
12248
12249
12250 # PATH needs CR, and LINENO needs CR and PATH.
12251 # Avoid depending upon Character Ranges.
12252 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12253 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12254 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12255 as_cr_digits='0123456789'
12256 as_cr_alnum=$as_cr_Letters$as_cr_digits
12257
12258 # The user is always right.
12259 if test "${PATH_SEPARATOR+set}" != set; then
12260   echo "#! /bin/sh" >conf$$.sh
12261   echo  "exit 0"   >>conf$$.sh
12262   chmod +x conf$$.sh
12263   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12264     PATH_SEPARATOR=';'
12265   else
12266     PATH_SEPARATOR=:
12267   fi
12268   rm -f conf$$.sh
12269 fi
12270
12271
12272   as_lineno_1=$LINENO
12273   as_lineno_2=$LINENO
12274   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12275   test "x$as_lineno_1" != "x$as_lineno_2" &&
12276   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12277   # Find who we are.  Look in the path if we contain no path at all
12278   # relative or not.
12279   case $0 in
12280     *[\\/]* ) as_myself=$0 ;;
12281     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12282 for as_dir in $PATH
12283 do
12284   IFS=$as_save_IFS
12285   test -z "$as_dir" && as_dir=.
12286   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12287 done
12288
12289        ;;
12290   esac
12291   # We did not find ourselves, most probably we were run as `sh COMMAND'
12292   # in which case we are not to be found in the path.
12293   if test "x$as_myself" = x; then
12294     as_myself=$0
12295   fi
12296   if test ! -f "$as_myself"; then
12297     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12298 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12299    { (exit 1); exit 1; }; }
12300   fi
12301   case $CONFIG_SHELL in
12302   '')
12303     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12304 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12305 do
12306   IFS=$as_save_IFS
12307   test -z "$as_dir" && as_dir=.
12308   for as_base in sh bash ksh sh5; do
12309          case $as_dir in
12310          /*)
12311            if ("$as_dir/$as_base" -c '
12312   as_lineno_1=$LINENO
12313   as_lineno_2=$LINENO
12314   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12315   test "x$as_lineno_1" != "x$as_lineno_2" &&
12316   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12317              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12318              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12319              CONFIG_SHELL=$as_dir/$as_base
12320              export CONFIG_SHELL
12321              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12322            fi;;
12323          esac
12324        done
12325 done
12326 ;;
12327   esac
12328
12329   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12330   # uniformly replaced by the line number.  The first 'sed' inserts a
12331   # line-number line before each line; the second 'sed' does the real
12332   # work.  The second script uses 'N' to pair each line-number line
12333   # with the numbered line, and appends trailing '-' during
12334   # substitution so that $LINENO is not a special case at line end.
12335   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12336   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12337   sed '=' <$as_myself |
12338     sed '
12339       N
12340       s,$,-,
12341       : loop
12342       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12343       t loop
12344       s,-$,,
12345       s,^['$as_cr_digits']*\n,,
12346     ' >$as_me.lineno &&
12347   chmod +x $as_me.lineno ||
12348     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12349 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12350    { (exit 1); exit 1; }; }
12351
12352   # Don't try to exec as it changes $[0], causing all sort of problems
12353   # (the dirname of $[0] is not the place where we might find the
12354   # original and so on.  Autoconf is especially sensible to this).
12355   . ./$as_me.lineno
12356   # Exit status is that of the last command.
12357   exit
12358 }
12359
12360
12361 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12362   *c*,-n*) ECHO_N= ECHO_C='
12363 ' ECHO_T='      ' ;;
12364   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12365   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12366 esac
12367
12368 if expr a : '\(a\)' >/dev/null 2>&1; then
12369   as_expr=expr
12370 else
12371   as_expr=false
12372 fi
12373
12374 rm -f conf$$ conf$$.exe conf$$.file
12375 echo >conf$$.file
12376 if ln -s conf$$.file conf$$ 2>/dev/null; then
12377   # We could just check for DJGPP; but this test a) works b) is more generic
12378   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12379   if test -f conf$$.exe; then
12380     # Don't use ln at all; we don't have any links
12381     as_ln_s='cp -p'
12382   else
12383     as_ln_s='ln -s'
12384   fi
12385 elif ln conf$$.file conf$$ 2>/dev/null; then
12386   as_ln_s=ln
12387 else
12388   as_ln_s='cp -p'
12389 fi
12390 rm -f conf$$ conf$$.exe conf$$.file
12391
12392 if mkdir -p . 2>/dev/null; then
12393   as_mkdir_p=:
12394 else
12395   test -d ./-p && rmdir ./-p
12396   as_mkdir_p=false
12397 fi
12398
12399 as_executable_p="test -f"
12400
12401 # Sed expression to map a string onto a valid CPP name.
12402 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12403
12404 # Sed expression to map a string onto a valid variable name.
12405 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12406
12407
12408 # IFS
12409 # We need space, tab and new line, in precisely that order.
12410 as_nl='
12411 '
12412 IFS="   $as_nl"
12413
12414 # CDPATH.
12415 $as_unset CDPATH
12416
12417 exec 6>&1
12418
12419 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12420 # report actual input values of CONFIG_FILES etc. instead of their
12421 # values after options handling.  Logging --version etc. is OK.
12422 exec 5>>config.log
12423 {
12424   echo
12425   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12426 ## Running $as_me. ##
12427 _ASBOX
12428 } >&5
12429 cat >&5 <<_CSEOF
12430
12431 This file was extended by $as_me, which was
12432 generated by GNU Autoconf 2.59.  Invocation command line was
12433
12434   CONFIG_FILES    = $CONFIG_FILES
12435   CONFIG_HEADERS  = $CONFIG_HEADERS
12436   CONFIG_LINKS    = $CONFIG_LINKS
12437   CONFIG_COMMANDS = $CONFIG_COMMANDS
12438   $ $0 $@
12439
12440 _CSEOF
12441 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12442 echo >&5
12443 _ACEOF
12444
12445 # Files that config.status was made for.
12446 if test -n "$ac_config_files"; then
12447   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12448 fi
12449
12450 if test -n "$ac_config_headers"; then
12451   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12452 fi
12453
12454 if test -n "$ac_config_links"; then
12455   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12456 fi
12457
12458 if test -n "$ac_config_commands"; then
12459   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12460 fi
12461
12462 cat >>$CONFIG_STATUS <<\_ACEOF
12463
12464 ac_cs_usage="\
12465 \`$as_me' instantiates files from templates according to the
12466 current configuration.
12467
12468 Usage: $0 [OPTIONS] [FILE]...
12469
12470   -h, --help       print this help, then exit
12471   -V, --version    print version number, then exit
12472   -q, --quiet      do not print progress messages
12473   -d, --debug      don't remove temporary files
12474       --recheck    update $as_me by reconfiguring in the same conditions
12475   --file=FILE[:TEMPLATE]
12476                    instantiate the configuration file FILE
12477
12478 Configuration files:
12479 $config_files
12480
12481 Report bugs to <bug-autoconf@gnu.org>."
12482 _ACEOF
12483
12484 cat >>$CONFIG_STATUS <<_ACEOF
12485 ac_cs_version="\\
12486 config.status
12487 configured by $0, generated by GNU Autoconf 2.59,
12488   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12489
12490 Copyright (C) 2003 Free Software Foundation, Inc.
12491 This config.status script is free software; the Free Software Foundation
12492 gives unlimited permission to copy, distribute and modify it."
12493 srcdir=$srcdir
12494 INSTALL="$INSTALL"
12495 _ACEOF
12496
12497 cat >>$CONFIG_STATUS <<\_ACEOF
12498 # If no file are specified by the user, then we need to provide default
12499 # value.  By we need to know if files were specified by the user.
12500 ac_need_defaults=:
12501 while test $# != 0
12502 do
12503   case $1 in
12504   --*=*)
12505     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12506     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12507     ac_shift=:
12508     ;;
12509   -*)
12510     ac_option=$1
12511     ac_optarg=$2
12512     ac_shift=shift
12513     ;;
12514   *) # This is not an option, so the user has probably given explicit
12515      # arguments.
12516      ac_option=$1
12517      ac_need_defaults=false;;
12518   esac
12519
12520   case $ac_option in
12521   # Handling of the options.
12522 _ACEOF
12523 cat >>$CONFIG_STATUS <<\_ACEOF
12524   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12525     ac_cs_recheck=: ;;
12526   --version | --vers* | -V )
12527     echo "$ac_cs_version"; exit 0 ;;
12528   --he | --h)
12529     # Conflict between --help and --header
12530     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12531 Try \`$0 --help' for more information." >&5
12532 echo "$as_me: error: ambiguous option: $1
12533 Try \`$0 --help' for more information." >&2;}
12534    { (exit 1); exit 1; }; };;
12535   --help | --hel | -h )
12536     echo "$ac_cs_usage"; exit 0 ;;
12537   --debug | --d* | -d )
12538     debug=: ;;
12539   --file | --fil | --fi | --f )
12540     $ac_shift
12541     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12542     ac_need_defaults=false;;
12543   --header | --heade | --head | --hea )
12544     $ac_shift
12545     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12546     ac_need_defaults=false;;
12547   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12548   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12549     ac_cs_silent=: ;;
12550
12551   # This is an error.
12552   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12553 Try \`$0 --help' for more information." >&5
12554 echo "$as_me: error: unrecognized option: $1
12555 Try \`$0 --help' for more information." >&2;}
12556    { (exit 1); exit 1; }; } ;;
12557
12558   *) ac_config_targets="$ac_config_targets $1" ;;
12559
12560   esac
12561   shift
12562 done
12563
12564 ac_configure_extra_args=
12565
12566 if $ac_cs_silent; then
12567   exec 6>/dev/null
12568   ac_configure_extra_args="$ac_configure_extra_args --silent"
12569 fi
12570
12571 _ACEOF
12572 cat >>$CONFIG_STATUS <<_ACEOF
12573 if \$ac_cs_recheck; then
12574   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12575   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12576 fi
12577
12578 _ACEOF
12579
12580
12581
12582
12583
12584 cat >>$CONFIG_STATUS <<\_ACEOF
12585 for ac_config_target in $ac_config_targets
12586 do
12587   case "$ac_config_target" in
12588   # Handling of arguments.
12589   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12590   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12591 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12592    { (exit 1); exit 1; }; };;
12593   esac
12594 done
12595
12596 # If the user did not use the arguments to specify the items to instantiate,
12597 # then the envvar interface is used.  Set only those that are not.
12598 # We use the long form for the default assignment because of an extremely
12599 # bizarre bug on SunOS 4.1.3.
12600 if $ac_need_defaults; then
12601   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12602 fi
12603
12604 # Have a temporary directory for convenience.  Make it in the build tree
12605 # simply because there is no reason to put it here, and in addition,
12606 # creating and moving files from /tmp can sometimes cause problems.
12607 # Create a temporary directory, and hook for its removal unless debugging.
12608 $debug ||
12609 {
12610   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12611   trap '{ (exit 1); exit 1; }' 1 2 13 15
12612 }
12613
12614 # Create a (secure) tmp directory for tmp files.
12615
12616 {
12617   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12618   test -n "$tmp" && test -d "$tmp"
12619 }  ||
12620 {
12621   tmp=./confstat$$-$RANDOM
12622   (umask 077 && mkdir $tmp)
12623 } ||
12624 {
12625    echo "$me: cannot create a temporary directory in ." >&2
12626    { (exit 1); exit 1; }
12627 }
12628
12629 _ACEOF
12630
12631 cat >>$CONFIG_STATUS <<_ACEOF
12632
12633 #
12634 # CONFIG_FILES section.
12635 #
12636
12637 # No need to generate the scripts if there are no CONFIG_FILES.
12638 # This happens for instance when ./config.status config.h
12639 if test -n "\$CONFIG_FILES"; then
12640   # Protect against being on the right side of a sed subst in config.status.
12641   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12642    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12643 s,@SHELL@,$SHELL,;t t
12644 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12645 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12646 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12647 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12648 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12649 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12650 s,@exec_prefix@,$exec_prefix,;t t
12651 s,@prefix@,$prefix,;t t
12652 s,@program_transform_name@,$program_transform_name,;t t
12653 s,@bindir@,$bindir,;t t
12654 s,@sbindir@,$sbindir,;t t
12655 s,@libexecdir@,$libexecdir,;t t
12656 s,@datadir@,$datadir,;t t
12657 s,@sysconfdir@,$sysconfdir,;t t
12658 s,@sharedstatedir@,$sharedstatedir,;t t
12659 s,@localstatedir@,$localstatedir,;t t
12660 s,@libdir@,$libdir,;t t
12661 s,@includedir@,$includedir,;t t
12662 s,@oldincludedir@,$oldincludedir,;t t
12663 s,@infodir@,$infodir,;t t
12664 s,@mandir@,$mandir,;t t
12665 s,@build_alias@,$build_alias,;t t
12666 s,@host_alias@,$host_alias,;t t
12667 s,@target_alias@,$target_alias,;t t
12668 s,@DEFS@,$DEFS,;t t
12669 s,@ECHO_C@,$ECHO_C,;t t
12670 s,@ECHO_N@,$ECHO_N,;t t
12671 s,@ECHO_T@,$ECHO_T,;t t
12672 s,@LIBS@,$LIBS,;t t
12673 s,@build@,$build,;t t
12674 s,@build_cpu@,$build_cpu,;t t
12675 s,@build_vendor@,$build_vendor,;t t
12676 s,@build_os@,$build_os,;t t
12677 s,@build_noncanonical@,$build_noncanonical,;t t
12678 s,@host_noncanonical@,$host_noncanonical,;t t
12679 s,@target_noncanonical@,$target_noncanonical,;t t
12680 s,@host@,$host,;t t
12681 s,@host_cpu@,$host_cpu,;t t
12682 s,@host_vendor@,$host_vendor,;t t
12683 s,@host_os@,$host_os,;t t
12684 s,@target@,$target,;t t
12685 s,@target_cpu@,$target_cpu,;t t
12686 s,@target_vendor@,$target_vendor,;t t
12687 s,@target_os@,$target_os,;t t
12688 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12689 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12690 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12691 s,@LN@,$LN,;t t
12692 s,@LN_S@,$LN_S,;t t
12693 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12694 s,@build_libsubdir@,$build_libsubdir,;t t
12695 s,@build_subdir@,$build_subdir,;t t
12696 s,@host_subdir@,$host_subdir,;t t
12697 s,@target_subdir@,$target_subdir,;t t
12698 s,@CC@,$CC,;t t
12699 s,@CFLAGS@,$CFLAGS,;t t
12700 s,@LDFLAGS@,$LDFLAGS,;t t
12701 s,@CPPFLAGS@,$CPPFLAGS,;t t
12702 s,@ac_ct_CC@,$ac_ct_CC,;t t
12703 s,@EXEEXT@,$EXEEXT,;t t
12704 s,@OBJEXT@,$OBJEXT,;t t
12705 s,@CXX@,$CXX,;t t
12706 s,@CXXFLAGS@,$CXXFLAGS,;t t
12707 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12708 s,@GNATBIND@,$GNATBIND,;t t
12709 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12710 s,@GNATMAKE@,$GNATMAKE,;t t
12711 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12712 s,@do_compare@,$do_compare,;t t
12713 s,@gmplibs@,$gmplibs,;t t
12714 s,@gmpinc@,$gmpinc,;t t
12715 s,@stage1_languages@,$stage1_languages,;t t
12716 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12717 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12718 s,@tooldir@,$tooldir,;t t
12719 s,@build_tooldir@,$build_tooldir,;t t
12720 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12721 s,@GDB_TK@,$GDB_TK,;t t
12722 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12723 s,@build_configargs@,$build_configargs,;t t
12724 s,@build_configdirs@,$build_configdirs,;t t
12725 s,@host_configargs@,$host_configargs,;t t
12726 s,@configdirs@,$configdirs,;t t
12727 s,@target_configargs@,$target_configargs,;t t
12728 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12729 s,@config_shell@,$config_shell,;t t
12730 s,@YACC@,$YACC,;t t
12731 s,@BISON@,$BISON,;t t
12732 s,@M4@,$M4,;t t
12733 s,@LEX@,$LEX,;t t
12734 s,@FLEX@,$FLEX,;t t
12735 s,@MAKEINFO@,$MAKEINFO,;t t
12736 s,@EXPECT@,$EXPECT,;t t
12737 s,@RUNTEST@,$RUNTEST,;t t
12738 s,@AR@,$AR,;t t
12739 s,@AS@,$AS,;t t
12740 s,@DLLTOOL@,$DLLTOOL,;t t
12741 s,@LD@,$LD,;t t
12742 s,@LIPO@,$LIPO,;t t
12743 s,@NM@,$NM,;t t
12744 s,@RANLIB@,$RANLIB,;t t
12745 s,@STRIP@,$STRIP,;t t
12746 s,@WINDRES@,$WINDRES,;t t
12747 s,@WINDMC@,$WINDMC,;t t
12748 s,@OBJCOPY@,$OBJCOPY,;t t
12749 s,@OBJDUMP@,$OBJDUMP,;t t
12750 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12751 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12752 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12753 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12754 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12755 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12756 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12757 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12758 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12759 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12760 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12761 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12762 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12763 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12764 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12765 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12766 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12767 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12768 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12769 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12770 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12771 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12772 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12773 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12774 s,@MAINT@,$MAINT,;t t
12775 s,@stage1_cflags@,$stage1_cflags,;t t
12776 s,@stage1_checking@,$stage1_checking,;t t
12777 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12778 s,@datarootdir@,$datarootdir,;t t
12779 s,@docdir@,$docdir,;t t
12780 s,@pdfdir@,$pdfdir,;t t
12781 s,@htmldir@,$htmldir,;t t
12782 s,@LIBOBJS@,$LIBOBJS,;t t
12783 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12784 /@serialization_dependencies@/r $serialization_dependencies
12785 s,@serialization_dependencies@,,;t t
12786 /@host_makefile_frag@/r $host_makefile_frag
12787 s,@host_makefile_frag@,,;t t
12788 /@target_makefile_frag@/r $target_makefile_frag
12789 s,@target_makefile_frag@,,;t t
12790 /@alphaieee_frag@/r $alphaieee_frag
12791 s,@alphaieee_frag@,,;t t
12792 /@ospace_frag@/r $ospace_frag
12793 s,@ospace_frag@,,;t t
12794 CEOF
12795
12796 _ACEOF
12797
12798   cat >>$CONFIG_STATUS <<\_ACEOF
12799   # Split the substitutions into bite-sized pieces for seds with
12800   # small command number limits, like on Digital OSF/1 and HP-UX.
12801   ac_max_sed_lines=48
12802   ac_sed_frag=1 # Number of current file.
12803   ac_beg=1 # First line for current file.
12804   ac_end=$ac_max_sed_lines # Line after last line for current file.
12805   ac_more_lines=:
12806   ac_sed_cmds=
12807   while $ac_more_lines; do
12808     if test $ac_beg -gt 1; then
12809       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12810     else
12811       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12812     fi
12813     if test ! -s $tmp/subs.frag; then
12814       ac_more_lines=false
12815     else
12816       # The purpose of the label and of the branching condition is to
12817       # speed up the sed processing (if there are no `@' at all, there
12818       # is no need to browse any of the substitutions).
12819       # These are the two extra sed commands mentioned above.
12820       (echo ':t
12821   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12822       if test -z "$ac_sed_cmds"; then
12823         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12824       else
12825         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12826       fi
12827       ac_sed_frag=`expr $ac_sed_frag + 1`
12828       ac_beg=$ac_end
12829       ac_end=`expr $ac_end + $ac_max_sed_lines`
12830     fi
12831   done
12832   if test -z "$ac_sed_cmds"; then
12833     ac_sed_cmds=cat
12834   fi
12835 fi # test -n "$CONFIG_FILES"
12836
12837 _ACEOF
12838 cat >>$CONFIG_STATUS <<\_ACEOF
12839 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12840   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12841   case $ac_file in
12842   - | *:- | *:-:* ) # input from stdin
12843         cat >$tmp/stdin
12844         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12845         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12846   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12847         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12848   * )   ac_file_in=$ac_file.in ;;
12849   esac
12850
12851   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12852   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12853 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12854          X"$ac_file" : 'X\(//\)[^/]' \| \
12855          X"$ac_file" : 'X\(//\)$' \| \
12856          X"$ac_file" : 'X\(/\)' \| \
12857          .     : '\(.\)' 2>/dev/null ||
12858 echo X"$ac_file" |
12859     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12860           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12861           /^X\(\/\/\)$/{ s//\1/; q; }
12862           /^X\(\/\).*/{ s//\1/; q; }
12863           s/.*/./; q'`
12864   { if $as_mkdir_p; then
12865     mkdir -p "$ac_dir"
12866   else
12867     as_dir="$ac_dir"
12868     as_dirs=
12869     while test ! -d "$as_dir"; do
12870       as_dirs="$as_dir $as_dirs"
12871       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12872 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12873          X"$as_dir" : 'X\(//\)[^/]' \| \
12874          X"$as_dir" : 'X\(//\)$' \| \
12875          X"$as_dir" : 'X\(/\)' \| \
12876          .     : '\(.\)' 2>/dev/null ||
12877 echo X"$as_dir" |
12878     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12879           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12880           /^X\(\/\/\)$/{ s//\1/; q; }
12881           /^X\(\/\).*/{ s//\1/; q; }
12882           s/.*/./; q'`
12883     done
12884     test ! -n "$as_dirs" || mkdir $as_dirs
12885   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
12886 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
12887    { (exit 1); exit 1; }; }; }
12888
12889   ac_builddir=.
12890
12891 if test "$ac_dir" != .; then
12892   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
12893   # A "../" for each directory in $ac_dir_suffix.
12894   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
12895 else
12896   ac_dir_suffix= ac_top_builddir=
12897 fi
12898
12899 case $srcdir in
12900   .)  # No --srcdir option.  We are building in place.
12901     ac_srcdir=.
12902     if test -z "$ac_top_builddir"; then
12903        ac_top_srcdir=.
12904     else
12905        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
12906     fi ;;
12907   [\\/]* | ?:[\\/]* )  # Absolute path.
12908     ac_srcdir=$srcdir$ac_dir_suffix;
12909     ac_top_srcdir=$srcdir ;;
12910   *) # Relative path.
12911     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
12912     ac_top_srcdir=$ac_top_builddir$srcdir ;;
12913 esac
12914
12915 # Do not use `cd foo && pwd` to compute absolute paths, because
12916 # the directories may not exist.
12917 case `pwd` in
12918 .) ac_abs_builddir="$ac_dir";;
12919 *)
12920   case "$ac_dir" in
12921   .) ac_abs_builddir=`pwd`;;
12922   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
12923   *) ac_abs_builddir=`pwd`/"$ac_dir";;
12924   esac;;
12925 esac
12926 case $ac_abs_builddir in
12927 .) ac_abs_top_builddir=${ac_top_builddir}.;;
12928 *)
12929   case ${ac_top_builddir}. in
12930   .) ac_abs_top_builddir=$ac_abs_builddir;;
12931   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
12932   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
12933   esac;;
12934 esac
12935 case $ac_abs_builddir in
12936 .) ac_abs_srcdir=$ac_srcdir;;
12937 *)
12938   case $ac_srcdir in
12939   .) ac_abs_srcdir=$ac_abs_builddir;;
12940   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
12941   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
12942   esac;;
12943 esac
12944 case $ac_abs_builddir in
12945 .) ac_abs_top_srcdir=$ac_top_srcdir;;
12946 *)
12947   case $ac_top_srcdir in
12948   .) ac_abs_top_srcdir=$ac_abs_builddir;;
12949   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
12950   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
12951   esac;;
12952 esac
12953
12954
12955   case $INSTALL in
12956   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
12957   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
12958   esac
12959
12960   if test x"$ac_file" != x-; then
12961     { echo "$as_me:$LINENO: creating $ac_file" >&5
12962 echo "$as_me: creating $ac_file" >&6;}
12963     rm -f "$ac_file"
12964   fi
12965   # Let's still pretend it is `configure' which instantiates (i.e., don't
12966   # use $as_me), people would be surprised to read:
12967   #    /* config.h.  Generated by config.status.  */
12968   if test x"$ac_file" = x-; then
12969     configure_input=
12970   else
12971     configure_input="$ac_file.  "
12972   fi
12973   configure_input=$configure_input"Generated from `echo $ac_file_in |
12974                                      sed 's,.*/,,'` by configure."
12975
12976   # First look for the input files in the build tree, otherwise in the
12977   # src tree.
12978   ac_file_inputs=`IFS=:
12979     for f in $ac_file_in; do
12980       case $f in
12981       -) echo $tmp/stdin ;;
12982       [\\/$]*)
12983          # Absolute (can't be DOS-style, as IFS=:)
12984          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
12985 echo "$as_me: error: cannot find input file: $f" >&2;}
12986    { (exit 1); exit 1; }; }
12987          echo "$f";;
12988       *) # Relative
12989          if test -f "$f"; then
12990            # Build tree
12991            echo "$f"
12992          elif test -f "$srcdir/$f"; then
12993            # Source tree
12994            echo "$srcdir/$f"
12995          else
12996            # /dev/null tree
12997            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
12998 echo "$as_me: error: cannot find input file: $f" >&2;}
12999    { (exit 1); exit 1; }; }
13000          fi;;
13001       esac
13002     done` || { (exit 1); exit 1; }
13003 _ACEOF
13004 cat >>$CONFIG_STATUS <<_ACEOF
13005   sed "$ac_vpsub
13006 $extrasub
13007 _ACEOF
13008 cat >>$CONFIG_STATUS <<\_ACEOF
13009 :t
13010 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13011 s,@configure_input@,$configure_input,;t t
13012 s,@srcdir@,$ac_srcdir,;t t
13013 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13014 s,@top_srcdir@,$ac_top_srcdir,;t t
13015 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13016 s,@builddir@,$ac_builddir,;t t
13017 s,@abs_builddir@,$ac_abs_builddir,;t t
13018 s,@top_builddir@,$ac_top_builddir,;t t
13019 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13020 s,@INSTALL@,$ac_INSTALL,;t t
13021 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13022   rm -f $tmp/stdin
13023   if test x"$ac_file" != x-; then
13024     mv $tmp/out $ac_file
13025   else
13026     cat $tmp/out
13027     rm -f $tmp/out
13028   fi
13029
13030 done
13031 _ACEOF
13032
13033 cat >>$CONFIG_STATUS <<\_ACEOF
13034
13035 { (exit 0); exit 0; }
13036 _ACEOF
13037 chmod +x $CONFIG_STATUS
13038 ac_clean_files=$ac_clean_files_save
13039
13040
13041 # configure is writing to config.log, and then calls config.status.
13042 # config.status does its own redirection, appending to config.log.
13043 # Unfortunately, on DOS this fails, as config.log is still kept open
13044 # by configure, so config.status won't be able to write to it; its
13045 # output is simply discarded.  So we exec the FD to /dev/null,
13046 # effectively closing config.log, so it can be properly (re)opened and
13047 # appended to by config.status.  When coming back to configure, we
13048 # need to make the FD available again.
13049 if test "$no_create" != yes; then
13050   ac_cs_success=:
13051   ac_config_status_args=
13052   test "$silent" = yes &&
13053     ac_config_status_args="$ac_config_status_args --quiet"
13054   exec 5>/dev/null
13055   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13056   exec 5>>config.log
13057   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13058   # would make configure fail if this is the last instruction.
13059   $ac_cs_success || { (exit 1); exit 1; }
13060 fi
13061