configure

   1 #! /bin/sh
   2 # Guess values for system-dependent variables and create Makefiles.
   3 # Generated by GNU Autoconf 2.59.
   4 #
   5 # Copyright (C) 2003 Free Software Foundation, Inc.
   6 # This configure script is free software; the Free Software Foundation
   7 # gives unlimited permission to copy, distribute and modify it.
   8 ## --------------------- ##
   9 ## M4sh Initialization.  ##
  10 ## --------------------- ##
  11
  12 # Be Bourne compatible
  13 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
  14   emulate sh
  15   NULLCMD=:
  16   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
  17   # is contrary to our usage.  Disable this feature.
  18   alias -g '${1+"$@"}'='"$@"'
  19 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
  20   set -o posix
  21 fi
  22 DUALCASE=1; export DUALCASE # for MKS sh
  23
  24 # Support unset when possible.
  25 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
  26   as_unset=unset
  27 else
  28   as_unset=false
  29 fi
  30
  31
  32 # Work around bugs in pre-3.0 UWIN ksh.
  33 $as_unset ENV MAIL MAILPATH
  34 PS1='$ '
  35 PS2='> '
  36 PS4='+ '
  37
  38 # NLS nuisances.
  39 for as_var in \
  40   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
  41   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
  42   LC_TELEPHONE LC_TIME
  43 do
  44   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
  45     eval $as_var=C; export $as_var
  46   else
  47     $as_unset $as_var
  48   fi
  49 done
  50
  51 # Required to use basename.
  52 if expr a : '\(a\)' >/dev/null 2>&1; then
  53   as_expr=expr
  54 else
  55   as_expr=false
  56 fi
  57
  58 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
  59   as_basename=basename
  60 else
  61   as_basename=false
  62 fi
  63
  64
  65 # Name of the executable.
  66 as_me=`$as_basename "$0" ||
  67 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
  68          X"$0" : 'X\(//\)$' \| \
  69          X"$0" : 'X\(/\)$' \| \
  70          .     : '\(.\)' 2>/dev/null ||
  71 echo X/"$0" |
  72     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
  73           /^X\/\(\/\/\)$/{ s//\1/; q; }
  74           /^X\/\(\/\).*/{ s//\1/; q; }
  75           s/.*/./; q'`
  76
  77
  78 # PATH needs CR, and LINENO needs CR and PATH.
  79 # Avoid depending upon Character Ranges.
  80 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
  81 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
  82 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
  83 as_cr_digits='0123456789'
  84 as_cr_alnum=$as_cr_Letters$as_cr_digits
  85
  86 # The user is always right.
  87 if test "${PATH_SEPARATOR+set}" != set; then
  88   echo "#! /bin/sh" >conf$$.sh
  89   echo  "exit 0"   >>conf$$.sh
  90   chmod +x conf$$.sh
  91   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
  92     PATH_SEPARATOR=';'
  93   else
  94     PATH_SEPARATOR=:
  95   fi
  96   rm -f conf$$.sh
  97 fi
  98
  99
 100   as_lineno_1=$LINENO
 101   as_lineno_2=$LINENO
 102   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 103   test "x$as_lineno_1" != "x$as_lineno_2" &&
 104   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
 105   # Find who we are.  Look in the path if we contain no path at all
 106   # relative or not.
 107   case $0 in
 108     *[\\/]* ) as_myself=$0 ;;
 109     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 110 for as_dir in $PATH
 111 do
 112   IFS=$as_save_IFS
 113   test -z "$as_dir" && as_dir=.
 114   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
 115 done
 116
 117        ;;
 118   esac
 119   # We did not find ourselves, most probably we were run as `sh COMMAND'
 120   # in which case we are not to be found in the path.
 121   if test "x$as_myself" = x; then
 122     as_myself=$0
 123   fi
 124   if test ! -f "$as_myself"; then
 125     { echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2
 126    { (exit 1); exit 1; }; }
 127   fi
 128   case $CONFIG_SHELL in
 129   '')
 130     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 131 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
 132 do
 133   IFS=$as_save_IFS
 134   test -z "$as_dir" && as_dir=.
 135   for as_base in sh bash ksh sh5; do
 136          case $as_dir in
 137          /*)
 138            if ("$as_dir/$as_base" -c '
 139   as_lineno_1=$LINENO
 140   as_lineno_2=$LINENO
 141   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
 142   test "x$as_lineno_1" != "x$as_lineno_2" &&
 143   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
 144              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
 145              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
 146              CONFIG_SHELL=$as_dir/$as_base
 147              export CONFIG_SHELL
 148              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
 149            fi;;
 150          esac
 151        done
 152 done
 153 ;;
 154   esac
 155
 156   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
 157   # uniformly replaced by the line number.  The first 'sed' inserts a
 158   # line-number line before each line; the second 'sed' does the real
 159   # work.  The second script uses 'N' to pair each line-number line
 160   # with the numbered line, and appends trailing '-' during
 161   # substitution so that $LINENO is not a special case at line end.
 162   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
 163   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
 164   sed '=' <$as_myself |
 165     sed '
 166       N
 167       s,$,-,
 168       : loop
 169       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
 170       t loop
 171       s,-$,,
 172       s,^['$as_cr_digits']*\n,,
 173     ' >$as_me.lineno &&
 174   chmod +x $as_me.lineno ||
 175     { echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2
 176    { (exit 1); exit 1; }; }
 177
 178   # Don't try to exec as it changes $[0], causing all sort of problems
 179   # (the dirname of $[0] is not the place where we might find the
 180   # original and so on.  Autoconf is especially sensible to this).
 181   . ./$as_me.lineno
 182   # Exit status is that of the last command.
 183   exit
 184 }
 185
 186
 187 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
 188   *c*,-n*) ECHO_N= ECHO_C='
 189 ' ECHO_T='      ' ;;
 190   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
 191   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
 192 esac
 193
 194 if expr a : '\(a\)' >/dev/null 2>&1; then
 195   as_expr=expr
 196 else
 197   as_expr=false
 198 fi
 199
 200 rm -f conf$$ conf$$.exe conf$$.file
 201 echo >conf$$.file
 202 if ln -s conf$$.file conf$$ 2>/dev/null; then
 203   # We could just check for DJGPP; but this test a) works b) is more generic
 204   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
 205   if test -f conf$$.exe; then
 206     # Don't use ln at all; we don't have any links
 207     as_ln_s='cp -p'
 208   else
 209     as_ln_s='ln -s'
 210   fi
 211 elif ln conf$$.file conf$$ 2>/dev/null; then
 212   as_ln_s=ln
 213 else
 214   as_ln_s='cp -p'
 215 fi
 216 rm -f conf$$ conf$$.exe conf$$.file
 217
 218 if mkdir -p . 2>/dev/null; then
 219   as_mkdir_p=:
 220 else
 221   test -d ./-p && rmdir ./-p
 222   as_mkdir_p=false
 223 fi
 224
 225 as_executable_p="test -f"
 226
 227 # Sed expression to map a string onto a valid CPP name.
 228 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
 229
 230 # Sed expression to map a string onto a valid variable name.
 231 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
 232
 233
 234 # IFS
 235 # We need space, tab and new line, in precisely that order.
 236 as_nl='
 237 '
 238 IFS="   $as_nl"
 239
 240 # CDPATH.
 241 $as_unset CDPATH
 242
 243
 244 # Name of the host.
 245 # hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
 246 # so uname gets run too.
 247 ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
 248
 249 exec 6>&1
 250
 251 #
 252 # Initializations.
 253 #
 254 ac_default_prefix=/usr/local
 255 ac_config_libobj_dir=.
 256 cross_compiling=no
 257 subdirs=
 258 MFLAGS=
 259 MAKEFLAGS=
 260 SHELL=${CONFIG_SHELL-/bin/sh}
 261
 262 # Maximum number of lines to put in a shell here document.
 263 # This variable seems obsolete.  It should probably be removed, and
 264 # only ac_max_sed_lines should be used.
 265 : ${ac_max_here_lines=38}
 266
 267 # Identity of this package.
 268 PACKAGE_NAME=
 269 PACKAGE_TARNAME=
 270 PACKAGE_VERSION=
 271 PACKAGE_STRING=
 272 PACKAGE_BUGREPORT=
 273
 274 ac_unique_file="move-if-change"
 275 ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os build_noncanonical host_noncanonical target_noncanonical host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA LN LN_S TOPLEVEL_CONFIGURE_ARGUMENTS build_libsubdir build_subdir host_subdir target_subdir CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT CXX CXXFLAGS ac_ct_CXX GNATBIND ac_ct_GNATBIND GNATMAKE ac_ct_GNATMAKE do_compare gmplibs gmpinc stage1_languages SYSROOT_CFLAGS_FOR_TARGET DEBUG_PREFIX_CFLAGS_FOR_TARGET CFLAGS_FOR_TARGET CXXFLAGS_FOR_TARGET RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs AR_FOR_BUILD AS_FOR_BUILD CC_FOR_BUILD CFLAGS_FOR_BUILD CXXFLAGS_FOR_BUILD CXX_FOR_BUILD DLLTOOL_FOR_BUILD GCJ_FOR_BUILD GFORTRAN_FOR_BUILD LDFLAGS_FOR_BUILD LD_FOR_BUILD NM_FOR_BUILD RANLIB_FOR_BUILD WINDMC_FOR_BUILD WINDRES_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP 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_subdirs_all=`cd $srcdir && echo */configure | sed 's,/configure,,g'`
 717
 718 ac_env_CC_set=${CC+set}
 719 ac_env_CC_value=$CC
 720 ac_cv_env_CC_set=${CC+set}
 721 ac_cv_env_CC_value=$CC
 722 ac_env_CFLAGS_set=${CFLAGS+set}
 723 ac_env_CFLAGS_value=$CFLAGS
 724 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 725 ac_cv_env_CFLAGS_value=$CFLAGS
 726 ac_env_LDFLAGS_set=${LDFLAGS+set}
 727 ac_env_LDFLAGS_value=$LDFLAGS
 728 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 729 ac_cv_env_LDFLAGS_value=$LDFLAGS
 730 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 731 ac_env_CPPFLAGS_value=$CPPFLAGS
 732 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 733 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 734 ac_env_CXX_set=${CXX+set}
 735 ac_env_CXX_value=$CXX
 736 ac_cv_env_CXX_set=${CXX+set}
 737 ac_cv_env_CXX_value=$CXX
 738 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 739 ac_env_CXXFLAGS_value=$CXXFLAGS
 740 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 741 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 742 ac_env_AR_set=${AR+set}
 743 ac_env_AR_value=$AR
 744 ac_cv_env_AR_set=${AR+set}
 745 ac_cv_env_AR_value=$AR
 746 ac_env_AS_set=${AS+set}
 747 ac_env_AS_value=$AS
 748 ac_cv_env_AS_set=${AS+set}
 749 ac_cv_env_AS_value=$AS
 750 ac_env_DLLTOOL_set=${DLLTOOL+set}
 751 ac_env_DLLTOOL_value=$DLLTOOL
 752 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 753 ac_cv_env_DLLTOOL_value=$DLLTOOL
 754 ac_env_LD_set=${LD+set}
 755 ac_env_LD_value=$LD
 756 ac_cv_env_LD_set=${LD+set}
 757 ac_cv_env_LD_value=$LD
 758 ac_env_LIPO_set=${LIPO+set}
 759 ac_env_LIPO_value=$LIPO
 760 ac_cv_env_LIPO_set=${LIPO+set}
 761 ac_cv_env_LIPO_value=$LIPO
 762 ac_env_NM_set=${NM+set}
 763 ac_env_NM_value=$NM
 764 ac_cv_env_NM_set=${NM+set}
 765 ac_cv_env_NM_value=$NM
 766 ac_env_RANLIB_set=${RANLIB+set}
 767 ac_env_RANLIB_value=$RANLIB
 768 ac_cv_env_RANLIB_set=${RANLIB+set}
 769 ac_cv_env_RANLIB_value=$RANLIB
 770 ac_env_STRIP_set=${STRIP+set}
 771 ac_env_STRIP_value=$STRIP
 772 ac_cv_env_STRIP_set=${STRIP+set}
 773 ac_cv_env_STRIP_value=$STRIP
 774 ac_env_WINDRES_set=${WINDRES+set}
 775 ac_env_WINDRES_value=$WINDRES
 776 ac_cv_env_WINDRES_set=${WINDRES+set}
 777 ac_cv_env_WINDRES_value=$WINDRES
 778 ac_env_WINDMC_set=${WINDMC+set}
 779 ac_env_WINDMC_value=$WINDMC
 780 ac_cv_env_WINDMC_set=${WINDMC+set}
 781 ac_cv_env_WINDMC_value=$WINDMC
 782 ac_env_OBJCOPY_set=${OBJCOPY+set}
 783 ac_env_OBJCOPY_value=$OBJCOPY
 784 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 785 ac_cv_env_OBJCOPY_value=$OBJCOPY
 786 ac_env_OBJDUMP_set=${OBJDUMP+set}
 787 ac_env_OBJDUMP_value=$OBJDUMP
 788 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 789 ac_cv_env_OBJDUMP_value=$OBJDUMP
 790 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 791 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 792 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 793 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 794 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 795 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 796 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 797 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 798 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 799 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 800 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 801 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 802 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 803 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 804 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 805 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 806 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 807 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 808 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 809 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 810 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 811 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 812 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 813 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 814 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 815 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 816 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 817 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 818 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 819 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 820 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 821 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 822 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 823 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 824 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 825 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 826 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 827 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 828 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 829 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 830 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 831 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 832 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 833 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 834 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 835 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 836 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 837 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 838 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 839 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 840 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 841 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 842 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 843 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 844 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 845 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 846 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 847 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 848 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 849 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 850 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 851 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 852 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 853 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 854
 855 #
 856 # Report the --help message.
 857 #
 858 if test "$ac_init_help" = "long"; then
 859   # Omit some internal or obsolete options to make the list less imposing.
 860   # This message is too long to be a string in the A/UX 3.1 sh.
 861   cat <<_ACEOF
 862 \`configure' configures this package to adapt to many kinds of systems.
 863
 864 Usage: $0 [OPTION]... [VAR=VALUE]...
 865
 866 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 867 VAR=VALUE.  See below for descriptions of some of the useful variables.
 868
 869 Defaults for the options are specified in brackets.
 870
 871 Configuration:
 872   -h, --help              display this help and exit
 873       --help=short        display options specific to this package
 874       --help=recursive    display the short help of all the included packages
 875   -V, --version           display version information and exit
 876   -q, --quiet, --silent   do not print \`checking...' messages
 877       --cache-file=FILE   cache test results in FILE [disabled]
 878   -C, --config-cache      alias for \`--cache-file=config.cache'
 879   -n, --no-create         do not create output files
 880       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 881
 882 _ACEOF
 883
 884   cat <<_ACEOF
 885 Installation directories:
 886   --prefix=PREFIX         install architecture-independent files in PREFIX
 887                           [$ac_default_prefix]
 888   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 889                           [PREFIX]
 890
 891 By default, \`make install' will install all the files in
 892 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 893 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 894 for instance \`--prefix=\$HOME'.
 895
 896 For better control, use the options below.
 897
 898 Fine tuning of the installation directories:
 899   --bindir=DIR           user executables [EPREFIX/bin]
 900   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 901   --libexecdir=DIR       program executables [EPREFIX/libexec]
 902   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 903   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 904   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 905   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 906   --libdir=DIR           object code libraries [EPREFIX/lib]
 907   --includedir=DIR       C header files [PREFIX/include]
 908   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 909   --infodir=DIR          info documentation [PREFIX/info]
 910   --mandir=DIR           man documentation [PREFIX/man]
 911 _ACEOF
 912
 913   cat <<\_ACEOF
 914
 915 Program names:
 916   --program-prefix=PREFIX            prepend PREFIX to installed program names
 917   --program-suffix=SUFFIX            append SUFFIX to installed program names
 918   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 919
 920 System types:
 921   --build=BUILD     configure for building on BUILD [guessed]
 922   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 923   --target=TARGET   configure for building compilers for TARGET [HOST]
 924 _ACEOF
 925 fi
 926
 927 if test -n "$ac_init_help"; then
 928
 929   cat <<\_ACEOF
 930
 931 Optional Features:
 932   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 933   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 934   --enable-gold           use gold instead of ld
 935   --enable-libada         build libada directory
 936   --enable-libssp         build libssp directory
 937   --enable-stage1-languages[=all]   choose additional languages to build during
 938                           stage1.  Mostly useful for compiler development.
 939   --enable-objc-gc        enable use of Boehm's garbage collector with the
 940                           GNU Objective-C runtime
 941   --enable-bootstrap      enable bootstrapping [yes if native build]
 942   --enable-serial-[{host,target,build}-]configure
 943                           force sequential configuration of
 944                           sub-packages for the host, target or build
 945                           machine, or all sub-packages
 946   --enable-maintainer-mode enable make rules and dependencies not useful
 947                           (and sometimes confusing) to the casual installer
 948   --enable-stage1-checking[=all]   choose additional checking for stage1
 949                           of the compiler
 950   --enable-werror         enable -Werror in bootstrap stage2 and later
 951
 952 Optional Packages:
 953   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 954   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 955   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 956   --with-mpfr-dir=PATH    this option has been REMOVED
 957   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 958                           Equivalent to --with-mpfr-include=PATH/include
 959                           plus --with-mpfr-lib=PATH/lib
 960   --with-mpfr-include=PATH
 961                           specify directory for installed MPFR include files
 962   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 963   --with-gmp-dir=PATH     this option has been REMOVED
 964   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 965                           Equivalent to --with-gmp-include=PATH/include
 966                           plus --with-gmp-lib=PATH/lib
 967   --with-gmp-include=PATH specify directory for installed GMP include files
 968   --with-gmp-lib=PATH     specify directory for the installed GMP library
 969   --with-build-sysroot=SYSROOT
 970                           use sysroot as the system root during the build
 971   --with-debug-prefix-map='A=B C=D ...'
 972                              map A to B, C to D ... in debug information
 973   --with-build-time-tools=PATH
 974                           use given path to find target tools during the build
 975   --with-datarootdir      use datarootdir as the data root directory.
 976   --with-docdir           install documentation in this directory.
 977   --with-pdfdir           install pdf in this directory.
 978   --with-htmldir          install html in this directory.
 979
 980 Some influential environment variables:
 981   CC          C compiler command
 982   CFLAGS      C compiler flags
 983   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 984               nonstandard directory <lib dir>
 985   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 986               headers in a nonstandard directory <include dir>
 987   CXX         C++ compiler command
 988   CXXFLAGS    C++ compiler flags
 989   AR          AR for the host
 990   AS          AS for the host
 991   DLLTOOL     DLLTOOL for the host
 992   LD          LD for the host
 993   LIPO        LIPO for the host
 994   NM          NM for the host
 995   RANLIB      RANLIB for the host
 996   STRIP       STRIP for the host
 997   WINDRES     WINDRES for the host
 998   WINDMC      WINDMC for the host
 999   OBJCOPY     OBJCOPY for the host
1000   OBJDUMP     OBJDUMP for the host
1001   CC_FOR_TARGET
1002               CC for the target
1003   CXX_FOR_TARGET
1004               CXX for the target
1005   GCC_FOR_TARGET
1006               GCC for the target
1007   GCJ_FOR_TARGET
1008               GCJ for the target
1009   GFORTRAN_FOR_TARGET
1010               GFORTRAN for the target
1011   AR_FOR_TARGET
1012               AR for the target
1013   AS_FOR_TARGET
1014               AS for the target
1015   DLLTOOL_FOR_TARGET
1016               DLLTOOL for the target
1017   LD_FOR_TARGET
1018               LD for the target
1019   LIPO_FOR_TARGET
1020               LIPO for the target
1021   NM_FOR_TARGET
1022               NM for the target
1023   OBJDUMP_FOR_TARGET
1024               OBJDUMP for the target
1025   RANLIB_FOR_TARGET
1026               RANLIB for the target
1027   STRIP_FOR_TARGET
1028               STRIP for the target
1029   WINDRES_FOR_TARGET
1030               WINDRES for the target
1031   WINDMC_FOR_TARGET
1032               WINDMC for the target
1033
1034 Use these variables to override the choices made by `configure' or to help
1035 it to find libraries and programs with nonstandard names/locations.
1036
1037 _ACEOF
1038 fi
1039
1040 if test "$ac_init_help" = "recursive"; then
1041   # If there are subdirs, report their specific --help.
1042   ac_popdir=`pwd`
1043   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1044     test -d $ac_dir || continue
1045     ac_builddir=.
1046
1047 if test "$ac_dir" != .; then
1048   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1049   # A "../" for each directory in $ac_dir_suffix.
1050   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1051 else
1052   ac_dir_suffix= ac_top_builddir=
1053 fi
1054
1055 case $srcdir in
1056   .)  # No --srcdir option.  We are building in place.
1057     ac_srcdir=.
1058     if test -z "$ac_top_builddir"; then
1059        ac_top_srcdir=.
1060     else
1061        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1062     fi ;;
1063   [\\/]* | ?:[\\/]* )  # Absolute path.
1064     ac_srcdir=$srcdir$ac_dir_suffix;
1065     ac_top_srcdir=$srcdir ;;
1066   *) # Relative path.
1067     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1068     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1069 esac
1070
1071 # Do not use `cd foo && pwd` to compute absolute paths, because
1072 # the directories may not exist.
1073 case `pwd` in
1074 .) ac_abs_builddir="$ac_dir";;
1075 *)
1076   case "$ac_dir" in
1077   .) ac_abs_builddir=`pwd`;;
1078   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1079   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1080   esac;;
1081 esac
1082 case $ac_abs_builddir in
1083 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1084 *)
1085   case ${ac_top_builddir}. in
1086   .) ac_abs_top_builddir=$ac_abs_builddir;;
1087   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1088   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1089   esac;;
1090 esac
1091 case $ac_abs_builddir in
1092 .) ac_abs_srcdir=$ac_srcdir;;
1093 *)
1094   case $ac_srcdir in
1095   .) ac_abs_srcdir=$ac_abs_builddir;;
1096   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1097   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1098   esac;;
1099 esac
1100 case $ac_abs_builddir in
1101 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1102 *)
1103   case $ac_top_srcdir in
1104   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1105   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1106   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1107   esac;;
1108 esac
1109
1110     cd $ac_dir
1111     # Check for guested configure; otherwise get Cygnus style configure.
1112     if test -f $ac_srcdir/configure.gnu; then
1113       echo
1114       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1115     elif test -f $ac_srcdir/configure; then
1116       echo
1117       $SHELL $ac_srcdir/configure  --help=recursive
1118     elif test -f $ac_srcdir/configure.ac ||
1119            test -f $ac_srcdir/configure.in; then
1120       echo
1121       $ac_configure --help
1122     else
1123       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1124     fi
1125     cd $ac_popdir
1126   done
1127 fi
1128
1129 test -n "$ac_init_help" && exit 0
1130 if $ac_init_version; then
1131   cat <<\_ACEOF
1132
1133 Copyright (C) 2003 Free Software Foundation, Inc.
1134 This configure script is free software; the Free Software Foundation
1135 gives unlimited permission to copy, distribute and modify it.
1136 _ACEOF
1137   exit 0
1138 fi
1139 exec 5>config.log
1140 cat >&5 <<_ACEOF
1141 This file contains any messages produced by compilers while
1142 running configure, to aid debugging if configure makes a mistake.
1143
1144 It was created by $as_me, which was
1145 generated by GNU Autoconf 2.59.  Invocation command line was
1146
1147   $ $0 $@
1148
1149 _ACEOF
1150 {
1151 cat <<_ASUNAME
1152 ## --------- ##
1153 ## Platform. ##
1154 ## --------- ##
1155
1156 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1157 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1158 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1159 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1160 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1161
1162 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1163 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1164
1165 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1166 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1167 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1168 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1169 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1170 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1171 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1172
1173 _ASUNAME
1174
1175 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1176 for as_dir in $PATH
1177 do
1178   IFS=$as_save_IFS
1179   test -z "$as_dir" && as_dir=.
1180   echo "PATH: $as_dir"
1181 done
1182
1183 } >&5
1184
1185 cat >&5 <<_ACEOF
1186
1187
1188 ## ----------- ##
1189 ## Core tests. ##
1190 ## ----------- ##
1191
1192 _ACEOF
1193
1194
1195 # Keep a trace of the command line.
1196 # Strip out --no-create and --no-recursion so they do not pile up.
1197 # Strip out --silent because we don't want to record it for future runs.
1198 # Also quote any args containing shell meta-characters.
1199 # Make two passes to allow for proper duplicate-argument suppression.
1200 ac_configure_args=
1201 ac_configure_args0=
1202 ac_configure_args1=
1203 ac_sep=
1204 ac_must_keep_next=false
1205 for ac_pass in 1 2
1206 do
1207   for ac_arg
1208   do
1209     case $ac_arg in
1210     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1211     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1212     | -silent | --silent | --silen | --sile | --sil)
1213       continue ;;
1214     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1215       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1216     esac
1217     case $ac_pass in
1218     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1219     2)
1220       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1221       if test $ac_must_keep_next = true; then
1222         ac_must_keep_next=false # Got value, back to normal.
1223       else
1224         case $ac_arg in
1225           *=* | --config-cache | -C | -disable-* | --disable-* \
1226           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1227           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1228           | -with-* | --with-* | -without-* | --without-* | --x)
1229             case "$ac_configure_args0 " in
1230               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1231             esac
1232             ;;
1233           -* ) ac_must_keep_next=true ;;
1234         esac
1235       fi
1236       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1237       # Get rid of the leading space.
1238       ac_sep=" "
1239       ;;
1240     esac
1241   done
1242 done
1243 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1244 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1245
1246 # When interrupted or exit'd, cleanup temporary files, and complete
1247 # config.log.  We remove comments because anyway the quotes in there
1248 # would cause problems or look ugly.
1249 # WARNING: Be sure not to use single quotes in there, as some shells,
1250 # such as our DU 5.0 friend, will then `close' the trap.
1251 trap 'exit_status=$?
1252   # Save into config.log some information that might help in debugging.
1253   {
1254     echo
1255
1256     cat <<\_ASBOX
1257 ## ---------------- ##
1258 ## Cache variables. ##
1259 ## ---------------- ##
1260 _ASBOX
1261     echo
1262     # The following way of writing the cache mishandles newlines in values,
1263 {
1264   (set) 2>&1 |
1265     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1266     *ac_space=\ *)
1267       sed -n \
1268         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1269           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1270       ;;
1271     *)
1272       sed -n \
1273         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1274       ;;
1275     esac;
1276 }
1277     echo
1278
1279     cat <<\_ASBOX
1280 ## ----------------- ##
1281 ## Output variables. ##
1282 ## ----------------- ##
1283 _ASBOX
1284     echo
1285     for ac_var in $ac_subst_vars
1286     do
1287       eval ac_val=$`echo $ac_var`
1288       echo "$ac_var='"'"'$ac_val'"'"'"
1289     done | sort
1290     echo
1291
1292     if test -n "$ac_subst_files"; then
1293       cat <<\_ASBOX
1294 ## ------------- ##
1295 ## Output files. ##
1296 ## ------------- ##
1297 _ASBOX
1298       echo
1299       for ac_var in $ac_subst_files
1300       do
1301         eval ac_val=$`echo $ac_var`
1302         echo "$ac_var='"'"'$ac_val'"'"'"
1303       done | sort
1304       echo
1305     fi
1306
1307     if test -s confdefs.h; then
1308       cat <<\_ASBOX
1309 ## ----------- ##
1310 ## confdefs.h. ##
1311 ## ----------- ##
1312 _ASBOX
1313       echo
1314       sed "/^$/d" confdefs.h | sort
1315       echo
1316     fi
1317     test "$ac_signal" != 0 &&
1318       echo "$as_me: caught signal $ac_signal"
1319     echo "$as_me: exit $exit_status"
1320   } >&5
1321   rm -f core *.core &&
1322   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1323     exit $exit_status
1324      ' 0
1325 for ac_signal in 1 2 13 15; do
1326   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1327 done
1328 ac_signal=0
1329
1330 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1331 rm -rf conftest* confdefs.h
1332 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1333 echo >confdefs.h
1334
1335 # Predefined preprocessor variables.
1336
1337 cat >>confdefs.h <<_ACEOF
1338 #define PACKAGE_NAME "$PACKAGE_NAME"
1339 _ACEOF
1340
1341
1342 cat >>confdefs.h <<_ACEOF
1343 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1344 _ACEOF
1345
1346
1347 cat >>confdefs.h <<_ACEOF
1348 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1349 _ACEOF
1350
1351
1352 cat >>confdefs.h <<_ACEOF
1353 #define PACKAGE_STRING "$PACKAGE_STRING"
1354 _ACEOF
1355
1356
1357 cat >>confdefs.h <<_ACEOF
1358 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1359 _ACEOF
1360
1361
1362 # Let the site file select an alternate cache file if it wants to.
1363 # Prefer explicitly selected file to automatically selected ones.
1364 if test -z "$CONFIG_SITE"; then
1365   if test "x$prefix" != xNONE; then
1366     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1367   else
1368     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1369   fi
1370 fi
1371 for ac_site_file in $CONFIG_SITE; do
1372   if test -r "$ac_site_file"; then
1373     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1374 echo "$as_me: loading site script $ac_site_file" >&6;}
1375     sed 's/^/| /' "$ac_site_file" >&5
1376     . "$ac_site_file"
1377   fi
1378 done
1379
1380 if test -r "$cache_file"; then
1381   # Some versions of bash will fail to source /dev/null (special
1382   # files actually), so we avoid doing that.
1383   if test -f "$cache_file"; then
1384     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1385 echo "$as_me: loading cache $cache_file" >&6;}
1386     case $cache_file in
1387       [\\/]* | ?:[\\/]* ) . $cache_file;;
1388       *)                      . ./$cache_file;;
1389     esac
1390   fi
1391 else
1392   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1393 echo "$as_me: creating cache $cache_file" >&6;}
1394   >$cache_file
1395 fi
1396
1397 # Check that the precious variables saved in the cache have kept the same
1398 # value.
1399 ac_cache_corrupted=false
1400 for ac_var in `(set) 2>&1 |
1401                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1402   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1403   eval ac_new_set=\$ac_env_${ac_var}_set
1404   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1405   eval ac_new_val="\$ac_env_${ac_var}_value"
1406   case $ac_old_set,$ac_new_set in
1407     set,)
1408       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1409 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1410       ac_cache_corrupted=: ;;
1411     ,set)
1412       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1413 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1414       ac_cache_corrupted=: ;;
1415     ,);;
1416     *)
1417       if test "x$ac_old_val" != "x$ac_new_val"; then
1418         # differences in whitespace do not lead to failure.
1419         ac_old_val_w=`echo x $ac_old_val`
1420         ac_new_val_w=`echo x $ac_new_val`
1421         if test "$ac_old_val_w" != "$ac_new_val_w"; then
1422           { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1423 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1424           ac_cache_corrupted=:
1425         else
1426           { echo "$as_me:$LINENO: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
1427 echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
1428           eval $ac_var=\$ac_old_val
1429         fi
1430         { echo "$as_me:$LINENO:   former value:  \`$ac_old_val'" >&5
1431 echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
1432         { echo "$as_me:$LINENO:   current value: \`$ac_new_val'" >&5
1433 echo "$as_me:   current value: \`$ac_new_val'" >&2;}
1434       fi;;
1435   esac
1436   # Pass precious variables to config.status.
1437   if test "$ac_new_set" = set; then
1438     case $ac_new_val in
1439     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1440       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1441     *) ac_arg=$ac_var=$ac_new_val ;;
1442     esac
1443     case " $ac_configure_args " in
1444       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1445       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1446     esac
1447   fi
1448 done
1449 if $ac_cache_corrupted; then
1450   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1451 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1452   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1453 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1454    { (exit 1); exit 1; }; }
1455 fi
1456
1457 ac_ext=c
1458 ac_cpp='$CPP $CPPFLAGS'
1459 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1460 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1461 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483 # Find the build, host, and target systems.
1484 ac_aux_dir=
1485 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1486   if test -f $ac_dir/install-sh; then
1487     ac_aux_dir=$ac_dir
1488     ac_install_sh="$ac_aux_dir/install-sh -c"
1489     break
1490   elif test -f $ac_dir/install.sh; then
1491     ac_aux_dir=$ac_dir
1492     ac_install_sh="$ac_aux_dir/install.sh -c"
1493     break
1494   elif test -f $ac_dir/shtool; then
1495     ac_aux_dir=$ac_dir
1496     ac_install_sh="$ac_aux_dir/shtool install -c"
1497     break
1498   fi
1499 done
1500 if test -z "$ac_aux_dir"; then
1501   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1502 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1503    { (exit 1); exit 1; }; }
1504 fi
1505 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1506 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1507 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1508
1509 # Make sure we can run config.sub.
1510 $ac_config_sub sun4 >/dev/null 2>&1 ||
1511   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1512 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1513    { (exit 1); exit 1; }; }
1514
1515 echo "$as_me:$LINENO: checking build system type" >&5
1516 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1517 if test "${ac_cv_build+set}" = set; then
1518   echo $ECHO_N "(cached) $ECHO_C" >&6
1519 else
1520   ac_cv_build_alias=$build_alias
1521 test -z "$ac_cv_build_alias" &&
1522   ac_cv_build_alias=`$ac_config_guess`
1523 test -z "$ac_cv_build_alias" &&
1524   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1525 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1526    { (exit 1); exit 1; }; }
1527 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1528   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1529 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1530    { (exit 1); exit 1; }; }
1531
1532 fi
1533 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1534 echo "${ECHO_T}$ac_cv_build" >&6
1535 build=$ac_cv_build
1536 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1537 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1538 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1539
1540
1541  case ${build_alias} in
1542   "") build_noncanonical=${build} ;;
1543   *) build_noncanonical=${build_alias} ;;
1544 esac
1545
1546
1547
1548  case ${host_alias} in
1549   "") host_noncanonical=${build_noncanonical} ;;
1550   *) host_noncanonical=${host_alias} ;;
1551 esac
1552
1553
1554
1555  case ${target_alias} in
1556   "") target_noncanonical=${host_noncanonical} ;;
1557   *) target_noncanonical=${target_alias} ;;
1558 esac
1559
1560
1561
1562
1563 test "$host_noncanonical" = "$target_noncanonical" &&
1564   test "$program_prefix$program_suffix$program_transform_name" = \
1565     NONENONEs,x,x, &&
1566   program_transform_name=s,y,y,
1567
1568 echo "$as_me:$LINENO: checking host system type" >&5
1569 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1570 if test "${ac_cv_host+set}" = set; then
1571   echo $ECHO_N "(cached) $ECHO_C" >&6
1572 else
1573   ac_cv_host_alias=$host_alias
1574 test -z "$ac_cv_host_alias" &&
1575   ac_cv_host_alias=$ac_cv_build_alias
1576 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1577   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1578 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1579    { (exit 1); exit 1; }; }
1580
1581 fi
1582 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1583 echo "${ECHO_T}$ac_cv_host" >&6
1584 host=$ac_cv_host
1585 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1586 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1587 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1588
1589
1590 echo "$as_me:$LINENO: checking target system type" >&5
1591 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1592 if test "${ac_cv_target+set}" = set; then
1593   echo $ECHO_N "(cached) $ECHO_C" >&6
1594 else
1595   ac_cv_target_alias=$target_alias
1596 test "x$ac_cv_target_alias" = "x" &&
1597   ac_cv_target_alias=$ac_cv_host_alias
1598 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1599   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1600 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1601    { (exit 1); exit 1; }; }
1602
1603 fi
1604 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1605 echo "${ECHO_T}$ac_cv_target" >&6
1606 target=$ac_cv_target
1607 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1608 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1609 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1610
1611
1612 # The aliases save the names the user supplied, while $host etc.
1613 # will get canonicalized.
1614 test -n "$target_alias" &&
1615   test "$program_prefix$program_suffix$program_transform_name" = \
1616     NONENONEs,x,x, &&
1617   program_prefix=${target_alias}-
1618 test "$program_prefix" != NONE &&
1619   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1620 # Use a double $ so make ignores it.
1621 test "$program_suffix" != NONE &&
1622   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1623 # Double any \ or $.  echo might interpret backslashes.
1624 # By default was `s,x,x', remove it if useless.
1625 cat <<\_ACEOF >conftest.sed
1626 s/[\\$]/&&/g;s/;s,x,x,$//
1627 _ACEOF
1628 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1629 rm conftest.sed
1630
1631
1632
1633 # Get 'install' or 'install-sh' and its variants.
1634 # Find a good install program.  We prefer a C program (faster),
1635 # so one script is as good as another.  But avoid the broken or
1636 # incompatible versions:
1637 # SysV /etc/install, /usr/sbin/install
1638 # SunOS /usr/etc/install
1639 # IRIX /sbin/install
1640 # AIX /bin/install
1641 # AmigaOS /C/install, which installs bootblocks on floppy discs
1642 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1643 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1644 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1645 # OS/2's system install, which has a completely different semantic
1646 # ./install, which can be erroneously created by make from ./install.sh.
1647 # Reject install programs that cannot install multiple files.
1648 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1649 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1650 if test -z "$INSTALL"; then
1651 if test "${ac_cv_path_install+set}" = set; then
1652   echo $ECHO_N "(cached) $ECHO_C" >&6
1653 else
1654   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1655 for as_dir in $PATH
1656 do
1657   IFS=$as_save_IFS
1658   test -z "$as_dir" && as_dir=.
1659   # Account for people who put trailing slashes in PATH elements.
1660 case $as_dir/ in
1661   ./ | .// | /cC/* | \
1662   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1663   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1664   /usr/ucb/* ) ;;
1665   *)
1666     # OSF1 and SCO ODT 3.0 have their own names for install.
1667     # Don't use installbsd from OSF since it installs stuff as root
1668     # by default.
1669     for ac_prog in ginstall scoinst install; do
1670       for ac_exec_ext in '' $ac_executable_extensions; do
1671         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1672           if test $ac_prog = install &&
1673             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1674             # AIX install.  It has an incompatible calling convention.
1675             :
1676           elif test $ac_prog = install &&
1677             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1678             # program-specific install script used by HP pwplus--don't use.
1679             :
1680           else
1681             rm -rf conftest.one conftest.two conftest.dir
1682             echo one > conftest.one
1683             echo two > conftest.two
1684             mkdir conftest.dir
1685             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1686               test -s conftest.one && test -s conftest.two &&
1687               test -s conftest.dir/conftest.one &&
1688               test -s conftest.dir/conftest.two
1689             then
1690               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1691               break 3
1692             fi
1693           fi
1694         fi
1695       done
1696     done
1697     ;;
1698 esac
1699 done
1700
1701 rm -rf conftest.one conftest.two conftest.dir
1702
1703 fi
1704   if test "${ac_cv_path_install+set}" = set; then
1705     INSTALL=$ac_cv_path_install
1706   else
1707     # As a last resort, use the slow shell script.  Don't cache a
1708     # value for INSTALL within a source directory, because that will
1709     # break other packages using the cache if that directory is
1710     # removed, or if the value is a relative name.
1711     INSTALL=$ac_install_sh
1712   fi
1713 fi
1714 echo "$as_me:$LINENO: result: $INSTALL" >&5
1715 echo "${ECHO_T}$INSTALL" >&6
1716
1717 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1718 # It thinks the first close brace ends the variable substitution.
1719 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1720
1721 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1722
1723 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1724
1725 echo "$as_me:$LINENO: checking whether ln works" >&5
1726 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1727 if test "${acx_cv_prog_LN+set}" = set; then
1728   echo $ECHO_N "(cached) $ECHO_C" >&6
1729 else
1730   rm -f conftestdata_t
1731 echo >conftestdata_f
1732 if ln conftestdata_f conftestdata_t 2>/dev/null
1733 then
1734   acx_cv_prog_LN=ln
1735 else
1736   acx_cv_prog_LN=no
1737 fi
1738 rm -f conftestdata_f conftestdata_t
1739
1740 fi
1741 if test $acx_cv_prog_LN = no; then
1742   LN="cp"
1743   echo "$as_me:$LINENO: result: no, using $LN" >&5
1744 echo "${ECHO_T}no, using $LN" >&6
1745 else
1746   LN="$acx_cv_prog_LN"
1747   echo "$as_me:$LINENO: result: yes" >&5
1748 echo "${ECHO_T}yes" >&6
1749 fi
1750
1751 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1752 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1753 LN_S=$as_ln_s
1754 if test "$LN_S" = "ln -s"; then
1755   echo "$as_me:$LINENO: result: yes" >&5
1756 echo "${ECHO_T}yes" >&6
1757 else
1758   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1759 echo "${ECHO_T}no, using $LN_S" >&6
1760 fi
1761
1762
1763 ### we might need to use some other shell than /bin/sh for running subshells
1764 ### If we are on Windows, search for the shell.  This will permit people
1765 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1766 ### without also having to set CONFIG_SHELL.  This code will work when
1767 ### using bash, which sets OSTYPE.
1768 case "${OSTYPE}" in
1769 *win32*)
1770   if test x${CONFIG_SHELL} = x ; then
1771     if test ! -f /bin/sh ; then
1772       if test x${SHELL} != x && test -f ${SHELL} ; then
1773         CONFIG_SHELL=${SHELL}
1774         export CONFIG_SHELL
1775       else
1776         for prog in sh sh.exe bash bash.exe; do
1777           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1778           for dir in $PATH; do
1779             test -z "$dir" && dir=.
1780             if test -f $dir/$prog; then
1781               CONFIG_SHELL=$dir/$prog
1782               export CONFIG_SHELL
1783               break
1784             fi
1785           done
1786           IFS="$save_ifs"
1787           test -n "${CONFIG_SHELL}" && break
1788         done
1789       fi
1790     fi
1791   fi
1792   ;;
1793 esac
1794
1795 config_shell=${CONFIG_SHELL-/bin/sh}
1796
1797 progname=$0
1798 # if PWD already has a value, it is probably wrong.
1799 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1800
1801 # Export original configure arguments for use by sub-configures.
1802 # Quote arguments with shell meta charatcers.
1803 TOPLEVEL_CONFIGURE_ARGUMENTS=
1804 set -- "$progname" "$@"
1805 for ac_arg
1806 do
1807   case "$ac_arg" in
1808   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1809     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1810     # if the argument is of the form -foo=baz, quote the baz part only
1811     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1812   *) ;;
1813   esac
1814   # Add the quoted argument to the list.
1815   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1816 done
1817 if test "$silent" = yes; then
1818   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1819 fi
1820 # Remove the initial space we just introduced and, as these will be
1821 # expanded by make, quote '$'.
1822 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1823
1824
1825 moveifchange=${srcdir}/move-if-change
1826
1827 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1828
1829 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1830 # a relative path.
1831 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1832   INSTALL="${srcpwd}/install-sh -c"
1833 fi
1834
1835 # Set srcdir to "." if that's what it is.
1836 # This is important for multilib support.
1837 pwd=`${PWDCMD-pwd}`
1838 if test "${pwd}" = "${srcpwd}" ; then
1839   srcdir=.
1840 fi
1841
1842 topsrcdir=$srcpwd
1843
1844 extra_host_args=
1845
1846 ### To add a new directory to the tree, first choose whether it is a target
1847 ### or a host dependent tool.  Then put it into the appropriate list
1848 ### (library or tools, host or target), doing a dependency sort.
1849
1850 # Subdirs will be configured in the order listed in build_configdirs,
1851 # configdirs, or target_configdirs; see the serialization section below.
1852
1853 # Dependency sorting is only needed when *configuration* must be done in
1854 # a particular order.  In all cases a dependency should be specified in
1855 # the Makefile, whether or not it's implicitly specified here.
1856
1857 # Double entries in build_configdirs, configdirs, or target_configdirs may
1858 # cause circular dependencies and break everything horribly.
1859
1860 # these library is used by various programs built for the build
1861 # environment
1862 #
1863 build_libs="build-libiberty"
1864
1865 # these tools are built for the build environment
1866 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1867
1868 # these libraries are used by various programs built for the host environment
1869 #
1870 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1871
1872 # these tools are built for the host environment
1873 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1874 # know that we are building the simulator.
1875 # binutils, gas and ld appear in that order because it makes sense to run
1876 # "make check" in that particular order.
1877 # If --enable-gold is used, "gold" will replace "ld".
1878 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"
1879
1880 # libgcj represents the runtime libraries only used by gcj.
1881 libgcj="target-libffi \
1882         target-zlib \
1883         target-qthreads \
1884         target-libjava"
1885
1886 # these libraries are built for the target environment, and are built after
1887 # the host libraries and the host tools (which may be a cross compiler)
1888 #
1889 target_libraries="target-libgcc \
1890                 target-libiberty \
1891                 target-libgloss \
1892                 target-newlib \
1893                 target-libgomp \
1894                 target-libstdc++-v3 \
1895                 target-libmudflap \
1896                 target-libssp \
1897                 target-libgfortran \
1898                 target-boehm-gc \
1899                 ${libgcj} \
1900                 target-libobjc \
1901                 target-libada"
1902
1903 # these tools are built using the target libraries, and are intended to
1904 # run only in the target environment
1905 #
1906 # note: any program that *uses* libraries that are in the "target_libraries"
1907 # list belongs in this list.  those programs are also very likely
1908 # candidates for the "native_only" list which follows
1909 #
1910 target_tools="target-examples target-groff target-gperf target-rda"
1911
1912 ################################################################################
1913
1914 ## All tools belong in one of the four categories, and are assigned above
1915 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1916 ## is important because configure will choke if they ever get through.
1917 ## ${configdirs} is directories we build using the host tools.
1918 ## ${target_configdirs} is directories we build using the target tools.
1919 configdirs=`echo ${host_libs} ${host_tools}`
1920 target_configdirs=`echo ${target_libraries} ${target_tools}`
1921 build_configdirs=`echo ${build_libs} ${build_tools}`
1922
1923
1924
1925 ################################################################################
1926
1927 srcname="gnu development package"
1928
1929 # This gets set non-empty for some net releases of packages.
1930 appdirs=""
1931
1932 # Define is_cross_compiler to save on calls to 'test'.
1933 is_cross_compiler=
1934 if test x"${host}" = x"${target}" ; then
1935   is_cross_compiler=no
1936 else
1937   is_cross_compiler=yes
1938 fi
1939
1940 # Find the build and target subdir names.
1941
1942 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1943 # have matching libraries, they should use host libraries: Makefile.tpl
1944 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1945 # However, they still use the build modules, because the corresponding
1946 # host modules (e.g. bison) are only built for the host when bootstrap
1947 # finishes. So:
1948 # - build_subdir is where we find build modules, and never changes.
1949 # - build_libsubdir is where we find build libraries, and can be overridden.
1950
1951 # Prefix 'build-' so this never conflicts with target_subdir.
1952 build_subdir="build-${build_noncanonical}"
1953
1954 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1955 if test "${with_build_libsubdir+set}" = set; then
1956   withval="$with_build_libsubdir"
1957   build_libsubdir="$withval"
1958 else
1959   build_libsubdir="$build_subdir"
1960 fi;
1961 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1962 if ( test $srcdir = . && test -d gcc ) \
1963    || test -d $srcdir/../host-${host_noncanonical}; then
1964   host_subdir="host-${host_noncanonical}"
1965 else
1966   host_subdir=.
1967 fi
1968 # No prefix.
1969 target_subdir=${target_noncanonical}
1970
1971
1972 # Skipdirs are removed silently.
1973 skipdirs=
1974 # Noconfigdirs are removed loudly.
1975 noconfigdirs=""
1976
1977 use_gnu_ld=
1978 # Make sure we don't let GNU ld be added if we didn't want it.
1979 if test x$with_gnu_ld = xno ; then
1980   use_gnu_ld=no
1981   noconfigdirs="$noconfigdirs ld gold"
1982 fi
1983
1984 use_gnu_as=
1985 # Make sure we don't let GNU as be added if we didn't want it.
1986 if test x$with_gnu_as = xno ; then
1987   use_gnu_as=no
1988   noconfigdirs="$noconfigdirs gas"
1989 fi
1990
1991 # some tools are so dependent upon X11 that if we're not building with X,
1992 # it's not even worth trying to configure, much less build, that tool.
1993
1994 case ${with_x} in
1995   yes | "") ;; # the default value for this tree is that X11 is available
1996   no)
1997     skipdirs="${skipdirs} tk itcl libgui"
1998     # We won't be able to build gdbtk without X.
1999     enable_gdbtk=no
2000     ;;
2001   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
2002 esac
2003
2004 # Some tools are only suitable for building in a "native" situation.
2005 # Remove these if host!=target.
2006 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"
2007
2008 # Similarly, some are only suitable for cross toolchains.
2009 # Remove these if host=target.
2010 cross_only="target-libgloss target-newlib target-opcodes"
2011
2012 case $is_cross_compiler in
2013   no) skipdirs="${skipdirs} ${cross_only}" ;;
2014   yes) skipdirs="${skipdirs} ${native_only}" ;;
2015 esac
2016
2017 # If both --with-headers and --with-libs are specified, default to
2018 # --without-newlib.
2019 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2020    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2021   if test x"${with_newlib}" = x ; then
2022     with_newlib=no
2023   fi
2024 fi
2025
2026 # Recognize --with-newlib/--without-newlib.
2027 case ${with_newlib} in
2028   no) skipdirs="${skipdirs} target-newlib" ;;
2029   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2030 esac
2031
2032 # Handle --enable-gold.
2033
2034 # Check whether --enable-gold or --disable-gold was given.
2035 if test "${enable_gold+set}" = set; then
2036   enableval="$enable_gold"
2037   ENABLE_GOLD=$enableval
2038 else
2039   ENABLE_GOLD=no
2040 fi;
2041 if test "${ENABLE_GOLD}" = "yes"; then
2042   # Check for ELF target.
2043   is_elf=no
2044   case "${target}" in
2045     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2046     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2047     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2048       case "${target}" in
2049         *-*-linux*aout* | *-*-linux*oldld*)
2050           ;;
2051         *)
2052           is_elf=yes
2053           ;;
2054       esac
2055   esac
2056
2057   if test "$is_elf" = "yes"; then
2058     # Check for target supported by gold.
2059     case "${target}" in
2060       i?86-*-* | x86_64-*-* | sparc*-*-*)
2061         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2062         ;;
2063     esac
2064   fi
2065 fi
2066
2067 # Configure extra directories which are host specific
2068
2069 case "${host}" in
2070   *-cygwin*)
2071     configdirs="$configdirs libtermcap" ;;
2072 esac
2073
2074 # A target can indicate whether a language isn't supported for some reason.
2075 # Only spaces may be used in this macro; not newlines or tabs.
2076 unsupported_languages=
2077
2078 # Remove more programs from consideration, based on the host or
2079 # target this usually means that a port of the program doesn't
2080 # exist yet.
2081
2082 case "${host}" in
2083   hppa*64*-*-*)
2084     noconfigdirs="$noconfigdirs byacc"
2085     ;;
2086   i[3456789]86-*-vsta)
2087     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2088     ;;
2089   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2090     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2091     ;;
2092   x86_64-*-mingw*)
2093     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2094     ;;
2095   i[3456789]86-*-mingw32*)
2096     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2097     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2098     ;;
2099   i[3456789]86-*-beos*)
2100     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2101     ;;
2102   *-*-cygwin*)
2103     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2104     ;;
2105   *-*-netbsd*)
2106     noconfigdirs="$noconfigdirs rcs"
2107     ;;
2108   ppc*-*-pe)
2109     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2110     ;;
2111   powerpc-*-beos*)
2112     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2113     ;;
2114 esac
2115
2116
2117 # Check whether --enable-libada or --disable-libada was given.
2118 if test "${enable_libada+set}" = set; then
2119   enableval="$enable_libada"
2120   ENABLE_LIBADA=$enableval
2121 else
2122   ENABLE_LIBADA=yes
2123 fi;
2124 if test "${ENABLE_LIBADA}" != "yes" ; then
2125   noconfigdirs="$noconfigdirs gnattools"
2126 fi
2127
2128 # Check whether --enable-libssp or --disable-libssp was given.
2129 if test "${enable_libssp+set}" = set; then
2130   enableval="$enable_libssp"
2131   ENABLE_LIBSSP=$enableval
2132 else
2133   ENABLE_LIBSSP=yes
2134 fi;
2135
2136 # Save it here so that, even in case of --enable-libgcj, if the Java
2137 # front-end isn't enabled, we still get libgcj disabled.
2138 libgcj_saved=$libgcj
2139 case $enable_libgcj in
2140 yes)
2141   # If we reset it here, it won't get added to noconfigdirs in the
2142   # target-specific build rules, so it will be forcibly enabled
2143   # (unless the Java language itself isn't enabled).
2144   libgcj=
2145   ;;
2146 no)
2147   # Make sure we get it printed in the list of not supported target libs.
2148   noconfigdirs="$noconfigdirs ${libgcj}"
2149   ;;
2150 esac
2151
2152
2153 # Disable libmudflap on some systems.
2154 if test x$enable_libmudflap = x ; then
2155     case "${target}" in
2156     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2157         # Enable libmudflap by default in GNU and friends.
2158         ;;
2159     *-*-freebsd*)
2160         # Enable libmudflap by default in FreeBSD.
2161         ;;
2162     *)
2163         # Disable it by default everywhere else.
2164         noconfigdirs="$noconfigdirs target-libmudflap"
2165         ;;
2166     esac
2167 fi
2168
2169 # Disable libgomp on non POSIX hosted systems.
2170 if test x$enable_libgomp = x ; then
2171     # Enable libgomp by default on hosted POSIX systems.
2172     case "${target}" in
2173     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2174         ;;
2175     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2176         ;;
2177     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2178         ;;
2179     *-*-darwin* | *-*-aix*)
2180         ;;
2181     *)
2182         noconfigdirs="$noconfigdirs target-libgomp"
2183         ;;
2184     esac
2185 fi
2186
2187 # Default libgloss CPU subdirectory.
2188 libgloss_dir="$target_cpu"
2189
2190 case "${target}" in
2191   *-*-chorusos)
2192     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2193     ;;
2194   powerpc-*-darwin* | i[3456789]86-*-darwin* | x86_64-*-darwin9*)
2195     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2196     noconfigdirs="$noconfigdirs sim target-rda"
2197     ;;
2198   *-*-darwin*)
2199     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2200     noconfigdirs="$noconfigdirs sim target-rda"
2201     noconfigdirs="$noconfigdirs ${libgcj}"
2202     ;;
2203   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2204     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2205     ;;
2206   *-*-freebsd*)
2207     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2208     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2209         && test -f /usr/local/include/gmp.h; then
2210       with_gmp=/usr/local
2211     fi
2212
2213     # Skip some stuff that's unsupported on some FreeBSD configurations.
2214     case "${target}" in
2215       i*86-*-*) ;;
2216       alpha*-*-*) ;;
2217       *)
2218         noconfigdirs="$noconfigdirs ${libgcj}"
2219         ;;
2220     esac
2221     ;;
2222   *-*-kaos*)
2223     # Remove unsupported stuff on all kaOS configurations.
2224     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2225     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2226     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2227     noconfigdirs="$noconfigdirs target-libgloss"
2228     ;;
2229   *-*-netbsd*)
2230     # Skip some stuff on all NetBSD configurations.
2231     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2232
2233     # Skip some stuff that's unsupported on some NetBSD configurations.
2234     case "${target}" in
2235       i*86-*-netbsdelf*) ;;
2236       arm*-*-netbsdelf*) ;;
2237       *)
2238         noconfigdirs="$noconfigdirs ${libgcj}"
2239         ;;
2240     esac
2241     ;;
2242   *-*-netware*)
2243     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2244     ;;
2245   *-*-rtems*)
2246     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2247     ;;
2248     # The tpf target doesn't support gdb yet.
2249   *-*-tpf*)
2250     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2251     ;;
2252   *-*-uclinux*)
2253     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2254     ;;
2255   *-*-vxworks*)
2256     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2257     ;;
2258   alpha*-dec-osf*)
2259     # ld works, but does not support shared libraries.
2260     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2261     # gas doesn't generate exception information.
2262     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2263     ;;
2264   alpha*-*-*vms*)
2265     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2266     ;;
2267   alpha*-*-linux*)
2268     # newlib is not 64 bit ready
2269     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2270     ;;
2271   alpha*-*-*)
2272     # newlib is not 64 bit ready
2273     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2274     ;;
2275   am33_2.0-*-linux*)
2276     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2277     ;;
2278   sh-*-linux*)
2279     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2280     ;;
2281   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2282     noconfigdirs="$noconfigdirs ${libgcj}"
2283     noconfigdirs="$noconfigdirs target-examples"
2284     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2285     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2286     noconfigdirs="$noconfigdirs expect dejagnu"
2287     # the C++ libraries don't build on top of CE's C libraries
2288     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2289     noconfigdirs="$noconfigdirs target-newlib"
2290     case "${host}" in
2291       *-*-cygwin*) ;; # keep gdb and readline
2292       *) noconfigdirs="$noconfigdirs gdb readline"
2293          ;;
2294     esac
2295     libgloss_dir=wince
2296     ;;
2297   arc-*-*)
2298     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2299     ;;
2300   arm-semi-aof )
2301     ;;
2302   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2303     noconfigdirs="$noconfigdirs ${libgcj}"
2304     libgloss_dir=arm
2305     ;;
2306   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2307     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2308     libgloss_dir=arm
2309     ;;
2310   arm*-*-linux-gnueabi)
2311     noconfigdirs="$noconfigdirs target-qthreads"
2312     noconfigdirs="$noconfigdirs target-libobjc"
2313     case ${with_newlib} in
2314       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2315     esac
2316     libgloss_dir=arm
2317     ;;
2318   arm*-*-symbianelf*)
2319     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2320     libgloss_dir=arm
2321     ;;
2322   arm-*-pe*)
2323     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2324     ;;
2325   thumb-*-coff)
2326     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2327     ;;
2328   thumb-*-elf)
2329     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2330     ;;
2331   thumb-*-pe)
2332     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2333     ;;
2334   arm-*-riscix*)
2335     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2336     ;;
2337   avr-*-*)
2338     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj} target-libssp"
2339     ;;
2340   bfin-*-*)
2341     noconfigdirs="$noconfigdirs gdb"
2342     if test x${is_cross_compiler} != xno ; then
2343       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2344     fi
2345     ;;
2346   c4x-*-* | tic4x-*-*)
2347     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2348     ;;
2349   c54x*-*-* | tic54x-*-*)
2350     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2351     ;;
2352   cr16-*-*)
2353     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2354     ;;
2355   cris-*-* | crisv32-*-*)
2356     unsupported_languages="$unsupported_languages java"
2357     case "${target}" in
2358       *-*-aout)
2359         unsupported_languages="$unsupported_languages fortran"
2360         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2361       *-*-elf)
2362         noconfigdirs="$noconfigdirs target-boehm-gc";;
2363       *-*-linux*)
2364         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2365       *)
2366         unsupported_languages="$unsupported_languages fortran"
2367         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2368     esac
2369     libgloss_dir=cris
2370     ;;
2371   crx-*-*)
2372     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2373     ;;
2374   d10v-*-*)
2375     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2376     ;;
2377   d30v-*-*)
2378     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2379     ;;
2380   ep9312-*-elf | ep9312-*-coff)
2381     libgloss_dir=arm
2382     ;;
2383   fr30-*-elf*)
2384     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2385     ;;
2386   frv-*-*)
2387     noconfigdirs="$noconfigdirs ${libgcj}"
2388     ;;
2389   h8300*-*-*)
2390     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2391     ;;
2392   h8500-*-*)
2393     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2394     ;;
2395   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2396     ;;
2397   hppa*64*-*-linux* | parisc*64*-*-linux*)
2398     # In this case, it's because the hppa64-linux target is for
2399     # the kernel only at this point and has no libc, and thus no
2400     # headers, crt*.o, etc., all of which are needed by these.
2401     noconfigdirs="$noconfigdirs target-zlib"
2402     ;;
2403   parisc*-*-linux* | hppa*-*-linux*)
2404     ;;
2405   hppa*-*-*elf* | \
2406   hppa*-*-lites* | \
2407   hppa*-*-openbsd* | \
2408   hppa*64*-*-*)
2409     noconfigdirs="$noconfigdirs ${libgcj}"
2410     ;;
2411   hppa*-hp-hpux11*)
2412     noconfigdirs="$noconfigdirs ld shellutils"
2413     ;;
2414   hppa*-*-pro*)
2415     libgloss_dir=pa
2416     ;;
2417   hppa*-*-*)
2418     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2419     # build on HP-UX 10.20.
2420     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2421     ;;
2422   i960-*-*)
2423     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2424     ;;
2425   ia64*-*-elf*)
2426     # No gdb support yet.
2427     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2428     ;;
2429   ia64*-**-hpux*)
2430     # No gdb or ld support yet.
2431     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2432     ;;
2433   i370-*-opened*)
2434     ;;
2435   i[3456789]86-*-coff | i[3456789]86-*-elf)
2436     noconfigdirs="$noconfigdirs ${libgcj}"
2437     libgloss_dir=i386
2438     ;;
2439   i[3456789]86-*-linux*)
2440     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2441     # not build java stuff by default.
2442     case "${target}" in
2443       *-*-*libc1*)
2444         noconfigdirs="$noconfigdirs ${libgcj}";;
2445     esac
2446
2447     # This section makes it possible to build newlib natively on linux.
2448     # If we are using a cross compiler then don't configure newlib.
2449     if test x${is_cross_compiler} != xno ; then
2450       noconfigdirs="$noconfigdirs target-newlib"
2451     fi
2452     noconfigdirs="$noconfigdirs target-libgloss"
2453     # If we are not using a cross compiler, do configure newlib.
2454     # Note however, that newlib will only be configured in this situation
2455     # if the --with-newlib option has been given, because otherwise
2456     # 'target-newlib' will appear in skipdirs.
2457     ;;
2458   i[3456789]86-*-mingw32*)
2459     target_configdirs="$target_configdirs target-winsup"
2460     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2461     ;;
2462   x86_64-*-mingw*)
2463     target_configdirs="$target_configdirs target-winsup"
2464     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2465     ;;
2466   *-*-cygwin*)
2467     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2468     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2469     # always build newlib if winsup directory is present.
2470     if test -d "$srcdir/winsup/cygwin"; then
2471       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2472     elif test -d "$srcdir/newlib"; then
2473       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2474     fi
2475     ;;
2476   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2477   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2478     ;;
2479   i[3456789]86-*-pe)
2480     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2481     ;;
2482   i[3456789]86-*-sco3.2v5*)
2483     # The linker does not yet know about weak symbols in COFF,
2484     # and is not configured to handle mixed ELF and COFF.
2485     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2486     ;;
2487   i[3456789]86-*-sco*)
2488     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2489     ;;
2490   i[3456789]86-*-solaris2*)
2491     noconfigdirs="$noconfigdirs target-libgloss"
2492     ;;
2493   i[3456789]86-*-sysv4*)
2494     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2495     ;;
2496   i[3456789]86-*-beos*)
2497     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2498     ;;
2499   i[3456789]86-*-rdos*)
2500     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2501     ;;
2502   m32r-*-*)
2503     noconfigdirs="$noconfigdirs ${libgcj}"
2504     ;;
2505   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2506     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2507     libgloss_dir=m68hc11
2508     ;;
2509   m68k-*-elf*)
2510     noconfigdirs="$noconfigdirs ${libgcj}"
2511     ;;
2512   m68k-*-coff*)
2513     noconfigdirs="$noconfigdirs ${libgcj}"
2514     ;;
2515   m68*-*-* | fido-*-*)
2516     libgloss_dir=m68k
2517     ;;
2518   mcore-*-pe*)
2519   # The EPOC C++ environment does not support exceptions or rtti,
2520   # and so building libstdc++-v3 tends not to always work.
2521     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2522     ;;
2523   mmix-*-*)
2524     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2525     unsupported_languages="$unsupported_languages fortran java"
2526     ;;
2527   mn10200-*-*)
2528     noconfigdirs="$noconfigdirs ${libgcj}"
2529     ;;
2530   mn10300-*-*)
2531     noconfigdirs="$noconfigdirs ${libgcj}"
2532     ;;
2533   mt-*-*)
2534     noconfigdirs="$noconfigdirs sim"
2535     ;;
2536   powerpc-*-aix*)
2537     # copied from rs6000-*-* entry
2538     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2539     ;;
2540   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2541     target_configdirs="$target_configdirs target-winsup"
2542     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2543     # always build newlib.
2544     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2545     ;;
2546     # This is temporary until we can link against shared libraries
2547   powerpcle-*-solaris*)
2548     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2549     libgloss_dir=rs6000
2550     ;;
2551   powerpc-*-beos*)
2552     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2553     ;;
2554   powerpc-*-eabi)
2555     noconfigdirs="$noconfigdirs ${libgcj}"
2556     libgloss_dir=rs6000
2557     ;;
2558   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2559     libgloss_dir=rs6000
2560     ;;
2561   rs6000-*-lynxos*)
2562     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2563     ;;
2564   rs6000-*-aix*)
2565     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2566     ;;
2567   rs6000-*-*)
2568     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2569     ;;
2570   m68k-apollo-*)
2571     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2572     ;;
2573   mips*-sde-elf*)
2574     skipdirs="$skipdirs target-libiberty"
2575     noconfigdirs="$noconfigdirs ${libgcj}"
2576     if test x$with_newlib = xyes; then
2577       noconfigdirs="$noconfigdirs gprof"
2578     fi
2579     libgloss_dir=mips
2580     ;;
2581   mips*-*-irix5*)
2582     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2583     ;;
2584   mips*-*-irix6*)
2585     # Linking libjava exceeds command-line length limits on at least
2586     # IRIX 6.2, but not on IRIX 6.5.
2587     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2588     # <oldham@codesourcery.com>
2589     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2590     ;;
2591   mips*-*-bsd*)
2592     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2593     ;;
2594   mips*-*-linux*)
2595     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2596     ;;
2597   mips*-*-*)
2598     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2599     libgloss_dir=mips
2600     ;;
2601   romp-*-*)
2602     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2603     ;;
2604   sh-*-* | sh64-*-*)
2605     case "${host}" in
2606       i[3456789]86-*-vsta) ;; # don't add gprof back in
2607       i[3456789]86-*-go32*) ;; # don't add gprof back in
2608       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2609       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2610     esac
2611     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2612     ;;
2613   sparclet-*-aout* | sparc86x-*-*)
2614     libgloss_dir=sparc
2615     ;;
2616   sparc-*-elf*)
2617     noconfigdirs="$noconfigdirs ${libgcj}"
2618     ;;
2619   sparc64-*-elf*)
2620     noconfigdirs="$noconfigdirs ${libgcj}"
2621     libgloss_dir=sparc
2622     ;;
2623   sparclite-*-*)
2624     noconfigdirs="$noconfigdirs ${libgcj}"
2625     libgloss_dir=sparc
2626     ;;
2627   sparc-*-sunos4*)
2628     noconfigdirs="$noconfigdirs ${libgcj}"
2629     if test x${is_cross_compiler} != xno ; then
2630            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2631     else
2632            use_gnu_ld=no
2633     fi
2634     ;;
2635   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2636     noconfigdirs="$noconfigdirs ${libgcj}"
2637     ;;
2638   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2639     ;;
2640   spu-*-*)
2641     skipdirs="target-libssp"
2642     ;;
2643   v810-*-*)
2644     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2645     ;;
2646   v850-*-*)
2647     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2648     ;;
2649   v850e-*-*)
2650     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2651     ;;
2652   v850ea-*-*)
2653     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2654     ;;
2655   vax-*-vms)
2656     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2657     ;;
2658   vax-*-*)
2659     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2660     ;;
2661   xtensa*-*-*)
2662     noconfigdirs="$noconfigdirs ${libgcj}"
2663     ;;
2664   ip2k-*-*)
2665     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2666     ;;
2667   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2668     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2669     ;;
2670   *-*-lynxos*)
2671     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2672     ;;
2673   *-*-*)
2674     noconfigdirs="$noconfigdirs ${libgcj}"
2675     ;;
2676 esac
2677
2678 # If we aren't building newlib, then don't build libgloss, since libgloss
2679 # depends upon some newlib header files.
2680 case "${noconfigdirs}" in
2681   *target-libgloss*) ;;
2682   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2683 esac
2684
2685 # Work in distributions that contain no compiler tools, like Autoconf.
2686 tentative_cc=""
2687 host_makefile_frag=/dev/null
2688 if test -d ${srcdir}/config ; then
2689 case "${host}" in
2690   m68k-hp-hpux*)
2691     # Avoid "too much defining" errors from HPUX compiler.
2692     tentative_cc="cc -Wp,-H256000"
2693     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2694     # If it's HP/UX ar, this should be harmless.
2695     RANLIB="ar ts"
2696     ;;
2697   m68k-apollo-sysv*)
2698     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2699     ;;
2700   m68k-apollo-bsd*)
2701     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2702     # chokes on bfd, the compiler won't let you assign integers to enums, and
2703     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2704     # the apollo compiler" (the preferred version of GCC could be called cc,
2705     # or whatever), but I'm not sure leaving CC as cc is any better...
2706     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2707     # Used to have BISON=yacc.
2708     tentative_cc=gcc
2709     ;;
2710   m88k-dg-dgux*)
2711     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2712     ;;
2713   m88k-harris-cxux*)
2714     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2715     tentative_cc="cc -Xa"
2716     host_makefile_frag="config/mh-cxux"
2717     ;;
2718   m88k-motorola-sysv*)
2719     ;;
2720   mips*-dec-ultrix*)
2721     tentative_cc="cc -Wf,-XNg1000"
2722     host_makefile_frag="config/mh-decstation"
2723     ;;
2724   mips*-nec-sysv4*)
2725     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2726     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2727     host_makefile_frag="config/mh-necv4"
2728     ;;
2729   mips*-sgi-irix4*)
2730     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2731     # environment.  Also bump switch table size so that cp-parse will
2732     # compile.  Bump string length limit so linker builds.
2733     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2734     ;;
2735   mips*-*-sysv4*)
2736     host_makefile_frag="config/mh-sysv4"
2737     ;;
2738   mips*-*-sysv*)
2739     # This is for a MIPS running RISC/os 4.52C.
2740
2741     # This is needed for GDB, but needs to be in the top-level make because
2742     # if a library is compiled with the bsd headers and gets linked with the
2743     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2744     # a different size).
2745     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2746     # known except to select the sysv environment.  Could we use /proc instead?
2747     # These "sysv environments" and "bsd environments" often end up being a pain.
2748     #
2749     # This is not part of CFLAGS because perhaps not all C compilers have this
2750     # option.
2751     tentative_cc="cc -systype sysv"
2752     ;;
2753   i370-ibm-opened*)
2754     tentative_cc="c89"
2755     ;;
2756   i[3456789]86-*-sysv5*)
2757     host_makefile_frag="config/mh-sysv5"
2758     ;;
2759   i[3456789]86-*-dgux*)
2760     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2761     host_makefile_frag="config/mh-dgux386"
2762     ;;
2763   i[3456789]86-ncr-sysv4.3*)
2764     # The MetaWare compiler will generate a copyright message unless you
2765     # turn it off by adding the -Hnocopyr flag.
2766     tentative_cc="cc -Hnocopyr"
2767     ;;
2768   i[3456789]86-ncr-sysv4*)
2769     # for an NCR 3000 (i486/SVR4) system.
2770     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2771     # This compiler not only emits obnoxious copyright messages every time
2772     # you run it, but it chokes and dies on a whole bunch of GNU source
2773     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2774     tentative_cc="/usr/ccs/ATT/cc"
2775     host_makefile_frag="config/mh-ncr3000"
2776     ;;
2777   i[3456789]86-*-sco3.2v5*)
2778     ;;
2779   i[3456789]86-*-sco*)
2780     # The native C compiler botches some simple uses of const.  Unfortunately,
2781     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2782     tentative_cc="cc -Dconst="
2783     host_makefile_frag="config/mh-sco"
2784     ;;
2785   i[3456789]86-*-udk*)
2786     host_makefile_frag="config/mh-sysv5"
2787     ;;
2788   i[3456789]86-*-solaris2*)
2789     host_makefile_frag="config/mh-sysv4"
2790     ;;
2791   i[3456789]86-*-msdosdjgpp*)
2792     host_makefile_frag="config/mh-djgpp"
2793     ;;
2794   *-cygwin*)
2795
2796 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2797 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2798 echo a >cygwin-cat-check
2799 if test `cat cygwin-cat-check` == a ; then
2800   rm cygwin-cat-check
2801   echo "$as_me:$LINENO: result: yes" >&5
2802 echo "${ECHO_T}yes" >&6
2803 else
2804   rm cygwin-cat-check
2805   echo "$as_me:$LINENO: result: no" >&5
2806 echo "${ECHO_T}no" >&6
2807   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2808   Please either mount the build directory in binary mode or run the following
2809   commands before running any configure script:
2810 set -o igncr
2811 export SHELLOPTS
2812   " >&5
2813 echo "$as_me: error: The cat command does not ignore carriage return characters.
2814   Please either mount the build directory in binary mode or run the following
2815   commands before running any configure script:
2816 set -o igncr
2817 export SHELLOPTS
2818   " >&2;}
2819    { (exit 1); exit 1; }; }
2820 fi
2821
2822     host_makefile_frag="config/mh-cygwin"
2823     ;;
2824   *-mingw*)
2825     host_makefile_frag="config/mh-mingw"
2826     ;;
2827   *-interix*)
2828     host_makefile_frag="config/mh-interix"
2829     ;;
2830   vax-*-ultrix2*)
2831     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2832     tentative_cc=gcc
2833     ;;
2834   *-*-solaris2*)
2835     host_makefile_frag="config/mh-solaris"
2836     ;;
2837   m68k-sun-sunos*)
2838     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2839     # without overflowing the jump tables (-J says to use a 32 bit table)
2840     tentative_cc="cc -J"
2841     ;;
2842   *-hp-hpux*)
2843     tentative_cc="cc -Wp,-H256000"
2844     ;;
2845   *-*-hiux*)
2846     tentative_cc="cc -Wp,-H256000"
2847     ;;
2848   rs6000-*-lynxos*)
2849     # /bin/cc is less than useful for our purposes.  Always use GCC
2850     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2851     host_makefile_frag="config/mh-lynxrs6k"
2852     ;;
2853   powerpc-*-darwin*)
2854     host_makefile_frag="config/mh-ppc-darwin"
2855     ;;
2856   powerpc-*-aix*)
2857     host_makefile_frag="config/mh-ppc-aix"
2858     ;;
2859   rs6000-*-aix*)
2860     host_makefile_frag="config/mh-ppc-aix"
2861     ;;
2862   *-*-lynxos*)
2863     # /bin/cc is less than useful for our purposes.  Always use GCC
2864     tentative_cc="/bin/gcc"
2865     ;;
2866   *-*-sysv4*)
2867     host_makefile_frag="config/mh-sysv4"
2868     ;;
2869   # This is placed last to prevent interfering with the cases above.
2870   i[3456789]86-*-*)
2871     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2872     host_makefile_frag="config/mh-x86omitfp"
2873     ;;
2874 esac
2875 fi
2876
2877 # If we aren't going to be using gcc, see if we can extract a definition
2878 # of CC from the fragment.
2879 # Actually, use the 'pre-extracted' version above.
2880 if test -z "${CC}" && test "${build}" = "${host}" ; then
2881   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2882   found=
2883   for dir in $PATH; do
2884     test -z "$dir" && dir=.
2885     if test -f $dir/gcc; then
2886       found=yes
2887       break
2888     fi
2889   done
2890   IFS="$save_ifs"
2891   if test -z "${found}" && test -n "${tentative_cc}" ; then
2892     CC=$tentative_cc
2893   fi
2894 fi
2895
2896 if test "${build}" != "${host}" ; then
2897   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2898   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2899   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2900   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2901   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2902   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2903   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2904   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2905   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2906   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2907   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2908   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2909 else
2910   AR_FOR_BUILD="\$(AR)"
2911   AS_FOR_BUILD="\$(AS)"
2912   CC_FOR_BUILD="\$(CC)"
2913   CXX_FOR_BUILD="\$(CXX)"
2914   GCJ_FOR_BUILD="\$(GCJ)"
2915   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2916   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2917   LD_FOR_BUILD="\$(LD)"
2918   NM_FOR_BUILD="\$(NM)"
2919   RANLIB_FOR_BUILD="\$(RANLIB)"
2920   WINDRES_FOR_BUILD="\$(WINDRES)"
2921   WINDMC_FOR_BUILD="\$(WINDMC)"
2922 fi
2923
2924 ac_ext=c
2925 ac_cpp='$CPP $CPPFLAGS'
2926 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2927 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2928 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2929 if test -n "$ac_tool_prefix"; then
2930   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2931 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2932 echo "$as_me:$LINENO: checking for $ac_word" >&5
2933 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2934 if test "${ac_cv_prog_CC+set}" = set; then
2935   echo $ECHO_N "(cached) $ECHO_C" >&6
2936 else
2937   if test -n "$CC"; then
2938   ac_cv_prog_CC="$CC" # Let the user override the test.
2939 else
2940 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2941 for as_dir in $PATH
2942 do
2943   IFS=$as_save_IFS
2944   test -z "$as_dir" && as_dir=.
2945   for ac_exec_ext in '' $ac_executable_extensions; do
2946   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2947     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2948     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2949     break 2
2950   fi
2951 done
2952 done
2953
2954 fi
2955 fi
2956 CC=$ac_cv_prog_CC
2957 if test -n "$CC"; then
2958   echo "$as_me:$LINENO: result: $CC" >&5
2959 echo "${ECHO_T}$CC" >&6
2960 else
2961   echo "$as_me:$LINENO: result: no" >&5
2962 echo "${ECHO_T}no" >&6
2963 fi
2964
2965 fi
2966 if test -z "$ac_cv_prog_CC"; then
2967   ac_ct_CC=$CC
2968   # Extract the first word of "gcc", so it can be a program name with args.
2969 set dummy gcc; ac_word=$2
2970 echo "$as_me:$LINENO: checking for $ac_word" >&5
2971 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2972 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2973   echo $ECHO_N "(cached) $ECHO_C" >&6
2974 else
2975   if test -n "$ac_ct_CC"; then
2976   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2977 else
2978 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2979 for as_dir in $PATH
2980 do
2981   IFS=$as_save_IFS
2982   test -z "$as_dir" && as_dir=.
2983   for ac_exec_ext in '' $ac_executable_extensions; do
2984   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2985     ac_cv_prog_ac_ct_CC="gcc"
2986     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2987     break 2
2988   fi
2989 done
2990 done
2991
2992 fi
2993 fi
2994 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2995 if test -n "$ac_ct_CC"; then
2996   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2997 echo "${ECHO_T}$ac_ct_CC" >&6
2998 else
2999   echo "$as_me:$LINENO: result: no" >&5
3000 echo "${ECHO_T}no" >&6
3001 fi
3002
3003   CC=$ac_ct_CC
3004 else
3005   CC="$ac_cv_prog_CC"
3006 fi
3007
3008 if test -z "$CC"; then
3009   if test -n "$ac_tool_prefix"; then
3010   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3011 set dummy ${ac_tool_prefix}cc; ac_word=$2
3012 echo "$as_me:$LINENO: checking for $ac_word" >&5
3013 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3014 if test "${ac_cv_prog_CC+set}" = set; then
3015   echo $ECHO_N "(cached) $ECHO_C" >&6
3016 else
3017   if test -n "$CC"; then
3018   ac_cv_prog_CC="$CC" # Let the user override the test.
3019 else
3020 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3021 for as_dir in $PATH
3022 do
3023   IFS=$as_save_IFS
3024   test -z "$as_dir" && as_dir=.
3025   for ac_exec_ext in '' $ac_executable_extensions; do
3026   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3027     ac_cv_prog_CC="${ac_tool_prefix}cc"
3028     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3029     break 2
3030   fi
3031 done
3032 done
3033
3034 fi
3035 fi
3036 CC=$ac_cv_prog_CC
3037 if test -n "$CC"; then
3038   echo "$as_me:$LINENO: result: $CC" >&5
3039 echo "${ECHO_T}$CC" >&6
3040 else
3041   echo "$as_me:$LINENO: result: no" >&5
3042 echo "${ECHO_T}no" >&6
3043 fi
3044
3045 fi
3046 if test -z "$ac_cv_prog_CC"; then
3047   ac_ct_CC=$CC
3048   # Extract the first word of "cc", so it can be a program name with args.
3049 set dummy cc; ac_word=$2
3050 echo "$as_me:$LINENO: checking for $ac_word" >&5
3051 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3052 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3053   echo $ECHO_N "(cached) $ECHO_C" >&6
3054 else
3055   if test -n "$ac_ct_CC"; then
3056   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3057 else
3058 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3059 for as_dir in $PATH
3060 do
3061   IFS=$as_save_IFS
3062   test -z "$as_dir" && as_dir=.
3063   for ac_exec_ext in '' $ac_executable_extensions; do
3064   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3065     ac_cv_prog_ac_ct_CC="cc"
3066     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3067     break 2
3068   fi
3069 done
3070 done
3071
3072 fi
3073 fi
3074 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3075 if test -n "$ac_ct_CC"; then
3076   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3077 echo "${ECHO_T}$ac_ct_CC" >&6
3078 else
3079   echo "$as_me:$LINENO: result: no" >&5
3080 echo "${ECHO_T}no" >&6
3081 fi
3082
3083   CC=$ac_ct_CC
3084 else
3085   CC="$ac_cv_prog_CC"
3086 fi
3087
3088 fi
3089 if test -z "$CC"; then
3090   # Extract the first word of "cc", so it can be a program name with args.
3091 set dummy cc; ac_word=$2
3092 echo "$as_me:$LINENO: checking for $ac_word" >&5
3093 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3094 if test "${ac_cv_prog_CC+set}" = set; then
3095   echo $ECHO_N "(cached) $ECHO_C" >&6
3096 else
3097   if test -n "$CC"; then
3098   ac_cv_prog_CC="$CC" # Let the user override the test.
3099 else
3100   ac_prog_rejected=no
3101 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3102 for as_dir in $PATH
3103 do
3104   IFS=$as_save_IFS
3105   test -z "$as_dir" && as_dir=.
3106   for ac_exec_ext in '' $ac_executable_extensions; do
3107   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3108     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3109        ac_prog_rejected=yes
3110        continue
3111      fi
3112     ac_cv_prog_CC="cc"
3113     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3114     break 2
3115   fi
3116 done
3117 done
3118
3119 if test $ac_prog_rejected = yes; then
3120   # We found a bogon in the path, so make sure we never use it.
3121   set dummy $ac_cv_prog_CC
3122   shift
3123   if test $# != 0; then
3124     # We chose a different compiler from the bogus one.
3125     # However, it has the same basename, so the bogon will be chosen
3126     # first if we set CC to just the basename; use the full file name.
3127     shift
3128     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3129   fi
3130 fi
3131 fi
3132 fi
3133 CC=$ac_cv_prog_CC
3134 if test -n "$CC"; then
3135   echo "$as_me:$LINENO: result: $CC" >&5
3136 echo "${ECHO_T}$CC" >&6
3137 else
3138   echo "$as_me:$LINENO: result: no" >&5
3139 echo "${ECHO_T}no" >&6
3140 fi
3141
3142 fi
3143 if test -z "$CC"; then
3144   if test -n "$ac_tool_prefix"; then
3145   for ac_prog in cl
3146   do
3147     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3148 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3149 echo "$as_me:$LINENO: checking for $ac_word" >&5
3150 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3151 if test "${ac_cv_prog_CC+set}" = set; then
3152   echo $ECHO_N "(cached) $ECHO_C" >&6
3153 else
3154   if test -n "$CC"; then
3155   ac_cv_prog_CC="$CC" # Let the user override the test.
3156 else
3157 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3158 for as_dir in $PATH
3159 do
3160   IFS=$as_save_IFS
3161   test -z "$as_dir" && as_dir=.
3162   for ac_exec_ext in '' $ac_executable_extensions; do
3163   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3164     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3165     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3166     break 2
3167   fi
3168 done
3169 done
3170
3171 fi
3172 fi
3173 CC=$ac_cv_prog_CC
3174 if test -n "$CC"; then
3175   echo "$as_me:$LINENO: result: $CC" >&5
3176 echo "${ECHO_T}$CC" >&6
3177 else
3178   echo "$as_me:$LINENO: result: no" >&5
3179 echo "${ECHO_T}no" >&6
3180 fi
3181
3182     test -n "$CC" && break
3183   done
3184 fi
3185 if test -z "$CC"; then
3186   ac_ct_CC=$CC
3187   for ac_prog in cl
3188 do
3189   # Extract the first word of "$ac_prog", so it can be a program name with args.
3190 set dummy $ac_prog; ac_word=$2
3191 echo "$as_me:$LINENO: checking for $ac_word" >&5
3192 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3193 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3194   echo $ECHO_N "(cached) $ECHO_C" >&6
3195 else
3196   if test -n "$ac_ct_CC"; then
3197   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3198 else
3199 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3200 for as_dir in $PATH
3201 do
3202   IFS=$as_save_IFS
3203   test -z "$as_dir" && as_dir=.
3204   for ac_exec_ext in '' $ac_executable_extensions; do
3205   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3206     ac_cv_prog_ac_ct_CC="$ac_prog"
3207     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3208     break 2
3209   fi
3210 done
3211 done
3212
3213 fi
3214 fi
3215 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3216 if test -n "$ac_ct_CC"; then
3217   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3218 echo "${ECHO_T}$ac_ct_CC" >&6
3219 else
3220   echo "$as_me:$LINENO: result: no" >&5
3221 echo "${ECHO_T}no" >&6
3222 fi
3223
3224   test -n "$ac_ct_CC" && break
3225 done
3226
3227   CC=$ac_ct_CC
3228 fi
3229
3230 fi
3231
3232
3233 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3234 See \`config.log' for more details." >&5
3235 echo "$as_me: error: no acceptable C compiler found in \$PATH
3236 See \`config.log' for more details." >&2;}
3237    { (exit 1); exit 1; }; }
3238
3239 # Provide some information about the compiler.
3240 echo "$as_me:$LINENO:" \
3241      "checking for C compiler version" >&5
3242 ac_compiler=`set X $ac_compile; echo $2`
3243 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3244   (eval $ac_compiler --version </dev/null >&5) 2>&5
3245   ac_status=$?
3246   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3247   (exit $ac_status); }
3248 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3249   (eval $ac_compiler -v </dev/null >&5) 2>&5
3250   ac_status=$?
3251   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3252   (exit $ac_status); }
3253 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3254   (eval $ac_compiler -V </dev/null >&5) 2>&5
3255   ac_status=$?
3256   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3257   (exit $ac_status); }
3258
3259 cat >conftest.$ac_ext <<_ACEOF
3260 /* confdefs.h.  */
3261 _ACEOF
3262 cat confdefs.h >>conftest.$ac_ext
3263 cat >>conftest.$ac_ext <<_ACEOF
3264 /* end confdefs.h.  */
3265
3266 int
3267 main ()
3268 {
3269
3270   ;
3271   return 0;
3272 }
3273 _ACEOF
3274 ac_clean_files_save=$ac_clean_files
3275 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3276 # Try to create an executable without -o first, disregard a.out.
3277 # It will help us diagnose broken compilers, and finding out an intuition
3278 # of exeext.
3279 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3280 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3281 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3282 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3283   (eval $ac_link_default) 2>&5
3284   ac_status=$?
3285   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3286   (exit $ac_status); }; then
3287   # Find the output, starting from the most likely.  This scheme is
3288 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3289 # resort.
3290
3291 # Be careful to initialize this variable, since it used to be cached.
3292 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3293 ac_cv_exeext=
3294 # b.out is created by i960 compilers.
3295 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3296 do
3297   test -f "$ac_file" || continue
3298   case $ac_file in
3299     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3300         ;;
3301     conftest.$ac_ext )
3302         # This is the source file.
3303         ;;
3304     [ab].out )
3305         # We found the default executable, but exeext='' is most
3306         # certainly right.
3307         break;;
3308     *.* )
3309         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3310         # FIXME: I believe we export ac_cv_exeext for Libtool,
3311         # but it would be cool to find out if it's true.  Does anybody
3312         # maintain Libtool? --akim.
3313         export ac_cv_exeext
3314         break;;
3315     * )
3316         break;;
3317   esac
3318 done
3319 else
3320   echo "$as_me: failed program was:" >&5
3321 sed 's/^/| /' conftest.$ac_ext >&5
3322
3323 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3324 See \`config.log' for more details." >&5
3325 echo "$as_me: error: C compiler cannot create executables
3326 See \`config.log' for more details." >&2;}
3327    { (exit 77); exit 77; }; }
3328 fi
3329
3330 ac_exeext=$ac_cv_exeext
3331 echo "$as_me:$LINENO: result: $ac_file" >&5
3332 echo "${ECHO_T}$ac_file" >&6
3333
3334 # Check the compiler produces executables we can run.  If not, either
3335 # the compiler is broken, or we cross compile.
3336 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3337 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3338 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3339 # If not cross compiling, check that we can run a simple program.
3340 if test "$cross_compiling" != yes; then
3341   if { ac_try='./$ac_file'
3342   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3343   (eval $ac_try) 2>&5
3344   ac_status=$?
3345   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3346   (exit $ac_status); }; }; then
3347     cross_compiling=no
3348   else
3349     if test "$cross_compiling" = maybe; then
3350         cross_compiling=yes
3351     else
3352         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3353 If you meant to cross compile, use \`--host'.
3354 See \`config.log' for more details." >&5
3355 echo "$as_me: error: cannot run C compiled programs.
3356 If you meant to cross compile, use \`--host'.
3357 See \`config.log' for more details." >&2;}
3358    { (exit 1); exit 1; }; }
3359     fi
3360   fi
3361 fi
3362 echo "$as_me:$LINENO: result: yes" >&5
3363 echo "${ECHO_T}yes" >&6
3364
3365 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3366 ac_clean_files=$ac_clean_files_save
3367 # Check the compiler produces executables we can run.  If not, either
3368 # the compiler is broken, or we cross compile.
3369 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3370 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3371 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3372 echo "${ECHO_T}$cross_compiling" >&6
3373
3374 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3375 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3376 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3377   (eval $ac_link) 2>&5
3378   ac_status=$?
3379   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3380   (exit $ac_status); }; then
3381   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3382 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3383 # work properly (i.e., refer to `conftest.exe'), while it won't with
3384 # `rm'.
3385 for ac_file in conftest.exe conftest conftest.*; do
3386   test -f "$ac_file" || continue
3387   case $ac_file in
3388     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3389     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3390           export ac_cv_exeext
3391           break;;
3392     * ) break;;
3393   esac
3394 done
3395 else
3396   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3397 See \`config.log' for more details." >&5
3398 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3399 See \`config.log' for more details." >&2;}
3400    { (exit 1); exit 1; }; }
3401 fi
3402
3403 rm -f conftest$ac_cv_exeext
3404 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3405 echo "${ECHO_T}$ac_cv_exeext" >&6
3406
3407 rm -f conftest.$ac_ext
3408 EXEEXT=$ac_cv_exeext
3409 ac_exeext=$EXEEXT
3410 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3411 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3412 if test "${ac_cv_objext+set}" = set; then
3413   echo $ECHO_N "(cached) $ECHO_C" >&6
3414 else
3415   cat >conftest.$ac_ext <<_ACEOF
3416 /* confdefs.h.  */
3417 _ACEOF
3418 cat confdefs.h >>conftest.$ac_ext
3419 cat >>conftest.$ac_ext <<_ACEOF
3420 /* end confdefs.h.  */
3421
3422 int
3423 main ()
3424 {
3425
3426   ;
3427   return 0;
3428 }
3429 _ACEOF
3430 rm -f conftest.o conftest.obj
3431 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3432   (eval $ac_compile) 2>&5
3433   ac_status=$?
3434   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3435   (exit $ac_status); }; then
3436   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3437   case $ac_file in
3438     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3439     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3440        break;;
3441   esac
3442 done
3443 else
3444   echo "$as_me: failed program was:" >&5
3445 sed 's/^/| /' conftest.$ac_ext >&5
3446
3447 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3448 See \`config.log' for more details." >&5
3449 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3450 See \`config.log' for more details." >&2;}
3451    { (exit 1); exit 1; }; }
3452 fi
3453
3454 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3455 fi
3456 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3457 echo "${ECHO_T}$ac_cv_objext" >&6
3458 OBJEXT=$ac_cv_objext
3459 ac_objext=$OBJEXT
3460 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3461 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3462 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3463   echo $ECHO_N "(cached) $ECHO_C" >&6
3464 else
3465   cat >conftest.$ac_ext <<_ACEOF
3466 /* confdefs.h.  */
3467 _ACEOF
3468 cat confdefs.h >>conftest.$ac_ext
3469 cat >>conftest.$ac_ext <<_ACEOF
3470 /* end confdefs.h.  */
3471
3472 int
3473 main ()
3474 {
3475 #ifndef __GNUC__
3476        choke me
3477 #endif
3478
3479   ;
3480   return 0;
3481 }
3482 _ACEOF
3483 rm -f conftest.$ac_objext
3484 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3485   (eval $ac_compile) 2>conftest.er1
3486   ac_status=$?
3487   grep -v '^ *+' conftest.er1 >conftest.err
3488   rm -f conftest.er1
3489   cat conftest.err >&5
3490   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3491   (exit $ac_status); } &&
3492          { ac_try='test -z "$ac_c_werror_flag"
3493                          || test ! -s conftest.err'
3494   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3495   (eval $ac_try) 2>&5
3496   ac_status=$?
3497   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3498   (exit $ac_status); }; } &&
3499          { ac_try='test -s conftest.$ac_objext'
3500   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3501   (eval $ac_try) 2>&5
3502   ac_status=$?
3503   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3504   (exit $ac_status); }; }; then
3505   ac_compiler_gnu=yes
3506 else
3507   echo "$as_me: failed program was:" >&5
3508 sed 's/^/| /' conftest.$ac_ext >&5
3509
3510 ac_compiler_gnu=no
3511 fi
3512 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3513 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3514
3515 fi
3516 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3517 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3518 GCC=`test $ac_compiler_gnu = yes && echo yes`
3519 ac_test_CFLAGS=${CFLAGS+set}
3520 ac_save_CFLAGS=$CFLAGS
3521 CFLAGS="-g"
3522 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3523 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3524 if test "${ac_cv_prog_cc_g+set}" = set; then
3525   echo $ECHO_N "(cached) $ECHO_C" >&6
3526 else
3527   cat >conftest.$ac_ext <<_ACEOF
3528 /* confdefs.h.  */
3529 _ACEOF
3530 cat confdefs.h >>conftest.$ac_ext
3531 cat >>conftest.$ac_ext <<_ACEOF
3532 /* end confdefs.h.  */
3533
3534 int
3535 main ()
3536 {
3537
3538   ;
3539   return 0;
3540 }
3541 _ACEOF
3542 rm -f conftest.$ac_objext
3543 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3544   (eval $ac_compile) 2>conftest.er1
3545   ac_status=$?
3546   grep -v '^ *+' conftest.er1 >conftest.err
3547   rm -f conftest.er1
3548   cat conftest.err >&5
3549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3550   (exit $ac_status); } &&
3551          { ac_try='test -z "$ac_c_werror_flag"
3552                          || test ! -s conftest.err'
3553   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3554   (eval $ac_try) 2>&5
3555   ac_status=$?
3556   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3557   (exit $ac_status); }; } &&
3558          { ac_try='test -s conftest.$ac_objext'
3559   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3560   (eval $ac_try) 2>&5
3561   ac_status=$?
3562   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3563   (exit $ac_status); }; }; then
3564   ac_cv_prog_cc_g=yes
3565 else
3566   echo "$as_me: failed program was:" >&5
3567 sed 's/^/| /' conftest.$ac_ext >&5
3568
3569 ac_cv_prog_cc_g=no
3570 fi
3571 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3572 fi
3573 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3574 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3575 if test "$ac_test_CFLAGS" = set; then
3576   CFLAGS=$ac_save_CFLAGS
3577 elif test $ac_cv_prog_cc_g = yes; then
3578   if test "$GCC" = yes; then
3579     CFLAGS="-g -O2"
3580   else
3581     CFLAGS="-g"
3582   fi
3583 else
3584   if test "$GCC" = yes; then
3585     CFLAGS="-O2"
3586   else
3587     CFLAGS=
3588   fi
3589 fi
3590 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3591 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3592 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3593   echo $ECHO_N "(cached) $ECHO_C" >&6
3594 else
3595   ac_cv_prog_cc_stdc=no
3596 ac_save_CC=$CC
3597 cat >conftest.$ac_ext <<_ACEOF
3598 /* confdefs.h.  */
3599 _ACEOF
3600 cat confdefs.h >>conftest.$ac_ext
3601 cat >>conftest.$ac_ext <<_ACEOF
3602 /* end confdefs.h.  */
3603 #include <stdarg.h>
3604 #include <stdio.h>
3605 #include <sys/types.h>
3606 #include <sys/stat.h>
3607 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3608 struct buf { int x; };
3609 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3610 static char *e (p, i)
3611      char **p;
3612      int i;
3613 {
3614   return p[i];
3615 }
3616 static char *f (char * (*g) (char **, int), char **p, ...)
3617 {
3618   char *s;
3619   va_list v;
3620   va_start (v,p);
3621   s = g (p, va_arg (v,int));
3622   va_end (v);
3623   return s;
3624 }
3625
3626 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3627    function prototypes and stuff, but not '\xHH' hex character constants.
3628    These don't provoke an error unfortunately, instead are silently treated
3629    as 'x'.  The following induces an error, until -std1 is added to get
3630    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3631    array size at least.  It's necessary to write '\x00'==0 to get something
3632    that's true only with -std1.  */
3633 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3634
3635 int test (int i, double x);
3636 struct s1 {int (*f) (int a);};
3637 struct s2 {int (*f) (double a);};
3638 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3639 int argc;
3640 char **argv;
3641 int
3642 main ()
3643 {
3644 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3645   ;
3646   return 0;
3647 }
3648 _ACEOF
3649 # Don't try gcc -ansi; that turns off useful extensions and
3650 # breaks some systems' header files.
3651 # AIX                   -qlanglvl=ansi
3652 # Ultrix and OSF/1      -std1
3653 # HP-UX 10.20 and later -Ae
3654 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3655 # SVR4                  -Xc -D__EXTENSIONS__
3656 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3657 do
3658   CC="$ac_save_CC $ac_arg"
3659   rm -f conftest.$ac_objext
3660 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3661   (eval $ac_compile) 2>conftest.er1
3662   ac_status=$?
3663   grep -v '^ *+' conftest.er1 >conftest.err
3664   rm -f conftest.er1
3665   cat conftest.err >&5
3666   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3667   (exit $ac_status); } &&
3668          { ac_try='test -z "$ac_c_werror_flag"
3669                          || test ! -s conftest.err'
3670   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3671   (eval $ac_try) 2>&5
3672   ac_status=$?
3673   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3674   (exit $ac_status); }; } &&
3675          { ac_try='test -s conftest.$ac_objext'
3676   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3677   (eval $ac_try) 2>&5
3678   ac_status=$?
3679   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3680   (exit $ac_status); }; }; then
3681   ac_cv_prog_cc_stdc=$ac_arg
3682 break
3683 else
3684   echo "$as_me: failed program was:" >&5
3685 sed 's/^/| /' conftest.$ac_ext >&5
3686
3687 fi
3688 rm -f conftest.err conftest.$ac_objext
3689 done
3690 rm -f conftest.$ac_ext conftest.$ac_objext
3691 CC=$ac_save_CC
3692
3693 fi
3694
3695 case "x$ac_cv_prog_cc_stdc" in
3696   x|xno)
3697     echo "$as_me:$LINENO: result: none needed" >&5
3698 echo "${ECHO_T}none needed" >&6 ;;
3699   *)
3700     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3701 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3702     CC="$CC $ac_cv_prog_cc_stdc" ;;
3703 esac
3704
3705 # Some people use a C++ compiler to compile C.  Since we use `exit',
3706 # in C++ we need to declare it.  In case someone uses the same compiler
3707 # for both compiling C and C++ we need to have the C++ compiler decide
3708 # the declaration of exit, since it's the most demanding environment.
3709 cat >conftest.$ac_ext <<_ACEOF
3710 #ifndef __cplusplus
3711   choke me
3712 #endif
3713 _ACEOF
3714 rm -f conftest.$ac_objext
3715 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3716   (eval $ac_compile) 2>conftest.er1
3717   ac_status=$?
3718   grep -v '^ *+' conftest.er1 >conftest.err
3719   rm -f conftest.er1
3720   cat conftest.err >&5
3721   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3722   (exit $ac_status); } &&
3723          { ac_try='test -z "$ac_c_werror_flag"
3724                          || test ! -s conftest.err'
3725   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3726   (eval $ac_try) 2>&5
3727   ac_status=$?
3728   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3729   (exit $ac_status); }; } &&
3730          { ac_try='test -s conftest.$ac_objext'
3731   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3732   (eval $ac_try) 2>&5
3733   ac_status=$?
3734   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3735   (exit $ac_status); }; }; then
3736   for ac_declaration in \
3737    '' \
3738    'extern "C" void std::exit (int) throw (); using std::exit;' \
3739    'extern "C" void std::exit (int); using std::exit;' \
3740    'extern "C" void exit (int) throw ();' \
3741    'extern "C" void exit (int);' \
3742    'void exit (int);'
3743 do
3744   cat >conftest.$ac_ext <<_ACEOF
3745 /* confdefs.h.  */
3746 _ACEOF
3747 cat confdefs.h >>conftest.$ac_ext
3748 cat >>conftest.$ac_ext <<_ACEOF
3749 /* end confdefs.h.  */
3750 $ac_declaration
3751 #include <stdlib.h>
3752 int
3753 main ()
3754 {
3755 exit (42);
3756   ;
3757   return 0;
3758 }
3759 _ACEOF
3760 rm -f conftest.$ac_objext
3761 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3762   (eval $ac_compile) 2>conftest.er1
3763   ac_status=$?
3764   grep -v '^ *+' conftest.er1 >conftest.err
3765   rm -f conftest.er1
3766   cat conftest.err >&5
3767   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3768   (exit $ac_status); } &&
3769          { ac_try='test -z "$ac_c_werror_flag"
3770                          || test ! -s conftest.err'
3771   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3772   (eval $ac_try) 2>&5
3773   ac_status=$?
3774   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3775   (exit $ac_status); }; } &&
3776          { ac_try='test -s conftest.$ac_objext'
3777   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3778   (eval $ac_try) 2>&5
3779   ac_status=$?
3780   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3781   (exit $ac_status); }; }; then
3782   :
3783 else
3784   echo "$as_me: failed program was:" >&5
3785 sed 's/^/| /' conftest.$ac_ext >&5
3786
3787 continue
3788 fi
3789 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3790   cat >conftest.$ac_ext <<_ACEOF
3791 /* confdefs.h.  */
3792 _ACEOF
3793 cat confdefs.h >>conftest.$ac_ext
3794 cat >>conftest.$ac_ext <<_ACEOF
3795 /* end confdefs.h.  */
3796 $ac_declaration
3797 int
3798 main ()
3799 {
3800 exit (42);
3801   ;
3802   return 0;
3803 }
3804 _ACEOF
3805 rm -f conftest.$ac_objext
3806 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3807   (eval $ac_compile) 2>conftest.er1
3808   ac_status=$?
3809   grep -v '^ *+' conftest.er1 >conftest.err
3810   rm -f conftest.er1
3811   cat conftest.err >&5
3812   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3813   (exit $ac_status); } &&
3814          { ac_try='test -z "$ac_c_werror_flag"
3815                          || test ! -s conftest.err'
3816   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3817   (eval $ac_try) 2>&5
3818   ac_status=$?
3819   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3820   (exit $ac_status); }; } &&
3821          { ac_try='test -s conftest.$ac_objext'
3822   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3823   (eval $ac_try) 2>&5
3824   ac_status=$?
3825   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3826   (exit $ac_status); }; }; then
3827   break
3828 else
3829   echo "$as_me: failed program was:" >&5
3830 sed 's/^/| /' conftest.$ac_ext >&5
3831
3832 fi
3833 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3834 done
3835 rm -f conftest*
3836 if test -n "$ac_declaration"; then
3837   echo '#ifdef __cplusplus' >>confdefs.h
3838   echo $ac_declaration      >>confdefs.h
3839   echo '#endif'             >>confdefs.h
3840 fi
3841
3842 else
3843   echo "$as_me: failed program was:" >&5
3844 sed 's/^/| /' conftest.$ac_ext >&5
3845
3846 fi
3847 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3848 ac_ext=c
3849 ac_cpp='$CPP $CPPFLAGS'
3850 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3851 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3852 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3853
3854 ac_ext=cc
3855 ac_cpp='$CXXCPP $CPPFLAGS'
3856 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3857 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3858 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3859 if test -n "$ac_tool_prefix"; then
3860   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3861   do
3862     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3863 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3864 echo "$as_me:$LINENO: checking for $ac_word" >&5
3865 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3866 if test "${ac_cv_prog_CXX+set}" = set; then
3867   echo $ECHO_N "(cached) $ECHO_C" >&6
3868 else
3869   if test -n "$CXX"; then
3870   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3871 else
3872 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3873 for as_dir in $PATH
3874 do
3875   IFS=$as_save_IFS
3876   test -z "$as_dir" && as_dir=.
3877   for ac_exec_ext in '' $ac_executable_extensions; do
3878   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3879     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3880     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3881     break 2
3882   fi
3883 done
3884 done
3885
3886 fi
3887 fi
3888 CXX=$ac_cv_prog_CXX
3889 if test -n "$CXX"; then
3890   echo "$as_me:$LINENO: result: $CXX" >&5
3891 echo "${ECHO_T}$CXX" >&6
3892 else
3893   echo "$as_me:$LINENO: result: no" >&5
3894 echo "${ECHO_T}no" >&6
3895 fi
3896
3897     test -n "$CXX" && break
3898   done
3899 fi
3900 if test -z "$CXX"; then
3901   ac_ct_CXX=$CXX
3902   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3903 do
3904   # Extract the first word of "$ac_prog", so it can be a program name with args.
3905 set dummy $ac_prog; ac_word=$2
3906 echo "$as_me:$LINENO: checking for $ac_word" >&5
3907 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3908 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3909   echo $ECHO_N "(cached) $ECHO_C" >&6
3910 else
3911   if test -n "$ac_ct_CXX"; then
3912   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3913 else
3914 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3915 for as_dir in $PATH
3916 do
3917   IFS=$as_save_IFS
3918   test -z "$as_dir" && as_dir=.
3919   for ac_exec_ext in '' $ac_executable_extensions; do
3920   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3921     ac_cv_prog_ac_ct_CXX="$ac_prog"
3922     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3923     break 2
3924   fi
3925 done
3926 done
3927
3928 fi
3929 fi
3930 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3931 if test -n "$ac_ct_CXX"; then
3932   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3933 echo "${ECHO_T}$ac_ct_CXX" >&6
3934 else
3935   echo "$as_me:$LINENO: result: no" >&5
3936 echo "${ECHO_T}no" >&6
3937 fi
3938
3939   test -n "$ac_ct_CXX" && break
3940 done
3941 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3942
3943   CXX=$ac_ct_CXX
3944 fi
3945
3946
3947 # Provide some information about the compiler.
3948 echo "$as_me:$LINENO:" \
3949      "checking for C++ compiler version" >&5
3950 ac_compiler=`set X $ac_compile; echo $2`
3951 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3952   (eval $ac_compiler --version </dev/null >&5) 2>&5
3953   ac_status=$?
3954   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3955   (exit $ac_status); }
3956 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3957   (eval $ac_compiler -v </dev/null >&5) 2>&5
3958   ac_status=$?
3959   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3960   (exit $ac_status); }
3961 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3962   (eval $ac_compiler -V </dev/null >&5) 2>&5
3963   ac_status=$?
3964   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3965   (exit $ac_status); }
3966
3967 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3968 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3969 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3970   echo $ECHO_N "(cached) $ECHO_C" >&6
3971 else
3972   cat >conftest.$ac_ext <<_ACEOF
3973 /* confdefs.h.  */
3974 _ACEOF
3975 cat confdefs.h >>conftest.$ac_ext
3976 cat >>conftest.$ac_ext <<_ACEOF
3977 /* end confdefs.h.  */
3978
3979 int
3980 main ()
3981 {
3982 #ifndef __GNUC__
3983        choke me
3984 #endif
3985
3986   ;
3987   return 0;
3988 }
3989 _ACEOF
3990 rm -f conftest.$ac_objext
3991 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3992   (eval $ac_compile) 2>conftest.er1
3993   ac_status=$?
3994   grep -v '^ *+' conftest.er1 >conftest.err
3995   rm -f conftest.er1
3996   cat conftest.err >&5
3997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3998   (exit $ac_status); } &&
3999          { ac_try='test -z "$ac_cxx_werror_flag"
4000                          || test ! -s conftest.err'
4001   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4002   (eval $ac_try) 2>&5
4003   ac_status=$?
4004   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4005   (exit $ac_status); }; } &&
4006          { ac_try='test -s conftest.$ac_objext'
4007   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4008   (eval $ac_try) 2>&5
4009   ac_status=$?
4010   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4011   (exit $ac_status); }; }; then
4012   ac_compiler_gnu=yes
4013 else
4014   echo "$as_me: failed program was:" >&5
4015 sed 's/^/| /' conftest.$ac_ext >&5
4016
4017 ac_compiler_gnu=no
4018 fi
4019 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4020 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4021
4022 fi
4023 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4024 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4025 GXX=`test $ac_compiler_gnu = yes && echo yes`
4026 ac_test_CXXFLAGS=${CXXFLAGS+set}
4027 ac_save_CXXFLAGS=$CXXFLAGS
4028 CXXFLAGS="-g"
4029 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4030 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4031 if test "${ac_cv_prog_cxx_g+set}" = set; then
4032   echo $ECHO_N "(cached) $ECHO_C" >&6
4033 else
4034   cat >conftest.$ac_ext <<_ACEOF
4035 /* confdefs.h.  */
4036 _ACEOF
4037 cat confdefs.h >>conftest.$ac_ext
4038 cat >>conftest.$ac_ext <<_ACEOF
4039 /* end confdefs.h.  */
4040
4041 int
4042 main ()
4043 {
4044
4045   ;
4046   return 0;
4047 }
4048 _ACEOF
4049 rm -f conftest.$ac_objext
4050 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4051   (eval $ac_compile) 2>conftest.er1
4052   ac_status=$?
4053   grep -v '^ *+' conftest.er1 >conftest.err
4054   rm -f conftest.er1
4055   cat conftest.err >&5
4056   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4057   (exit $ac_status); } &&
4058          { ac_try='test -z "$ac_cxx_werror_flag"
4059                          || test ! -s conftest.err'
4060   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4061   (eval $ac_try) 2>&5
4062   ac_status=$?
4063   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4064   (exit $ac_status); }; } &&
4065          { ac_try='test -s conftest.$ac_objext'
4066   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4067   (eval $ac_try) 2>&5
4068   ac_status=$?
4069   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4070   (exit $ac_status); }; }; then
4071   ac_cv_prog_cxx_g=yes
4072 else
4073   echo "$as_me: failed program was:" >&5
4074 sed 's/^/| /' conftest.$ac_ext >&5
4075
4076 ac_cv_prog_cxx_g=no
4077 fi
4078 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4079 fi
4080 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4081 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4082 if test "$ac_test_CXXFLAGS" = set; then
4083   CXXFLAGS=$ac_save_CXXFLAGS
4084 elif test $ac_cv_prog_cxx_g = yes; then
4085   if test "$GXX" = yes; then
4086     CXXFLAGS="-g -O2"
4087   else
4088     CXXFLAGS="-g"
4089   fi
4090 else
4091   if test "$GXX" = yes; then
4092     CXXFLAGS="-O2"
4093   else
4094     CXXFLAGS=
4095   fi
4096 fi
4097 for ac_declaration in \
4098    '' \
4099    'extern "C" void std::exit (int) throw (); using std::exit;' \
4100    'extern "C" void std::exit (int); using std::exit;' \
4101    'extern "C" void exit (int) throw ();' \
4102    'extern "C" void exit (int);' \
4103    'void exit (int);'
4104 do
4105   cat >conftest.$ac_ext <<_ACEOF
4106 /* confdefs.h.  */
4107 _ACEOF
4108 cat confdefs.h >>conftest.$ac_ext
4109 cat >>conftest.$ac_ext <<_ACEOF
4110 /* end confdefs.h.  */
4111 $ac_declaration
4112 #include <stdlib.h>
4113 int
4114 main ()
4115 {
4116 exit (42);
4117   ;
4118   return 0;
4119 }
4120 _ACEOF
4121 rm -f conftest.$ac_objext
4122 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4123   (eval $ac_compile) 2>conftest.er1
4124   ac_status=$?
4125   grep -v '^ *+' conftest.er1 >conftest.err
4126   rm -f conftest.er1
4127   cat conftest.err >&5
4128   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4129   (exit $ac_status); } &&
4130          { ac_try='test -z "$ac_cxx_werror_flag"
4131                          || test ! -s conftest.err'
4132   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4133   (eval $ac_try) 2>&5
4134   ac_status=$?
4135   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4136   (exit $ac_status); }; } &&
4137          { ac_try='test -s conftest.$ac_objext'
4138   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4139   (eval $ac_try) 2>&5
4140   ac_status=$?
4141   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4142   (exit $ac_status); }; }; then
4143   :
4144 else
4145   echo "$as_me: failed program was:" >&5
4146 sed 's/^/| /' conftest.$ac_ext >&5
4147
4148 continue
4149 fi
4150 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4151   cat >conftest.$ac_ext <<_ACEOF
4152 /* confdefs.h.  */
4153 _ACEOF
4154 cat confdefs.h >>conftest.$ac_ext
4155 cat >>conftest.$ac_ext <<_ACEOF
4156 /* end confdefs.h.  */
4157 $ac_declaration
4158 int
4159 main ()
4160 {
4161 exit (42);
4162   ;
4163   return 0;
4164 }
4165 _ACEOF
4166 rm -f conftest.$ac_objext
4167 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4168   (eval $ac_compile) 2>conftest.er1
4169   ac_status=$?
4170   grep -v '^ *+' conftest.er1 >conftest.err
4171   rm -f conftest.er1
4172   cat conftest.err >&5
4173   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4174   (exit $ac_status); } &&
4175          { ac_try='test -z "$ac_cxx_werror_flag"
4176                          || test ! -s conftest.err'
4177   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4178   (eval $ac_try) 2>&5
4179   ac_status=$?
4180   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4181   (exit $ac_status); }; } &&
4182          { ac_try='test -s conftest.$ac_objext'
4183   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4184   (eval $ac_try) 2>&5
4185   ac_status=$?
4186   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4187   (exit $ac_status); }; }; then
4188   break
4189 else
4190   echo "$as_me: failed program was:" >&5
4191 sed 's/^/| /' conftest.$ac_ext >&5
4192
4193 fi
4194 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4195 done
4196 rm -f conftest*
4197 if test -n "$ac_declaration"; then
4198   echo '#ifdef __cplusplus' >>confdefs.h
4199   echo $ac_declaration      >>confdefs.h
4200   echo '#endif'             >>confdefs.h
4201 fi
4202
4203 ac_ext=c
4204 ac_cpp='$CPP $CPPFLAGS'
4205 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4206 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4207 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4208
4209
4210 # We must set the default linker to the linker used by gcc for the correct
4211 # operation of libtool.  If LD is not defined and we are using gcc, try to
4212 # set the LD default to the ld used by gcc.
4213 if test -z "$LD"; then
4214   if test "$GCC" = yes; then
4215     case $build in
4216     *-*-mingw*)
4217       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4218     *)
4219       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4220     esac
4221     case $gcc_prog_ld in
4222     # Accept absolute paths.
4223     [\\/]* | [A-Za-z]:[\\/]*)
4224       LD="$gcc_prog_ld" ;;
4225     esac
4226   fi
4227 fi
4228
4229
4230
4231
4232 if test -n "$ac_tool_prefix"; then
4233   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4234 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4235 echo "$as_me:$LINENO: checking for $ac_word" >&5
4236 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4237 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4238   echo $ECHO_N "(cached) $ECHO_C" >&6
4239 else
4240   if test -n "$GNATBIND"; then
4241   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4242 else
4243 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4244 for as_dir in $PATH
4245 do
4246   IFS=$as_save_IFS
4247   test -z "$as_dir" && as_dir=.
4248   for ac_exec_ext in '' $ac_executable_extensions; do
4249   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4250     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4251     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4252     break 2
4253   fi
4254 done
4255 done
4256
4257 fi
4258 fi
4259 GNATBIND=$ac_cv_prog_GNATBIND
4260 if test -n "$GNATBIND"; then
4261   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4262 echo "${ECHO_T}$GNATBIND" >&6
4263 else
4264   echo "$as_me:$LINENO: result: no" >&5
4265 echo "${ECHO_T}no" >&6
4266 fi
4267
4268 fi
4269 if test -z "$ac_cv_prog_GNATBIND"; then
4270   ac_ct_GNATBIND=$GNATBIND
4271   # Extract the first word of "gnatbind", so it can be a program name with args.
4272 set dummy gnatbind; ac_word=$2
4273 echo "$as_me:$LINENO: checking for $ac_word" >&5
4274 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4275 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4276   echo $ECHO_N "(cached) $ECHO_C" >&6
4277 else
4278   if test -n "$ac_ct_GNATBIND"; then
4279   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4280 else
4281 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4282 for as_dir in $PATH
4283 do
4284   IFS=$as_save_IFS
4285   test -z "$as_dir" && as_dir=.
4286   for ac_exec_ext in '' $ac_executable_extensions; do
4287   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4288     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4289     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4290     break 2
4291   fi
4292 done
4293 done
4294
4295   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4296 fi
4297 fi
4298 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4299 if test -n "$ac_ct_GNATBIND"; then
4300   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4301 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4302 else
4303   echo "$as_me:$LINENO: result: no" >&5
4304 echo "${ECHO_T}no" >&6
4305 fi
4306
4307   GNATBIND=$ac_ct_GNATBIND
4308 else
4309   GNATBIND="$ac_cv_prog_GNATBIND"
4310 fi
4311
4312 if test -n "$ac_tool_prefix"; then
4313   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4314 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4315 echo "$as_me:$LINENO: checking for $ac_word" >&5
4316 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4317 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4318   echo $ECHO_N "(cached) $ECHO_C" >&6
4319 else
4320   if test -n "$GNATMAKE"; then
4321   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4322 else
4323 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4324 for as_dir in $PATH
4325 do
4326   IFS=$as_save_IFS
4327   test -z "$as_dir" && as_dir=.
4328   for ac_exec_ext in '' $ac_executable_extensions; do
4329   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4330     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4331     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4332     break 2
4333   fi
4334 done
4335 done
4336
4337 fi
4338 fi
4339 GNATMAKE=$ac_cv_prog_GNATMAKE
4340 if test -n "$GNATMAKE"; then
4341   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4342 echo "${ECHO_T}$GNATMAKE" >&6
4343 else
4344   echo "$as_me:$LINENO: result: no" >&5
4345 echo "${ECHO_T}no" >&6
4346 fi
4347
4348 fi
4349 if test -z "$ac_cv_prog_GNATMAKE"; then
4350   ac_ct_GNATMAKE=$GNATMAKE
4351   # Extract the first word of "gnatmake", so it can be a program name with args.
4352 set dummy gnatmake; ac_word=$2
4353 echo "$as_me:$LINENO: checking for $ac_word" >&5
4354 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4355 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4356   echo $ECHO_N "(cached) $ECHO_C" >&6
4357 else
4358   if test -n "$ac_ct_GNATMAKE"; then
4359   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4360 else
4361 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4362 for as_dir in $PATH
4363 do
4364   IFS=$as_save_IFS
4365   test -z "$as_dir" && as_dir=.
4366   for ac_exec_ext in '' $ac_executable_extensions; do
4367   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4368     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4369     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4370     break 2
4371   fi
4372 done
4373 done
4374
4375   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4376 fi
4377 fi
4378 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4379 if test -n "$ac_ct_GNATMAKE"; then
4380   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4381 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4382 else
4383   echo "$as_me:$LINENO: result: no" >&5
4384 echo "${ECHO_T}no" >&6
4385 fi
4386
4387   GNATMAKE=$ac_ct_GNATMAKE
4388 else
4389   GNATMAKE="$ac_cv_prog_GNATMAKE"
4390 fi
4391
4392 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4393 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4394 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4395   echo $ECHO_N "(cached) $ECHO_C" >&6
4396 else
4397   cat >conftest.adb <<EOF
4398 procedure conftest is begin null; end conftest;
4399 EOF
4400 acx_cv_cc_gcc_supports_ada=no
4401 # There is a bug in old released versions of GCC which causes the
4402 # driver to exit successfully when the appropriate language module
4403 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4404 # Therefore we must check for the error message as well as an
4405 # unsuccessful exit.
4406 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4407 # given a .adb file, but produce no object file.  So we must check
4408 # if an object file was really produced to guard against this.
4409 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4410 if test x"$errors" = x && test -f conftest.$ac_objext; then
4411   acx_cv_cc_gcc_supports_ada=yes
4412 fi
4413 rm -f conftest.*
4414 fi
4415 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4416 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4417
4418 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4419   have_gnat=yes
4420 else
4421   have_gnat=no
4422 fi
4423
4424 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4425 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4426 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4427   echo $ECHO_N "(cached) $ECHO_C" >&6
4428 else
4429    echo abfoo >t1
4430   echo cdfoo >t2
4431   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4432   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4433     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4434       :
4435     else
4436       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4437     fi
4438   fi
4439   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4440     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4441       :
4442     else
4443       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4444     fi
4445   fi
4446   rm t1 t2
4447
4448 fi
4449 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4450 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4451 do_compare="$gcc_cv_prog_cmp_skip"
4452
4453
4454
4455 # Check for GMP and MPFR
4456 gmplibs="-lmpfr -lgmp"
4457 gmpinc=
4458 have_gmp=no
4459
4460 # Specify a location for mpfr
4461 # check for this first so it ends up on the link line before gmp.
4462
4463 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4464 if test "${with_mpfr_dir+set}" = set; then
4465   withval="$with_mpfr_dir"
4466   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4467 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4468 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4469 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4470    { (exit 1); exit 1; }; }
4471 fi;
4472
4473
4474 # Check whether --with-mpfr or --without-mpfr was given.
4475 if test "${with_mpfr+set}" = set; then
4476   withval="$with_mpfr"
4477
4478 fi;
4479
4480 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4481 if test "${with_mpfr_include+set}" = set; then
4482   withval="$with_mpfr_include"
4483
4484 fi;
4485
4486 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4487 if test "${with_mpfr_lib+set}" = set; then
4488   withval="$with_mpfr_lib"
4489
4490 fi;
4491
4492 if test "x$with_mpfr" != x; then
4493   gmplibs="-L$with_mpfr/lib $gmplibs"
4494   gmpinc="-I$with_mpfr/include"
4495 fi
4496 if test "x$with_mpfr_include" != x; then
4497   gmpinc="-I$with_mpfr_include"
4498 fi
4499 if test "x$with_mpfr_lib" != x; then
4500   gmplibs="-L$with_mpfr_lib $gmplibs"
4501 fi
4502 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4503   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4504   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4505   # Do not test the mpfr version.  Assume that it is sufficient, since
4506   # it is in the source tree, and the library has not been built yet
4507   # but it would be included on the link line in the version check below
4508   # hence making the test fail.
4509   have_gmp=yes
4510 fi
4511
4512 # Specify a location for gmp
4513
4514 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4515 if test "${with_gmp_dir+set}" = set; then
4516   withval="$with_gmp_dir"
4517   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4518 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4519 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4520 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4521    { (exit 1); exit 1; }; }
4522 fi;
4523
4524
4525 # Check whether --with-gmp or --without-gmp was given.
4526 if test "${with_gmp+set}" = set; then
4527   withval="$with_gmp"
4528
4529 fi;
4530
4531 # Check whether --with-gmp_include or --without-gmp_include was given.
4532 if test "${with_gmp_include+set}" = set; then
4533   withval="$with_gmp_include"
4534
4535 fi;
4536
4537 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4538 if test "${with_gmp_lib+set}" = set; then
4539   withval="$with_gmp_lib"
4540
4541 fi;
4542
4543
4544 if test "x$with_gmp" != x; then
4545   gmplibs="-L$with_gmp/lib $gmplibs"
4546   gmpinc="-I$with_gmp/include $gmpinc"
4547 fi
4548 if test "x$with_gmp_include" != x; then
4549   gmpinc="-I$with_gmp_include $gmpinc"
4550 fi
4551 if test "x$with_gmp_lib" != x; then
4552   gmplibs="-L$with_gmp_lib $gmplibs"
4553 fi
4554 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4555   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4556   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4557   # Do not test the gmp version.  Assume that it is sufficient, since
4558   # it is in the source tree, and the library has not been built yet
4559   # but it would be included on the link line in the version check below
4560   # hence making the test fail.
4561   have_gmp=yes
4562 fi
4563
4564 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4565   have_gmp=yes
4566   saved_CFLAGS="$CFLAGS"
4567   CFLAGS="$CFLAGS $gmpinc"
4568   # Check GMP actually works
4569   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4570 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4571
4572 cat >conftest.$ac_ext <<_ACEOF
4573 /* confdefs.h.  */
4574 _ACEOF
4575 cat confdefs.h >>conftest.$ac_ext
4576 cat >>conftest.$ac_ext <<_ACEOF
4577 /* end confdefs.h.  */
4578 #include "gmp.h"
4579 int
4580 main ()
4581 {
4582
4583   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4584   choke me
4585   #endif
4586
4587   ;
4588   return 0;
4589 }
4590 _ACEOF
4591 rm -f conftest.$ac_objext
4592 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4593   (eval $ac_compile) 2>conftest.er1
4594   ac_status=$?
4595   grep -v '^ *+' conftest.er1 >conftest.err
4596   rm -f conftest.er1
4597   cat conftest.err >&5
4598   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4599   (exit $ac_status); } &&
4600          { ac_try='test -z "$ac_c_werror_flag"
4601                          || test ! -s conftest.err'
4602   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4603   (eval $ac_try) 2>&5
4604   ac_status=$?
4605   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4606   (exit $ac_status); }; } &&
4607          { ac_try='test -s conftest.$ac_objext'
4608   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4609   (eval $ac_try) 2>&5
4610   ac_status=$?
4611   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4612   (exit $ac_status); }; }; then
4613   echo "$as_me:$LINENO: result: yes" >&5
4614 echo "${ECHO_T}yes" >&6
4615 else
4616   echo "$as_me: failed program was:" >&5
4617 sed 's/^/| /' conftest.$ac_ext >&5
4618
4619 echo "$as_me:$LINENO: result: no" >&5
4620 echo "${ECHO_T}no" >&6; have_gmp=no
4621 fi
4622 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4623
4624   if test x"$have_gmp" = xyes; then
4625     saved_LIBS="$LIBS"
4626     LIBS="$LIBS $gmplibs"
4627         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4628 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4629     cat >conftest.$ac_ext <<_ACEOF
4630 /* confdefs.h.  */
4631 _ACEOF
4632 cat confdefs.h >>conftest.$ac_ext
4633 cat >>conftest.$ac_ext <<_ACEOF
4634 /* end confdefs.h.  */
4635 #include <gmp.h>
4636     #include <mpfr.h>
4637 int
4638 main ()
4639 {
4640
4641     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4642     choke me
4643     #endif
4644     mpfr_t n;
4645     mpfr_t x;
4646     int t;
4647     mpfr_init (n);
4648     mpfr_init (x);
4649     mpfr_atan2 (n, n, x, GMP_RNDN);
4650     mpfr_erfc (n, x, GMP_RNDN);
4651     mpfr_subnormalize (x, t, GMP_RNDN);
4652
4653   ;
4654   return 0;
4655 }
4656 _ACEOF
4657 rm -f conftest.$ac_objext conftest$ac_exeext
4658 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4659   (eval $ac_link) 2>conftest.er1
4660   ac_status=$?
4661   grep -v '^ *+' conftest.er1 >conftest.err
4662   rm -f conftest.er1
4663   cat conftest.err >&5
4664   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4665   (exit $ac_status); } &&
4666          { ac_try='test -z "$ac_c_werror_flag"
4667                          || test ! -s conftest.err'
4668   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4669   (eval $ac_try) 2>&5
4670   ac_status=$?
4671   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4672   (exit $ac_status); }; } &&
4673          { ac_try='test -s conftest$ac_exeext'
4674   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4675   (eval $ac_try) 2>&5
4676   ac_status=$?
4677   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4678   (exit $ac_status); }; }; then
4679   cat >conftest.$ac_ext <<_ACEOF
4680 /* confdefs.h.  */
4681 _ACEOF
4682 cat confdefs.h >>conftest.$ac_ext
4683 cat >>conftest.$ac_ext <<_ACEOF
4684 /* end confdefs.h.  */
4685 #include <gmp.h>
4686     #include <mpfr.h>
4687 int
4688 main ()
4689 {
4690
4691     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4692     choke me
4693     #endif
4694     mpfr_t n; mpfr_init(n);
4695
4696   ;
4697   return 0;
4698 }
4699 _ACEOF
4700 rm -f conftest.$ac_objext conftest$ac_exeext
4701 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4702   (eval $ac_link) 2>conftest.er1
4703   ac_status=$?
4704   grep -v '^ *+' conftest.er1 >conftest.err
4705   rm -f conftest.er1
4706   cat conftest.err >&5
4707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4708   (exit $ac_status); } &&
4709          { ac_try='test -z "$ac_c_werror_flag"
4710                          || test ! -s conftest.err'
4711   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4712   (eval $ac_try) 2>&5
4713   ac_status=$?
4714   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4715   (exit $ac_status); }; } &&
4716          { ac_try='test -s conftest$ac_exeext'
4717   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4718   (eval $ac_try) 2>&5
4719   ac_status=$?
4720   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4721   (exit $ac_status); }; }; then
4722   echo "$as_me:$LINENO: result: yes" >&5
4723 echo "${ECHO_T}yes" >&6
4724 else
4725   echo "$as_me: failed program was:" >&5
4726 sed 's/^/| /' conftest.$ac_ext >&5
4727
4728 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4729 echo "${ECHO_T}buggy but acceptable" >&6
4730 fi
4731 rm -f conftest.err conftest.$ac_objext \
4732       conftest$ac_exeext conftest.$ac_ext
4733 else
4734   echo "$as_me: failed program was:" >&5
4735 sed 's/^/| /' conftest.$ac_ext >&5
4736
4737 echo "$as_me:$LINENO: result: no" >&5
4738 echo "${ECHO_T}no" >&6; have_gmp=no
4739 fi
4740 rm -f conftest.err conftest.$ac_objext \
4741       conftest$ac_exeext conftest.$ac_ext
4742       LIBS="$saved_LIBS"
4743   fi
4744   CFLAGS="$saved_CFLAGS"
4745
4746   if test x$have_gmp != xyes; then
4747     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4748 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4749 Copies of these libraries' source code can be found at their respective
4750 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4751 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4752 If you obtained GMP and/or MPFR from a vendor distribution package, make
4753 sure that you have installed both the libraries and the header files.
4754 They may be located in separate packages." >&5
4755 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4756 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4757 Copies of these libraries' source code can be found at their respective
4758 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4759 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4760 If you obtained GMP and/or MPFR from a vendor distribution package, make
4761 sure that you have installed both the libraries and the header files.
4762 They may be located in separate packages." >&2;}
4763    { (exit 1); exit 1; }; }
4764   fi
4765 fi
4766
4767 # Flags needed for both GMP and/or MPFR
4768
4769
4770
4771 # By default, C is the only stage 1 language.
4772 stage1_languages=,c,
4773
4774 # Figure out what language subdirectories are present.
4775 # Look if the user specified --enable-languages="..."; if not, use
4776 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4777 # go away some day.
4778 # NB:  embedded tabs in this IF block -- do not untabify
4779 if test -d ${srcdir}/gcc; then
4780   if test x"${enable_languages+set}" != xset; then
4781     if test x"${LANGUAGES+set}" = xset; then
4782       enable_languages="${LANGUAGES}"
4783         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4784     else
4785       enable_languages=all
4786     fi
4787   else
4788     if test x"${enable_languages}" = x ||
4789        test x"${enable_languages}" = xyes;
4790        then
4791       echo configure.in: --enable-languages needs at least one language argument 1>&2
4792       exit 1
4793     fi
4794   fi
4795   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4796
4797   # 'f95' is the old name for the 'fortran' language. We issue a warning
4798   # and make the substitution.
4799   case ,${enable_languages}, in
4800     *,f95,*)
4801       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4802       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4803       ;;
4804   esac
4805
4806   # First scan to see if an enabled language requires some other language.
4807   # We assume that a given config-lang.in will list all the language
4808   # front ends it requires, even if some are required indirectly.
4809   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4810     case ${lang_frag} in
4811       ..) ;;
4812       # The odd quoting in the next line works around
4813       # an apparent bug in bash 1.12 on linux.
4814       ${srcdir}/gcc/[*]/config-lang.in) ;;
4815       *)
4816         # From the config-lang.in, get $language, $lang_requires
4817         language=
4818         lang_requires=
4819         . ${lang_frag}
4820         for other in ${lang_requires} ; do
4821           case ,${enable_languages}, in
4822             *,$other,*) ;;
4823             *,all,*) ;;
4824             *,$language,*)
4825               echo " \`$other' language required by \`$language'; enabling" 1>&2
4826               enable_languages="${enable_languages},${other}"
4827               ;;
4828           esac
4829         done
4830         ;;
4831     esac
4832   done
4833
4834   new_enable_languages=,c,
4835   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4836   potential_languages=,c,
4837
4838   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4839     case ${lang_frag} in
4840       ..) ;;
4841       # The odd quoting in the next line works around
4842       # an apparent bug in bash 1.12 on linux.
4843       ${srcdir}/gcc/[*]/config-lang.in) ;;
4844       *)
4845         # From the config-lang.in, get $language, $target_libs,
4846         # $lang_dirs, $boot_language, and $build_by_default
4847         language=
4848         target_libs=
4849         lang_dirs=
4850         subdir_requires=
4851         boot_language=no
4852         build_by_default=yes
4853         . ${lang_frag}
4854         if test x${language} = x; then
4855           echo "${lang_frag} doesn't set \$language." 1>&2
4856           exit 1
4857         fi
4858
4859         case ,${enable_languages}, in
4860           *,${language},*)
4861             # Language was explicitly selected; include it.
4862             add_this_lang=yes
4863             ;;
4864           *,all,*)
4865             # 'all' was selected, select it if it is a default language
4866             add_this_lang=${build_by_default}
4867             ;;
4868           *)
4869             add_this_lang=no
4870             ;;
4871         esac
4872
4873         # Disable languages that need other directories if these aren't available.
4874         for i in $subdir_requires; do
4875           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4876           case ,${enable_languages}, in
4877             *,${language},*)
4878               # Specifically requested language; tell them.
4879               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4880 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4881    { (exit 1); exit 1; }; }
4882               ;;
4883             *)
4884               # Silently disable.
4885               add_this_lang=unsupported
4886               ;;
4887           esac
4888         done
4889
4890         # Disable Ada if no preexisting GNAT is available.
4891         case ,${enable_languages},:${language}:${have_gnat} in
4892           *,${language},*:ada:no)
4893             # Specifically requested language; tell them.
4894             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4895 echo "$as_me: error: GNAT is required to build $language" >&2;}
4896    { (exit 1); exit 1; }; }
4897             ;;
4898           *:ada:no)
4899             # Silently disable.
4900             add_this_lang=unsupported
4901             ;;
4902         esac
4903
4904         # Disable a language that is unsupported by the target.
4905         case " $unsupported_languages " in
4906           *" $language "*)
4907             add_this_lang=unsupported
4908             ;;
4909         esac
4910
4911         case $add_this_lang in
4912           unsupported)
4913             # Remove language-dependent dirs.
4914             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4915             ;;
4916           no)
4917             # Remove language-dependent dirs; still show language as supported.
4918             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4919             potential_languages="${potential_languages}${language},"
4920             ;;
4921           yes)
4922             new_enable_languages="${new_enable_languages}${language},"
4923             potential_languages="${potential_languages}${language},"
4924             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4925             case ${boot_language} in
4926               yes)
4927                 # Add to (comma-separated) list of stage 1 languages.
4928                 stage1_languages="${stage1_languages}${language},"
4929                 ;;
4930             esac
4931             ;;
4932         esac
4933         ;;
4934     esac
4935   done
4936
4937   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4938 if test "${enable_stage1_languages+set}" = set; then
4939   enableval="$enable_stage1_languages"
4940   case ,${enable_stage1_languages}, in
4941     ,no,|,,)
4942       # Set it to something that will have no effect in the loop below
4943       enable_stage1_languages=c ;;
4944     ,yes,)
4945       enable_stage1_languages=`echo $new_enable_languages | \
4946         sed -e "s/^,//" -e "s/,$//" ` ;;
4947     *,all,*)
4948       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4949         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4950   esac
4951
4952   # Add "good" languages from enable_stage1_languages to stage1_languages,
4953   # while "bad" languages go in missing_languages.  Leave no duplicates.
4954   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4955     case $potential_languages in
4956       *,$i,*)
4957         case $stage1_languages in
4958           *,$i,*) ;;
4959           *) stage1_languages="$stage1_languages$i," ;;
4960         esac ;;
4961       *)
4962         case $missing_languages in
4963           *,$i,*) ;;
4964           *) missing_languages="$missing_languages$i," ;;
4965         esac ;;
4966      esac
4967   done
4968 fi;
4969
4970   # Remove leading/trailing commas that were added for simplicity
4971   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4972   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4973   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4974   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4975
4976   if test "x$missing_languages" != x; then
4977     { { echo "$as_me:$LINENO: error:
4978 The following requested languages could not be built: ${missing_languages}
4979 Supported languages are: ${potential_languages}" >&5
4980 echo "$as_me: error:
4981 The following requested languages could not be built: ${missing_languages}
4982 Supported languages are: ${potential_languages}" >&2;}
4983    { (exit 1); exit 1; }; }
4984   fi
4985   if test "x$new_enable_languages" != "x$enable_languages"; then
4986     echo The following languages will be built: ${new_enable_languages}
4987     enable_languages="$new_enable_languages"
4988   fi
4989
4990
4991   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4992 fi
4993
4994 # Handle --disable-<component> generically.
4995 for dir in $configdirs $build_configdirs $target_configdirs ; do
4996   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4997   varname=`echo $dirname | sed -e s/+/_/g`
4998   if eval test x\${enable_${varname}} "=" xno ; then
4999     noconfigdirs="$noconfigdirs $dir"
5000   fi
5001 done
5002
5003 # Check for Boehm's garbage collector
5004 # Check whether --enable-objc-gc or --disable-objc-gc was given.
5005 if test "${enable_objc_gc+set}" = set; then
5006   enableval="$enable_objc_gc"
5007   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
5008   *,objc,*:*:yes:*target-boehm-gc*)
5009     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
5010 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
5011    { (exit 1); exit 1; }; }
5012     ;;
5013 esac
5014 fi;
5015
5016 # Make sure we only build Boehm's garbage collector if required.
5017 case ,${enable_languages},:${enable_objc_gc} in
5018   *,objc,*:yes)
5019     # Keep target-boehm-gc if requested for Objective-C.
5020     ;;
5021   *)
5022     # Otherwise remove target-boehm-gc depending on target-libjava.
5023     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5024       noconfigdirs="$noconfigdirs target-boehm-gc"
5025     fi
5026     ;;
5027 esac
5028
5029 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5030 # $build_configdirs and $target_configdirs.
5031 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5032
5033 notsupp=""
5034 for dir in . $skipdirs $noconfigdirs ; do
5035   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5036   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5037     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5038     if test -r $srcdir/$dirname/configure ; then
5039       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5040         true
5041       else
5042         notsupp="$notsupp $dir"
5043       fi
5044     fi
5045   fi
5046   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5047     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5048     if test -r $srcdir/$dirname/configure ; then
5049       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5050         true
5051       else
5052         notsupp="$notsupp $dir"
5053       fi
5054     fi
5055   fi
5056   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5057     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5058     if test -r $srcdir/$dirname/configure ; then
5059       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5060         true
5061       else
5062         notsupp="$notsupp $dir"
5063       fi
5064     fi
5065   fi
5066 done
5067
5068 # Sometimes the tools are distributed with libiberty but with no other
5069 # libraries.  In that case, we don't want to build target-libiberty.
5070 # Don't let libgcc imply libiberty either.
5071 if test -n "${target_configdirs}" ; then
5072   libgcc=
5073   others=
5074   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5075     if test "$i" = "libgcc"; then
5076       libgcc=target-libgcc
5077     elif test "$i" != "libiberty" ; then
5078       if test -r $srcdir/$i/configure ; then
5079         others=yes;
5080         break;
5081       fi
5082     fi
5083   done
5084   if test -z "${others}" ; then
5085     target_configdirs=$libgcc
5086   fi
5087 fi
5088
5089 # Quietly strip out all directories which aren't configurable in this tree.
5090 # This relies on all configurable subdirectories being autoconfiscated, which
5091 # is now the case.
5092 build_configdirs_all="$build_configdirs"
5093 build_configdirs=
5094 for i in ${build_configdirs_all} ; do
5095   j=`echo $i | sed -e s/build-//g`
5096   if test -f ${srcdir}/$j/configure ; then
5097     build_configdirs="${build_configdirs} $i"
5098   fi
5099 done
5100
5101 configdirs_all="$configdirs"
5102 configdirs=
5103 for i in ${configdirs_all} ; do
5104   if test -f ${srcdir}/$i/configure ; then
5105     configdirs="${configdirs} $i"
5106   fi
5107 done
5108
5109 target_configdirs_all="$target_configdirs"
5110 target_configdirs=
5111 for i in ${target_configdirs_all} ; do
5112   j=`echo $i | sed -e s/target-//g`
5113   if test -f ${srcdir}/$j/configure ; then
5114     target_configdirs="${target_configdirs} $i"
5115   fi
5116 done
5117
5118 # Produce a warning message for the subdirs we can't configure.
5119 # This isn't especially interesting in the Cygnus tree, but in the individual
5120 # FSF releases, it's important to let people know when their machine isn't
5121 # supported by the one or two programs in a package.
5122
5123 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5124   # If $appdirs is non-empty, at least one of those directories must still
5125   # be configured, or we error out.  (E.g., if the gas release supports a
5126   # specified target in some subdirs but not the gas subdir, we shouldn't
5127   # pretend that all is well.)
5128   if test -n "$appdirs" ; then
5129     for dir in $appdirs ; do
5130       if test -r $dir/Makefile.in ; then
5131         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5132           appdirs=""
5133           break
5134         fi
5135         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5136           appdirs=""
5137           break
5138         fi
5139       fi
5140     done
5141     if test -n "$appdirs" ; then
5142       echo "*** This configuration is not supported by this package." 1>&2
5143       exit 1
5144     fi
5145   fi
5146   # Okay, some application will build, or we don't care to check.  Still
5147   # notify of subdirs not getting built.
5148   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5149   echo "    ${notsupp}" 1>&2
5150   echo "    (Any other directories should still work fine.)" 1>&2
5151 fi
5152
5153 case "$host" in
5154   *msdosdjgpp*)
5155     enable_gdbtk=no ;;
5156 esac
5157
5158 # To find our prefix, in gcc_cv_tool_prefix.
5159
5160 # The user is always right.
5161 if test "${PATH_SEPARATOR+set}" != set; then
5162   echo "#! /bin/sh" >conf$$.sh
5163   echo  "exit 0"   >>conf$$.sh
5164   chmod +x conf$$.sh
5165   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5166     PATH_SEPARATOR=';'
5167   else
5168     PATH_SEPARATOR=:
5169   fi
5170   rm -f conf$$.sh
5171 fi
5172
5173
5174
5175 if test "x$exec_prefix" = xNONE; then
5176         if test "x$prefix" = xNONE; then
5177                 gcc_cv_tool_prefix=$ac_default_prefix
5178         else
5179                 gcc_cv_tool_prefix=$prefix
5180         fi
5181 else
5182         gcc_cv_tool_prefix=$exec_prefix
5183 fi
5184
5185 # If there is no compiler in the tree, use the PATH only.  In any
5186 # case, if there is no compiler in the tree nobody should use
5187 # AS_FOR_TARGET and LD_FOR_TARGET.
5188 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5189     gcc_version=`cat $srcdir/gcc/BASE-VER`
5190     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5191     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5192     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5193     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5194     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5195     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5196 else
5197     gcc_cv_tool_dirs=
5198 fi
5199
5200 if test x$build = x$target && test -n "$md_exec_prefix"; then
5201         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5202 fi
5203
5204
5205
5206 copy_dirs=
5207
5208
5209 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5210 if test "${with_build_sysroot+set}" = set; then
5211   withval="$with_build_sysroot"
5212   if test x"$withval" != x ; then
5213      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5214    fi
5215 else
5216   SYSROOT_CFLAGS_FOR_TARGET=
5217 fi;
5218
5219
5220
5221 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5222 if test "${with_debug_prefix_map+set}" = set; then
5223   withval="$with_debug_prefix_map"
5224   if test x"$withval" != x; then
5225      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5226      for debug_map in $withval; do
5227        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5228      done
5229    fi
5230 else
5231   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5232 fi;
5233
5234
5235 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5236 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5237 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5238 # We want to ensure that TARGET libraries (which we know are built with
5239 # gcc) are built with "-O2 -g", so include those options when setting
5240 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5241 if test "x$CFLAGS_FOR_TARGET" = x; then
5242   CFLAGS_FOR_TARGET=$CFLAGS
5243   case " $CFLAGS " in
5244     *" -O2 "*) ;;
5245     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5246   esac
5247   case " $CFLAGS " in
5248     *" -g "* | *" -g3 "*) ;;
5249     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5250   esac
5251 fi
5252
5253
5254 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5255   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5256   case " $CXXFLAGS " in
5257     *" -O2 "*) ;;
5258     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5259   esac
5260   case " $CXXFLAGS " in
5261     *" -g "* | *" -g3 "*) ;;
5262     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5263   esac
5264 fi
5265
5266
5267 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5268 # the named directory are copied to $(tooldir)/sys-include.
5269 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5270   if test x${is_cross_compiler} = xno ; then
5271     echo 1>&2 '***' --with-headers is only supported when cross compiling
5272     exit 1
5273   fi
5274   if test x"${with_headers}" != xyes ; then
5275     x=${gcc_cv_tool_prefix}
5276     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5277   fi
5278 fi
5279
5280 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5281 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5282 # are permitted.
5283 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5284   if test x${is_cross_compiler} = xno ; then
5285     echo 1>&2 '***' --with-libs is only supported when cross compiling
5286     exit 1
5287   fi
5288   if test x"${with_libs}" != xyes ; then
5289     # Copy the libraries in reverse order, so that files in the first named
5290     # library override files in subsequent libraries.
5291     x=${gcc_cv_tool_prefix}
5292     for l in ${with_libs}; do
5293       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5294     done
5295   fi
5296 fi
5297
5298 # Set with_gnu_as and with_gnu_ld as appropriate.
5299 #
5300 # This is done by determining whether or not the appropriate directory
5301 # is available, and by checking whether or not specific configurations
5302 # have requested that this magic not happen.
5303 #
5304 # The command line options always override the explicit settings in
5305 # configure.in, and the settings in configure.in override this magic.
5306 #
5307 # If the default for a toolchain is to use GNU as and ld, and you don't
5308 # want to do that, then you should use the --without-gnu-as and
5309 # --without-gnu-ld options for the configure script.
5310
5311 if test x${use_gnu_as} = x &&
5312    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5313   with_gnu_as=yes
5314   extra_host_args="$extra_host_args --with-gnu-as"
5315 fi
5316
5317 if test x${use_gnu_ld} = x &&
5318    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5319   with_gnu_ld=yes
5320   extra_host_args="$extra_host_args --with-gnu-ld"
5321 fi
5322
5323 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5324 # can detect this case.
5325
5326 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5327   with_newlib=yes
5328   extra_host_args="$extra_host_args --with-newlib"
5329 fi
5330
5331 # Handle ${copy_dirs}
5332 set fnord ${copy_dirs}
5333 shift
5334 while test $# != 0 ; do
5335   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5336     :
5337   else
5338     echo Copying $1 to $2
5339
5340     # Use the install script to create the directory and all required
5341     # parent directories.
5342     if test -d $2 ; then
5343       :
5344     else
5345       echo >config.temp
5346       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5347     fi
5348
5349     # Copy the directory, assuming we have tar.
5350     # FIXME: Should we use B in the second tar?  Not all systems support it.
5351     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5352
5353     # It is the responsibility of the user to correctly adjust all
5354     # symlinks.  If somebody can figure out how to handle them correctly
5355     # here, feel free to add the code.
5356
5357     echo $1 > $2/COPIED
5358   fi
5359   shift; shift
5360 done
5361
5362 # Determine a target-dependent exec_prefix that the installed
5363 # gcc will search in.  Keep this list sorted by triplet, with
5364 # the *-*-osname triplets last.
5365 md_exec_prefix=
5366 case "${target}" in
5367   alpha*-*-*vms*)
5368     md_exec_prefix=/gnu/lib/gcc-lib
5369     ;;
5370   i[34567]86-pc-msdosdjgpp*)
5371     md_exec_prefix=/dev/env/DJDIR/bin
5372     ;;
5373   i[34567]86-*-sco3.2v5*)
5374     if test $with_gnu_as = yes; then
5375       md_exec_prefix=/usr/gnu/bin
5376     else
5377       md_exec_prefix=/usr/ccs/bin/elf
5378     fi
5379     ;;
5380
5381   mn10300-*-* | \
5382   powerpc-*-chorusos* | \
5383   powerpc*-*-eabi* | \
5384   powerpc*-*-sysv* | \
5385   powerpc*-*-kaos* | \
5386   s390x-ibm-tpf*)
5387     md_exec_prefix=/usr/ccs/bin
5388     ;;
5389   sparc64-*-elf*)
5390     ;;
5391   v850*-*-*)
5392     md_exec_prefix=/usr/ccs/bin
5393     ;;
5394   xtensa*-*-elf*)
5395     ;;
5396
5397   *-*-beos* | \
5398   *-*-elf* | \
5399   *-*-hpux* | \
5400   *-*-netware* | \
5401   *-*-nto-qnx* | \
5402   *-*-rtems* | \
5403   *-*-solaris2* | \
5404   *-*-sysv[45]* | \
5405   *-*-vxworks* | \
5406   *-wrs-windiss)
5407     md_exec_prefix=/usr/ccs/bin
5408     ;;
5409 esac
5410
5411 extra_arflags_for_target=
5412 extra_nmflags_for_target=
5413 extra_ranlibflags_for_target=
5414 target_makefile_frag=/dev/null
5415 case "${target}" in
5416   mep*-*-*)
5417     target_makefile_frag="config/mt-mep"
5418     ;;
5419   spu-*-*)
5420     target_makefile_frag="config/mt-spu"
5421     ;;
5422   mips*-sde-elf*)
5423     target_makefile_frag="config/mt-sde"
5424     ;;
5425   mipsisa*-*-elfoabi*)
5426     target_makefile_frag="config/mt-mips-elfoabi"
5427     ;;
5428   *-*-netware*)
5429     target_makefile_frag="config/mt-netware"
5430     ;;
5431   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5432     target_makefile_frag="config/mt-gnu"
5433     ;;
5434   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5435     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5436     # commands to handle both 32-bit and 64-bit objects.  These flags are
5437     # harmless if we're using GNU nm or ar.
5438     extra_arflags_for_target=" -X32_64"
5439     extra_nmflags_for_target=" -B -X32_64"
5440     ;;
5441   *-*-darwin*)
5442     # ranlib from Darwin requires the -c flag to look at common symbols.
5443     extra_ranlibflags_for_target=" -c"
5444     ;;
5445   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5446     target_makefile_frag="config/mt-wince"
5447     ;;
5448 esac
5449
5450 alphaieee_frag=/dev/null
5451 case $target in
5452   alpha*-*-*)
5453     # This just makes sure to use the -mieee option to build target libs.
5454     # This should probably be set individually by each library.
5455     alphaieee_frag="config/mt-alphaieee"
5456     ;;
5457 esac
5458
5459 # If --enable-target-optspace always use -Os instead of -O2 to build
5460 # the target libraries, similarly if it is not specified, use -Os
5461 # on selected platforms.
5462 ospace_frag=/dev/null
5463 case "${enable_target_optspace}:${target}" in
5464   yes:*)
5465     ospace_frag="config/mt-ospace"
5466     ;;
5467   :d30v-*)
5468     ospace_frag="config/mt-d30v"
5469     ;;
5470   :m32r-* | :d10v-* | :fr30-*)
5471     ospace_frag="config/mt-ospace"
5472     ;;
5473   no:* | :*)
5474     ;;
5475   *)
5476     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5477     ;;
5478 esac
5479
5480 # Default to using --with-stabs for certain targets.
5481 if test x${with_stabs} = x ; then
5482   case "${target}" in
5483   mips*-*-irix[56]*)
5484     ;;
5485   mips*-*-* | alpha*-*-osf*)
5486     with_stabs=yes;
5487     extra_host_args="${extra_host_args} --with-stabs"
5488     ;;
5489   esac
5490 fi
5491
5492 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5493 # them automatically.
5494 case "${host}" in
5495   hppa*64*-*-hpux11*)
5496     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5497     ;;
5498 esac
5499
5500 # Some systems (e.g., one of the i386-aix systems the gas testers are
5501 # using) don't handle "\$" correctly, so don't use it here.
5502 tooldir='${exec_prefix}'/${target_noncanonical}
5503 build_tooldir=${tooldir}
5504
5505 # Create a .gdbinit file which runs the one in srcdir
5506 # and tells GDB to look there for source files.
5507
5508 if test -r ${srcdir}/.gdbinit ; then
5509   case ${srcdir} in
5510     .) ;;
5511     *) cat > ./.gdbinit <<EOF
5512 # ${NO_EDIT}
5513 dir ${srcdir}
5514 dir .
5515 source ${srcdir}/.gdbinit
5516 EOF
5517     ;;
5518   esac
5519 fi
5520
5521 # Make sure that the compiler is able to generate an executable.  If it
5522 # can't, we are probably in trouble.  We don't care whether we can run the
5523 # executable--we might be using a cross compiler--we only care whether it
5524 # can be created.  At this point the main configure script has set CC.
5525 we_are_ok=no
5526 echo "int main () { return 0; }" > conftest.c
5527 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5528 if test $? = 0 ; then
5529   if test -s conftest || test -s conftest.exe ; then
5530     we_are_ok=yes
5531   fi
5532 fi
5533 case $we_are_ok in
5534   no)
5535     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5536     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5537     rm -f conftest*
5538     exit 1
5539     ;;
5540 esac
5541 rm -f conftest*
5542
5543 # The Solaris /usr/ucb/cc compiler does not appear to work.
5544 case "${host}" in
5545   sparc-sun-solaris2*)
5546       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5547       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5548           could_use=
5549           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5550           if test -d /opt/cygnus/bin ; then
5551               if test "$could_use" = "" ; then
5552                   could_use="/opt/cygnus/bin"
5553               else
5554                   could_use="$could_use or /opt/cygnus/bin"
5555               fi
5556           fi
5557         if test "$could_use" = "" ; then
5558             echo "Warning: compilation may fail because you're using"
5559             echo "/usr/ucb/cc.  You should change your PATH or CC "
5560             echo "variable and rerun configure."
5561         else
5562             echo "Warning: compilation may fail because you're using"
5563             echo "/usr/ucb/cc, when you should use the C compiler from"
5564             echo "$could_use.  You should change your"
5565             echo "PATH or CC variable and rerun configure."
5566         fi
5567       fi
5568   ;;
5569 esac
5570
5571 case "${host}" in
5572   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5573   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5574   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5575 esac
5576
5577 # Record target_configdirs and the configure arguments for target and
5578 # build configuration in Makefile.
5579 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5580 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5581
5582 # Determine whether gdb needs tk/tcl or not.
5583 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5584 # and in that case we want gdb to be built without tk.  Ugh!
5585 # In fact I believe gdb is the *only* package directly dependent on tk,
5586 # so we should be able to put the 'maybe's in unconditionally and
5587 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5588 # 100% sure that that's safe though.
5589
5590 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5591 case "$enable_gdbtk" in
5592   no)
5593     GDB_TK="" ;;
5594   yes)
5595     GDB_TK="${gdb_tk}" ;;
5596   *)
5597     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5598     # distro.  Eventually someone will fix this and move Insight, nee
5599     # gdbtk to a separate directory.
5600     if test -d ${srcdir}/gdb/gdbtk ; then
5601       GDB_TK="${gdb_tk}"
5602     else
5603       GDB_TK=""
5604     fi
5605     ;;
5606 esac
5607 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5608 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5609
5610 # Strip out unwanted targets.
5611
5612 # While at that, we remove Makefiles if we were started for recursive
5613 # configuration, so that the top-level Makefile reconfigures them,
5614 # like we used to do when configure itself was recursive.
5615
5616 # Loop over modules.  $extrasub must be used with care, limiting as
5617 # much as possible the usage of range addresses.  That's because autoconf
5618 # splits the sed script to overcome limits in the number of commands,
5619 # and relying on carefully-timed sed passes may turn out to be very hard
5620 # to maintain later.  In this particular case, you just have to be careful
5621 # not to nest @if/@endif pairs, because configure will not warn you at all.
5622
5623 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5624 if test "${enable_bootstrap+set}" = set; then
5625   enableval="$enable_bootstrap"
5626
5627 else
5628   enable_bootstrap=default
5629 fi;
5630
5631 # Issue errors and warnings for invalid/strange bootstrap combinations.
5632 case "$configdirs" in
5633   *gcc*) have_compiler=yes ;;
5634   *) have_compiler=no ;;
5635 esac
5636
5637 case "$have_compiler:$host:$target:$enable_bootstrap" in
5638   *:*:*:no) ;;
5639
5640   # Default behavior.  Enable bootstrap if we have a compiler
5641   # and we are in a native configuration.
5642   yes:$build:$build:default)
5643     enable_bootstrap=yes ;;
5644
5645   *:*:*:default)
5646     enable_bootstrap=no ;;
5647
5648   # We have a compiler and we are in a native configuration, bootstrap is ok
5649   yes:$build:$build:yes)
5650     ;;
5651
5652   # Other configurations, but we have a compiler.  Assume the user knows
5653   # what he's doing.
5654   yes:*:*:yes)
5655     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5656 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5657     ;;
5658
5659   # No compiler: if they passed --enable-bootstrap explicitly, fail
5660   no:*:*:yes)
5661     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5662 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5663    { (exit 1); exit 1; }; } ;;
5664
5665   # Fail if wrong command line
5666   *)
5667     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5668 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5669    { (exit 1); exit 1; }; }
5670     ;;
5671 esac
5672
5673 # Adjust the toplevel makefile according to whether bootstrap was selected.
5674 case "$enable_bootstrap" in
5675   yes)
5676     bootstrap_suffix=bootstrap ;;
5677   no)
5678     bootstrap_suffix=no-bootstrap ;;
5679 esac
5680
5681 for module in ${build_configdirs} ; do
5682   if test -z "${no_recursion}" \
5683      && test -f ${build_subdir}/${module}/Makefile; then
5684     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5685     rm -f ${build_subdir}/${module}/Makefile
5686   fi
5687   extrasub="$extrasub
5688 /^@if build-$module\$/d
5689 /^@endif build-$module\$/d
5690 /^@if build-$module-$bootstrap_suffix\$/d
5691 /^@endif build-$module-$bootstrap_suffix\$/d"
5692 done
5693 for module in ${configdirs} ; do
5694   if test -z "${no_recursion}"; then
5695     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5696       if test -f ${file}; then
5697         echo 1>&2 "*** removing ${file} to force reconfigure"
5698         rm -f ${file}
5699       fi
5700     done
5701   fi
5702   extrasub="$extrasub
5703 /^@if $module\$/d
5704 /^@endif $module\$/d
5705 /^@if $module-$bootstrap_suffix\$/d
5706 /^@endif $module-$bootstrap_suffix\$/d"
5707 done
5708 for module in ${target_configdirs} ; do
5709   if test -z "${no_recursion}" \
5710      && test -f ${target_subdir}/${module}/Makefile; then
5711     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5712     rm -f ${target_subdir}/${module}/Makefile
5713   fi
5714   extrasub="$extrasub
5715 /^@if target-$module\$/d
5716 /^@endif target-$module\$/d
5717 /^@if target-$module-$bootstrap_suffix\$/d
5718 /^@endif target-$module-$bootstrap_suffix\$/d"
5719 done
5720
5721 extrasub="$extrasub
5722 /^@if /,/^@endif /d"
5723
5724 # Create the serialization dependencies.  This uses a temporary file.
5725
5726 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5727 if test "${enable_serial_configure+set}" = set; then
5728   enableval="$enable_serial_configure"
5729
5730 fi;
5731
5732 case ${enable_serial_configure} in
5733   yes)
5734     enable_serial_build_configure=yes
5735     enable_serial_host_configure=yes
5736     enable_serial_target_configure=yes
5737     ;;
5738 esac
5739
5740 # These force 'configure's to be done one at a time, to avoid problems
5741 # with contention over a shared config.cache.
5742 rm -f serdep.tmp
5743 echo '# serdep.tmp' > serdep.tmp
5744 olditem=
5745 test "x${enable_serial_build_configure}" = xyes &&
5746 for item in ${build_configdirs} ; do
5747   case ${olditem} in
5748     "") ;;
5749     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5750   esac
5751   olditem=${item}
5752 done
5753 olditem=
5754 test "x${enable_serial_host_configure}" = xyes &&
5755 for item in ${configdirs} ; do
5756   case ${olditem} in
5757     "") ;;
5758     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5759   esac
5760   olditem=${item}
5761 done
5762 olditem=
5763 test "x${enable_serial_target_configure}" = xyes &&
5764 for item in ${target_configdirs} ; do
5765   case ${olditem} in
5766     "") ;;
5767     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5768   esac
5769   olditem=${item}
5770 done
5771 serialization_dependencies=serdep.tmp
5772
5773
5774 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5775 # target, nonopt, and variable assignments.  These are the ones we
5776 # might not want to pass down to subconfigures.  Also strip
5777 # program-prefix, program-suffix, and program-transform-name, so that
5778 # we can pass down a consistent program-transform-name.
5779 baseargs=
5780 keep_next=no
5781 skip_next=no
5782 eval "set -- $ac_configure_args"
5783 for ac_arg
5784 do
5785   if test X"$skip_next" = X"yes"; then
5786     skip_next=no
5787     continue
5788   fi
5789   if test X"$keep_next" = X"yes"; then
5790     case $ac_arg in
5791       *\'*)
5792         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5793     esac
5794     baseargs="$baseargs '$ac_arg'"
5795     keep_next=no
5796     continue
5797   fi
5798
5799   # Handle separated arguments.  Based on the logic generated by
5800   # autoconf 2.59.
5801   case $ac_arg in
5802     *=* | --config-cache | -C | -disable-* | --disable-* \
5803       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5804       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5805       | -with-* | --with-* | -without-* | --without-* | --x)
5806       separate_arg=no
5807       ;;
5808     -*)
5809       separate_arg=yes
5810       ;;
5811     *)
5812       separate_arg=no
5813       ;;
5814   esac
5815
5816   case "$ac_arg" in
5817     --no*)
5818       continue
5819       ;;
5820     --c* | \
5821     --sr* | \
5822     --ho* | \
5823     --bu* | \
5824     --t* | \
5825     --program-* | \
5826     -cache_file* | \
5827     -srcdir* | \
5828     -host* | \
5829     -build* | \
5830     -target* | \
5831     -program-prefix* | \
5832     -program-suffix* | \
5833     -program-transform-name* )
5834       skip_next=$separate_arg
5835       continue
5836       ;;
5837     -*)
5838       # An option.  Add it.
5839       case $ac_arg in
5840         *\'*)
5841           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5842       esac
5843       baseargs="$baseargs '$ac_arg'"
5844       keep_next=$separate_arg
5845       ;;
5846     *)
5847       # Either a variable assignment, or a nonopt (triplet).  Don't
5848       # pass it down; let the Makefile handle this.
5849       continue
5850       ;;
5851   esac
5852 done
5853 # Remove the initial space we just introduced and, as these will be
5854 # expanded by make, quote '$'.
5855 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5856
5857 # Add in --program-transform-name, after --program-prefix and
5858 # --program-suffix have been applied to it.  Autoconf has already
5859 # doubled dollar signs and backslashes in program_transform_name; we want
5860 # the backslashes un-doubled, and then the entire thing wrapped in single
5861 # quotes, because this will be expanded first by make and then by the shell.
5862 # Also, because we want to override the logic in subdir configure scripts to
5863 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5864 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5865 ${program_transform_name}
5866 EOF_SED
5867 gcc_transform_name=`cat conftestsed.out`
5868 rm -f conftestsed.out
5869 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5870 if test "$silent" = yes; then
5871   baseargs="$baseargs --silent"
5872 fi
5873
5874 # For the build-side libraries, we just need to pretend we're native,
5875 # and not use the same cache file.  Multilibs are neither needed nor
5876 # desired.
5877 build_configargs="--cache-file=../config.cache ${baseargs}"
5878
5879 # For host modules, accept cache file option, or specification as blank.
5880 case "${cache_file}" in
5881 "") # empty
5882   cache_file_option="" ;;
5883 /* | [A-Za-z]:[\\/]* ) # absolute path
5884   cache_file_option="--cache-file=${cache_file}" ;;
5885 *) # relative path
5886   cache_file_option="--cache-file=../${cache_file}" ;;
5887 esac
5888
5889 # Host dirs don't like to share a cache file either, horribly enough.
5890 # This seems to be due to autoconf 2.5x stupidity.
5891 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5892
5893 target_configargs=${baseargs}
5894
5895 # Passing a --with-cross-host argument lets the target libraries know
5896 # whether they are being built with a cross-compiler or being built
5897 # native.  However, it would be better to use other mechanisms to make the
5898 # sorts of decisions they want to make on this basis.  Please consider
5899 # this option to be deprecated.  FIXME.
5900 if test x${is_cross_compiler} = xyes ; then
5901   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5902 fi
5903
5904 # Default to --enable-multilib.
5905 if test x${enable_multilib} = x ; then
5906   target_configargs="--enable-multilib ${target_configargs}"
5907 fi
5908
5909 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5910 # changed from the earlier setting of with_newlib.
5911 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5912   target_configargs="--with-newlib ${target_configargs}"
5913 fi
5914
5915 # Different target subdirs use different values of certain variables
5916 # (notably CXX).  Worse, multilibs use *lots* of different values.
5917 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5918 # it doesn't automatically accept command-line overrides of them.
5919 # This means it's not safe for target subdirs to share a cache file,
5920 # which is disgusting, but there you have it.  Hopefully this can be
5921 # fixed in future.  It's still worthwhile to use a cache file for each
5922 # directory.  I think.
5923
5924 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5925 # We need to pass --target, as newer autoconf's requires consistency
5926 # for target_alias and gcc doesn't manage it consistently.
5927 target_configargs="--cache-file=./config.cache ${target_configargs}"
5928
5929 FLAGS_FOR_TARGET=
5930 case " $target_configdirs " in
5931  *" newlib "*)
5932   case " $target_configargs " in
5933   *" --with-newlib "*)
5934    case "$target" in
5935    *-cygwin*)
5936      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' ;;
5937    esac
5938
5939    # If we're not building GCC, don't discard standard headers.
5940    if test -d ${srcdir}/gcc; then
5941      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5942
5943      if test "${build}" != "${host}"; then
5944        # On Canadian crosses, CC_FOR_TARGET will have already been set
5945        # by `configure', so we won't have an opportunity to add -Bgcc/
5946        # to it.  This is right: we don't want to search that directory
5947        # for binaries, but we want the header files in there, so add
5948        # them explicitly.
5949        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5950
5951        # Someone might think of using the pre-installed headers on
5952        # Canadian crosses, in case the installed compiler is not fully
5953        # compatible with the compiler being built.  In this case, it
5954        # would be better to flag an error than risking having
5955        # incompatible object files being constructed.  We can't
5956        # guarantee that an error will be flagged, but let's hope the
5957        # compiler will do it, when presented with incompatible header
5958        # files.
5959      fi
5960    fi
5961
5962    case "${target}-${is_cross_compiler}" in
5963    i[3456789]86-*-linux*-no)
5964       # Here host == target, so we don't need to build gcc,
5965       # so we don't want to discard standard headers.
5966       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5967       ;;
5968    *)
5969       # If we're building newlib, use its generic headers last, but search
5970       # for any libc-related directories first (so make it the last -B
5971       # switch).
5972       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5973
5974       # If we're building libgloss, find the startup file, simulator library
5975       # and linker script.
5976       case " $target_configdirs " in
5977         *" libgloss "*)
5978         # Look for startup file, simulator library and maybe linker script.
5979         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
5980         # Look for libnosys.a in case the target needs it.
5981         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5982         # Most targets have the linker script in the source directory.
5983         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
5984         ;;
5985       esac
5986       ;;
5987    esac
5988    ;;
5989   esac
5990   ;;
5991 esac
5992 case "$target" in
5993 *-mingw*)
5994   # Can't be handled as Cygwin above since Mingw does not use newlib.
5995   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' ;;
5996 esac
5997
5998 # Allow the user to override the flags for
5999 # our build compiler if desired.
6000 if test x"${build}" = x"${host}" ; then
6001   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
6002   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
6003   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
6004 fi
6005
6006 # On Canadian crosses, we'll be searching the right directories for
6007 # the previously-installed cross compiler, so don't bother to add
6008 # flags for directories within the install tree of the compiler
6009 # being built; programs in there won't even run.
6010 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
6011   # Search for pre-installed headers if nothing else fits.
6012   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6013 fi
6014
6015 if test "x${use_gnu_ld}" = x &&
6016    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6017   # Arrange for us to find uninstalled linker scripts.
6018   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6019 fi
6020
6021 # Search for other target-specific linker scripts and such.
6022 case "${target}" in
6023   mep*)
6024     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6025     ;;
6026 esac
6027
6028 # Makefile fragments.
6029 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6030 do
6031   eval fragval=\$$frag
6032   if test $fragval != /dev/null; then
6033     eval $frag=${srcdir}/$fragval
6034   fi
6035 done
6036
6037
6038
6039
6040
6041 # Miscellanea: directories, flags, etc.
6042
6043
6044
6045
6046
6047
6048
6049 # Build module lists & subconfigure args.
6050
6051
6052
6053 # Host module lists & subconfigure args.
6054
6055
6056
6057 # Target module lists & subconfigure args.
6058
6059
6060
6061 # Build tools.
6062
6063
6064
6065
6066
6067
6068
6069
6070
6071
6072
6073
6074
6075
6076
6077
6078
6079 # Generate default definitions for YACC, M4, LEX and other programs that run
6080 # on the build machine.  These are used if the Makefile can't locate these
6081 # programs in objdir.
6082 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6083
6084 for ac_prog in 'bison -y' byacc yacc
6085 do
6086   # Extract the first word of "$ac_prog", so it can be a program name with args.
6087 set dummy $ac_prog; ac_word=$2
6088 echo "$as_me:$LINENO: checking for $ac_word" >&5
6089 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6090 if test "${ac_cv_prog_YACC+set}" = set; then
6091   echo $ECHO_N "(cached) $ECHO_C" >&6
6092 else
6093   if test -n "$YACC"; then
6094   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6095 else
6096 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6097 for as_dir in $PATH
6098 do
6099   IFS=$as_save_IFS
6100   test -z "$as_dir" && as_dir=.
6101   for ac_exec_ext in '' $ac_executable_extensions; do
6102   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6103     ac_cv_prog_YACC="$ac_prog"
6104     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6105     break 2
6106   fi
6107 done
6108 done
6109
6110 fi
6111 fi
6112 YACC=$ac_cv_prog_YACC
6113 if test -n "$YACC"; then
6114   echo "$as_me:$LINENO: result: $YACC" >&5
6115 echo "${ECHO_T}$YACC" >&6
6116 else
6117   echo "$as_me:$LINENO: result: no" >&5
6118 echo "${ECHO_T}no" >&6
6119 fi
6120
6121   test -n "$YACC" && break
6122 done
6123 test -n "$YACC" || YACC="$MISSING bison -y"
6124
6125 case " $build_configdirs " in
6126   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6127   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6128 esac
6129
6130 for ac_prog in bison
6131 do
6132   # Extract the first word of "$ac_prog", so it can be a program name with args.
6133 set dummy $ac_prog; ac_word=$2
6134 echo "$as_me:$LINENO: checking for $ac_word" >&5
6135 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6136 if test "${ac_cv_prog_BISON+set}" = set; then
6137   echo $ECHO_N "(cached) $ECHO_C" >&6
6138 else
6139   if test -n "$BISON"; then
6140   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6141 else
6142 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6143 for as_dir in $PATH
6144 do
6145   IFS=$as_save_IFS
6146   test -z "$as_dir" && as_dir=.
6147   for ac_exec_ext in '' $ac_executable_extensions; do
6148   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6149     ac_cv_prog_BISON="$ac_prog"
6150     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6151     break 2
6152   fi
6153 done
6154 done
6155
6156 fi
6157 fi
6158 BISON=$ac_cv_prog_BISON
6159 if test -n "$BISON"; then
6160   echo "$as_me:$LINENO: result: $BISON" >&5
6161 echo "${ECHO_T}$BISON" >&6
6162 else
6163   echo "$as_me:$LINENO: result: no" >&5
6164 echo "${ECHO_T}no" >&6
6165 fi
6166
6167   test -n "$BISON" && break
6168 done
6169 test -n "$BISON" || BISON="$MISSING bison"
6170
6171 case " $build_configdirs " in
6172   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6173 esac
6174
6175 for ac_prog in gm4 gnum4 m4
6176 do
6177   # Extract the first word of "$ac_prog", so it can be a program name with args.
6178 set dummy $ac_prog; ac_word=$2
6179 echo "$as_me:$LINENO: checking for $ac_word" >&5
6180 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6181 if test "${ac_cv_prog_M4+set}" = set; then
6182   echo $ECHO_N "(cached) $ECHO_C" >&6
6183 else
6184   if test -n "$M4"; then
6185   ac_cv_prog_M4="$M4" # Let the user override the test.
6186 else
6187 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6188 for as_dir in $PATH
6189 do
6190   IFS=$as_save_IFS
6191   test -z "$as_dir" && as_dir=.
6192   for ac_exec_ext in '' $ac_executable_extensions; do
6193   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6194     ac_cv_prog_M4="$ac_prog"
6195     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6196     break 2
6197   fi
6198 done
6199 done
6200
6201 fi
6202 fi
6203 M4=$ac_cv_prog_M4
6204 if test -n "$M4"; then
6205   echo "$as_me:$LINENO: result: $M4" >&5
6206 echo "${ECHO_T}$M4" >&6
6207 else
6208   echo "$as_me:$LINENO: result: no" >&5
6209 echo "${ECHO_T}no" >&6
6210 fi
6211
6212   test -n "$M4" && break
6213 done
6214 test -n "$M4" || M4="$MISSING m4"
6215
6216 case " $build_configdirs " in
6217   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6218 esac
6219
6220 for ac_prog in flex lex
6221 do
6222   # Extract the first word of "$ac_prog", so it can be a program name with args.
6223 set dummy $ac_prog; ac_word=$2
6224 echo "$as_me:$LINENO: checking for $ac_word" >&5
6225 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6226 if test "${ac_cv_prog_LEX+set}" = set; then
6227   echo $ECHO_N "(cached) $ECHO_C" >&6
6228 else
6229   if test -n "$LEX"; then
6230   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6231 else
6232 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6233 for as_dir in $PATH
6234 do
6235   IFS=$as_save_IFS
6236   test -z "$as_dir" && as_dir=.
6237   for ac_exec_ext in '' $ac_executable_extensions; do
6238   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6239     ac_cv_prog_LEX="$ac_prog"
6240     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6241     break 2
6242   fi
6243 done
6244 done
6245
6246 fi
6247 fi
6248 LEX=$ac_cv_prog_LEX
6249 if test -n "$LEX"; then
6250   echo "$as_me:$LINENO: result: $LEX" >&5
6251 echo "${ECHO_T}$LEX" >&6
6252 else
6253   echo "$as_me:$LINENO: result: no" >&5
6254 echo "${ECHO_T}no" >&6
6255 fi
6256
6257   test -n "$LEX" && break
6258 done
6259 test -n "$LEX" || LEX="$MISSING flex"
6260
6261 case " $build_configdirs " in
6262   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6263   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6264 esac
6265
6266 for ac_prog in flex
6267 do
6268   # Extract the first word of "$ac_prog", so it can be a program name with args.
6269 set dummy $ac_prog; ac_word=$2
6270 echo "$as_me:$LINENO: checking for $ac_word" >&5
6271 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6272 if test "${ac_cv_prog_FLEX+set}" = set; then
6273   echo $ECHO_N "(cached) $ECHO_C" >&6
6274 else
6275   if test -n "$FLEX"; then
6276   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6277 else
6278 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6279 for as_dir in $PATH
6280 do
6281   IFS=$as_save_IFS
6282   test -z "$as_dir" && as_dir=.
6283   for ac_exec_ext in '' $ac_executable_extensions; do
6284   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6285     ac_cv_prog_FLEX="$ac_prog"
6286     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6287     break 2
6288   fi
6289 done
6290 done
6291
6292 fi
6293 fi
6294 FLEX=$ac_cv_prog_FLEX
6295 if test -n "$FLEX"; then
6296   echo "$as_me:$LINENO: result: $FLEX" >&5
6297 echo "${ECHO_T}$FLEX" >&6
6298 else
6299   echo "$as_me:$LINENO: result: no" >&5
6300 echo "${ECHO_T}no" >&6
6301 fi
6302
6303   test -n "$FLEX" && break
6304 done
6305 test -n "$FLEX" || FLEX="$MISSING flex"
6306
6307 case " $build_configdirs " in
6308   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6309 esac
6310
6311 for ac_prog in makeinfo
6312 do
6313   # Extract the first word of "$ac_prog", so it can be a program name with args.
6314 set dummy $ac_prog; ac_word=$2
6315 echo "$as_me:$LINENO: checking for $ac_word" >&5
6316 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6317 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6318   echo $ECHO_N "(cached) $ECHO_C" >&6
6319 else
6320   if test -n "$MAKEINFO"; then
6321   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6322 else
6323 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6324 for as_dir in $PATH
6325 do
6326   IFS=$as_save_IFS
6327   test -z "$as_dir" && as_dir=.
6328   for ac_exec_ext in '' $ac_executable_extensions; do
6329   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6330     ac_cv_prog_MAKEINFO="$ac_prog"
6331     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6332     break 2
6333   fi
6334 done
6335 done
6336
6337 fi
6338 fi
6339 MAKEINFO=$ac_cv_prog_MAKEINFO
6340 if test -n "$MAKEINFO"; then
6341   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6342 echo "${ECHO_T}$MAKEINFO" >&6
6343 else
6344   echo "$as_me:$LINENO: result: no" >&5
6345 echo "${ECHO_T}no" >&6
6346 fi
6347
6348   test -n "$MAKEINFO" && break
6349 done
6350 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6351
6352 case " $build_configdirs " in
6353   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6354   *)
6355
6356     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6357     # higher, else we use the "missing" dummy.
6358     if ${MAKEINFO} --version \
6359        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6360       :
6361     else
6362       MAKEINFO="$MISSING makeinfo"
6363     fi
6364     ;;
6365
6366 esac
6367
6368 # FIXME: expect and dejagnu may become build tools?
6369
6370 for ac_prog in expect
6371 do
6372   # Extract the first word of "$ac_prog", so it can be a program name with args.
6373 set dummy $ac_prog; ac_word=$2
6374 echo "$as_me:$LINENO: checking for $ac_word" >&5
6375 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6376 if test "${ac_cv_prog_EXPECT+set}" = set; then
6377   echo $ECHO_N "(cached) $ECHO_C" >&6
6378 else
6379   if test -n "$EXPECT"; then
6380   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6381 else
6382 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6383 for as_dir in $PATH
6384 do
6385   IFS=$as_save_IFS
6386   test -z "$as_dir" && as_dir=.
6387   for ac_exec_ext in '' $ac_executable_extensions; do
6388   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6389     ac_cv_prog_EXPECT="$ac_prog"
6390     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6391     break 2
6392   fi
6393 done
6394 done
6395
6396 fi
6397 fi
6398 EXPECT=$ac_cv_prog_EXPECT
6399 if test -n "$EXPECT"; then
6400   echo "$as_me:$LINENO: result: $EXPECT" >&5
6401 echo "${ECHO_T}$EXPECT" >&6
6402 else
6403   echo "$as_me:$LINENO: result: no" >&5
6404 echo "${ECHO_T}no" >&6
6405 fi
6406
6407   test -n "$EXPECT" && break
6408 done
6409 test -n "$EXPECT" || EXPECT="expect"
6410
6411 case " $configdirs " in
6412   *" expect "*)
6413     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6414     ;;
6415 esac
6416
6417 for ac_prog in runtest
6418 do
6419   # Extract the first word of "$ac_prog", so it can be a program name with args.
6420 set dummy $ac_prog; ac_word=$2
6421 echo "$as_me:$LINENO: checking for $ac_word" >&5
6422 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6423 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6424   echo $ECHO_N "(cached) $ECHO_C" >&6
6425 else
6426   if test -n "$RUNTEST"; then
6427   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6428 else
6429 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6430 for as_dir in $PATH
6431 do
6432   IFS=$as_save_IFS
6433   test -z "$as_dir" && as_dir=.
6434   for ac_exec_ext in '' $ac_executable_extensions; do
6435   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6436     ac_cv_prog_RUNTEST="$ac_prog"
6437     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6438     break 2
6439   fi
6440 done
6441 done
6442
6443 fi
6444 fi
6445 RUNTEST=$ac_cv_prog_RUNTEST
6446 if test -n "$RUNTEST"; then
6447   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6448 echo "${ECHO_T}$RUNTEST" >&6
6449 else
6450   echo "$as_me:$LINENO: result: no" >&5
6451 echo "${ECHO_T}no" >&6
6452 fi
6453
6454   test -n "$RUNTEST" && break
6455 done
6456 test -n "$RUNTEST" || RUNTEST="runtest"
6457
6458 case " $configdirs " in
6459   *" dejagnu "*)
6460     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6461     ;;
6462 esac
6463
6464
6465 # Host tools.
6466 ncn_tool_prefix=
6467 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6468 ncn_target_tool_prefix=
6469 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6470
6471
6472
6473 if test -n "$AR"; then
6474   ac_cv_prog_AR=$AR
6475 elif test -n "$ac_cv_prog_AR"; then
6476   AR=$ac_cv_prog_AR
6477 fi
6478
6479 if test -n "$ac_cv_prog_AR"; then
6480   for ncn_progname in ar; do
6481     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6482 set dummy ${ncn_progname}; ac_word=$2
6483 echo "$as_me:$LINENO: checking for $ac_word" >&5
6484 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6485 if test "${ac_cv_prog_AR+set}" = set; then
6486   echo $ECHO_N "(cached) $ECHO_C" >&6
6487 else
6488   if test -n "$AR"; then
6489   ac_cv_prog_AR="$AR" # Let the user override the test.
6490 else
6491 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6492 for as_dir in $PATH
6493 do
6494   IFS=$as_save_IFS
6495   test -z "$as_dir" && as_dir=.
6496   for ac_exec_ext in '' $ac_executable_extensions; do
6497   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6498     ac_cv_prog_AR="${ncn_progname}"
6499     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6500     break 2
6501   fi
6502 done
6503 done
6504
6505 fi
6506 fi
6507 AR=$ac_cv_prog_AR
6508 if test -n "$AR"; then
6509   echo "$as_me:$LINENO: result: $AR" >&5
6510 echo "${ECHO_T}$AR" >&6
6511 else
6512   echo "$as_me:$LINENO: result: no" >&5
6513 echo "${ECHO_T}no" >&6
6514 fi
6515
6516   done
6517 fi
6518
6519 for ncn_progname in ar; do
6520   if test -n "$ncn_tool_prefix"; then
6521     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6522 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6523 echo "$as_me:$LINENO: checking for $ac_word" >&5
6524 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6525 if test "${ac_cv_prog_AR+set}" = set; then
6526   echo $ECHO_N "(cached) $ECHO_C" >&6
6527 else
6528   if test -n "$AR"; then
6529   ac_cv_prog_AR="$AR" # Let the user override the test.
6530 else
6531 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6532 for as_dir in $PATH
6533 do
6534   IFS=$as_save_IFS
6535   test -z "$as_dir" && as_dir=.
6536   for ac_exec_ext in '' $ac_executable_extensions; do
6537   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6538     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6539     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6540     break 2
6541   fi
6542 done
6543 done
6544
6545 fi
6546 fi
6547 AR=$ac_cv_prog_AR
6548 if test -n "$AR"; then
6549   echo "$as_me:$LINENO: result: $AR" >&5
6550 echo "${ECHO_T}$AR" >&6
6551 else
6552   echo "$as_me:$LINENO: result: no" >&5
6553 echo "${ECHO_T}no" >&6
6554 fi
6555
6556   fi
6557   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6558     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6559 set dummy ${ncn_progname}; ac_word=$2
6560 echo "$as_me:$LINENO: checking for $ac_word" >&5
6561 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6562 if test "${ac_cv_prog_AR+set}" = set; then
6563   echo $ECHO_N "(cached) $ECHO_C" >&6
6564 else
6565   if test -n "$AR"; then
6566   ac_cv_prog_AR="$AR" # Let the user override the test.
6567 else
6568 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6569 for as_dir in $PATH
6570 do
6571   IFS=$as_save_IFS
6572   test -z "$as_dir" && as_dir=.
6573   for ac_exec_ext in '' $ac_executable_extensions; do
6574   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6575     ac_cv_prog_AR="${ncn_progname}"
6576     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6577     break 2
6578   fi
6579 done
6580 done
6581
6582 fi
6583 fi
6584 AR=$ac_cv_prog_AR
6585 if test -n "$AR"; then
6586   echo "$as_me:$LINENO: result: $AR" >&5
6587 echo "${ECHO_T}$AR" >&6
6588 else
6589   echo "$as_me:$LINENO: result: no" >&5
6590 echo "${ECHO_T}no" >&6
6591 fi
6592
6593   fi
6594   test -n "$ac_cv_prog_AR" && break
6595 done
6596
6597 if test -z "$ac_cv_prog_AR" ; then
6598   set dummy ar
6599   if test $build = $host ; then
6600     AR="$2"
6601   else
6602     AR="${ncn_tool_prefix}$2"
6603   fi
6604 fi
6605
6606
6607
6608 if test -n "$AS"; then
6609   ac_cv_prog_AS=$AS
6610 elif test -n "$ac_cv_prog_AS"; then
6611   AS=$ac_cv_prog_AS
6612 fi
6613
6614 if test -n "$ac_cv_prog_AS"; then
6615   for ncn_progname in as; do
6616     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6617 set dummy ${ncn_progname}; ac_word=$2
6618 echo "$as_me:$LINENO: checking for $ac_word" >&5
6619 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6620 if test "${ac_cv_prog_AS+set}" = set; then
6621   echo $ECHO_N "(cached) $ECHO_C" >&6
6622 else
6623   if test -n "$AS"; then
6624   ac_cv_prog_AS="$AS" # Let the user override the test.
6625 else
6626 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6627 for as_dir in $PATH
6628 do
6629   IFS=$as_save_IFS
6630   test -z "$as_dir" && as_dir=.
6631   for ac_exec_ext in '' $ac_executable_extensions; do
6632   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6633     ac_cv_prog_AS="${ncn_progname}"
6634     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6635     break 2
6636   fi
6637 done
6638 done
6639
6640 fi
6641 fi
6642 AS=$ac_cv_prog_AS
6643 if test -n "$AS"; then
6644   echo "$as_me:$LINENO: result: $AS" >&5
6645 echo "${ECHO_T}$AS" >&6
6646 else
6647   echo "$as_me:$LINENO: result: no" >&5
6648 echo "${ECHO_T}no" >&6
6649 fi
6650
6651   done
6652 fi
6653
6654 for ncn_progname in as; do
6655   if test -n "$ncn_tool_prefix"; then
6656     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6657 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6658 echo "$as_me:$LINENO: checking for $ac_word" >&5
6659 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6660 if test "${ac_cv_prog_AS+set}" = set; then
6661   echo $ECHO_N "(cached) $ECHO_C" >&6
6662 else
6663   if test -n "$AS"; then
6664   ac_cv_prog_AS="$AS" # Let the user override the test.
6665 else
6666 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6667 for as_dir in $PATH
6668 do
6669   IFS=$as_save_IFS
6670   test -z "$as_dir" && as_dir=.
6671   for ac_exec_ext in '' $ac_executable_extensions; do
6672   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6673     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6674     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6675     break 2
6676   fi
6677 done
6678 done
6679
6680 fi
6681 fi
6682 AS=$ac_cv_prog_AS
6683 if test -n "$AS"; then
6684   echo "$as_me:$LINENO: result: $AS" >&5
6685 echo "${ECHO_T}$AS" >&6
6686 else
6687   echo "$as_me:$LINENO: result: no" >&5
6688 echo "${ECHO_T}no" >&6
6689 fi
6690
6691   fi
6692   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6693     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6694 set dummy ${ncn_progname}; ac_word=$2
6695 echo "$as_me:$LINENO: checking for $ac_word" >&5
6696 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6697 if test "${ac_cv_prog_AS+set}" = set; then
6698   echo $ECHO_N "(cached) $ECHO_C" >&6
6699 else
6700   if test -n "$AS"; then
6701   ac_cv_prog_AS="$AS" # Let the user override the test.
6702 else
6703 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6704 for as_dir in $PATH
6705 do
6706   IFS=$as_save_IFS
6707   test -z "$as_dir" && as_dir=.
6708   for ac_exec_ext in '' $ac_executable_extensions; do
6709   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6710     ac_cv_prog_AS="${ncn_progname}"
6711     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6712     break 2
6713   fi
6714 done
6715 done
6716
6717 fi
6718 fi
6719 AS=$ac_cv_prog_AS
6720 if test -n "$AS"; then
6721   echo "$as_me:$LINENO: result: $AS" >&5
6722 echo "${ECHO_T}$AS" >&6
6723 else
6724   echo "$as_me:$LINENO: result: no" >&5
6725 echo "${ECHO_T}no" >&6
6726 fi
6727
6728   fi
6729   test -n "$ac_cv_prog_AS" && break
6730 done
6731
6732 if test -z "$ac_cv_prog_AS" ; then
6733   set dummy as
6734   if test $build = $host ; then
6735     AS="$2"
6736   else
6737     AS="${ncn_tool_prefix}$2"
6738   fi
6739 fi
6740
6741
6742
6743 if test -n "$DLLTOOL"; then
6744   ac_cv_prog_DLLTOOL=$DLLTOOL
6745 elif test -n "$ac_cv_prog_DLLTOOL"; then
6746   DLLTOOL=$ac_cv_prog_DLLTOOL
6747 fi
6748
6749 if test -n "$ac_cv_prog_DLLTOOL"; then
6750   for ncn_progname in dlltool; do
6751     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6752 set dummy ${ncn_progname}; ac_word=$2
6753 echo "$as_me:$LINENO: checking for $ac_word" >&5
6754 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6755 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6756   echo $ECHO_N "(cached) $ECHO_C" >&6
6757 else
6758   if test -n "$DLLTOOL"; then
6759   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6760 else
6761 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6762 for as_dir in $PATH
6763 do
6764   IFS=$as_save_IFS
6765   test -z "$as_dir" && as_dir=.
6766   for ac_exec_ext in '' $ac_executable_extensions; do
6767   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6768     ac_cv_prog_DLLTOOL="${ncn_progname}"
6769     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6770     break 2
6771   fi
6772 done
6773 done
6774
6775 fi
6776 fi
6777 DLLTOOL=$ac_cv_prog_DLLTOOL
6778 if test -n "$DLLTOOL"; then
6779   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6780 echo "${ECHO_T}$DLLTOOL" >&6
6781 else
6782   echo "$as_me:$LINENO: result: no" >&5
6783 echo "${ECHO_T}no" >&6
6784 fi
6785
6786   done
6787 fi
6788
6789 for ncn_progname in dlltool; do
6790   if test -n "$ncn_tool_prefix"; then
6791     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6792 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6793 echo "$as_me:$LINENO: checking for $ac_word" >&5
6794 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6795 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6796   echo $ECHO_N "(cached) $ECHO_C" >&6
6797 else
6798   if test -n "$DLLTOOL"; then
6799   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6800 else
6801 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6802 for as_dir in $PATH
6803 do
6804   IFS=$as_save_IFS
6805   test -z "$as_dir" && as_dir=.
6806   for ac_exec_ext in '' $ac_executable_extensions; do
6807   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6808     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6809     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6810     break 2
6811   fi
6812 done
6813 done
6814
6815 fi
6816 fi
6817 DLLTOOL=$ac_cv_prog_DLLTOOL
6818 if test -n "$DLLTOOL"; then
6819   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6820 echo "${ECHO_T}$DLLTOOL" >&6
6821 else
6822   echo "$as_me:$LINENO: result: no" >&5
6823 echo "${ECHO_T}no" >&6
6824 fi
6825
6826   fi
6827   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6828     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6829 set dummy ${ncn_progname}; ac_word=$2
6830 echo "$as_me:$LINENO: checking for $ac_word" >&5
6831 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6832 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6833   echo $ECHO_N "(cached) $ECHO_C" >&6
6834 else
6835   if test -n "$DLLTOOL"; then
6836   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6837 else
6838 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6839 for as_dir in $PATH
6840 do
6841   IFS=$as_save_IFS
6842   test -z "$as_dir" && as_dir=.
6843   for ac_exec_ext in '' $ac_executable_extensions; do
6844   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6845     ac_cv_prog_DLLTOOL="${ncn_progname}"
6846     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6847     break 2
6848   fi
6849 done
6850 done
6851
6852 fi
6853 fi
6854 DLLTOOL=$ac_cv_prog_DLLTOOL
6855 if test -n "$DLLTOOL"; then
6856   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6857 echo "${ECHO_T}$DLLTOOL" >&6
6858 else
6859   echo "$as_me:$LINENO: result: no" >&5
6860 echo "${ECHO_T}no" >&6
6861 fi
6862
6863   fi
6864   test -n "$ac_cv_prog_DLLTOOL" && break
6865 done
6866
6867 if test -z "$ac_cv_prog_DLLTOOL" ; then
6868   set dummy dlltool
6869   if test $build = $host ; then
6870     DLLTOOL="$2"
6871   else
6872     DLLTOOL="${ncn_tool_prefix}$2"
6873   fi
6874 fi
6875
6876
6877
6878 if test -n "$LD"; then
6879   ac_cv_prog_LD=$LD
6880 elif test -n "$ac_cv_prog_LD"; then
6881   LD=$ac_cv_prog_LD
6882 fi
6883
6884 if test -n "$ac_cv_prog_LD"; then
6885   for ncn_progname in ld; do
6886     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6887 set dummy ${ncn_progname}; ac_word=$2
6888 echo "$as_me:$LINENO: checking for $ac_word" >&5
6889 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6890 if test "${ac_cv_prog_LD+set}" = set; then
6891   echo $ECHO_N "(cached) $ECHO_C" >&6
6892 else
6893   if test -n "$LD"; then
6894   ac_cv_prog_LD="$LD" # Let the user override the test.
6895 else
6896 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6897 for as_dir in $PATH
6898 do
6899   IFS=$as_save_IFS
6900   test -z "$as_dir" && as_dir=.
6901   for ac_exec_ext in '' $ac_executable_extensions; do
6902   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6903     ac_cv_prog_LD="${ncn_progname}"
6904     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6905     break 2
6906   fi
6907 done
6908 done
6909
6910 fi
6911 fi
6912 LD=$ac_cv_prog_LD
6913 if test -n "$LD"; then
6914   echo "$as_me:$LINENO: result: $LD" >&5
6915 echo "${ECHO_T}$LD" >&6
6916 else
6917   echo "$as_me:$LINENO: result: no" >&5
6918 echo "${ECHO_T}no" >&6
6919 fi
6920
6921   done
6922 fi
6923
6924 for ncn_progname in ld; do
6925   if test -n "$ncn_tool_prefix"; then
6926     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6927 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6928 echo "$as_me:$LINENO: checking for $ac_word" >&5
6929 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6930 if test "${ac_cv_prog_LD+set}" = set; then
6931   echo $ECHO_N "(cached) $ECHO_C" >&6
6932 else
6933   if test -n "$LD"; then
6934   ac_cv_prog_LD="$LD" # Let the user override the test.
6935 else
6936 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6937 for as_dir in $PATH
6938 do
6939   IFS=$as_save_IFS
6940   test -z "$as_dir" && as_dir=.
6941   for ac_exec_ext in '' $ac_executable_extensions; do
6942   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6943     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6944     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6945     break 2
6946   fi
6947 done
6948 done
6949
6950 fi
6951 fi
6952 LD=$ac_cv_prog_LD
6953 if test -n "$LD"; then
6954   echo "$as_me:$LINENO: result: $LD" >&5
6955 echo "${ECHO_T}$LD" >&6
6956 else
6957   echo "$as_me:$LINENO: result: no" >&5
6958 echo "${ECHO_T}no" >&6
6959 fi
6960
6961   fi
6962   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6963     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6964 set dummy ${ncn_progname}; ac_word=$2
6965 echo "$as_me:$LINENO: checking for $ac_word" >&5
6966 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6967 if test "${ac_cv_prog_LD+set}" = set; then
6968   echo $ECHO_N "(cached) $ECHO_C" >&6
6969 else
6970   if test -n "$LD"; then
6971   ac_cv_prog_LD="$LD" # Let the user override the test.
6972 else
6973 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6974 for as_dir in $PATH
6975 do
6976   IFS=$as_save_IFS
6977   test -z "$as_dir" && as_dir=.
6978   for ac_exec_ext in '' $ac_executable_extensions; do
6979   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6980     ac_cv_prog_LD="${ncn_progname}"
6981     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6982     break 2
6983   fi
6984 done
6985 done
6986
6987 fi
6988 fi
6989 LD=$ac_cv_prog_LD
6990 if test -n "$LD"; then
6991   echo "$as_me:$LINENO: result: $LD" >&5
6992 echo "${ECHO_T}$LD" >&6
6993 else
6994   echo "$as_me:$LINENO: result: no" >&5
6995 echo "${ECHO_T}no" >&6
6996 fi
6997
6998   fi
6999   test -n "$ac_cv_prog_LD" && break
7000 done
7001
7002 if test -z "$ac_cv_prog_LD" ; then
7003   set dummy ld
7004   if test $build = $host ; then
7005     LD="$2"
7006   else
7007     LD="${ncn_tool_prefix}$2"
7008   fi
7009 fi
7010
7011
7012
7013 if test -n "$LIPO"; then
7014   ac_cv_prog_LIPO=$LIPO
7015 elif test -n "$ac_cv_prog_LIPO"; then
7016   LIPO=$ac_cv_prog_LIPO
7017 fi
7018
7019 if test -n "$ac_cv_prog_LIPO"; then
7020   for ncn_progname in lipo; do
7021     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7022 set dummy ${ncn_progname}; ac_word=$2
7023 echo "$as_me:$LINENO: checking for $ac_word" >&5
7024 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7025 if test "${ac_cv_prog_LIPO+set}" = set; then
7026   echo $ECHO_N "(cached) $ECHO_C" >&6
7027 else
7028   if test -n "$LIPO"; then
7029   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7030 else
7031 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7032 for as_dir in $PATH
7033 do
7034   IFS=$as_save_IFS
7035   test -z "$as_dir" && as_dir=.
7036   for ac_exec_ext in '' $ac_executable_extensions; do
7037   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7038     ac_cv_prog_LIPO="${ncn_progname}"
7039     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7040     break 2
7041   fi
7042 done
7043 done
7044
7045 fi
7046 fi
7047 LIPO=$ac_cv_prog_LIPO
7048 if test -n "$LIPO"; then
7049   echo "$as_me:$LINENO: result: $LIPO" >&5
7050 echo "${ECHO_T}$LIPO" >&6
7051 else
7052   echo "$as_me:$LINENO: result: no" >&5
7053 echo "${ECHO_T}no" >&6
7054 fi
7055
7056   done
7057 fi
7058
7059 for ncn_progname in lipo; do
7060   if test -n "$ncn_tool_prefix"; then
7061     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7062 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7063 echo "$as_me:$LINENO: checking for $ac_word" >&5
7064 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7065 if test "${ac_cv_prog_LIPO+set}" = set; then
7066   echo $ECHO_N "(cached) $ECHO_C" >&6
7067 else
7068   if test -n "$LIPO"; then
7069   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7070 else
7071 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7072 for as_dir in $PATH
7073 do
7074   IFS=$as_save_IFS
7075   test -z "$as_dir" && as_dir=.
7076   for ac_exec_ext in '' $ac_executable_extensions; do
7077   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7078     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7079     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7080     break 2
7081   fi
7082 done
7083 done
7084
7085 fi
7086 fi
7087 LIPO=$ac_cv_prog_LIPO
7088 if test -n "$LIPO"; then
7089   echo "$as_me:$LINENO: result: $LIPO" >&5
7090 echo "${ECHO_T}$LIPO" >&6
7091 else
7092   echo "$as_me:$LINENO: result: no" >&5
7093 echo "${ECHO_T}no" >&6
7094 fi
7095
7096   fi
7097   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7098     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7099 set dummy ${ncn_progname}; ac_word=$2
7100 echo "$as_me:$LINENO: checking for $ac_word" >&5
7101 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7102 if test "${ac_cv_prog_LIPO+set}" = set; then
7103   echo $ECHO_N "(cached) $ECHO_C" >&6
7104 else
7105   if test -n "$LIPO"; then
7106   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7107 else
7108 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7109 for as_dir in $PATH
7110 do
7111   IFS=$as_save_IFS
7112   test -z "$as_dir" && as_dir=.
7113   for ac_exec_ext in '' $ac_executable_extensions; do
7114   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7115     ac_cv_prog_LIPO="${ncn_progname}"
7116     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7117     break 2
7118   fi
7119 done
7120 done
7121
7122 fi
7123 fi
7124 LIPO=$ac_cv_prog_LIPO
7125 if test -n "$LIPO"; then
7126   echo "$as_me:$LINENO: result: $LIPO" >&5
7127 echo "${ECHO_T}$LIPO" >&6
7128 else
7129   echo "$as_me:$LINENO: result: no" >&5
7130 echo "${ECHO_T}no" >&6
7131 fi
7132
7133   fi
7134   test -n "$ac_cv_prog_LIPO" && break
7135 done
7136
7137 if test -z "$ac_cv_prog_LIPO" ; then
7138   set dummy lipo
7139   if test $build = $host ; then
7140     LIPO="$2"
7141   else
7142     LIPO="${ncn_tool_prefix}$2"
7143   fi
7144 fi
7145
7146
7147
7148 if test -n "$NM"; then
7149   ac_cv_prog_NM=$NM
7150 elif test -n "$ac_cv_prog_NM"; then
7151   NM=$ac_cv_prog_NM
7152 fi
7153
7154 if test -n "$ac_cv_prog_NM"; then
7155   for ncn_progname in nm; do
7156     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7157 set dummy ${ncn_progname}; ac_word=$2
7158 echo "$as_me:$LINENO: checking for $ac_word" >&5
7159 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7160 if test "${ac_cv_prog_NM+set}" = set; then
7161   echo $ECHO_N "(cached) $ECHO_C" >&6
7162 else
7163   if test -n "$NM"; then
7164   ac_cv_prog_NM="$NM" # Let the user override the test.
7165 else
7166 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7167 for as_dir in $PATH
7168 do
7169   IFS=$as_save_IFS
7170   test -z "$as_dir" && as_dir=.
7171   for ac_exec_ext in '' $ac_executable_extensions; do
7172   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7173     ac_cv_prog_NM="${ncn_progname}"
7174     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7175     break 2
7176   fi
7177 done
7178 done
7179
7180 fi
7181 fi
7182 NM=$ac_cv_prog_NM
7183 if test -n "$NM"; then
7184   echo "$as_me:$LINENO: result: $NM" >&5
7185 echo "${ECHO_T}$NM" >&6
7186 else
7187   echo "$as_me:$LINENO: result: no" >&5
7188 echo "${ECHO_T}no" >&6
7189 fi
7190
7191   done
7192 fi
7193
7194 for ncn_progname in nm; do
7195   if test -n "$ncn_tool_prefix"; then
7196     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7197 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7198 echo "$as_me:$LINENO: checking for $ac_word" >&5
7199 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7200 if test "${ac_cv_prog_NM+set}" = set; then
7201   echo $ECHO_N "(cached) $ECHO_C" >&6
7202 else
7203   if test -n "$NM"; then
7204   ac_cv_prog_NM="$NM" # Let the user override the test.
7205 else
7206 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7207 for as_dir in $PATH
7208 do
7209   IFS=$as_save_IFS
7210   test -z "$as_dir" && as_dir=.
7211   for ac_exec_ext in '' $ac_executable_extensions; do
7212   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7213     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7214     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7215     break 2
7216   fi
7217 done
7218 done
7219
7220 fi
7221 fi
7222 NM=$ac_cv_prog_NM
7223 if test -n "$NM"; then
7224   echo "$as_me:$LINENO: result: $NM" >&5
7225 echo "${ECHO_T}$NM" >&6
7226 else
7227   echo "$as_me:$LINENO: result: no" >&5
7228 echo "${ECHO_T}no" >&6
7229 fi
7230
7231   fi
7232   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7233     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7234 set dummy ${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_NM+set}" = set; then
7238   echo $ECHO_N "(cached) $ECHO_C" >&6
7239 else
7240   if test -n "$NM"; then
7241   ac_cv_prog_NM="$NM" # 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_NM="${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 NM=$ac_cv_prog_NM
7260 if test -n "$NM"; then
7261   echo "$as_me:$LINENO: result: $NM" >&5
7262 echo "${ECHO_T}$NM" >&6
7263 else
7264   echo "$as_me:$LINENO: result: no" >&5
7265 echo "${ECHO_T}no" >&6
7266 fi
7267
7268   fi
7269   test -n "$ac_cv_prog_NM" && break
7270 done
7271
7272 if test -z "$ac_cv_prog_NM" ; then
7273   set dummy nm
7274   if test $build = $host ; then
7275     NM="$2"
7276   else
7277     NM="${ncn_tool_prefix}$2"
7278   fi
7279 fi
7280
7281
7282
7283 if test -n "$RANLIB"; then
7284   ac_cv_prog_RANLIB=$RANLIB
7285 elif test -n "$ac_cv_prog_RANLIB"; then
7286   RANLIB=$ac_cv_prog_RANLIB
7287 fi
7288
7289 if test -n "$ac_cv_prog_RANLIB"; then
7290   for ncn_progname in ranlib; do
7291     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7292 set dummy ${ncn_progname}; ac_word=$2
7293 echo "$as_me:$LINENO: checking for $ac_word" >&5
7294 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7295 if test "${ac_cv_prog_RANLIB+set}" = set; then
7296   echo $ECHO_N "(cached) $ECHO_C" >&6
7297 else
7298   if test -n "$RANLIB"; then
7299   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7300 else
7301 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7302 for as_dir in $PATH
7303 do
7304   IFS=$as_save_IFS
7305   test -z "$as_dir" && as_dir=.
7306   for ac_exec_ext in '' $ac_executable_extensions; do
7307   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7308     ac_cv_prog_RANLIB="${ncn_progname}"
7309     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7310     break 2
7311   fi
7312 done
7313 done
7314
7315 fi
7316 fi
7317 RANLIB=$ac_cv_prog_RANLIB
7318 if test -n "$RANLIB"; then
7319   echo "$as_me:$LINENO: result: $RANLIB" >&5
7320 echo "${ECHO_T}$RANLIB" >&6
7321 else
7322   echo "$as_me:$LINENO: result: no" >&5
7323 echo "${ECHO_T}no" >&6
7324 fi
7325
7326   done
7327 fi
7328
7329 for ncn_progname in ranlib; do
7330   if test -n "$ncn_tool_prefix"; then
7331     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7332 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7333 echo "$as_me:$LINENO: checking for $ac_word" >&5
7334 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7335 if test "${ac_cv_prog_RANLIB+set}" = set; then
7336   echo $ECHO_N "(cached) $ECHO_C" >&6
7337 else
7338   if test -n "$RANLIB"; then
7339   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7340 else
7341 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7342 for as_dir in $PATH
7343 do
7344   IFS=$as_save_IFS
7345   test -z "$as_dir" && as_dir=.
7346   for ac_exec_ext in '' $ac_executable_extensions; do
7347   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7348     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7349     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7350     break 2
7351   fi
7352 done
7353 done
7354
7355 fi
7356 fi
7357 RANLIB=$ac_cv_prog_RANLIB
7358 if test -n "$RANLIB"; then
7359   echo "$as_me:$LINENO: result: $RANLIB" >&5
7360 echo "${ECHO_T}$RANLIB" >&6
7361 else
7362   echo "$as_me:$LINENO: result: no" >&5
7363 echo "${ECHO_T}no" >&6
7364 fi
7365
7366   fi
7367   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7368     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7369 set dummy ${ncn_progname}; ac_word=$2
7370 echo "$as_me:$LINENO: checking for $ac_word" >&5
7371 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7372 if test "${ac_cv_prog_RANLIB+set}" = set; then
7373   echo $ECHO_N "(cached) $ECHO_C" >&6
7374 else
7375   if test -n "$RANLIB"; then
7376   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7377 else
7378 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7379 for as_dir in $PATH
7380 do
7381   IFS=$as_save_IFS
7382   test -z "$as_dir" && as_dir=.
7383   for ac_exec_ext in '' $ac_executable_extensions; do
7384   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7385     ac_cv_prog_RANLIB="${ncn_progname}"
7386     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7387     break 2
7388   fi
7389 done
7390 done
7391
7392 fi
7393 fi
7394 RANLIB=$ac_cv_prog_RANLIB
7395 if test -n "$RANLIB"; then
7396   echo "$as_me:$LINENO: result: $RANLIB" >&5
7397 echo "${ECHO_T}$RANLIB" >&6
7398 else
7399   echo "$as_me:$LINENO: result: no" >&5
7400 echo "${ECHO_T}no" >&6
7401 fi
7402
7403   fi
7404   test -n "$ac_cv_prog_RANLIB" && break
7405 done
7406
7407 if test -z "$ac_cv_prog_RANLIB" ; then
7408   RANLIB=":"
7409 fi
7410
7411
7412
7413 if test -n "$STRIP"; then
7414   ac_cv_prog_STRIP=$STRIP
7415 elif test -n "$ac_cv_prog_STRIP"; then
7416   STRIP=$ac_cv_prog_STRIP
7417 fi
7418
7419 if test -n "$ac_cv_prog_STRIP"; then
7420   for ncn_progname in strip; do
7421     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7422 set dummy ${ncn_progname}; ac_word=$2
7423 echo "$as_me:$LINENO: checking for $ac_word" >&5
7424 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7425 if test "${ac_cv_prog_STRIP+set}" = set; then
7426   echo $ECHO_N "(cached) $ECHO_C" >&6
7427 else
7428   if test -n "$STRIP"; then
7429   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7430 else
7431 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7432 for as_dir in $PATH
7433 do
7434   IFS=$as_save_IFS
7435   test -z "$as_dir" && as_dir=.
7436   for ac_exec_ext in '' $ac_executable_extensions; do
7437   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7438     ac_cv_prog_STRIP="${ncn_progname}"
7439     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7440     break 2
7441   fi
7442 done
7443 done
7444
7445 fi
7446 fi
7447 STRIP=$ac_cv_prog_STRIP
7448 if test -n "$STRIP"; then
7449   echo "$as_me:$LINENO: result: $STRIP" >&5
7450 echo "${ECHO_T}$STRIP" >&6
7451 else
7452   echo "$as_me:$LINENO: result: no" >&5
7453 echo "${ECHO_T}no" >&6
7454 fi
7455
7456   done
7457 fi
7458
7459 for ncn_progname in strip; do
7460   if test -n "$ncn_tool_prefix"; then
7461     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7462 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7463 echo "$as_me:$LINENO: checking for $ac_word" >&5
7464 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7465 if test "${ac_cv_prog_STRIP+set}" = set; then
7466   echo $ECHO_N "(cached) $ECHO_C" >&6
7467 else
7468   if test -n "$STRIP"; then
7469   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7470 else
7471 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7472 for as_dir in $PATH
7473 do
7474   IFS=$as_save_IFS
7475   test -z "$as_dir" && as_dir=.
7476   for ac_exec_ext in '' $ac_executable_extensions; do
7477   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7478     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7479     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7480     break 2
7481   fi
7482 done
7483 done
7484
7485 fi
7486 fi
7487 STRIP=$ac_cv_prog_STRIP
7488 if test -n "$STRIP"; then
7489   echo "$as_me:$LINENO: result: $STRIP" >&5
7490 echo "${ECHO_T}$STRIP" >&6
7491 else
7492   echo "$as_me:$LINENO: result: no" >&5
7493 echo "${ECHO_T}no" >&6
7494 fi
7495
7496   fi
7497   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7498     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7499 set dummy ${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_STRIP+set}" = set; then
7503   echo $ECHO_N "(cached) $ECHO_C" >&6
7504 else
7505   if test -n "$STRIP"; then
7506   ac_cv_prog_STRIP="$STRIP" # 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_STRIP="${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 STRIP=$ac_cv_prog_STRIP
7525 if test -n "$STRIP"; then
7526   echo "$as_me:$LINENO: result: $STRIP" >&5
7527 echo "${ECHO_T}$STRIP" >&6
7528 else
7529   echo "$as_me:$LINENO: result: no" >&5
7530 echo "${ECHO_T}no" >&6
7531 fi
7532
7533   fi
7534   test -n "$ac_cv_prog_STRIP" && break
7535 done
7536
7537 if test -z "$ac_cv_prog_STRIP" ; then
7538   STRIP=":"
7539 fi
7540
7541
7542
7543 if test -n "$WINDRES"; then
7544   ac_cv_prog_WINDRES=$WINDRES
7545 elif test -n "$ac_cv_prog_WINDRES"; then
7546   WINDRES=$ac_cv_prog_WINDRES
7547 fi
7548
7549 if test -n "$ac_cv_prog_WINDRES"; then
7550   for ncn_progname in windres; do
7551     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7552 set dummy ${ncn_progname}; ac_word=$2
7553 echo "$as_me:$LINENO: checking for $ac_word" >&5
7554 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7555 if test "${ac_cv_prog_WINDRES+set}" = set; then
7556   echo $ECHO_N "(cached) $ECHO_C" >&6
7557 else
7558   if test -n "$WINDRES"; then
7559   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7560 else
7561 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7562 for as_dir in $PATH
7563 do
7564   IFS=$as_save_IFS
7565   test -z "$as_dir" && as_dir=.
7566   for ac_exec_ext in '' $ac_executable_extensions; do
7567   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7568     ac_cv_prog_WINDRES="${ncn_progname}"
7569     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7570     break 2
7571   fi
7572 done
7573 done
7574
7575 fi
7576 fi
7577 WINDRES=$ac_cv_prog_WINDRES
7578 if test -n "$WINDRES"; then
7579   echo "$as_me:$LINENO: result: $WINDRES" >&5
7580 echo "${ECHO_T}$WINDRES" >&6
7581 else
7582   echo "$as_me:$LINENO: result: no" >&5
7583 echo "${ECHO_T}no" >&6
7584 fi
7585
7586   done
7587 fi
7588
7589 for ncn_progname in windres; do
7590   if test -n "$ncn_tool_prefix"; then
7591     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7592 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7593 echo "$as_me:$LINENO: checking for $ac_word" >&5
7594 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7595 if test "${ac_cv_prog_WINDRES+set}" = set; then
7596   echo $ECHO_N "(cached) $ECHO_C" >&6
7597 else
7598   if test -n "$WINDRES"; then
7599   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7600 else
7601 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7602 for as_dir in $PATH
7603 do
7604   IFS=$as_save_IFS
7605   test -z "$as_dir" && as_dir=.
7606   for ac_exec_ext in '' $ac_executable_extensions; do
7607   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7608     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7609     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7610     break 2
7611   fi
7612 done
7613 done
7614
7615 fi
7616 fi
7617 WINDRES=$ac_cv_prog_WINDRES
7618 if test -n "$WINDRES"; then
7619   echo "$as_me:$LINENO: result: $WINDRES" >&5
7620 echo "${ECHO_T}$WINDRES" >&6
7621 else
7622   echo "$as_me:$LINENO: result: no" >&5
7623 echo "${ECHO_T}no" >&6
7624 fi
7625
7626   fi
7627   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7628     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7629 set dummy ${ncn_progname}; ac_word=$2
7630 echo "$as_me:$LINENO: checking for $ac_word" >&5
7631 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7632 if test "${ac_cv_prog_WINDRES+set}" = set; then
7633   echo $ECHO_N "(cached) $ECHO_C" >&6
7634 else
7635   if test -n "$WINDRES"; then
7636   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7637 else
7638 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7639 for as_dir in $PATH
7640 do
7641   IFS=$as_save_IFS
7642   test -z "$as_dir" && as_dir=.
7643   for ac_exec_ext in '' $ac_executable_extensions; do
7644   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7645     ac_cv_prog_WINDRES="${ncn_progname}"
7646     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7647     break 2
7648   fi
7649 done
7650 done
7651
7652 fi
7653 fi
7654 WINDRES=$ac_cv_prog_WINDRES
7655 if test -n "$WINDRES"; then
7656   echo "$as_me:$LINENO: result: $WINDRES" >&5
7657 echo "${ECHO_T}$WINDRES" >&6
7658 else
7659   echo "$as_me:$LINENO: result: no" >&5
7660 echo "${ECHO_T}no" >&6
7661 fi
7662
7663   fi
7664   test -n "$ac_cv_prog_WINDRES" && break
7665 done
7666
7667 if test -z "$ac_cv_prog_WINDRES" ; then
7668   set dummy windres
7669   if test $build = $host ; then
7670     WINDRES="$2"
7671   else
7672     WINDRES="${ncn_tool_prefix}$2"
7673   fi
7674 fi
7675
7676
7677
7678 if test -n "$WINDMC"; then
7679   ac_cv_prog_WINDMC=$WINDMC
7680 elif test -n "$ac_cv_prog_WINDMC"; then
7681   WINDMC=$ac_cv_prog_WINDMC
7682 fi
7683
7684 if test -n "$ac_cv_prog_WINDMC"; then
7685   for ncn_progname in windmc; do
7686     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7687 set dummy ${ncn_progname}; ac_word=$2
7688 echo "$as_me:$LINENO: checking for $ac_word" >&5
7689 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7690 if test "${ac_cv_prog_WINDMC+set}" = set; then
7691   echo $ECHO_N "(cached) $ECHO_C" >&6
7692 else
7693   if test -n "$WINDMC"; then
7694   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7695 else
7696 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7697 for as_dir in $PATH
7698 do
7699   IFS=$as_save_IFS
7700   test -z "$as_dir" && as_dir=.
7701   for ac_exec_ext in '' $ac_executable_extensions; do
7702   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7703     ac_cv_prog_WINDMC="${ncn_progname}"
7704     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7705     break 2
7706   fi
7707 done
7708 done
7709
7710 fi
7711 fi
7712 WINDMC=$ac_cv_prog_WINDMC
7713 if test -n "$WINDMC"; then
7714   echo "$as_me:$LINENO: result: $WINDMC" >&5
7715 echo "${ECHO_T}$WINDMC" >&6
7716 else
7717   echo "$as_me:$LINENO: result: no" >&5
7718 echo "${ECHO_T}no" >&6
7719 fi
7720
7721   done
7722 fi
7723
7724 for ncn_progname in windmc; do
7725   if test -n "$ncn_tool_prefix"; then
7726     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7727 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7728 echo "$as_me:$LINENO: checking for $ac_word" >&5
7729 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7730 if test "${ac_cv_prog_WINDMC+set}" = set; then
7731   echo $ECHO_N "(cached) $ECHO_C" >&6
7732 else
7733   if test -n "$WINDMC"; then
7734   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7735 else
7736 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7737 for as_dir in $PATH
7738 do
7739   IFS=$as_save_IFS
7740   test -z "$as_dir" && as_dir=.
7741   for ac_exec_ext in '' $ac_executable_extensions; do
7742   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7743     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7744     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7745     break 2
7746   fi
7747 done
7748 done
7749
7750 fi
7751 fi
7752 WINDMC=$ac_cv_prog_WINDMC
7753 if test -n "$WINDMC"; then
7754   echo "$as_me:$LINENO: result: $WINDMC" >&5
7755 echo "${ECHO_T}$WINDMC" >&6
7756 else
7757   echo "$as_me:$LINENO: result: no" >&5
7758 echo "${ECHO_T}no" >&6
7759 fi
7760
7761   fi
7762   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7763     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7764 set dummy ${ncn_progname}; ac_word=$2
7765 echo "$as_me:$LINENO: checking for $ac_word" >&5
7766 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7767 if test "${ac_cv_prog_WINDMC+set}" = set; then
7768   echo $ECHO_N "(cached) $ECHO_C" >&6
7769 else
7770   if test -n "$WINDMC"; then
7771   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7772 else
7773 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7774 for as_dir in $PATH
7775 do
7776   IFS=$as_save_IFS
7777   test -z "$as_dir" && as_dir=.
7778   for ac_exec_ext in '' $ac_executable_extensions; do
7779   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7780     ac_cv_prog_WINDMC="${ncn_progname}"
7781     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7782     break 2
7783   fi
7784 done
7785 done
7786
7787 fi
7788 fi
7789 WINDMC=$ac_cv_prog_WINDMC
7790 if test -n "$WINDMC"; then
7791   echo "$as_me:$LINENO: result: $WINDMC" >&5
7792 echo "${ECHO_T}$WINDMC" >&6
7793 else
7794   echo "$as_me:$LINENO: result: no" >&5
7795 echo "${ECHO_T}no" >&6
7796 fi
7797
7798   fi
7799   test -n "$ac_cv_prog_WINDMC" && break
7800 done
7801
7802 if test -z "$ac_cv_prog_WINDMC" ; then
7803   set dummy windmc
7804   if test $build = $host ; then
7805     WINDMC="$2"
7806   else
7807     WINDMC="${ncn_tool_prefix}$2"
7808   fi
7809 fi
7810
7811
7812
7813 if test -n "$OBJCOPY"; then
7814   ac_cv_prog_OBJCOPY=$OBJCOPY
7815 elif test -n "$ac_cv_prog_OBJCOPY"; then
7816   OBJCOPY=$ac_cv_prog_OBJCOPY
7817 fi
7818
7819 if test -n "$ac_cv_prog_OBJCOPY"; then
7820   for ncn_progname in objcopy; do
7821     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7822 set dummy ${ncn_progname}; ac_word=$2
7823 echo "$as_me:$LINENO: checking for $ac_word" >&5
7824 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7825 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7826   echo $ECHO_N "(cached) $ECHO_C" >&6
7827 else
7828   if test -n "$OBJCOPY"; then
7829   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7830 else
7831 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7832 for as_dir in $PATH
7833 do
7834   IFS=$as_save_IFS
7835   test -z "$as_dir" && as_dir=.
7836   for ac_exec_ext in '' $ac_executable_extensions; do
7837   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7838     ac_cv_prog_OBJCOPY="${ncn_progname}"
7839     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7840     break 2
7841   fi
7842 done
7843 done
7844
7845 fi
7846 fi
7847 OBJCOPY=$ac_cv_prog_OBJCOPY
7848 if test -n "$OBJCOPY"; then
7849   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7850 echo "${ECHO_T}$OBJCOPY" >&6
7851 else
7852   echo "$as_me:$LINENO: result: no" >&5
7853 echo "${ECHO_T}no" >&6
7854 fi
7855
7856   done
7857 fi
7858
7859 for ncn_progname in objcopy; do
7860   if test -n "$ncn_tool_prefix"; then
7861     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7862 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7863 echo "$as_me:$LINENO: checking for $ac_word" >&5
7864 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7865 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7866   echo $ECHO_N "(cached) $ECHO_C" >&6
7867 else
7868   if test -n "$OBJCOPY"; then
7869   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7870 else
7871 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7872 for as_dir in $PATH
7873 do
7874   IFS=$as_save_IFS
7875   test -z "$as_dir" && as_dir=.
7876   for ac_exec_ext in '' $ac_executable_extensions; do
7877   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7878     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7879     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7880     break 2
7881   fi
7882 done
7883 done
7884
7885 fi
7886 fi
7887 OBJCOPY=$ac_cv_prog_OBJCOPY
7888 if test -n "$OBJCOPY"; then
7889   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7890 echo "${ECHO_T}$OBJCOPY" >&6
7891 else
7892   echo "$as_me:$LINENO: result: no" >&5
7893 echo "${ECHO_T}no" >&6
7894 fi
7895
7896   fi
7897   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7898     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7899 set dummy ${ncn_progname}; ac_word=$2
7900 echo "$as_me:$LINENO: checking for $ac_word" >&5
7901 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7902 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7903   echo $ECHO_N "(cached) $ECHO_C" >&6
7904 else
7905   if test -n "$OBJCOPY"; then
7906   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7907 else
7908 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7909 for as_dir in $PATH
7910 do
7911   IFS=$as_save_IFS
7912   test -z "$as_dir" && as_dir=.
7913   for ac_exec_ext in '' $ac_executable_extensions; do
7914   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7915     ac_cv_prog_OBJCOPY="${ncn_progname}"
7916     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7917     break 2
7918   fi
7919 done
7920 done
7921
7922 fi
7923 fi
7924 OBJCOPY=$ac_cv_prog_OBJCOPY
7925 if test -n "$OBJCOPY"; then
7926   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7927 echo "${ECHO_T}$OBJCOPY" >&6
7928 else
7929   echo "$as_me:$LINENO: result: no" >&5
7930 echo "${ECHO_T}no" >&6
7931 fi
7932
7933   fi
7934   test -n "$ac_cv_prog_OBJCOPY" && break
7935 done
7936
7937 if test -z "$ac_cv_prog_OBJCOPY" ; then
7938   set dummy objcopy
7939   if test $build = $host ; then
7940     OBJCOPY="$2"
7941   else
7942     OBJCOPY="${ncn_tool_prefix}$2"
7943   fi
7944 fi
7945
7946
7947
7948 if test -n "$OBJDUMP"; then
7949   ac_cv_prog_OBJDUMP=$OBJDUMP
7950 elif test -n "$ac_cv_prog_OBJDUMP"; then
7951   OBJDUMP=$ac_cv_prog_OBJDUMP
7952 fi
7953
7954 if test -n "$ac_cv_prog_OBJDUMP"; then
7955   for ncn_progname in objdump; do
7956     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7957 set dummy ${ncn_progname}; ac_word=$2
7958 echo "$as_me:$LINENO: checking for $ac_word" >&5
7959 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7960 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7961   echo $ECHO_N "(cached) $ECHO_C" >&6
7962 else
7963   if test -n "$OBJDUMP"; then
7964   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7965 else
7966 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7967 for as_dir in $PATH
7968 do
7969   IFS=$as_save_IFS
7970   test -z "$as_dir" && as_dir=.
7971   for ac_exec_ext in '' $ac_executable_extensions; do
7972   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7973     ac_cv_prog_OBJDUMP="${ncn_progname}"
7974     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7975     break 2
7976   fi
7977 done
7978 done
7979
7980 fi
7981 fi
7982 OBJDUMP=$ac_cv_prog_OBJDUMP
7983 if test -n "$OBJDUMP"; then
7984   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7985 echo "${ECHO_T}$OBJDUMP" >&6
7986 else
7987   echo "$as_me:$LINENO: result: no" >&5
7988 echo "${ECHO_T}no" >&6
7989 fi
7990
7991   done
7992 fi
7993
7994 for ncn_progname in objdump; do
7995   if test -n "$ncn_tool_prefix"; then
7996     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7997 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7998 echo "$as_me:$LINENO: checking for $ac_word" >&5
7999 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8000 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8001   echo $ECHO_N "(cached) $ECHO_C" >&6
8002 else
8003   if test -n "$OBJDUMP"; then
8004   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8005 else
8006 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8007 for as_dir in $PATH
8008 do
8009   IFS=$as_save_IFS
8010   test -z "$as_dir" && as_dir=.
8011   for ac_exec_ext in '' $ac_executable_extensions; do
8012   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8013     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8014     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8015     break 2
8016   fi
8017 done
8018 done
8019
8020 fi
8021 fi
8022 OBJDUMP=$ac_cv_prog_OBJDUMP
8023 if test -n "$OBJDUMP"; then
8024   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8025 echo "${ECHO_T}$OBJDUMP" >&6
8026 else
8027   echo "$as_me:$LINENO: result: no" >&5
8028 echo "${ECHO_T}no" >&6
8029 fi
8030
8031   fi
8032   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8033     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8034 set dummy ${ncn_progname}; ac_word=$2
8035 echo "$as_me:$LINENO: checking for $ac_word" >&5
8036 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8037 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8038   echo $ECHO_N "(cached) $ECHO_C" >&6
8039 else
8040   if test -n "$OBJDUMP"; then
8041   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8042 else
8043 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8044 for as_dir in $PATH
8045 do
8046   IFS=$as_save_IFS
8047   test -z "$as_dir" && as_dir=.
8048   for ac_exec_ext in '' $ac_executable_extensions; do
8049   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8050     ac_cv_prog_OBJDUMP="${ncn_progname}"
8051     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8052     break 2
8053   fi
8054 done
8055 done
8056
8057 fi
8058 fi
8059 OBJDUMP=$ac_cv_prog_OBJDUMP
8060 if test -n "$OBJDUMP"; then
8061   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8062 echo "${ECHO_T}$OBJDUMP" >&6
8063 else
8064   echo "$as_me:$LINENO: result: no" >&5
8065 echo "${ECHO_T}no" >&6
8066 fi
8067
8068   fi
8069   test -n "$ac_cv_prog_OBJDUMP" && break
8070 done
8071
8072 if test -z "$ac_cv_prog_OBJDUMP" ; then
8073   set dummy objdump
8074   if test $build = $host ; then
8075     OBJDUMP="$2"
8076   else
8077     OBJDUMP="${ncn_tool_prefix}$2"
8078   fi
8079 fi
8080
8081
8082
8083
8084
8085
8086 # Target tools.
8087
8088 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8089 if test "${with_build_time_tools+set}" = set; then
8090   withval="$with_build_time_tools"
8091   case x"$withval" in
8092      x/*) ;;
8093      *)
8094        with_build_time_tools=
8095        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8096 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8097        ;;
8098    esac
8099 else
8100   with_build_time_tools=
8101 fi;
8102
8103
8104
8105 if test -n "$CC_FOR_TARGET"; then
8106   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8107 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8108   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8109 fi
8110
8111 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8112   for ncn_progname in cc gcc; do
8113     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8114 set dummy ${ncn_progname}; ac_word=$2
8115 echo "$as_me:$LINENO: checking for $ac_word" >&5
8116 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8117 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8118   echo $ECHO_N "(cached) $ECHO_C" >&6
8119 else
8120   if test -n "$CC_FOR_TARGET"; then
8121   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8122 else
8123 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8124 for as_dir in $PATH
8125 do
8126   IFS=$as_save_IFS
8127   test -z "$as_dir" && as_dir=.
8128   for ac_exec_ext in '' $ac_executable_extensions; do
8129   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8130     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8131     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8132     break 2
8133   fi
8134 done
8135 done
8136
8137 fi
8138 fi
8139 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8140 if test -n "$CC_FOR_TARGET"; then
8141   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8142 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8143 else
8144   echo "$as_me:$LINENO: result: no" >&5
8145 echo "${ECHO_T}no" >&6
8146 fi
8147
8148   done
8149 fi
8150
8151 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8152   for ncn_progname in cc gcc; do
8153     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8154 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8155     if test -x $with_build_time_tools/${ncn_progname}; then
8156       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8157       echo "$as_me:$LINENO: result: yes" >&5
8158 echo "${ECHO_T}yes" >&6
8159       break
8160     else
8161       echo "$as_me:$LINENO: result: no" >&5
8162 echo "${ECHO_T}no" >&6
8163     fi
8164   done
8165 fi
8166
8167 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8168   for ncn_progname in cc gcc; do
8169     if test -n "$ncn_target_tool_prefix"; then
8170       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8171 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8172 echo "$as_me:$LINENO: checking for $ac_word" >&5
8173 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8174 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8175   echo $ECHO_N "(cached) $ECHO_C" >&6
8176 else
8177   if test -n "$CC_FOR_TARGET"; then
8178   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8179 else
8180 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8181 for as_dir in $PATH
8182 do
8183   IFS=$as_save_IFS
8184   test -z "$as_dir" && as_dir=.
8185   for ac_exec_ext in '' $ac_executable_extensions; do
8186   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8187     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8188     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8189     break 2
8190   fi
8191 done
8192 done
8193
8194 fi
8195 fi
8196 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8197 if test -n "$CC_FOR_TARGET"; then
8198   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8199 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8200 else
8201   echo "$as_me:$LINENO: result: no" >&5
8202 echo "${ECHO_T}no" >&6
8203 fi
8204
8205     fi
8206     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8207       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8208 set dummy ${ncn_progname}; ac_word=$2
8209 echo "$as_me:$LINENO: checking for $ac_word" >&5
8210 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8211 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8212   echo $ECHO_N "(cached) $ECHO_C" >&6
8213 else
8214   if test -n "$CC_FOR_TARGET"; then
8215   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8216 else
8217 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8218 for as_dir in $PATH
8219 do
8220   IFS=$as_save_IFS
8221   test -z "$as_dir" && as_dir=.
8222   for ac_exec_ext in '' $ac_executable_extensions; do
8223   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8224     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8225     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8226     break 2
8227   fi
8228 done
8229 done
8230
8231 fi
8232 fi
8233 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8234 if test -n "$CC_FOR_TARGET"; then
8235   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8236 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8237 else
8238   echo "$as_me:$LINENO: result: no" >&5
8239 echo "${ECHO_T}no" >&6
8240 fi
8241
8242     fi
8243     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8244   done
8245 fi
8246
8247 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8248   set dummy cc gcc
8249   if test $build = $target ; then
8250     CC_FOR_TARGET="$2"
8251   else
8252     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8253   fi
8254 else
8255   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8256 fi
8257
8258
8259
8260 if test -n "$CXX_FOR_TARGET"; then
8261   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8262 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8263   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8264 fi
8265
8266 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8267   for ncn_progname in c++ g++ cxx gxx; do
8268     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8269 set dummy ${ncn_progname}; ac_word=$2
8270 echo "$as_me:$LINENO: checking for $ac_word" >&5
8271 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8272 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8273   echo $ECHO_N "(cached) $ECHO_C" >&6
8274 else
8275   if test -n "$CXX_FOR_TARGET"; then
8276   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8277 else
8278 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8279 for as_dir in $PATH
8280 do
8281   IFS=$as_save_IFS
8282   test -z "$as_dir" && as_dir=.
8283   for ac_exec_ext in '' $ac_executable_extensions; do
8284   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8285     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8286     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8287     break 2
8288   fi
8289 done
8290 done
8291
8292 fi
8293 fi
8294 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8295 if test -n "$CXX_FOR_TARGET"; then
8296   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8297 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8298 else
8299   echo "$as_me:$LINENO: result: no" >&5
8300 echo "${ECHO_T}no" >&6
8301 fi
8302
8303   done
8304 fi
8305
8306 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8307   for ncn_progname in c++ g++ cxx gxx; do
8308     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8309 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8310     if test -x $with_build_time_tools/${ncn_progname}; then
8311       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8312       echo "$as_me:$LINENO: result: yes" >&5
8313 echo "${ECHO_T}yes" >&6
8314       break
8315     else
8316       echo "$as_me:$LINENO: result: no" >&5
8317 echo "${ECHO_T}no" >&6
8318     fi
8319   done
8320 fi
8321
8322 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8323   for ncn_progname in c++ g++ cxx gxx; do
8324     if test -n "$ncn_target_tool_prefix"; then
8325       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8326 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8327 echo "$as_me:$LINENO: checking for $ac_word" >&5
8328 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8329 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8330   echo $ECHO_N "(cached) $ECHO_C" >&6
8331 else
8332   if test -n "$CXX_FOR_TARGET"; then
8333   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8334 else
8335 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8336 for as_dir in $PATH
8337 do
8338   IFS=$as_save_IFS
8339   test -z "$as_dir" && as_dir=.
8340   for ac_exec_ext in '' $ac_executable_extensions; do
8341   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8342     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8343     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8344     break 2
8345   fi
8346 done
8347 done
8348
8349 fi
8350 fi
8351 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8352 if test -n "$CXX_FOR_TARGET"; then
8353   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8354 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8355 else
8356   echo "$as_me:$LINENO: result: no" >&5
8357 echo "${ECHO_T}no" >&6
8358 fi
8359
8360     fi
8361     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8362       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8363 set dummy ${ncn_progname}; ac_word=$2
8364 echo "$as_me:$LINENO: checking for $ac_word" >&5
8365 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8366 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8367   echo $ECHO_N "(cached) $ECHO_C" >&6
8368 else
8369   if test -n "$CXX_FOR_TARGET"; then
8370   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8371 else
8372 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8373 for as_dir in $PATH
8374 do
8375   IFS=$as_save_IFS
8376   test -z "$as_dir" && as_dir=.
8377   for ac_exec_ext in '' $ac_executable_extensions; do
8378   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8379     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8380     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8381     break 2
8382   fi
8383 done
8384 done
8385
8386 fi
8387 fi
8388 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8389 if test -n "$CXX_FOR_TARGET"; then
8390   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8391 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8392 else
8393   echo "$as_me:$LINENO: result: no" >&5
8394 echo "${ECHO_T}no" >&6
8395 fi
8396
8397     fi
8398     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8399   done
8400 fi
8401
8402 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8403   set dummy c++ g++ cxx gxx
8404   if test $build = $target ; then
8405     CXX_FOR_TARGET="$2"
8406   else
8407     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8408   fi
8409 else
8410   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8411 fi
8412
8413
8414
8415 if test -n "$GCC_FOR_TARGET"; then
8416   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8417 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8418   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8419 fi
8420
8421 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8422   for ncn_progname in gcc; do
8423     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8424 set dummy ${ncn_progname}; ac_word=$2
8425 echo "$as_me:$LINENO: checking for $ac_word" >&5
8426 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8427 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8428   echo $ECHO_N "(cached) $ECHO_C" >&6
8429 else
8430   if test -n "$GCC_FOR_TARGET"; then
8431   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8432 else
8433 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8434 for as_dir in $PATH
8435 do
8436   IFS=$as_save_IFS
8437   test -z "$as_dir" && as_dir=.
8438   for ac_exec_ext in '' $ac_executable_extensions; do
8439   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8440     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8441     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8442     break 2
8443   fi
8444 done
8445 done
8446
8447 fi
8448 fi
8449 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8450 if test -n "$GCC_FOR_TARGET"; then
8451   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8452 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8453 else
8454   echo "$as_me:$LINENO: result: no" >&5
8455 echo "${ECHO_T}no" >&6
8456 fi
8457
8458   done
8459 fi
8460
8461 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8462   for ncn_progname in gcc; do
8463     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8464 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8465     if test -x $with_build_time_tools/${ncn_progname}; then
8466       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8467       echo "$as_me:$LINENO: result: yes" >&5
8468 echo "${ECHO_T}yes" >&6
8469       break
8470     else
8471       echo "$as_me:$LINENO: result: no" >&5
8472 echo "${ECHO_T}no" >&6
8473     fi
8474   done
8475 fi
8476
8477 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8478   for ncn_progname in gcc; do
8479     if test -n "$ncn_target_tool_prefix"; then
8480       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8481 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8482 echo "$as_me:$LINENO: checking for $ac_word" >&5
8483 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8484 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8485   echo $ECHO_N "(cached) $ECHO_C" >&6
8486 else
8487   if test -n "$GCC_FOR_TARGET"; then
8488   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8489 else
8490 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8491 for as_dir in $PATH
8492 do
8493   IFS=$as_save_IFS
8494   test -z "$as_dir" && as_dir=.
8495   for ac_exec_ext in '' $ac_executable_extensions; do
8496   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8497     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8498     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8499     break 2
8500   fi
8501 done
8502 done
8503
8504 fi
8505 fi
8506 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8507 if test -n "$GCC_FOR_TARGET"; then
8508   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8509 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8510 else
8511   echo "$as_me:$LINENO: result: no" >&5
8512 echo "${ECHO_T}no" >&6
8513 fi
8514
8515     fi
8516     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8517       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8518 set dummy ${ncn_progname}; ac_word=$2
8519 echo "$as_me:$LINENO: checking for $ac_word" >&5
8520 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8521 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8522   echo $ECHO_N "(cached) $ECHO_C" >&6
8523 else
8524   if test -n "$GCC_FOR_TARGET"; then
8525   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8526 else
8527 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8528 for as_dir in $PATH
8529 do
8530   IFS=$as_save_IFS
8531   test -z "$as_dir" && as_dir=.
8532   for ac_exec_ext in '' $ac_executable_extensions; do
8533   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8534     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8535     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8536     break 2
8537   fi
8538 done
8539 done
8540
8541 fi
8542 fi
8543 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8544 if test -n "$GCC_FOR_TARGET"; then
8545   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8546 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8547 else
8548   echo "$as_me:$LINENO: result: no" >&5
8549 echo "${ECHO_T}no" >&6
8550 fi
8551
8552     fi
8553     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8554   done
8555 fi
8556
8557 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8558   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8559 else
8560   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8561 fi
8562
8563
8564
8565 if test -n "$GCJ_FOR_TARGET"; then
8566   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8567 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8568   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8569 fi
8570
8571 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8572   for ncn_progname in gcj; do
8573     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8574 set dummy ${ncn_progname}; ac_word=$2
8575 echo "$as_me:$LINENO: checking for $ac_word" >&5
8576 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8577 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8578   echo $ECHO_N "(cached) $ECHO_C" >&6
8579 else
8580   if test -n "$GCJ_FOR_TARGET"; then
8581   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8582 else
8583 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8584 for as_dir in $PATH
8585 do
8586   IFS=$as_save_IFS
8587   test -z "$as_dir" && as_dir=.
8588   for ac_exec_ext in '' $ac_executable_extensions; do
8589   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8590     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8591     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8592     break 2
8593   fi
8594 done
8595 done
8596
8597 fi
8598 fi
8599 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8600 if test -n "$GCJ_FOR_TARGET"; then
8601   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8602 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8603 else
8604   echo "$as_me:$LINENO: result: no" >&5
8605 echo "${ECHO_T}no" >&6
8606 fi
8607
8608   done
8609 fi
8610
8611 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8612   for ncn_progname in gcj; do
8613     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8614 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8615     if test -x $with_build_time_tools/${ncn_progname}; then
8616       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8617       echo "$as_me:$LINENO: result: yes" >&5
8618 echo "${ECHO_T}yes" >&6
8619       break
8620     else
8621       echo "$as_me:$LINENO: result: no" >&5
8622 echo "${ECHO_T}no" >&6
8623     fi
8624   done
8625 fi
8626
8627 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8628   for ncn_progname in gcj; do
8629     if test -n "$ncn_target_tool_prefix"; then
8630       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8631 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8632 echo "$as_me:$LINENO: checking for $ac_word" >&5
8633 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8634 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8635   echo $ECHO_N "(cached) $ECHO_C" >&6
8636 else
8637   if test -n "$GCJ_FOR_TARGET"; then
8638   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8639 else
8640 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8641 for as_dir in $PATH
8642 do
8643   IFS=$as_save_IFS
8644   test -z "$as_dir" && as_dir=.
8645   for ac_exec_ext in '' $ac_executable_extensions; do
8646   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8647     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8648     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8649     break 2
8650   fi
8651 done
8652 done
8653
8654 fi
8655 fi
8656 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8657 if test -n "$GCJ_FOR_TARGET"; then
8658   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8659 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8660 else
8661   echo "$as_me:$LINENO: result: no" >&5
8662 echo "${ECHO_T}no" >&6
8663 fi
8664
8665     fi
8666     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8667       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8668 set dummy ${ncn_progname}; ac_word=$2
8669 echo "$as_me:$LINENO: checking for $ac_word" >&5
8670 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8671 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8672   echo $ECHO_N "(cached) $ECHO_C" >&6
8673 else
8674   if test -n "$GCJ_FOR_TARGET"; then
8675   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8676 else
8677 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8678 for as_dir in $PATH
8679 do
8680   IFS=$as_save_IFS
8681   test -z "$as_dir" && as_dir=.
8682   for ac_exec_ext in '' $ac_executable_extensions; do
8683   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8684     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8685     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8686     break 2
8687   fi
8688 done
8689 done
8690
8691 fi
8692 fi
8693 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8694 if test -n "$GCJ_FOR_TARGET"; then
8695   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8696 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8697 else
8698   echo "$as_me:$LINENO: result: no" >&5
8699 echo "${ECHO_T}no" >&6
8700 fi
8701
8702     fi
8703     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8704   done
8705 fi
8706
8707 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8708   set dummy gcj
8709   if test $build = $target ; then
8710     GCJ_FOR_TARGET="$2"
8711   else
8712     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8713   fi
8714 else
8715   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8716 fi
8717
8718
8719
8720 if test -n "$GFORTRAN_FOR_TARGET"; then
8721   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8722 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8723   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8724 fi
8725
8726 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8727   for ncn_progname in gfortran; do
8728     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8729 set dummy ${ncn_progname}; ac_word=$2
8730 echo "$as_me:$LINENO: checking for $ac_word" >&5
8731 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8732 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8733   echo $ECHO_N "(cached) $ECHO_C" >&6
8734 else
8735   if test -n "$GFORTRAN_FOR_TARGET"; then
8736   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8737 else
8738 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8739 for as_dir in $PATH
8740 do
8741   IFS=$as_save_IFS
8742   test -z "$as_dir" && as_dir=.
8743   for ac_exec_ext in '' $ac_executable_extensions; do
8744   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8745     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8746     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8747     break 2
8748   fi
8749 done
8750 done
8751
8752 fi
8753 fi
8754 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8755 if test -n "$GFORTRAN_FOR_TARGET"; then
8756   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8757 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8758 else
8759   echo "$as_me:$LINENO: result: no" >&5
8760 echo "${ECHO_T}no" >&6
8761 fi
8762
8763   done
8764 fi
8765
8766 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8767   for ncn_progname in gfortran; do
8768     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8769 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8770     if test -x $with_build_time_tools/${ncn_progname}; then
8771       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8772       echo "$as_me:$LINENO: result: yes" >&5
8773 echo "${ECHO_T}yes" >&6
8774       break
8775     else
8776       echo "$as_me:$LINENO: result: no" >&5
8777 echo "${ECHO_T}no" >&6
8778     fi
8779   done
8780 fi
8781
8782 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8783   for ncn_progname in gfortran; do
8784     if test -n "$ncn_target_tool_prefix"; then
8785       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8786 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8787 echo "$as_me:$LINENO: checking for $ac_word" >&5
8788 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8789 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8790   echo $ECHO_N "(cached) $ECHO_C" >&6
8791 else
8792   if test -n "$GFORTRAN_FOR_TARGET"; then
8793   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8794 else
8795 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8796 for as_dir in $PATH
8797 do
8798   IFS=$as_save_IFS
8799   test -z "$as_dir" && as_dir=.
8800   for ac_exec_ext in '' $ac_executable_extensions; do
8801   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8802     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8803     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8804     break 2
8805   fi
8806 done
8807 done
8808
8809 fi
8810 fi
8811 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8812 if test -n "$GFORTRAN_FOR_TARGET"; then
8813   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8814 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8815 else
8816   echo "$as_me:$LINENO: result: no" >&5
8817 echo "${ECHO_T}no" >&6
8818 fi
8819
8820     fi
8821     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8822       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8823 set dummy ${ncn_progname}; ac_word=$2
8824 echo "$as_me:$LINENO: checking for $ac_word" >&5
8825 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8826 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8827   echo $ECHO_N "(cached) $ECHO_C" >&6
8828 else
8829   if test -n "$GFORTRAN_FOR_TARGET"; then
8830   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8831 else
8832 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8833 for as_dir in $PATH
8834 do
8835   IFS=$as_save_IFS
8836   test -z "$as_dir" && as_dir=.
8837   for ac_exec_ext in '' $ac_executable_extensions; do
8838   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8839     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8840     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8841     break 2
8842   fi
8843 done
8844 done
8845
8846 fi
8847 fi
8848 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8849 if test -n "$GFORTRAN_FOR_TARGET"; then
8850   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8851 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8852 else
8853   echo "$as_me:$LINENO: result: no" >&5
8854 echo "${ECHO_T}no" >&6
8855 fi
8856
8857     fi
8858     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8859   done
8860 fi
8861
8862 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8863   set dummy gfortran
8864   if test $build = $target ; then
8865     GFORTRAN_FOR_TARGET="$2"
8866   else
8867     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8868   fi
8869 else
8870   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8871 fi
8872
8873
8874
8875 cat > conftest.c << \EOF
8876 #ifdef __GNUC__
8877   gcc_yay;
8878 #endif
8879 EOF
8880 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8881   have_gcc_for_target=yes
8882 else
8883   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8884   have_gcc_for_target=no
8885 fi
8886 rm conftest.c
8887
8888
8889
8890
8891 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8892   if test -n "$with_build_time_tools"; then
8893     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8894 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8895     if test -x $with_build_time_tools/ar; then
8896       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8897       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8898       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8899 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8900     else
8901       echo "$as_me:$LINENO: result: no" >&5
8902 echo "${ECHO_T}no" >&6
8903     fi
8904   elif test $build != $host && test $have_gcc_for_target = yes; then
8905     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8906     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8907     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8908   fi
8909 fi
8910 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8911   # Extract the first word of "ar", so it can be a program name with args.
8912 set dummy ar; ac_word=$2
8913 echo "$as_me:$LINENO: checking for $ac_word" >&5
8914 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8915 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8916   echo $ECHO_N "(cached) $ECHO_C" >&6
8917 else
8918   case $AR_FOR_TARGET in
8919   [\\/]* | ?:[\\/]*)
8920   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8921   ;;
8922   *)
8923   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8924 for as_dir in $gcc_cv_tool_dirs
8925 do
8926   IFS=$as_save_IFS
8927   test -z "$as_dir" && as_dir=.
8928   for ac_exec_ext in '' $ac_executable_extensions; do
8929   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8930     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8931     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8932     break 2
8933   fi
8934 done
8935 done
8936
8937   ;;
8938 esac
8939 fi
8940 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8941
8942 if test -n "$AR_FOR_TARGET"; then
8943   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8944 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8945 else
8946   echo "$as_me:$LINENO: result: no" >&5
8947 echo "${ECHO_T}no" >&6
8948 fi
8949
8950 fi
8951 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8952
8953
8954 if test -n "$AR_FOR_TARGET"; then
8955   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8956 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8957   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8958 fi
8959
8960 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8961   for ncn_progname in ar; do
8962     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8963 set dummy ${ncn_progname}; ac_word=$2
8964 echo "$as_me:$LINENO: checking for $ac_word" >&5
8965 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8966 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8967   echo $ECHO_N "(cached) $ECHO_C" >&6
8968 else
8969   if test -n "$AR_FOR_TARGET"; then
8970   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8971 else
8972 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8973 for as_dir in $PATH
8974 do
8975   IFS=$as_save_IFS
8976   test -z "$as_dir" && as_dir=.
8977   for ac_exec_ext in '' $ac_executable_extensions; do
8978   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8979     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8980     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8981     break 2
8982   fi
8983 done
8984 done
8985
8986 fi
8987 fi
8988 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8989 if test -n "$AR_FOR_TARGET"; then
8990   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8991 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8992 else
8993   echo "$as_me:$LINENO: result: no" >&5
8994 echo "${ECHO_T}no" >&6
8995 fi
8996
8997   done
8998 fi
8999
9000 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
9001   for ncn_progname in ar; do
9002     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9003 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9004     if test -x $with_build_time_tools/${ncn_progname}; then
9005       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9006       echo "$as_me:$LINENO: result: yes" >&5
9007 echo "${ECHO_T}yes" >&6
9008       break
9009     else
9010       echo "$as_me:$LINENO: result: no" >&5
9011 echo "${ECHO_T}no" >&6
9012     fi
9013   done
9014 fi
9015
9016 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9017   for ncn_progname in ar; do
9018     if test -n "$ncn_target_tool_prefix"; then
9019       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9020 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9021 echo "$as_me:$LINENO: checking for $ac_word" >&5
9022 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9023 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9024   echo $ECHO_N "(cached) $ECHO_C" >&6
9025 else
9026   if test -n "$AR_FOR_TARGET"; then
9027   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9028 else
9029 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9030 for as_dir in $PATH
9031 do
9032   IFS=$as_save_IFS
9033   test -z "$as_dir" && as_dir=.
9034   for ac_exec_ext in '' $ac_executable_extensions; do
9035   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9036     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9037     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9038     break 2
9039   fi
9040 done
9041 done
9042
9043 fi
9044 fi
9045 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9046 if test -n "$AR_FOR_TARGET"; then
9047   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9048 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9049 else
9050   echo "$as_me:$LINENO: result: no" >&5
9051 echo "${ECHO_T}no" >&6
9052 fi
9053
9054     fi
9055     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9056       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9057 set dummy ${ncn_progname}; ac_word=$2
9058 echo "$as_me:$LINENO: checking for $ac_word" >&5
9059 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9060 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9061   echo $ECHO_N "(cached) $ECHO_C" >&6
9062 else
9063   if test -n "$AR_FOR_TARGET"; then
9064   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9065 else
9066 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9067 for as_dir in $PATH
9068 do
9069   IFS=$as_save_IFS
9070   test -z "$as_dir" && as_dir=.
9071   for ac_exec_ext in '' $ac_executable_extensions; do
9072   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9073     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9074     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9075     break 2
9076   fi
9077 done
9078 done
9079
9080 fi
9081 fi
9082 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9083 if test -n "$AR_FOR_TARGET"; then
9084   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9085 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9086 else
9087   echo "$as_me:$LINENO: result: no" >&5
9088 echo "${ECHO_T}no" >&6
9089 fi
9090
9091     fi
9092     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9093   done
9094 fi
9095
9096 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9097   set dummy ar
9098   if test $build = $target ; then
9099     AR_FOR_TARGET="$2"
9100   else
9101     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9102   fi
9103 else
9104   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9105 fi
9106
9107 else
9108   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9109 fi
9110
9111
9112
9113
9114 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9115   if test -n "$with_build_time_tools"; then
9116     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9117 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9118     if test -x $with_build_time_tools/as; then
9119       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9120       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9121       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9122 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9123     else
9124       echo "$as_me:$LINENO: result: no" >&5
9125 echo "${ECHO_T}no" >&6
9126     fi
9127   elif test $build != $host && test $have_gcc_for_target = yes; then
9128     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9129     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9130     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9131   fi
9132 fi
9133 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9134   # Extract the first word of "as", so it can be a program name with args.
9135 set dummy as; ac_word=$2
9136 echo "$as_me:$LINENO: checking for $ac_word" >&5
9137 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9138 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9139   echo $ECHO_N "(cached) $ECHO_C" >&6
9140 else
9141   case $AS_FOR_TARGET in
9142   [\\/]* | ?:[\\/]*)
9143   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9144   ;;
9145   *)
9146   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9147 for as_dir in $gcc_cv_tool_dirs
9148 do
9149   IFS=$as_save_IFS
9150   test -z "$as_dir" && as_dir=.
9151   for ac_exec_ext in '' $ac_executable_extensions; do
9152   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9153     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9154     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9155     break 2
9156   fi
9157 done
9158 done
9159
9160   ;;
9161 esac
9162 fi
9163 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9164
9165 if test -n "$AS_FOR_TARGET"; then
9166   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9167 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9168 else
9169   echo "$as_me:$LINENO: result: no" >&5
9170 echo "${ECHO_T}no" >&6
9171 fi
9172
9173 fi
9174 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9175
9176
9177 if test -n "$AS_FOR_TARGET"; then
9178   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9179 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9180   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9181 fi
9182
9183 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9184   for ncn_progname in as; do
9185     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9186 set dummy ${ncn_progname}; ac_word=$2
9187 echo "$as_me:$LINENO: checking for $ac_word" >&5
9188 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9189 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9190   echo $ECHO_N "(cached) $ECHO_C" >&6
9191 else
9192   if test -n "$AS_FOR_TARGET"; then
9193   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9194 else
9195 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9196 for as_dir in $PATH
9197 do
9198   IFS=$as_save_IFS
9199   test -z "$as_dir" && as_dir=.
9200   for ac_exec_ext in '' $ac_executable_extensions; do
9201   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9202     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9203     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9204     break 2
9205   fi
9206 done
9207 done
9208
9209 fi
9210 fi
9211 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9212 if test -n "$AS_FOR_TARGET"; then
9213   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9214 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9215 else
9216   echo "$as_me:$LINENO: result: no" >&5
9217 echo "${ECHO_T}no" >&6
9218 fi
9219
9220   done
9221 fi
9222
9223 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9224   for ncn_progname in as; do
9225     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9226 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9227     if test -x $with_build_time_tools/${ncn_progname}; then
9228       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9229       echo "$as_me:$LINENO: result: yes" >&5
9230 echo "${ECHO_T}yes" >&6
9231       break
9232     else
9233       echo "$as_me:$LINENO: result: no" >&5
9234 echo "${ECHO_T}no" >&6
9235     fi
9236   done
9237 fi
9238
9239 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9240   for ncn_progname in as; do
9241     if test -n "$ncn_target_tool_prefix"; then
9242       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9243 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9244 echo "$as_me:$LINENO: checking for $ac_word" >&5
9245 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9246 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9247   echo $ECHO_N "(cached) $ECHO_C" >&6
9248 else
9249   if test -n "$AS_FOR_TARGET"; then
9250   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9251 else
9252 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9253 for as_dir in $PATH
9254 do
9255   IFS=$as_save_IFS
9256   test -z "$as_dir" && as_dir=.
9257   for ac_exec_ext in '' $ac_executable_extensions; do
9258   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9259     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9260     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9261     break 2
9262   fi
9263 done
9264 done
9265
9266 fi
9267 fi
9268 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9269 if test -n "$AS_FOR_TARGET"; then
9270   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9271 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9272 else
9273   echo "$as_me:$LINENO: result: no" >&5
9274 echo "${ECHO_T}no" >&6
9275 fi
9276
9277     fi
9278     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9279       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9280 set dummy ${ncn_progname}; ac_word=$2
9281 echo "$as_me:$LINENO: checking for $ac_word" >&5
9282 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9283 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9284   echo $ECHO_N "(cached) $ECHO_C" >&6
9285 else
9286   if test -n "$AS_FOR_TARGET"; then
9287   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9288 else
9289 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9290 for as_dir in $PATH
9291 do
9292   IFS=$as_save_IFS
9293   test -z "$as_dir" && as_dir=.
9294   for ac_exec_ext in '' $ac_executable_extensions; do
9295   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9296     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9297     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9298     break 2
9299   fi
9300 done
9301 done
9302
9303 fi
9304 fi
9305 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9306 if test -n "$AS_FOR_TARGET"; then
9307   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9308 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9309 else
9310   echo "$as_me:$LINENO: result: no" >&5
9311 echo "${ECHO_T}no" >&6
9312 fi
9313
9314     fi
9315     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9316   done
9317 fi
9318
9319 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9320   set dummy as
9321   if test $build = $target ; then
9322     AS_FOR_TARGET="$2"
9323   else
9324     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9325   fi
9326 else
9327   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9328 fi
9329
9330 else
9331   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9332 fi
9333
9334
9335
9336
9337 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9338   if test -n "$with_build_time_tools"; then
9339     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9340 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9341     if test -x $with_build_time_tools/dlltool; then
9342       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9343       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9344       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9345 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9346     else
9347       echo "$as_me:$LINENO: result: no" >&5
9348 echo "${ECHO_T}no" >&6
9349     fi
9350   elif test $build != $host && test $have_gcc_for_target = yes; then
9351     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9352     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9353     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9354   fi
9355 fi
9356 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9357   # Extract the first word of "dlltool", so it can be a program name with args.
9358 set dummy dlltool; ac_word=$2
9359 echo "$as_me:$LINENO: checking for $ac_word" >&5
9360 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9361 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9362   echo $ECHO_N "(cached) $ECHO_C" >&6
9363 else
9364   case $DLLTOOL_FOR_TARGET in
9365   [\\/]* | ?:[\\/]*)
9366   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9367   ;;
9368   *)
9369   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9370 for as_dir in $gcc_cv_tool_dirs
9371 do
9372   IFS=$as_save_IFS
9373   test -z "$as_dir" && as_dir=.
9374   for ac_exec_ext in '' $ac_executable_extensions; do
9375   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9376     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9377     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9378     break 2
9379   fi
9380 done
9381 done
9382
9383   ;;
9384 esac
9385 fi
9386 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9387
9388 if test -n "$DLLTOOL_FOR_TARGET"; then
9389   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9390 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9391 else
9392   echo "$as_me:$LINENO: result: no" >&5
9393 echo "${ECHO_T}no" >&6
9394 fi
9395
9396 fi
9397 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9398
9399
9400 if test -n "$DLLTOOL_FOR_TARGET"; then
9401   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9402 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9403   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9404 fi
9405
9406 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9407   for ncn_progname in dlltool; do
9408     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9409 set dummy ${ncn_progname}; ac_word=$2
9410 echo "$as_me:$LINENO: checking for $ac_word" >&5
9411 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9412 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9413   echo $ECHO_N "(cached) $ECHO_C" >&6
9414 else
9415   if test -n "$DLLTOOL_FOR_TARGET"; then
9416   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9417 else
9418 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9419 for as_dir in $PATH
9420 do
9421   IFS=$as_save_IFS
9422   test -z "$as_dir" && as_dir=.
9423   for ac_exec_ext in '' $ac_executable_extensions; do
9424   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9425     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9426     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9427     break 2
9428   fi
9429 done
9430 done
9431
9432 fi
9433 fi
9434 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9435 if test -n "$DLLTOOL_FOR_TARGET"; then
9436   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9437 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9438 else
9439   echo "$as_me:$LINENO: result: no" >&5
9440 echo "${ECHO_T}no" >&6
9441 fi
9442
9443   done
9444 fi
9445
9446 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9447   for ncn_progname in dlltool; do
9448     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9449 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9450     if test -x $with_build_time_tools/${ncn_progname}; then
9451       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9452       echo "$as_me:$LINENO: result: yes" >&5
9453 echo "${ECHO_T}yes" >&6
9454       break
9455     else
9456       echo "$as_me:$LINENO: result: no" >&5
9457 echo "${ECHO_T}no" >&6
9458     fi
9459   done
9460 fi
9461
9462 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9463   for ncn_progname in dlltool; do
9464     if test -n "$ncn_target_tool_prefix"; then
9465       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9466 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9467 echo "$as_me:$LINENO: checking for $ac_word" >&5
9468 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9469 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9470   echo $ECHO_N "(cached) $ECHO_C" >&6
9471 else
9472   if test -n "$DLLTOOL_FOR_TARGET"; then
9473   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9474 else
9475 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9476 for as_dir in $PATH
9477 do
9478   IFS=$as_save_IFS
9479   test -z "$as_dir" && as_dir=.
9480   for ac_exec_ext in '' $ac_executable_extensions; do
9481   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9482     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9483     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9484     break 2
9485   fi
9486 done
9487 done
9488
9489 fi
9490 fi
9491 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9492 if test -n "$DLLTOOL_FOR_TARGET"; then
9493   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9494 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9495 else
9496   echo "$as_me:$LINENO: result: no" >&5
9497 echo "${ECHO_T}no" >&6
9498 fi
9499
9500     fi
9501     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9502       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9503 set dummy ${ncn_progname}; ac_word=$2
9504 echo "$as_me:$LINENO: checking for $ac_word" >&5
9505 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9506 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9507   echo $ECHO_N "(cached) $ECHO_C" >&6
9508 else
9509   if test -n "$DLLTOOL_FOR_TARGET"; then
9510   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9511 else
9512 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9513 for as_dir in $PATH
9514 do
9515   IFS=$as_save_IFS
9516   test -z "$as_dir" && as_dir=.
9517   for ac_exec_ext in '' $ac_executable_extensions; do
9518   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9519     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9520     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9521     break 2
9522   fi
9523 done
9524 done
9525
9526 fi
9527 fi
9528 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9529 if test -n "$DLLTOOL_FOR_TARGET"; then
9530   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9531 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9532 else
9533   echo "$as_me:$LINENO: result: no" >&5
9534 echo "${ECHO_T}no" >&6
9535 fi
9536
9537     fi
9538     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9539   done
9540 fi
9541
9542 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9543   set dummy dlltool
9544   if test $build = $target ; then
9545     DLLTOOL_FOR_TARGET="$2"
9546   else
9547     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9548   fi
9549 else
9550   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9551 fi
9552
9553 else
9554   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9555 fi
9556
9557
9558
9559
9560 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9561   if test -n "$with_build_time_tools"; then
9562     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9563 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9564     if test -x $with_build_time_tools/ld; then
9565       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9566       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9567       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9568 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9569     else
9570       echo "$as_me:$LINENO: result: no" >&5
9571 echo "${ECHO_T}no" >&6
9572     fi
9573   elif test $build != $host && test $have_gcc_for_target = yes; then
9574     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9575     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9576     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9577   fi
9578 fi
9579 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9580   # Extract the first word of "ld", so it can be a program name with args.
9581 set dummy ld; ac_word=$2
9582 echo "$as_me:$LINENO: checking for $ac_word" >&5
9583 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9584 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9585   echo $ECHO_N "(cached) $ECHO_C" >&6
9586 else
9587   case $LD_FOR_TARGET in
9588   [\\/]* | ?:[\\/]*)
9589   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9590   ;;
9591   *)
9592   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9593 for as_dir in $gcc_cv_tool_dirs
9594 do
9595   IFS=$as_save_IFS
9596   test -z "$as_dir" && as_dir=.
9597   for ac_exec_ext in '' $ac_executable_extensions; do
9598   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9599     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9600     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9601     break 2
9602   fi
9603 done
9604 done
9605
9606   ;;
9607 esac
9608 fi
9609 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9610
9611 if test -n "$LD_FOR_TARGET"; then
9612   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9613 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9614 else
9615   echo "$as_me:$LINENO: result: no" >&5
9616 echo "${ECHO_T}no" >&6
9617 fi
9618
9619 fi
9620 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9621
9622
9623 if test -n "$LD_FOR_TARGET"; then
9624   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9625 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9626   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9627 fi
9628
9629 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9630   for ncn_progname in ld; do
9631     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9632 set dummy ${ncn_progname}; ac_word=$2
9633 echo "$as_me:$LINENO: checking for $ac_word" >&5
9634 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9635 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9636   echo $ECHO_N "(cached) $ECHO_C" >&6
9637 else
9638   if test -n "$LD_FOR_TARGET"; then
9639   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9640 else
9641 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9642 for as_dir in $PATH
9643 do
9644   IFS=$as_save_IFS
9645   test -z "$as_dir" && as_dir=.
9646   for ac_exec_ext in '' $ac_executable_extensions; do
9647   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9648     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9649     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9650     break 2
9651   fi
9652 done
9653 done
9654
9655 fi
9656 fi
9657 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9658 if test -n "$LD_FOR_TARGET"; then
9659   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9660 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9661 else
9662   echo "$as_me:$LINENO: result: no" >&5
9663 echo "${ECHO_T}no" >&6
9664 fi
9665
9666   done
9667 fi
9668
9669 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9670   for ncn_progname in ld; do
9671     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9672 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9673     if test -x $with_build_time_tools/${ncn_progname}; then
9674       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9675       echo "$as_me:$LINENO: result: yes" >&5
9676 echo "${ECHO_T}yes" >&6
9677       break
9678     else
9679       echo "$as_me:$LINENO: result: no" >&5
9680 echo "${ECHO_T}no" >&6
9681     fi
9682   done
9683 fi
9684
9685 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9686   for ncn_progname in ld; do
9687     if test -n "$ncn_target_tool_prefix"; then
9688       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9689 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9690 echo "$as_me:$LINENO: checking for $ac_word" >&5
9691 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9692 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9693   echo $ECHO_N "(cached) $ECHO_C" >&6
9694 else
9695   if test -n "$LD_FOR_TARGET"; then
9696   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9697 else
9698 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9699 for as_dir in $PATH
9700 do
9701   IFS=$as_save_IFS
9702   test -z "$as_dir" && as_dir=.
9703   for ac_exec_ext in '' $ac_executable_extensions; do
9704   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9705     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9706     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9707     break 2
9708   fi
9709 done
9710 done
9711
9712 fi
9713 fi
9714 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9715 if test -n "$LD_FOR_TARGET"; then
9716   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9717 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9718 else
9719   echo "$as_me:$LINENO: result: no" >&5
9720 echo "${ECHO_T}no" >&6
9721 fi
9722
9723     fi
9724     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9725       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9726 set dummy ${ncn_progname}; ac_word=$2
9727 echo "$as_me:$LINENO: checking for $ac_word" >&5
9728 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9729 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9730   echo $ECHO_N "(cached) $ECHO_C" >&6
9731 else
9732   if test -n "$LD_FOR_TARGET"; then
9733   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9734 else
9735 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9736 for as_dir in $PATH
9737 do
9738   IFS=$as_save_IFS
9739   test -z "$as_dir" && as_dir=.
9740   for ac_exec_ext in '' $ac_executable_extensions; do
9741   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9742     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9743     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9744     break 2
9745   fi
9746 done
9747 done
9748
9749 fi
9750 fi
9751 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9752 if test -n "$LD_FOR_TARGET"; then
9753   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9754 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9755 else
9756   echo "$as_me:$LINENO: result: no" >&5
9757 echo "${ECHO_T}no" >&6
9758 fi
9759
9760     fi
9761     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9762   done
9763 fi
9764
9765 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9766   set dummy ld
9767   if test $build = $target ; then
9768     LD_FOR_TARGET="$2"
9769   else
9770     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9771   fi
9772 else
9773   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9774 fi
9775
9776 else
9777   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9778 fi
9779
9780
9781
9782
9783 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9784   if test -n "$with_build_time_tools"; then
9785     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9786 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9787     if test -x $with_build_time_tools/lipo; then
9788       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9789       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9790       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9791 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9792     else
9793       echo "$as_me:$LINENO: result: no" >&5
9794 echo "${ECHO_T}no" >&6
9795     fi
9796   elif test $build != $host && test $have_gcc_for_target = yes; then
9797     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9798     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9799     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9800   fi
9801 fi
9802 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9803   # Extract the first word of "lipo", so it can be a program name with args.
9804 set dummy lipo; ac_word=$2
9805 echo "$as_me:$LINENO: checking for $ac_word" >&5
9806 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9807 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9808   echo $ECHO_N "(cached) $ECHO_C" >&6
9809 else
9810   case $LIPO_FOR_TARGET in
9811   [\\/]* | ?:[\\/]*)
9812   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9813   ;;
9814   *)
9815   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9816 for as_dir in $gcc_cv_tool_dirs
9817 do
9818   IFS=$as_save_IFS
9819   test -z "$as_dir" && as_dir=.
9820   for ac_exec_ext in '' $ac_executable_extensions; do
9821   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9822     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9823     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9824     break 2
9825   fi
9826 done
9827 done
9828
9829   ;;
9830 esac
9831 fi
9832 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9833
9834 if test -n "$LIPO_FOR_TARGET"; then
9835   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9836 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9837 else
9838   echo "$as_me:$LINENO: result: no" >&5
9839 echo "${ECHO_T}no" >&6
9840 fi
9841
9842 fi
9843 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9844
9845
9846 if test -n "$LIPO_FOR_TARGET"; then
9847   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9848 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9849   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9850 fi
9851
9852 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9853   for ncn_progname in lipo; do
9854     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9855 set dummy ${ncn_progname}; ac_word=$2
9856 echo "$as_me:$LINENO: checking for $ac_word" >&5
9857 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9858 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9859   echo $ECHO_N "(cached) $ECHO_C" >&6
9860 else
9861   if test -n "$LIPO_FOR_TARGET"; then
9862   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9863 else
9864 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9865 for as_dir in $PATH
9866 do
9867   IFS=$as_save_IFS
9868   test -z "$as_dir" && as_dir=.
9869   for ac_exec_ext in '' $ac_executable_extensions; do
9870   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9871     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9872     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9873     break 2
9874   fi
9875 done
9876 done
9877
9878 fi
9879 fi
9880 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9881 if test -n "$LIPO_FOR_TARGET"; then
9882   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9883 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9884 else
9885   echo "$as_me:$LINENO: result: no" >&5
9886 echo "${ECHO_T}no" >&6
9887 fi
9888
9889   done
9890 fi
9891
9892 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9893   for ncn_progname in lipo; do
9894     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9895 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9896     if test -x $with_build_time_tools/${ncn_progname}; then
9897       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9898       echo "$as_me:$LINENO: result: yes" >&5
9899 echo "${ECHO_T}yes" >&6
9900       break
9901     else
9902       echo "$as_me:$LINENO: result: no" >&5
9903 echo "${ECHO_T}no" >&6
9904     fi
9905   done
9906 fi
9907
9908 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9909   for ncn_progname in lipo; do
9910     if test -n "$ncn_target_tool_prefix"; then
9911       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9912 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9913 echo "$as_me:$LINENO: checking for $ac_word" >&5
9914 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9915 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9916   echo $ECHO_N "(cached) $ECHO_C" >&6
9917 else
9918   if test -n "$LIPO_FOR_TARGET"; then
9919   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9920 else
9921 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9922 for as_dir in $PATH
9923 do
9924   IFS=$as_save_IFS
9925   test -z "$as_dir" && as_dir=.
9926   for ac_exec_ext in '' $ac_executable_extensions; do
9927   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9928     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9929     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9930     break 2
9931   fi
9932 done
9933 done
9934
9935 fi
9936 fi
9937 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9938 if test -n "$LIPO_FOR_TARGET"; then
9939   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9940 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9941 else
9942   echo "$as_me:$LINENO: result: no" >&5
9943 echo "${ECHO_T}no" >&6
9944 fi
9945
9946     fi
9947     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9948       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9949 set dummy ${ncn_progname}; ac_word=$2
9950 echo "$as_me:$LINENO: checking for $ac_word" >&5
9951 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9952 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9953   echo $ECHO_N "(cached) $ECHO_C" >&6
9954 else
9955   if test -n "$LIPO_FOR_TARGET"; then
9956   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9957 else
9958 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9959 for as_dir in $PATH
9960 do
9961   IFS=$as_save_IFS
9962   test -z "$as_dir" && as_dir=.
9963   for ac_exec_ext in '' $ac_executable_extensions; do
9964   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9965     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9966     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9967     break 2
9968   fi
9969 done
9970 done
9971
9972 fi
9973 fi
9974 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9975 if test -n "$LIPO_FOR_TARGET"; then
9976   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9977 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9978 else
9979   echo "$as_me:$LINENO: result: no" >&5
9980 echo "${ECHO_T}no" >&6
9981 fi
9982
9983     fi
9984     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9985   done
9986 fi
9987
9988 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9989   set dummy lipo
9990   if test $build = $target ; then
9991     LIPO_FOR_TARGET="$2"
9992   else
9993     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9994   fi
9995 else
9996   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9997 fi
9998
9999 else
10000   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
10001 fi
10002
10003
10004
10005
10006 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10007   if test -n "$with_build_time_tools"; then
10008     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
10009 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
10010     if test -x $with_build_time_tools/nm; then
10011       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
10012       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10013       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10014 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10015     else
10016       echo "$as_me:$LINENO: result: no" >&5
10017 echo "${ECHO_T}no" >&6
10018     fi
10019   elif test $build != $host && test $have_gcc_for_target = yes; then
10020     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10021     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10022     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10023   fi
10024 fi
10025 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10026   # Extract the first word of "nm", so it can be a program name with args.
10027 set dummy nm; ac_word=$2
10028 echo "$as_me:$LINENO: checking for $ac_word" >&5
10029 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10030 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10031   echo $ECHO_N "(cached) $ECHO_C" >&6
10032 else
10033   case $NM_FOR_TARGET in
10034   [\\/]* | ?:[\\/]*)
10035   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10036   ;;
10037   *)
10038   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10039 for as_dir in $gcc_cv_tool_dirs
10040 do
10041   IFS=$as_save_IFS
10042   test -z "$as_dir" && as_dir=.
10043   for ac_exec_ext in '' $ac_executable_extensions; do
10044   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10045     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10046     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10047     break 2
10048   fi
10049 done
10050 done
10051
10052   ;;
10053 esac
10054 fi
10055 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10056
10057 if test -n "$NM_FOR_TARGET"; then
10058   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10059 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10060 else
10061   echo "$as_me:$LINENO: result: no" >&5
10062 echo "${ECHO_T}no" >&6
10063 fi
10064
10065 fi
10066 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10067
10068
10069 if test -n "$NM_FOR_TARGET"; then
10070   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10071 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10072   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10073 fi
10074
10075 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10076   for ncn_progname in nm; do
10077     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10078 set dummy ${ncn_progname}; ac_word=$2
10079 echo "$as_me:$LINENO: checking for $ac_word" >&5
10080 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10081 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10082   echo $ECHO_N "(cached) $ECHO_C" >&6
10083 else
10084   if test -n "$NM_FOR_TARGET"; then
10085   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10086 else
10087 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10088 for as_dir in $PATH
10089 do
10090   IFS=$as_save_IFS
10091   test -z "$as_dir" && as_dir=.
10092   for ac_exec_ext in '' $ac_executable_extensions; do
10093   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10094     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10095     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10096     break 2
10097   fi
10098 done
10099 done
10100
10101 fi
10102 fi
10103 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10104 if test -n "$NM_FOR_TARGET"; then
10105   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10106 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10107 else
10108   echo "$as_me:$LINENO: result: no" >&5
10109 echo "${ECHO_T}no" >&6
10110 fi
10111
10112   done
10113 fi
10114
10115 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10116   for ncn_progname in nm; do
10117     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10118 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10119     if test -x $with_build_time_tools/${ncn_progname}; then
10120       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10121       echo "$as_me:$LINENO: result: yes" >&5
10122 echo "${ECHO_T}yes" >&6
10123       break
10124     else
10125       echo "$as_me:$LINENO: result: no" >&5
10126 echo "${ECHO_T}no" >&6
10127     fi
10128   done
10129 fi
10130
10131 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10132   for ncn_progname in nm; do
10133     if test -n "$ncn_target_tool_prefix"; then
10134       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10135 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10136 echo "$as_me:$LINENO: checking for $ac_word" >&5
10137 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10138 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10139   echo $ECHO_N "(cached) $ECHO_C" >&6
10140 else
10141   if test -n "$NM_FOR_TARGET"; then
10142   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10143 else
10144 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10145 for as_dir in $PATH
10146 do
10147   IFS=$as_save_IFS
10148   test -z "$as_dir" && as_dir=.
10149   for ac_exec_ext in '' $ac_executable_extensions; do
10150   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10151     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10152     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10153     break 2
10154   fi
10155 done
10156 done
10157
10158 fi
10159 fi
10160 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10161 if test -n "$NM_FOR_TARGET"; then
10162   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10163 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10164 else
10165   echo "$as_me:$LINENO: result: no" >&5
10166 echo "${ECHO_T}no" >&6
10167 fi
10168
10169     fi
10170     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10171       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10172 set dummy ${ncn_progname}; ac_word=$2
10173 echo "$as_me:$LINENO: checking for $ac_word" >&5
10174 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10175 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10176   echo $ECHO_N "(cached) $ECHO_C" >&6
10177 else
10178   if test -n "$NM_FOR_TARGET"; then
10179   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10180 else
10181 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10182 for as_dir in $PATH
10183 do
10184   IFS=$as_save_IFS
10185   test -z "$as_dir" && as_dir=.
10186   for ac_exec_ext in '' $ac_executable_extensions; do
10187   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10188     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10189     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10190     break 2
10191   fi
10192 done
10193 done
10194
10195 fi
10196 fi
10197 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10198 if test -n "$NM_FOR_TARGET"; then
10199   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10200 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10201 else
10202   echo "$as_me:$LINENO: result: no" >&5
10203 echo "${ECHO_T}no" >&6
10204 fi
10205
10206     fi
10207     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10208   done
10209 fi
10210
10211 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10212   set dummy nm
10213   if test $build = $target ; then
10214     NM_FOR_TARGET="$2"
10215   else
10216     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10217   fi
10218 else
10219   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10220 fi
10221
10222 else
10223   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10224 fi
10225
10226
10227
10228
10229 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10230   if test -n "$with_build_time_tools"; then
10231     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10232 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10233     if test -x $with_build_time_tools/objdump; then
10234       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10235       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10236       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10237 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10238     else
10239       echo "$as_me:$LINENO: result: no" >&5
10240 echo "${ECHO_T}no" >&6
10241     fi
10242   elif test $build != $host && test $have_gcc_for_target = yes; then
10243     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10244     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10245     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10246   fi
10247 fi
10248 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10249   # Extract the first word of "objdump", so it can be a program name with args.
10250 set dummy objdump; ac_word=$2
10251 echo "$as_me:$LINENO: checking for $ac_word" >&5
10252 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10253 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10254   echo $ECHO_N "(cached) $ECHO_C" >&6
10255 else
10256   case $OBJDUMP_FOR_TARGET in
10257   [\\/]* | ?:[\\/]*)
10258   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10259   ;;
10260   *)
10261   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10262 for as_dir in $gcc_cv_tool_dirs
10263 do
10264   IFS=$as_save_IFS
10265   test -z "$as_dir" && as_dir=.
10266   for ac_exec_ext in '' $ac_executable_extensions; do
10267   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10268     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10269     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10270     break 2
10271   fi
10272 done
10273 done
10274
10275   ;;
10276 esac
10277 fi
10278 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10279
10280 if test -n "$OBJDUMP_FOR_TARGET"; then
10281   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10282 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10283 else
10284   echo "$as_me:$LINENO: result: no" >&5
10285 echo "${ECHO_T}no" >&6
10286 fi
10287
10288 fi
10289 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10290
10291
10292 if test -n "$OBJDUMP_FOR_TARGET"; then
10293   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10294 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10295   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10296 fi
10297
10298 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10299   for ncn_progname in objdump; do
10300     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10301 set dummy ${ncn_progname}; ac_word=$2
10302 echo "$as_me:$LINENO: checking for $ac_word" >&5
10303 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10304 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10305   echo $ECHO_N "(cached) $ECHO_C" >&6
10306 else
10307   if test -n "$OBJDUMP_FOR_TARGET"; then
10308   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10309 else
10310 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10311 for as_dir in $PATH
10312 do
10313   IFS=$as_save_IFS
10314   test -z "$as_dir" && as_dir=.
10315   for ac_exec_ext in '' $ac_executable_extensions; do
10316   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10317     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10318     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10319     break 2
10320   fi
10321 done
10322 done
10323
10324 fi
10325 fi
10326 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10327 if test -n "$OBJDUMP_FOR_TARGET"; then
10328   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10329 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10330 else
10331   echo "$as_me:$LINENO: result: no" >&5
10332 echo "${ECHO_T}no" >&6
10333 fi
10334
10335   done
10336 fi
10337
10338 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10339   for ncn_progname in objdump; do
10340     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10341 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10342     if test -x $with_build_time_tools/${ncn_progname}; then
10343       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10344       echo "$as_me:$LINENO: result: yes" >&5
10345 echo "${ECHO_T}yes" >&6
10346       break
10347     else
10348       echo "$as_me:$LINENO: result: no" >&5
10349 echo "${ECHO_T}no" >&6
10350     fi
10351   done
10352 fi
10353
10354 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10355   for ncn_progname in objdump; do
10356     if test -n "$ncn_target_tool_prefix"; then
10357       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10358 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10359 echo "$as_me:$LINENO: checking for $ac_word" >&5
10360 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10361 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10362   echo $ECHO_N "(cached) $ECHO_C" >&6
10363 else
10364   if test -n "$OBJDUMP_FOR_TARGET"; then
10365   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10366 else
10367 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10368 for as_dir in $PATH
10369 do
10370   IFS=$as_save_IFS
10371   test -z "$as_dir" && as_dir=.
10372   for ac_exec_ext in '' $ac_executable_extensions; do
10373   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10374     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10375     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10376     break 2
10377   fi
10378 done
10379 done
10380
10381 fi
10382 fi
10383 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10384 if test -n "$OBJDUMP_FOR_TARGET"; then
10385   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10386 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10387 else
10388   echo "$as_me:$LINENO: result: no" >&5
10389 echo "${ECHO_T}no" >&6
10390 fi
10391
10392     fi
10393     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10394       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10395 set dummy ${ncn_progname}; ac_word=$2
10396 echo "$as_me:$LINENO: checking for $ac_word" >&5
10397 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10398 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10399   echo $ECHO_N "(cached) $ECHO_C" >&6
10400 else
10401   if test -n "$OBJDUMP_FOR_TARGET"; then
10402   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10403 else
10404 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10405 for as_dir in $PATH
10406 do
10407   IFS=$as_save_IFS
10408   test -z "$as_dir" && as_dir=.
10409   for ac_exec_ext in '' $ac_executable_extensions; do
10410   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10411     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10412     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10413     break 2
10414   fi
10415 done
10416 done
10417
10418 fi
10419 fi
10420 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10421 if test -n "$OBJDUMP_FOR_TARGET"; then
10422   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10423 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10424 else
10425   echo "$as_me:$LINENO: result: no" >&5
10426 echo "${ECHO_T}no" >&6
10427 fi
10428
10429     fi
10430     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10431   done
10432 fi
10433
10434 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10435   set dummy objdump
10436   if test $build = $target ; then
10437     OBJDUMP_FOR_TARGET="$2"
10438   else
10439     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10440   fi
10441 else
10442   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10443 fi
10444
10445 else
10446   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10447 fi
10448
10449
10450
10451
10452 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10453   if test -n "$with_build_time_tools"; then
10454     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10455 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10456     if test -x $with_build_time_tools/ranlib; then
10457       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10458       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10459       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10460 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10461     else
10462       echo "$as_me:$LINENO: result: no" >&5
10463 echo "${ECHO_T}no" >&6
10464     fi
10465   elif test $build != $host && test $have_gcc_for_target = yes; then
10466     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10467     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10468     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10469   fi
10470 fi
10471 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10472   # Extract the first word of "ranlib", so it can be a program name with args.
10473 set dummy ranlib; ac_word=$2
10474 echo "$as_me:$LINENO: checking for $ac_word" >&5
10475 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10476 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10477   echo $ECHO_N "(cached) $ECHO_C" >&6
10478 else
10479   case $RANLIB_FOR_TARGET in
10480   [\\/]* | ?:[\\/]*)
10481   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10482   ;;
10483   *)
10484   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10485 for as_dir in $gcc_cv_tool_dirs
10486 do
10487   IFS=$as_save_IFS
10488   test -z "$as_dir" && as_dir=.
10489   for ac_exec_ext in '' $ac_executable_extensions; do
10490   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10491     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10492     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10493     break 2
10494   fi
10495 done
10496 done
10497
10498   ;;
10499 esac
10500 fi
10501 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10502
10503 if test -n "$RANLIB_FOR_TARGET"; then
10504   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10505 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10506 else
10507   echo "$as_me:$LINENO: result: no" >&5
10508 echo "${ECHO_T}no" >&6
10509 fi
10510
10511 fi
10512 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10513
10514
10515 if test -n "$RANLIB_FOR_TARGET"; then
10516   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10517 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10518   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10519 fi
10520
10521 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10522   for ncn_progname in ranlib; do
10523     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10524 set dummy ${ncn_progname}; ac_word=$2
10525 echo "$as_me:$LINENO: checking for $ac_word" >&5
10526 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10527 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10528   echo $ECHO_N "(cached) $ECHO_C" >&6
10529 else
10530   if test -n "$RANLIB_FOR_TARGET"; then
10531   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10532 else
10533 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10534 for as_dir in $PATH
10535 do
10536   IFS=$as_save_IFS
10537   test -z "$as_dir" && as_dir=.
10538   for ac_exec_ext in '' $ac_executable_extensions; do
10539   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10540     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10541     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10542     break 2
10543   fi
10544 done
10545 done
10546
10547 fi
10548 fi
10549 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10550 if test -n "$RANLIB_FOR_TARGET"; then
10551   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10552 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10553 else
10554   echo "$as_me:$LINENO: result: no" >&5
10555 echo "${ECHO_T}no" >&6
10556 fi
10557
10558   done
10559 fi
10560
10561 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10562   for ncn_progname in ranlib; do
10563     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10564 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10565     if test -x $with_build_time_tools/${ncn_progname}; then
10566       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10567       echo "$as_me:$LINENO: result: yes" >&5
10568 echo "${ECHO_T}yes" >&6
10569       break
10570     else
10571       echo "$as_me:$LINENO: result: no" >&5
10572 echo "${ECHO_T}no" >&6
10573     fi
10574   done
10575 fi
10576
10577 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10578   for ncn_progname in ranlib; do
10579     if test -n "$ncn_target_tool_prefix"; then
10580       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10581 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10582 echo "$as_me:$LINENO: checking for $ac_word" >&5
10583 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10584 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10585   echo $ECHO_N "(cached) $ECHO_C" >&6
10586 else
10587   if test -n "$RANLIB_FOR_TARGET"; then
10588   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10589 else
10590 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10591 for as_dir in $PATH
10592 do
10593   IFS=$as_save_IFS
10594   test -z "$as_dir" && as_dir=.
10595   for ac_exec_ext in '' $ac_executable_extensions; do
10596   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10597     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10598     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10599     break 2
10600   fi
10601 done
10602 done
10603
10604 fi
10605 fi
10606 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10607 if test -n "$RANLIB_FOR_TARGET"; then
10608   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10609 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10610 else
10611   echo "$as_me:$LINENO: result: no" >&5
10612 echo "${ECHO_T}no" >&6
10613 fi
10614
10615     fi
10616     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10617       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10618 set dummy ${ncn_progname}; ac_word=$2
10619 echo "$as_me:$LINENO: checking for $ac_word" >&5
10620 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10621 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10622   echo $ECHO_N "(cached) $ECHO_C" >&6
10623 else
10624   if test -n "$RANLIB_FOR_TARGET"; then
10625   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10626 else
10627 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10628 for as_dir in $PATH
10629 do
10630   IFS=$as_save_IFS
10631   test -z "$as_dir" && as_dir=.
10632   for ac_exec_ext in '' $ac_executable_extensions; do
10633   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10634     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10635     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10636     break 2
10637   fi
10638 done
10639 done
10640
10641 fi
10642 fi
10643 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10644 if test -n "$RANLIB_FOR_TARGET"; then
10645   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10646 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10647 else
10648   echo "$as_me:$LINENO: result: no" >&5
10649 echo "${ECHO_T}no" >&6
10650 fi
10651
10652     fi
10653     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10654   done
10655 fi
10656
10657 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10658   set dummy ranlib
10659   if test $build = $target ; then
10660     RANLIB_FOR_TARGET="$2"
10661   else
10662     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10663   fi
10664 else
10665   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10666 fi
10667
10668 else
10669   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10670 fi
10671
10672
10673
10674
10675 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10676   if test -n "$with_build_time_tools"; then
10677     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10678 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10679     if test -x $with_build_time_tools/strip; then
10680       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10681       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10682       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10683 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10684     else
10685       echo "$as_me:$LINENO: result: no" >&5
10686 echo "${ECHO_T}no" >&6
10687     fi
10688   elif test $build != $host && test $have_gcc_for_target = yes; then
10689     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10690     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10691     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10692   fi
10693 fi
10694 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10695   # Extract the first word of "strip", so it can be a program name with args.
10696 set dummy strip; ac_word=$2
10697 echo "$as_me:$LINENO: checking for $ac_word" >&5
10698 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10699 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10700   echo $ECHO_N "(cached) $ECHO_C" >&6
10701 else
10702   case $STRIP_FOR_TARGET in
10703   [\\/]* | ?:[\\/]*)
10704   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10705   ;;
10706   *)
10707   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10708 for as_dir in $gcc_cv_tool_dirs
10709 do
10710   IFS=$as_save_IFS
10711   test -z "$as_dir" && as_dir=.
10712   for ac_exec_ext in '' $ac_executable_extensions; do
10713   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10714     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10715     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10716     break 2
10717   fi
10718 done
10719 done
10720
10721   ;;
10722 esac
10723 fi
10724 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10725
10726 if test -n "$STRIP_FOR_TARGET"; then
10727   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10728 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10729 else
10730   echo "$as_me:$LINENO: result: no" >&5
10731 echo "${ECHO_T}no" >&6
10732 fi
10733
10734 fi
10735 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10736
10737
10738 if test -n "$STRIP_FOR_TARGET"; then
10739   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10740 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10741   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10742 fi
10743
10744 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10745   for ncn_progname in strip; do
10746     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10747 set dummy ${ncn_progname}; ac_word=$2
10748 echo "$as_me:$LINENO: checking for $ac_word" >&5
10749 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10750 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10751   echo $ECHO_N "(cached) $ECHO_C" >&6
10752 else
10753   if test -n "$STRIP_FOR_TARGET"; then
10754   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10755 else
10756 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10757 for as_dir in $PATH
10758 do
10759   IFS=$as_save_IFS
10760   test -z "$as_dir" && as_dir=.
10761   for ac_exec_ext in '' $ac_executable_extensions; do
10762   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10763     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10764     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10765     break 2
10766   fi
10767 done
10768 done
10769
10770 fi
10771 fi
10772 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10773 if test -n "$STRIP_FOR_TARGET"; then
10774   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10775 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10776 else
10777   echo "$as_me:$LINENO: result: no" >&5
10778 echo "${ECHO_T}no" >&6
10779 fi
10780
10781   done
10782 fi
10783
10784 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10785   for ncn_progname in strip; do
10786     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10787 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10788     if test -x $with_build_time_tools/${ncn_progname}; then
10789       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10790       echo "$as_me:$LINENO: result: yes" >&5
10791 echo "${ECHO_T}yes" >&6
10792       break
10793     else
10794       echo "$as_me:$LINENO: result: no" >&5
10795 echo "${ECHO_T}no" >&6
10796     fi
10797   done
10798 fi
10799
10800 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10801   for ncn_progname in strip; do
10802     if test -n "$ncn_target_tool_prefix"; then
10803       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10804 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10805 echo "$as_me:$LINENO: checking for $ac_word" >&5
10806 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10807 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10808   echo $ECHO_N "(cached) $ECHO_C" >&6
10809 else
10810   if test -n "$STRIP_FOR_TARGET"; then
10811   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10812 else
10813 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10814 for as_dir in $PATH
10815 do
10816   IFS=$as_save_IFS
10817   test -z "$as_dir" && as_dir=.
10818   for ac_exec_ext in '' $ac_executable_extensions; do
10819   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10820     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10821     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10822     break 2
10823   fi
10824 done
10825 done
10826
10827 fi
10828 fi
10829 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10830 if test -n "$STRIP_FOR_TARGET"; then
10831   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10832 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10833 else
10834   echo "$as_me:$LINENO: result: no" >&5
10835 echo "${ECHO_T}no" >&6
10836 fi
10837
10838     fi
10839     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10840       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10841 set dummy ${ncn_progname}; ac_word=$2
10842 echo "$as_me:$LINENO: checking for $ac_word" >&5
10843 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10844 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10845   echo $ECHO_N "(cached) $ECHO_C" >&6
10846 else
10847   if test -n "$STRIP_FOR_TARGET"; then
10848   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10849 else
10850 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10851 for as_dir in $PATH
10852 do
10853   IFS=$as_save_IFS
10854   test -z "$as_dir" && as_dir=.
10855   for ac_exec_ext in '' $ac_executable_extensions; do
10856   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10857     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10858     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10859     break 2
10860   fi
10861 done
10862 done
10863
10864 fi
10865 fi
10866 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10867 if test -n "$STRIP_FOR_TARGET"; then
10868   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10869 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10870 else
10871   echo "$as_me:$LINENO: result: no" >&5
10872 echo "${ECHO_T}no" >&6
10873 fi
10874
10875     fi
10876     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10877   done
10878 fi
10879
10880 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10881   set dummy strip
10882   if test $build = $target ; then
10883     STRIP_FOR_TARGET="$2"
10884   else
10885     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10886   fi
10887 else
10888   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10889 fi
10890
10891 else
10892   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10893 fi
10894
10895
10896
10897
10898 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10899   if test -n "$with_build_time_tools"; then
10900     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10901 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10902     if test -x $with_build_time_tools/windres; then
10903       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10904       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10905       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10906 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10907     else
10908       echo "$as_me:$LINENO: result: no" >&5
10909 echo "${ECHO_T}no" >&6
10910     fi
10911   elif test $build != $host && test $have_gcc_for_target = yes; then
10912     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10913     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10914     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10915   fi
10916 fi
10917 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10918   # Extract the first word of "windres", so it can be a program name with args.
10919 set dummy windres; ac_word=$2
10920 echo "$as_me:$LINENO: checking for $ac_word" >&5
10921 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10922 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10923   echo $ECHO_N "(cached) $ECHO_C" >&6
10924 else
10925   case $WINDRES_FOR_TARGET in
10926   [\\/]* | ?:[\\/]*)
10927   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10928   ;;
10929   *)
10930   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10931 for as_dir in $gcc_cv_tool_dirs
10932 do
10933   IFS=$as_save_IFS
10934   test -z "$as_dir" && as_dir=.
10935   for ac_exec_ext in '' $ac_executable_extensions; do
10936   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10937     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10938     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10939     break 2
10940   fi
10941 done
10942 done
10943
10944   ;;
10945 esac
10946 fi
10947 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10948
10949 if test -n "$WINDRES_FOR_TARGET"; then
10950   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10951 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10952 else
10953   echo "$as_me:$LINENO: result: no" >&5
10954 echo "${ECHO_T}no" >&6
10955 fi
10956
10957 fi
10958 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10959
10960
10961 if test -n "$WINDRES_FOR_TARGET"; then
10962   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10963 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10964   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10965 fi
10966
10967 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10968   for ncn_progname in windres; do
10969     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10970 set dummy ${ncn_progname}; ac_word=$2
10971 echo "$as_me:$LINENO: checking for $ac_word" >&5
10972 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10973 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10974   echo $ECHO_N "(cached) $ECHO_C" >&6
10975 else
10976   if test -n "$WINDRES_FOR_TARGET"; then
10977   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10978 else
10979 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10980 for as_dir in $PATH
10981 do
10982   IFS=$as_save_IFS
10983   test -z "$as_dir" && as_dir=.
10984   for ac_exec_ext in '' $ac_executable_extensions; do
10985   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10986     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10987     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10988     break 2
10989   fi
10990 done
10991 done
10992
10993 fi
10994 fi
10995 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10996 if test -n "$WINDRES_FOR_TARGET"; then
10997   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10998 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10999 else
11000   echo "$as_me:$LINENO: result: no" >&5
11001 echo "${ECHO_T}no" >&6
11002 fi
11003
11004   done
11005 fi
11006
11007 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
11008   for ncn_progname in windres; do
11009     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11010 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11011     if test -x $with_build_time_tools/${ncn_progname}; then
11012       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11013       echo "$as_me:$LINENO: result: yes" >&5
11014 echo "${ECHO_T}yes" >&6
11015       break
11016     else
11017       echo "$as_me:$LINENO: result: no" >&5
11018 echo "${ECHO_T}no" >&6
11019     fi
11020   done
11021 fi
11022
11023 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11024   for ncn_progname in windres; do
11025     if test -n "$ncn_target_tool_prefix"; then
11026       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11027 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11028 echo "$as_me:$LINENO: checking for $ac_word" >&5
11029 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11030 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11031   echo $ECHO_N "(cached) $ECHO_C" >&6
11032 else
11033   if test -n "$WINDRES_FOR_TARGET"; then
11034   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11035 else
11036 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11037 for as_dir in $PATH
11038 do
11039   IFS=$as_save_IFS
11040   test -z "$as_dir" && as_dir=.
11041   for ac_exec_ext in '' $ac_executable_extensions; do
11042   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11043     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11044     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11045     break 2
11046   fi
11047 done
11048 done
11049
11050 fi
11051 fi
11052 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11053 if test -n "$WINDRES_FOR_TARGET"; then
11054   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11055 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11056 else
11057   echo "$as_me:$LINENO: result: no" >&5
11058 echo "${ECHO_T}no" >&6
11059 fi
11060
11061     fi
11062     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11063       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11064 set dummy ${ncn_progname}; ac_word=$2
11065 echo "$as_me:$LINENO: checking for $ac_word" >&5
11066 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11067 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11068   echo $ECHO_N "(cached) $ECHO_C" >&6
11069 else
11070   if test -n "$WINDRES_FOR_TARGET"; then
11071   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11072 else
11073 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11074 for as_dir in $PATH
11075 do
11076   IFS=$as_save_IFS
11077   test -z "$as_dir" && as_dir=.
11078   for ac_exec_ext in '' $ac_executable_extensions; do
11079   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11080     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11081     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11082     break 2
11083   fi
11084 done
11085 done
11086
11087 fi
11088 fi
11089 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11090 if test -n "$WINDRES_FOR_TARGET"; then
11091   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11092 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11093 else
11094   echo "$as_me:$LINENO: result: no" >&5
11095 echo "${ECHO_T}no" >&6
11096 fi
11097
11098     fi
11099     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11100   done
11101 fi
11102
11103 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11104   set dummy windres
11105   if test $build = $target ; then
11106     WINDRES_FOR_TARGET="$2"
11107   else
11108     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11109   fi
11110 else
11111   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11112 fi
11113
11114 else
11115   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11116 fi
11117
11118
11119
11120
11121 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11122   if test -n "$with_build_time_tools"; then
11123     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11124 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11125     if test -x $with_build_time_tools/windmc; then
11126       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11127       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11128       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11129 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11130     else
11131       echo "$as_me:$LINENO: result: no" >&5
11132 echo "${ECHO_T}no" >&6
11133     fi
11134   elif test $build != $host && test $have_gcc_for_target = yes; then
11135     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11136     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11137     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11138   fi
11139 fi
11140 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11141   # Extract the first word of "windmc", so it can be a program name with args.
11142 set dummy windmc; ac_word=$2
11143 echo "$as_me:$LINENO: checking for $ac_word" >&5
11144 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11145 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11146   echo $ECHO_N "(cached) $ECHO_C" >&6
11147 else
11148   case $WINDMC_FOR_TARGET in
11149   [\\/]* | ?:[\\/]*)
11150   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11151   ;;
11152   *)
11153   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11154 for as_dir in $gcc_cv_tool_dirs
11155 do
11156   IFS=$as_save_IFS
11157   test -z "$as_dir" && as_dir=.
11158   for ac_exec_ext in '' $ac_executable_extensions; do
11159   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11160     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11161     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11162     break 2
11163   fi
11164 done
11165 done
11166
11167   ;;
11168 esac
11169 fi
11170 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11171
11172 if test -n "$WINDMC_FOR_TARGET"; then
11173   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11174 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11175 else
11176   echo "$as_me:$LINENO: result: no" >&5
11177 echo "${ECHO_T}no" >&6
11178 fi
11179
11180 fi
11181 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11182
11183
11184 if test -n "$WINDMC_FOR_TARGET"; then
11185   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11186 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11187   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11188 fi
11189
11190 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11191   for ncn_progname in windmc; do
11192     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11193 set dummy ${ncn_progname}; ac_word=$2
11194 echo "$as_me:$LINENO: checking for $ac_word" >&5
11195 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11196 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11197   echo $ECHO_N "(cached) $ECHO_C" >&6
11198 else
11199   if test -n "$WINDMC_FOR_TARGET"; then
11200   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11201 else
11202 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11203 for as_dir in $PATH
11204 do
11205   IFS=$as_save_IFS
11206   test -z "$as_dir" && as_dir=.
11207   for ac_exec_ext in '' $ac_executable_extensions; do
11208   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11209     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11210     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11211     break 2
11212   fi
11213 done
11214 done
11215
11216 fi
11217 fi
11218 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11219 if test -n "$WINDMC_FOR_TARGET"; then
11220   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11221 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11222 else
11223   echo "$as_me:$LINENO: result: no" >&5
11224 echo "${ECHO_T}no" >&6
11225 fi
11226
11227   done
11228 fi
11229
11230 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11231   for ncn_progname in windmc; do
11232     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11233 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11234     if test -x $with_build_time_tools/${ncn_progname}; then
11235       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11236       echo "$as_me:$LINENO: result: yes" >&5
11237 echo "${ECHO_T}yes" >&6
11238       break
11239     else
11240       echo "$as_me:$LINENO: result: no" >&5
11241 echo "${ECHO_T}no" >&6
11242     fi
11243   done
11244 fi
11245
11246 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11247   for ncn_progname in windmc; do
11248     if test -n "$ncn_target_tool_prefix"; then
11249       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11250 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11251 echo "$as_me:$LINENO: checking for $ac_word" >&5
11252 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11253 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11254   echo $ECHO_N "(cached) $ECHO_C" >&6
11255 else
11256   if test -n "$WINDMC_FOR_TARGET"; then
11257   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11258 else
11259 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11260 for as_dir in $PATH
11261 do
11262   IFS=$as_save_IFS
11263   test -z "$as_dir" && as_dir=.
11264   for ac_exec_ext in '' $ac_executable_extensions; do
11265   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11266     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11267     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11268     break 2
11269   fi
11270 done
11271 done
11272
11273 fi
11274 fi
11275 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11276 if test -n "$WINDMC_FOR_TARGET"; then
11277   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11278 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11279 else
11280   echo "$as_me:$LINENO: result: no" >&5
11281 echo "${ECHO_T}no" >&6
11282 fi
11283
11284     fi
11285     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11286       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11287 set dummy ${ncn_progname}; ac_word=$2
11288 echo "$as_me:$LINENO: checking for $ac_word" >&5
11289 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11290 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11291   echo $ECHO_N "(cached) $ECHO_C" >&6
11292 else
11293   if test -n "$WINDMC_FOR_TARGET"; then
11294   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11295 else
11296 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11297 for as_dir in $PATH
11298 do
11299   IFS=$as_save_IFS
11300   test -z "$as_dir" && as_dir=.
11301   for ac_exec_ext in '' $ac_executable_extensions; do
11302   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11303     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11304     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11305     break 2
11306   fi
11307 done
11308 done
11309
11310 fi
11311 fi
11312 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11313 if test -n "$WINDMC_FOR_TARGET"; then
11314   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11315 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11316 else
11317   echo "$as_me:$LINENO: result: no" >&5
11318 echo "${ECHO_T}no" >&6
11319 fi
11320
11321     fi
11322     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11323   done
11324 fi
11325
11326 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11327   set dummy windmc
11328   if test $build = $target ; then
11329     WINDMC_FOR_TARGET="$2"
11330   else
11331     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11332   fi
11333 else
11334   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11335 fi
11336
11337 else
11338   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11339 fi
11340
11341
11342 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11343
11344 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11345 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11346 if test "x${build}" != "x${host}" ; then
11347   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11348     # We already found the complete path
11349     ac_dir=`dirname $AR_FOR_TARGET`
11350     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11351 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11352   else
11353     # Canadian cross, just use what we found
11354     echo "$as_me:$LINENO: result: pre-installed" >&5
11355 echo "${ECHO_T}pre-installed" >&6
11356   fi
11357 else
11358   ok=yes
11359   case " ${configdirs} " in
11360     *" binutils "*) ;;
11361     *) ok=no ;;
11362   esac
11363
11364   if test $ok = yes; then
11365     # An in-tree tool is available and we can use it
11366     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11367     echo "$as_me:$LINENO: result: just compiled" >&5
11368 echo "${ECHO_T}just compiled" >&6
11369   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11370     # We already found the complete path
11371     ac_dir=`dirname $AR_FOR_TARGET`
11372     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11373 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11374   elif test "x$target" = "x$host"; then
11375     # We can use an host tool
11376     AR_FOR_TARGET='$(AR)'
11377     echo "$as_me:$LINENO: result: host tool" >&5
11378 echo "${ECHO_T}host tool" >&6
11379   else
11380     # We need a cross tool
11381     echo "$as_me:$LINENO: result: pre-installed" >&5
11382 echo "${ECHO_T}pre-installed" >&6
11383   fi
11384 fi
11385
11386 echo "$as_me:$LINENO: checking where to find the target as" >&5
11387 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11388 if test "x${build}" != "x${host}" ; then
11389   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11390     # We already found the complete path
11391     ac_dir=`dirname $AS_FOR_TARGET`
11392     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11393 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11394   else
11395     # Canadian cross, just use what we found
11396     echo "$as_me:$LINENO: result: pre-installed" >&5
11397 echo "${ECHO_T}pre-installed" >&6
11398   fi
11399 else
11400   ok=yes
11401   case " ${configdirs} " in
11402     *" gas "*) ;;
11403     *) ok=no ;;
11404   esac
11405
11406   if test $ok = yes; then
11407     # An in-tree tool is available and we can use it
11408     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11409     echo "$as_me:$LINENO: result: just compiled" >&5
11410 echo "${ECHO_T}just compiled" >&6
11411   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11412     # We already found the complete path
11413     ac_dir=`dirname $AS_FOR_TARGET`
11414     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11415 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11416   elif test "x$target" = "x$host"; then
11417     # We can use an host tool
11418     AS_FOR_TARGET='$(AS)'
11419     echo "$as_me:$LINENO: result: host tool" >&5
11420 echo "${ECHO_T}host tool" >&6
11421   else
11422     # We need a cross tool
11423     echo "$as_me:$LINENO: result: pre-installed" >&5
11424 echo "${ECHO_T}pre-installed" >&6
11425   fi
11426 fi
11427
11428 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11429 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11430 if test "x${build}" != "x${host}" ; then
11431   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11432     # We already found the complete path
11433     ac_dir=`dirname $CC_FOR_TARGET`
11434     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11435 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11436   else
11437     # Canadian cross, just use what we found
11438     echo "$as_me:$LINENO: result: pre-installed" >&5
11439 echo "${ECHO_T}pre-installed" >&6
11440   fi
11441 else
11442   ok=yes
11443   case " ${configdirs} " in
11444     *" gcc "*) ;;
11445     *) ok=no ;;
11446   esac
11447
11448   if test $ok = yes; then
11449     # An in-tree tool is available and we can use it
11450     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11451     echo "$as_me:$LINENO: result: just compiled" >&5
11452 echo "${ECHO_T}just compiled" >&6
11453   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11454     # We already found the complete path
11455     ac_dir=`dirname $CC_FOR_TARGET`
11456     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11457 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11458   elif test "x$target" = "x$host"; then
11459     # We can use an host tool
11460     CC_FOR_TARGET='$(CC)'
11461     echo "$as_me:$LINENO: result: host tool" >&5
11462 echo "${ECHO_T}host tool" >&6
11463   else
11464     # We need a cross tool
11465     echo "$as_me:$LINENO: result: pre-installed" >&5
11466 echo "${ECHO_T}pre-installed" >&6
11467   fi
11468 fi
11469
11470 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11471 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11472 if test "x${build}" != "x${host}" ; then
11473   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11474     # We already found the complete path
11475     ac_dir=`dirname $CXX_FOR_TARGET`
11476     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11477 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11478   else
11479     # Canadian cross, just use what we found
11480     echo "$as_me:$LINENO: result: pre-installed" >&5
11481 echo "${ECHO_T}pre-installed" >&6
11482   fi
11483 else
11484   ok=yes
11485   case " ${configdirs} " in
11486     *" gcc "*) ;;
11487     *) ok=no ;;
11488   esac
11489   case ,${enable_languages}, in
11490     *,c++,*) ;;
11491     *) ok=no ;;
11492   esac
11493   if test $ok = yes; then
11494     # An in-tree tool is available and we can use it
11495     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'
11496     echo "$as_me:$LINENO: result: just compiled" >&5
11497 echo "${ECHO_T}just compiled" >&6
11498   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11499     # We already found the complete path
11500     ac_dir=`dirname $CXX_FOR_TARGET`
11501     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11502 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11503   elif test "x$target" = "x$host"; then
11504     # We can use an host tool
11505     CXX_FOR_TARGET='$(CXX)'
11506     echo "$as_me:$LINENO: result: host tool" >&5
11507 echo "${ECHO_T}host tool" >&6
11508   else
11509     # We need a cross tool
11510     echo "$as_me:$LINENO: result: pre-installed" >&5
11511 echo "${ECHO_T}pre-installed" >&6
11512   fi
11513 fi
11514
11515 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11516 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11517 if test "x${build}" != "x${host}" ; then
11518   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11519     # We already found the complete path
11520     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11521     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11522 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11523   else
11524     # Canadian cross, just use what we found
11525     echo "$as_me:$LINENO: result: pre-installed" >&5
11526 echo "${ECHO_T}pre-installed" >&6
11527   fi
11528 else
11529   ok=yes
11530   case " ${configdirs} " in
11531     *" gcc "*) ;;
11532     *) ok=no ;;
11533   esac
11534   case ,${enable_languages}, in
11535     *,c++,*) ;;
11536     *) ok=no ;;
11537   esac
11538   if test $ok = yes; then
11539     # An in-tree tool is available and we can use it
11540     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'
11541     echo "$as_me:$LINENO: result: just compiled" >&5
11542 echo "${ECHO_T}just compiled" >&6
11543   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11544     # We already found the complete path
11545     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11546     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11547 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11548   elif test "x$target" = "x$host"; then
11549     # We can use an host tool
11550     RAW_CXX_FOR_TARGET='$(CXX)'
11551     echo "$as_me:$LINENO: result: host tool" >&5
11552 echo "${ECHO_T}host tool" >&6
11553   else
11554     # We need a cross tool
11555     echo "$as_me:$LINENO: result: pre-installed" >&5
11556 echo "${ECHO_T}pre-installed" >&6
11557   fi
11558 fi
11559
11560 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11561 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11562 if test "x${build}" != "x${host}" ; then
11563   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11564     # We already found the complete path
11565     ac_dir=`dirname $DLLTOOL_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   else
11569     # Canadian cross, just use what we found
11570     echo "$as_me:$LINENO: result: pre-installed" >&5
11571 echo "${ECHO_T}pre-installed" >&6
11572   fi
11573 else
11574   ok=yes
11575   case " ${configdirs} " in
11576     *" binutils "*) ;;
11577     *) ok=no ;;
11578   esac
11579
11580   if test $ok = yes; then
11581     # An in-tree tool is available and we can use it
11582     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11583     echo "$as_me:$LINENO: result: just compiled" >&5
11584 echo "${ECHO_T}just compiled" >&6
11585   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11586     # We already found the complete path
11587     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11588     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11589 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11590   elif test "x$target" = "x$host"; then
11591     # We can use an host tool
11592     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11593     echo "$as_me:$LINENO: result: host tool" >&5
11594 echo "${ECHO_T}host tool" >&6
11595   else
11596     # We need a cross tool
11597     echo "$as_me:$LINENO: result: pre-installed" >&5
11598 echo "${ECHO_T}pre-installed" >&6
11599   fi
11600 fi
11601
11602 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11603 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11604 if test "x${build}" != "x${host}" ; then
11605   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11606     # We already found the complete path
11607     ac_dir=`dirname $GCC_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   else
11611     # Canadian cross, just use what we found
11612     echo "$as_me:$LINENO: result: pre-installed" >&5
11613 echo "${ECHO_T}pre-installed" >&6
11614   fi
11615 else
11616   ok=yes
11617   case " ${configdirs} " in
11618     *" gcc "*) ;;
11619     *) ok=no ;;
11620   esac
11621
11622   if test $ok = yes; then
11623     # An in-tree tool is available and we can use it
11624     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11625     echo "$as_me:$LINENO: result: just compiled" >&5
11626 echo "${ECHO_T}just compiled" >&6
11627   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11628     # We already found the complete path
11629     ac_dir=`dirname $GCC_FOR_TARGET`
11630     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11631 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11632   elif test "x$target" = "x$host"; then
11633     # We can use an host tool
11634     GCC_FOR_TARGET='$()'
11635     echo "$as_me:$LINENO: result: host tool" >&5
11636 echo "${ECHO_T}host tool" >&6
11637   else
11638     # We need a cross tool
11639     echo "$as_me:$LINENO: result: pre-installed" >&5
11640 echo "${ECHO_T}pre-installed" >&6
11641   fi
11642 fi
11643
11644 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11645 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11646 if test "x${build}" != "x${host}" ; then
11647   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11648     # We already found the complete path
11649     ac_dir=`dirname $GCJ_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   else
11653     # Canadian cross, just use what we found
11654     echo "$as_me:$LINENO: result: pre-installed" >&5
11655 echo "${ECHO_T}pre-installed" >&6
11656   fi
11657 else
11658   ok=yes
11659   case " ${configdirs} " in
11660     *" gcc "*) ;;
11661     *) ok=no ;;
11662   esac
11663   case ,${enable_languages}, in
11664     *,java,*) ;;
11665     *) ok=no ;;
11666   esac
11667   if test $ok = yes; then
11668     # An in-tree tool is available and we can use it
11669     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11670     echo "$as_me:$LINENO: result: just compiled" >&5
11671 echo "${ECHO_T}just compiled" >&6
11672   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11673     # We already found the complete path
11674     ac_dir=`dirname $GCJ_FOR_TARGET`
11675     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11676 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11677   elif test "x$target" = "x$host"; then
11678     # We can use an host tool
11679     GCJ_FOR_TARGET='$(GCJ)'
11680     echo "$as_me:$LINENO: result: host tool" >&5
11681 echo "${ECHO_T}host tool" >&6
11682   else
11683     # We need a cross tool
11684     echo "$as_me:$LINENO: result: pre-installed" >&5
11685 echo "${ECHO_T}pre-installed" >&6
11686   fi
11687 fi
11688
11689 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11690 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11691 if test "x${build}" != "x${host}" ; then
11692   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11693     # We already found the complete path
11694     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11695     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11696 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11697   else
11698     # Canadian cross, just use what we found
11699     echo "$as_me:$LINENO: result: pre-installed" >&5
11700 echo "${ECHO_T}pre-installed" >&6
11701   fi
11702 else
11703   ok=yes
11704   case " ${configdirs} " in
11705     *" gcc "*) ;;
11706     *) ok=no ;;
11707   esac
11708   case ,${enable_languages}, in
11709     *,fortran,*) ;;
11710     *) ok=no ;;
11711   esac
11712   if test $ok = yes; then
11713     # An in-tree tool is available and we can use it
11714     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11715     echo "$as_me:$LINENO: result: just compiled" >&5
11716 echo "${ECHO_T}just compiled" >&6
11717   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11718     # We already found the complete path
11719     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11720     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11721 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11722   elif test "x$target" = "x$host"; then
11723     # We can use an host tool
11724     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11725     echo "$as_me:$LINENO: result: host tool" >&5
11726 echo "${ECHO_T}host tool" >&6
11727   else
11728     # We need a cross tool
11729     echo "$as_me:$LINENO: result: pre-installed" >&5
11730 echo "${ECHO_T}pre-installed" >&6
11731   fi
11732 fi
11733
11734 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11735 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11736 if test "x${build}" != "x${host}" ; then
11737   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11738     # We already found the complete path
11739     ac_dir=`dirname $LD_FOR_TARGET`
11740     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11741 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11742   else
11743     # Canadian cross, just use what we found
11744     echo "$as_me:$LINENO: result: pre-installed" >&5
11745 echo "${ECHO_T}pre-installed" >&6
11746   fi
11747 else
11748   ok=yes
11749   case " ${configdirs} " in
11750     *" ld "*) ;;
11751     *) ok=no ;;
11752   esac
11753
11754   if test $ok = yes; then
11755     # An in-tree tool is available and we can use it
11756     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11757     echo "$as_me:$LINENO: result: just compiled" >&5
11758 echo "${ECHO_T}just compiled" >&6
11759   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11760     # We already found the complete path
11761     ac_dir=`dirname $LD_FOR_TARGET`
11762     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11763 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11764   elif test "x$target" = "x$host"; then
11765     # We can use an host tool
11766     LD_FOR_TARGET='$(LD)'
11767     echo "$as_me:$LINENO: result: host tool" >&5
11768 echo "${ECHO_T}host tool" >&6
11769   else
11770     # We need a cross tool
11771     echo "$as_me:$LINENO: result: pre-installed" >&5
11772 echo "${ECHO_T}pre-installed" >&6
11773   fi
11774 fi
11775
11776 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11777 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11778 if test "x${build}" != "x${host}" ; then
11779   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11780     # We already found the complete path
11781     ac_dir=`dirname $LIPO_FOR_TARGET`
11782     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11783 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11784   else
11785     # Canadian cross, just use what we found
11786     echo "$as_me:$LINENO: result: pre-installed" >&5
11787 echo "${ECHO_T}pre-installed" >&6
11788   fi
11789 else
11790   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11791     # We already found the complete path
11792     ac_dir=`dirname $LIPO_FOR_TARGET`
11793     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11794 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11795   elif test "x$target" = "x$host"; then
11796     # We can use an host tool
11797     LIPO_FOR_TARGET='$(LIPO)'
11798     echo "$as_me:$LINENO: result: host tool" >&5
11799 echo "${ECHO_T}host tool" >&6
11800   else
11801     # We need a cross tool
11802     echo "$as_me:$LINENO: result: pre-installed" >&5
11803 echo "${ECHO_T}pre-installed" >&6
11804   fi
11805 fi
11806
11807 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11808 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11809 if test "x${build}" != "x${host}" ; then
11810   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11811     # We already found the complete path
11812     ac_dir=`dirname $NM_FOR_TARGET`
11813     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11814 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11815   else
11816     # Canadian cross, just use what we found
11817     echo "$as_me:$LINENO: result: pre-installed" >&5
11818 echo "${ECHO_T}pre-installed" >&6
11819   fi
11820 else
11821   ok=yes
11822   case " ${configdirs} " in
11823     *" binutils "*) ;;
11824     *) ok=no ;;
11825   esac
11826
11827   if test $ok = yes; then
11828     # An in-tree tool is available and we can use it
11829     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11830     echo "$as_me:$LINENO: result: just compiled" >&5
11831 echo "${ECHO_T}just compiled" >&6
11832   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11833     # We already found the complete path
11834     ac_dir=`dirname $NM_FOR_TARGET`
11835     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11836 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11837   elif test "x$target" = "x$host"; then
11838     # We can use an host tool
11839     NM_FOR_TARGET='$(NM)'
11840     echo "$as_me:$LINENO: result: host tool" >&5
11841 echo "${ECHO_T}host tool" >&6
11842   else
11843     # We need a cross tool
11844     echo "$as_me:$LINENO: result: pre-installed" >&5
11845 echo "${ECHO_T}pre-installed" >&6
11846   fi
11847 fi
11848
11849 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11850 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11851 if test "x${build}" != "x${host}" ; then
11852   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11853     # We already found the complete path
11854     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11855     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11856 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11857   else
11858     # Canadian cross, just use what we found
11859     echo "$as_me:$LINENO: result: pre-installed" >&5
11860 echo "${ECHO_T}pre-installed" >&6
11861   fi
11862 else
11863   ok=yes
11864   case " ${configdirs} " in
11865     *" binutils "*) ;;
11866     *) ok=no ;;
11867   esac
11868
11869   if test $ok = yes; then
11870     # An in-tree tool is available and we can use it
11871     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11872     echo "$as_me:$LINENO: result: just compiled" >&5
11873 echo "${ECHO_T}just compiled" >&6
11874   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11875     # We already found the complete path
11876     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11877     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11878 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11879   elif test "x$target" = "x$host"; then
11880     # We can use an host tool
11881     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11882     echo "$as_me:$LINENO: result: host tool" >&5
11883 echo "${ECHO_T}host tool" >&6
11884   else
11885     # We need a cross tool
11886     echo "$as_me:$LINENO: result: pre-installed" >&5
11887 echo "${ECHO_T}pre-installed" >&6
11888   fi
11889 fi
11890
11891 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11892 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11893 if test "x${build}" != "x${host}" ; then
11894   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11895     # We already found the complete path
11896     ac_dir=`dirname $RANLIB_FOR_TARGET`
11897     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11898 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11899   else
11900     # Canadian cross, just use what we found
11901     echo "$as_me:$LINENO: result: pre-installed" >&5
11902 echo "${ECHO_T}pre-installed" >&6
11903   fi
11904 else
11905   ok=yes
11906   case " ${configdirs} " in
11907     *" binutils "*) ;;
11908     *) ok=no ;;
11909   esac
11910
11911   if test $ok = yes; then
11912     # An in-tree tool is available and we can use it
11913     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11914     echo "$as_me:$LINENO: result: just compiled" >&5
11915 echo "${ECHO_T}just compiled" >&6
11916   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11917     # We already found the complete path
11918     ac_dir=`dirname $RANLIB_FOR_TARGET`
11919     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11920 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11921   elif test "x$target" = "x$host"; then
11922     # We can use an host tool
11923     RANLIB_FOR_TARGET='$(RANLIB)'
11924     echo "$as_me:$LINENO: result: host tool" >&5
11925 echo "${ECHO_T}host tool" >&6
11926   else
11927     # We need a cross tool
11928     echo "$as_me:$LINENO: result: pre-installed" >&5
11929 echo "${ECHO_T}pre-installed" >&6
11930   fi
11931 fi
11932
11933 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11934 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11935 if test "x${build}" != "x${host}" ; then
11936   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11937     # We already found the complete path
11938     ac_dir=`dirname $STRIP_FOR_TARGET`
11939     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11940 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11941   else
11942     # Canadian cross, just use what we found
11943     echo "$as_me:$LINENO: result: pre-installed" >&5
11944 echo "${ECHO_T}pre-installed" >&6
11945   fi
11946 else
11947   ok=yes
11948   case " ${configdirs} " in
11949     *" binutils "*) ;;
11950     *) ok=no ;;
11951   esac
11952
11953   if test $ok = yes; then
11954     # An in-tree tool is available and we can use it
11955     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11956     echo "$as_me:$LINENO: result: just compiled" >&5
11957 echo "${ECHO_T}just compiled" >&6
11958   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11959     # We already found the complete path
11960     ac_dir=`dirname $STRIP_FOR_TARGET`
11961     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11962 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11963   elif test "x$target" = "x$host"; then
11964     # We can use an host tool
11965     STRIP_FOR_TARGET='$(STRIP)'
11966     echo "$as_me:$LINENO: result: host tool" >&5
11967 echo "${ECHO_T}host tool" >&6
11968   else
11969     # We need a cross tool
11970     echo "$as_me:$LINENO: result: pre-installed" >&5
11971 echo "${ECHO_T}pre-installed" >&6
11972   fi
11973 fi
11974
11975 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11976 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11977 if test "x${build}" != "x${host}" ; then
11978   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11979     # We already found the complete path
11980     ac_dir=`dirname $WINDRES_FOR_TARGET`
11981     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11982 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11983   else
11984     # Canadian cross, just use what we found
11985     echo "$as_me:$LINENO: result: pre-installed" >&5
11986 echo "${ECHO_T}pre-installed" >&6
11987   fi
11988 else
11989   ok=yes
11990   case " ${configdirs} " in
11991     *" binutils "*) ;;
11992     *) ok=no ;;
11993   esac
11994
11995   if test $ok = yes; then
11996     # An in-tree tool is available and we can use it
11997     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11998     echo "$as_me:$LINENO: result: just compiled" >&5
11999 echo "${ECHO_T}just compiled" >&6
12000   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
12001     # We already found the complete path
12002     ac_dir=`dirname $WINDRES_FOR_TARGET`
12003     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12004 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12005   elif test "x$target" = "x$host"; then
12006     # We can use an host tool
12007     WINDRES_FOR_TARGET='$(WINDRES)'
12008     echo "$as_me:$LINENO: result: host tool" >&5
12009 echo "${ECHO_T}host tool" >&6
12010   else
12011     # We need a cross tool
12012     echo "$as_me:$LINENO: result: pre-installed" >&5
12013 echo "${ECHO_T}pre-installed" >&6
12014   fi
12015 fi
12016
12017 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12018 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12019 if test "x${build}" != "x${host}" ; then
12020   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12021     # We already found the complete path
12022     ac_dir=`dirname $WINDMC_FOR_TARGET`
12023     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12024 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12025   else
12026     # Canadian cross, just use what we found
12027     echo "$as_me:$LINENO: result: pre-installed" >&5
12028 echo "${ECHO_T}pre-installed" >&6
12029   fi
12030 else
12031   ok=yes
12032   case " ${configdirs} " in
12033     *" binutils "*) ;;
12034     *) ok=no ;;
12035   esac
12036
12037   if test $ok = yes; then
12038     # An in-tree tool is available and we can use it
12039     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12040     echo "$as_me:$LINENO: result: just compiled" >&5
12041 echo "${ECHO_T}just compiled" >&6
12042   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12043     # We already found the complete path
12044     ac_dir=`dirname $WINDMC_FOR_TARGET`
12045     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12046 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12047   elif test "x$target" = "x$host"; then
12048     # We can use an host tool
12049     WINDMC_FOR_TARGET='$(WINDMC)'
12050     echo "$as_me:$LINENO: result: host tool" >&5
12051 echo "${ECHO_T}host tool" >&6
12052   else
12053     # We need a cross tool
12054     echo "$as_me:$LINENO: result: pre-installed" >&5
12055 echo "${ECHO_T}pre-installed" >&6
12056   fi
12057 fi
12058
12059
12060
12061
12062
12063 # Certain tools may need extra flags.
12064 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12065 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12066 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12067
12068 # When building target libraries, except in a Canadian cross, we use
12069 # the same toolchain as the compiler we just built.
12070 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12071 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12072 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12073 if test $host = $build; then
12074   case " $configdirs " in
12075     *" gcc "*)
12076       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12077       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12078       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12079       ;;
12080   esac
12081 fi
12082
12083
12084
12085
12086
12087 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12088 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12089 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12090 if test "${enable_maintainer_mode+set}" = set; then
12091   enableval="$enable_maintainer_mode"
12092   USE_MAINTAINER_MODE=$enableval
12093 else
12094   USE_MAINTAINER_MODE=no
12095 fi;
12096 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12097 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12098
12099
12100 if test "$USE_MAINTAINER_MODE" = yes; then
12101   MAINTAINER_MODE_TRUE=
12102   MAINTAINER_MODE_FALSE='#'
12103 else
12104   MAINTAINER_MODE_TRUE='#'
12105   MAINTAINER_MODE_FALSE=
12106 fi
12107 MAINT=$MAINTAINER_MODE_TRUE
12108
12109 # ---------------------
12110 # GCC bootstrap support
12111 # ---------------------
12112
12113 # Stage specific cflags for build.
12114 stage1_cflags="-g"
12115 case $build in
12116   vax-*-*)
12117     case ${GCC} in
12118       yes) stage1_cflags="-g -Wa,-J" ;;
12119       *) stage1_cflags="-g -J" ;;
12120     esac ;;
12121 esac
12122
12123 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12124 if test "$GCC" = yes; then
12125   saved_CFLAGS="$CFLAGS"
12126
12127   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12128   CFLAGS="$CFLAGS -fkeep-inline-functions"
12129   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12130 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12131   cat >conftest.$ac_ext <<_ACEOF
12132 /* confdefs.h.  */
12133 _ACEOF
12134 cat confdefs.h >>conftest.$ac_ext
12135 cat >>conftest.$ac_ext <<_ACEOF
12136 /* end confdefs.h.  */
12137
12138 #if (__GNUC__ < 3) \
12139     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12140                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12141 #error http://gcc.gnu.org/PR29382
12142 #endif
12143
12144 int
12145 main ()
12146 {
12147
12148   ;
12149   return 0;
12150 }
12151 _ACEOF
12152 rm -f conftest.$ac_objext
12153 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12154   (eval $ac_compile) 2>conftest.er1
12155   ac_status=$?
12156   grep -v '^ *+' conftest.er1 >conftest.err
12157   rm -f conftest.er1
12158   cat conftest.err >&5
12159   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12160   (exit $ac_status); } &&
12161          { ac_try='test -z "$ac_c_werror_flag"
12162                          || test ! -s conftest.err'
12163   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12164   (eval $ac_try) 2>&5
12165   ac_status=$?
12166   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12167   (exit $ac_status); }; } &&
12168          { ac_try='test -s conftest.$ac_objext'
12169   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12170   (eval $ac_try) 2>&5
12171   ac_status=$?
12172   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12173   (exit $ac_status); }; }; then
12174   echo "$as_me:$LINENO: result: yes" >&5
12175 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12176 else
12177   echo "$as_me: failed program was:" >&5
12178 sed 's/^/| /' conftest.$ac_ext >&5
12179
12180 echo "$as_me:$LINENO: result: no" >&5
12181 echo "${ECHO_T}no" >&6
12182 fi
12183 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12184
12185   CFLAGS="$saved_CFLAGS"
12186 fi
12187
12188
12189
12190 # Enable --enable-checking in stage1 of the compiler.
12191 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12192 if test "${enable_stage1_checking+set}" = set; then
12193   enableval="$enable_stage1_checking"
12194   stage1_checking=--enable-checking=${enable_stage1_checking}
12195 else
12196   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12197   stage1_checking=--enable-checking=yes,types
12198 else
12199   stage1_checking=--enable-checking=$enable_checking,types
12200 fi
12201 fi;
12202
12203
12204 # Enable -Werror in bootstrap stage2 and later.
12205 # Check whether --enable-werror or --disable-werror was given.
12206 if test "${enable_werror+set}" = set; then
12207   enableval="$enable_werror"
12208
12209 else
12210   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12211   enable_werror=yes
12212 else
12213   enable_werror=no
12214 fi
12215 fi;
12216 case ${enable_werror} in
12217   yes) stage2_werror_flag="--enable-werror-always" ;;
12218   *) stage2_werror_flag="" ;;
12219 esac
12220
12221
12222 # Flags needed to enable html installing and building
12223
12224 # Check whether --with-datarootdir or --without-datarootdir was given.
12225 if test "${with_datarootdir+set}" = set; then
12226   withval="$with_datarootdir"
12227   datarootdir="\${prefix}/${withval}"
12228 else
12229   datarootdir="\${prefix}/share"
12230 fi;
12231
12232
12233 # Check whether --with-docdir or --without-docdir was given.
12234 if test "${with_docdir+set}" = set; then
12235   withval="$with_docdir"
12236   docdir="\${prefix}/${withval}"
12237 else
12238   docdir="\${datarootdir}/doc"
12239 fi;
12240
12241
12242 # Check whether --with-pdfdir or --without-pdfdir was given.
12243 if test "${with_pdfdir+set}" = set; then
12244   withval="$with_pdfdir"
12245   pdfdir="\${prefix}/${withval}"
12246 else
12247   pdfdir="\${docdir}"
12248 fi;
12249
12250
12251 # Check whether --with-htmldir or --without-htmldir was given.
12252 if test "${with_htmldir+set}" = set; then
12253   withval="$with_htmldir"
12254   htmldir="\${prefix}/${withval}"
12255 else
12256   htmldir="\${docdir}"
12257 fi;
12258
12259
12260
12261
12262
12263
12264           ac_config_files="$ac_config_files Makefile"
12265 cat >confcache <<\_ACEOF
12266 # This file is a shell script that caches the results of configure
12267 # tests run on this system so they can be shared between configure
12268 # scripts and configure runs, see configure's option --config-cache.
12269 # It is not useful on other systems.  If it contains results you don't
12270 # want to keep, you may remove or edit it.
12271 #
12272 # config.status only pays attention to the cache file if you give it
12273 # the --recheck option to rerun configure.
12274 #
12275 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12276 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12277 # following values.
12278
12279 _ACEOF
12280
12281 # The following way of writing the cache mishandles newlines in values,
12282 # but we know of no workaround that is simple, portable, and efficient.
12283 # So, don't put newlines in cache variables' values.
12284 # Ultrix sh set writes to stderr and can't be redirected directly,
12285 # and sets the high bit in the cache file unless we assign to the vars.
12286 {
12287   (set) 2>&1 |
12288     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12289     *ac_space=\ *)
12290       # `set' does not quote correctly, so add quotes (double-quote
12291       # substitution turns \\\\ into \\, and sed turns \\ into \).
12292       sed -n \
12293         "s/'/'\\\\''/g;
12294           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12295       ;;
12296     *)
12297       # `set' quotes correctly as required by POSIX, so do not add quotes.
12298       sed -n \
12299         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12300       ;;
12301     esac;
12302 } |
12303   sed '
12304      t clear
12305      : clear
12306      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12307      t end
12308      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12309      : end' >>confcache
12310 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12311   if test -w $cache_file; then
12312     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12313     cat confcache >$cache_file
12314   else
12315     echo "not updating unwritable cache $cache_file"
12316   fi
12317 fi
12318 rm -f confcache
12319
12320 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12321 # Let make expand exec_prefix.
12322 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12323
12324 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12325 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12326 # trailing colons and then remove the whole line if VPATH becomes empty
12327 # (actually we leave an empty line to preserve line numbers).
12328 if test "x$srcdir" = x.; then
12329   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12330 s/:*\$(srcdir):*/:/;
12331 s/:*\${srcdir}:*/:/;
12332 s/:*@srcdir@:*/:/;
12333 s/^\([^=]*=[     ]*\):*/\1/;
12334 s/:*$//;
12335 s/^[^=]*=[       ]*$//;
12336 }'
12337 fi
12338
12339 # Transform confdefs.h into DEFS.
12340 # Protect against shell expansion while executing Makefile rules.
12341 # Protect against Makefile macro expansion.
12342 #
12343 # If the first sed substitution is executed (which looks for macros that
12344 # take arguments), then we branch to the quote section.  Otherwise,
12345 # look for a macro that doesn't take arguments.
12346 cat >confdef2opt.sed <<\_ACEOF
12347 t clear
12348 : clear
12349 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12350 t quote
12351 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12352 t quote
12353 d
12354 : quote
12355 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12356 s,\[,\\&,g
12357 s,\],\\&,g
12358 s,\$,$$,g
12359 p
12360 _ACEOF
12361 # We use echo to avoid assuming a particular line-breaking character.
12362 # The extra dot is to prevent the shell from consuming trailing
12363 # line-breaks from the sub-command output.  A line-break within
12364 # single-quotes doesn't work because, if this script is created in a
12365 # platform that uses two characters for line-breaks (e.g., DOS), tr
12366 # would break.
12367 ac_LF_and_DOT=`echo; echo .`
12368 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12369 rm -f confdef2opt.sed
12370
12371
12372 ac_libobjs=
12373 ac_ltlibobjs=
12374 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12375   # 1. Remove the extension, and $U if already installed.
12376   ac_i=`echo "$ac_i" |
12377          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12378   # 2. Add them.
12379   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12380   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12381 done
12382 LIBOBJS=$ac_libobjs
12383
12384 LTLIBOBJS=$ac_ltlibobjs
12385
12386
12387
12388 : ${CONFIG_STATUS=./config.status}
12389 ac_clean_files_save=$ac_clean_files
12390 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12391 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12392 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12393 cat >$CONFIG_STATUS <<_ACEOF
12394 #! $SHELL
12395 # Generated by $as_me.
12396 # Run this file to recreate the current configuration.
12397 # Compiler output produced by configure, useful for debugging
12398 # configure, is in config.log if it exists.
12399
12400 debug=false
12401 ac_cs_recheck=false
12402 ac_cs_silent=false
12403 SHELL=\${CONFIG_SHELL-$SHELL}
12404 _ACEOF
12405
12406 cat >>$CONFIG_STATUS <<\_ACEOF
12407 ## --------------------- ##
12408 ## M4sh Initialization.  ##
12409 ## --------------------- ##
12410
12411 # Be Bourne compatible
12412 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12413   emulate sh
12414   NULLCMD=:
12415   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12416   # is contrary to our usage.  Disable this feature.
12417   alias -g '${1+"$@"}'='"$@"'
12418 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12419   set -o posix
12420 fi
12421 DUALCASE=1; export DUALCASE # for MKS sh
12422
12423 # Support unset when possible.
12424 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12425   as_unset=unset
12426 else
12427   as_unset=false
12428 fi
12429
12430
12431 # Work around bugs in pre-3.0 UWIN ksh.
12432 $as_unset ENV MAIL MAILPATH
12433 PS1='$ '
12434 PS2='> '
12435 PS4='+ '
12436
12437 # NLS nuisances.
12438 for as_var in \
12439   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12440   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12441   LC_TELEPHONE LC_TIME
12442 do
12443   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12444     eval $as_var=C; export $as_var
12445   else
12446     $as_unset $as_var
12447   fi
12448 done
12449
12450 # Required to use basename.
12451 if expr a : '\(a\)' >/dev/null 2>&1; then
12452   as_expr=expr
12453 else
12454   as_expr=false
12455 fi
12456
12457 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12458   as_basename=basename
12459 else
12460   as_basename=false
12461 fi
12462
12463
12464 # Name of the executable.
12465 as_me=`$as_basename "$0" ||
12466 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12467          X"$0" : 'X\(//\)$' \| \
12468          X"$0" : 'X\(/\)$' \| \
12469          .     : '\(.\)' 2>/dev/null ||
12470 echo X/"$0" |
12471     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12472           /^X\/\(\/\/\)$/{ s//\1/; q; }
12473           /^X\/\(\/\).*/{ s//\1/; q; }
12474           s/.*/./; q'`
12475
12476
12477 # PATH needs CR, and LINENO needs CR and PATH.
12478 # Avoid depending upon Character Ranges.
12479 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12480 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12481 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12482 as_cr_digits='0123456789'
12483 as_cr_alnum=$as_cr_Letters$as_cr_digits
12484
12485 # The user is always right.
12486 if test "${PATH_SEPARATOR+set}" != set; then
12487   echo "#! /bin/sh" >conf$$.sh
12488   echo  "exit 0"   >>conf$$.sh
12489   chmod +x conf$$.sh
12490   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12491     PATH_SEPARATOR=';'
12492   else
12493     PATH_SEPARATOR=:
12494   fi
12495   rm -f conf$$.sh
12496 fi
12497
12498
12499   as_lineno_1=$LINENO
12500   as_lineno_2=$LINENO
12501   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12502   test "x$as_lineno_1" != "x$as_lineno_2" &&
12503   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12504   # Find who we are.  Look in the path if we contain no path at all
12505   # relative or not.
12506   case $0 in
12507     *[\\/]* ) as_myself=$0 ;;
12508     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12509 for as_dir in $PATH
12510 do
12511   IFS=$as_save_IFS
12512   test -z "$as_dir" && as_dir=.
12513   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12514 done
12515
12516        ;;
12517   esac
12518   # We did not find ourselves, most probably we were run as `sh COMMAND'
12519   # in which case we are not to be found in the path.
12520   if test "x$as_myself" = x; then
12521     as_myself=$0
12522   fi
12523   if test ! -f "$as_myself"; then
12524     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12525 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12526    { (exit 1); exit 1; }; }
12527   fi
12528   case $CONFIG_SHELL in
12529   '')
12530     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12531 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12532 do
12533   IFS=$as_save_IFS
12534   test -z "$as_dir" && as_dir=.
12535   for as_base in sh bash ksh sh5; do
12536          case $as_dir in
12537          /*)
12538            if ("$as_dir/$as_base" -c '
12539   as_lineno_1=$LINENO
12540   as_lineno_2=$LINENO
12541   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12542   test "x$as_lineno_1" != "x$as_lineno_2" &&
12543   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12544              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12545              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12546              CONFIG_SHELL=$as_dir/$as_base
12547              export CONFIG_SHELL
12548              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12549            fi;;
12550          esac
12551        done
12552 done
12553 ;;
12554   esac
12555
12556   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12557   # uniformly replaced by the line number.  The first 'sed' inserts a
12558   # line-number line before each line; the second 'sed' does the real
12559   # work.  The second script uses 'N' to pair each line-number line
12560   # with the numbered line, and appends trailing '-' during
12561   # substitution so that $LINENO is not a special case at line end.
12562   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12563   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12564   sed '=' <$as_myself |
12565     sed '
12566       N
12567       s,$,-,
12568       : loop
12569       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12570       t loop
12571       s,-$,,
12572       s,^['$as_cr_digits']*\n,,
12573     ' >$as_me.lineno &&
12574   chmod +x $as_me.lineno ||
12575     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12576 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12577    { (exit 1); exit 1; }; }
12578
12579   # Don't try to exec as it changes $[0], causing all sort of problems
12580   # (the dirname of $[0] is not the place where we might find the
12581   # original and so on.  Autoconf is especially sensible to this).
12582   . ./$as_me.lineno
12583   # Exit status is that of the last command.
12584   exit
12585 }
12586
12587
12588 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12589   *c*,-n*) ECHO_N= ECHO_C='
12590 ' ECHO_T='      ' ;;
12591   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12592   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12593 esac
12594
12595 if expr a : '\(a\)' >/dev/null 2>&1; then
12596   as_expr=expr
12597 else
12598   as_expr=false
12599 fi
12600
12601 rm -f conf$$ conf$$.exe conf$$.file
12602 echo >conf$$.file
12603 if ln -s conf$$.file conf$$ 2>/dev/null; then
12604   # We could just check for DJGPP; but this test a) works b) is more generic
12605   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12606   if test -f conf$$.exe; then
12607     # Don't use ln at all; we don't have any links
12608     as_ln_s='cp -p'
12609   else
12610     as_ln_s='ln -s'
12611   fi
12612 elif ln conf$$.file conf$$ 2>/dev/null; then
12613   as_ln_s=ln
12614 else
12615   as_ln_s='cp -p'
12616 fi
12617 rm -f conf$$ conf$$.exe conf$$.file
12618
12619 if mkdir -p . 2>/dev/null; then
12620   as_mkdir_p=:
12621 else
12622   test -d ./-p && rmdir ./-p
12623   as_mkdir_p=false
12624 fi
12625
12626 as_executable_p="test -f"
12627
12628 # Sed expression to map a string onto a valid CPP name.
12629 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12630
12631 # Sed expression to map a string onto a valid variable name.
12632 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12633
12634
12635 # IFS
12636 # We need space, tab and new line, in precisely that order.
12637 as_nl='
12638 '
12639 IFS="   $as_nl"
12640
12641 # CDPATH.
12642 $as_unset CDPATH
12643
12644 exec 6>&1
12645
12646 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12647 # report actual input values of CONFIG_FILES etc. instead of their
12648 # values after options handling.  Logging --version etc. is OK.
12649 exec 5>>config.log
12650 {
12651   echo
12652   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12653 ## Running $as_me. ##
12654 _ASBOX
12655 } >&5
12656 cat >&5 <<_CSEOF
12657
12658 This file was extended by $as_me, which was
12659 generated by GNU Autoconf 2.59.  Invocation command line was
12660
12661   CONFIG_FILES    = $CONFIG_FILES
12662   CONFIG_HEADERS  = $CONFIG_HEADERS
12663   CONFIG_LINKS    = $CONFIG_LINKS
12664   CONFIG_COMMANDS = $CONFIG_COMMANDS
12665   $ $0 $@
12666
12667 _CSEOF
12668 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12669 echo >&5
12670 _ACEOF
12671
12672 # Files that config.status was made for.
12673 if test -n "$ac_config_files"; then
12674   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12675 fi
12676
12677 if test -n "$ac_config_headers"; then
12678   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12679 fi
12680
12681 if test -n "$ac_config_links"; then
12682   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12683 fi
12684
12685 if test -n "$ac_config_commands"; then
12686   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12687 fi
12688
12689 cat >>$CONFIG_STATUS <<\_ACEOF
12690
12691 ac_cs_usage="\
12692 \`$as_me' instantiates files from templates according to the
12693 current configuration.
12694
12695 Usage: $0 [OPTIONS] [FILE]...
12696
12697   -h, --help       print this help, then exit
12698   -V, --version    print version number, then exit
12699   -q, --quiet      do not print progress messages
12700   -d, --debug      don't remove temporary files
12701       --recheck    update $as_me by reconfiguring in the same conditions
12702   --file=FILE[:TEMPLATE]
12703                    instantiate the configuration file FILE
12704
12705 Configuration files:
12706 $config_files
12707
12708 Report bugs to <bug-autoconf@gnu.org>."
12709 _ACEOF
12710
12711 cat >>$CONFIG_STATUS <<_ACEOF
12712 ac_cs_version="\\
12713 config.status
12714 configured by $0, generated by GNU Autoconf 2.59,
12715   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12716
12717 Copyright (C) 2003 Free Software Foundation, Inc.
12718 This config.status script is free software; the Free Software Foundation
12719 gives unlimited permission to copy, distribute and modify it."
12720 srcdir=$srcdir
12721 INSTALL="$INSTALL"
12722 _ACEOF
12723
12724 cat >>$CONFIG_STATUS <<\_ACEOF
12725 # If no file are specified by the user, then we need to provide default
12726 # value.  By we need to know if files were specified by the user.
12727 ac_need_defaults=:
12728 while test $# != 0
12729 do
12730   case $1 in
12731   --*=*)
12732     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12733     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12734     ac_shift=:
12735     ;;
12736   -*)
12737     ac_option=$1
12738     ac_optarg=$2
12739     ac_shift=shift
12740     ;;
12741   *) # This is not an option, so the user has probably given explicit
12742      # arguments.
12743      ac_option=$1
12744      ac_need_defaults=false;;
12745   esac
12746
12747   case $ac_option in
12748   # Handling of the options.
12749 _ACEOF
12750 cat >>$CONFIG_STATUS <<\_ACEOF
12751   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12752     ac_cs_recheck=: ;;
12753   --version | --vers* | -V )
12754     echo "$ac_cs_version"; exit 0 ;;
12755   --he | --h)
12756     # Conflict between --help and --header
12757     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12758 Try \`$0 --help' for more information." >&5
12759 echo "$as_me: error: ambiguous option: $1
12760 Try \`$0 --help' for more information." >&2;}
12761    { (exit 1); exit 1; }; };;
12762   --help | --hel | -h )
12763     echo "$ac_cs_usage"; exit 0 ;;
12764   --debug | --d* | -d )
12765     debug=: ;;
12766   --file | --fil | --fi | --f )
12767     $ac_shift
12768     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12769     ac_need_defaults=false;;
12770   --header | --heade | --head | --hea )
12771     $ac_shift
12772     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12773     ac_need_defaults=false;;
12774   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12775   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12776     ac_cs_silent=: ;;
12777
12778   # This is an error.
12779   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12780 Try \`$0 --help' for more information." >&5
12781 echo "$as_me: error: unrecognized option: $1
12782 Try \`$0 --help' for more information." >&2;}
12783    { (exit 1); exit 1; }; } ;;
12784
12785   *) ac_config_targets="$ac_config_targets $1" ;;
12786
12787   esac
12788   shift
12789 done
12790
12791 ac_configure_extra_args=
12792
12793 if $ac_cs_silent; then
12794   exec 6>/dev/null
12795   ac_configure_extra_args="$ac_configure_extra_args --silent"
12796 fi
12797
12798 _ACEOF
12799 cat >>$CONFIG_STATUS <<_ACEOF
12800 if \$ac_cs_recheck; then
12801   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12802   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12803 fi
12804
12805 _ACEOF
12806
12807
12808
12809
12810
12811 cat >>$CONFIG_STATUS <<\_ACEOF
12812 for ac_config_target in $ac_config_targets
12813 do
12814   case "$ac_config_target" in
12815   # Handling of arguments.
12816   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12817   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12818 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12819    { (exit 1); exit 1; }; };;
12820   esac
12821 done
12822
12823 # If the user did not use the arguments to specify the items to instantiate,
12824 # then the envvar interface is used.  Set only those that are not.
12825 # We use the long form for the default assignment because of an extremely
12826 # bizarre bug on SunOS 4.1.3.
12827 if $ac_need_defaults; then
12828   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12829 fi
12830
12831 # Have a temporary directory for convenience.  Make it in the build tree
12832 # simply because there is no reason to put it here, and in addition,
12833 # creating and moving files from /tmp can sometimes cause problems.
12834 # Create a temporary directory, and hook for its removal unless debugging.
12835 $debug ||
12836 {
12837   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12838   trap '{ (exit 1); exit 1; }' 1 2 13 15
12839 }
12840
12841 # Create a (secure) tmp directory for tmp files.
12842
12843 {
12844   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12845   test -n "$tmp" && test -d "$tmp"
12846 }  ||
12847 {
12848   tmp=./confstat$$-$RANDOM
12849   (umask 077 && mkdir $tmp)
12850 } ||
12851 {
12852    echo "$me: cannot create a temporary directory in ." >&2
12853    { (exit 1); exit 1; }
12854 }
12855
12856 _ACEOF
12857
12858 cat >>$CONFIG_STATUS <<_ACEOF
12859
12860 #
12861 # CONFIG_FILES section.
12862 #
12863
12864 # No need to generate the scripts if there are no CONFIG_FILES.
12865 # This happens for instance when ./config.status config.h
12866 if test -n "\$CONFIG_FILES"; then
12867   # Protect against being on the right side of a sed subst in config.status.
12868   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12869    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12870 s,@SHELL@,$SHELL,;t t
12871 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12872 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12873 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12874 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12875 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12876 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12877 s,@exec_prefix@,$exec_prefix,;t t
12878 s,@prefix@,$prefix,;t t
12879 s,@program_transform_name@,$program_transform_name,;t t
12880 s,@bindir@,$bindir,;t t
12881 s,@sbindir@,$sbindir,;t t
12882 s,@libexecdir@,$libexecdir,;t t
12883 s,@datadir@,$datadir,;t t
12884 s,@sysconfdir@,$sysconfdir,;t t
12885 s,@sharedstatedir@,$sharedstatedir,;t t
12886 s,@localstatedir@,$localstatedir,;t t
12887 s,@libdir@,$libdir,;t t
12888 s,@includedir@,$includedir,;t t
12889 s,@oldincludedir@,$oldincludedir,;t t
12890 s,@infodir@,$infodir,;t t
12891 s,@mandir@,$mandir,;t t
12892 s,@build_alias@,$build_alias,;t t
12893 s,@host_alias@,$host_alias,;t t
12894 s,@target_alias@,$target_alias,;t t
12895 s,@DEFS@,$DEFS,;t t
12896 s,@ECHO_C@,$ECHO_C,;t t
12897 s,@ECHO_N@,$ECHO_N,;t t
12898 s,@ECHO_T@,$ECHO_T,;t t
12899 s,@LIBS@,$LIBS,;t t
12900 s,@build@,$build,;t t
12901 s,@build_cpu@,$build_cpu,;t t
12902 s,@build_vendor@,$build_vendor,;t t
12903 s,@build_os@,$build_os,;t t
12904 s,@build_noncanonical@,$build_noncanonical,;t t
12905 s,@host_noncanonical@,$host_noncanonical,;t t
12906 s,@target_noncanonical@,$target_noncanonical,;t t
12907 s,@host@,$host,;t t
12908 s,@host_cpu@,$host_cpu,;t t
12909 s,@host_vendor@,$host_vendor,;t t
12910 s,@host_os@,$host_os,;t t
12911 s,@target@,$target,;t t
12912 s,@target_cpu@,$target_cpu,;t t
12913 s,@target_vendor@,$target_vendor,;t t
12914 s,@target_os@,$target_os,;t t
12915 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12916 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12917 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12918 s,@LN@,$LN,;t t
12919 s,@LN_S@,$LN_S,;t t
12920 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12921 s,@build_libsubdir@,$build_libsubdir,;t t
12922 s,@build_subdir@,$build_subdir,;t t
12923 s,@host_subdir@,$host_subdir,;t t
12924 s,@target_subdir@,$target_subdir,;t t
12925 s,@CC@,$CC,;t t
12926 s,@CFLAGS@,$CFLAGS,;t t
12927 s,@LDFLAGS@,$LDFLAGS,;t t
12928 s,@CPPFLAGS@,$CPPFLAGS,;t t
12929 s,@ac_ct_CC@,$ac_ct_CC,;t t
12930 s,@EXEEXT@,$EXEEXT,;t t
12931 s,@OBJEXT@,$OBJEXT,;t t
12932 s,@CXX@,$CXX,;t t
12933 s,@CXXFLAGS@,$CXXFLAGS,;t t
12934 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12935 s,@GNATBIND@,$GNATBIND,;t t
12936 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12937 s,@GNATMAKE@,$GNATMAKE,;t t
12938 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12939 s,@do_compare@,$do_compare,;t t
12940 s,@gmplibs@,$gmplibs,;t t
12941 s,@gmpinc@,$gmpinc,;t t
12942 s,@stage1_languages@,$stage1_languages,;t t
12943 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12944 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12945 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
12946 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
12947 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12948 s,@tooldir@,$tooldir,;t t
12949 s,@build_tooldir@,$build_tooldir,;t t
12950 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12951 s,@GDB_TK@,$GDB_TK,;t t
12952 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12953 s,@build_configargs@,$build_configargs,;t t
12954 s,@build_configdirs@,$build_configdirs,;t t
12955 s,@host_configargs@,$host_configargs,;t t
12956 s,@configdirs@,$configdirs,;t t
12957 s,@target_configargs@,$target_configargs,;t t
12958 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12959 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12960 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12961 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12962 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
12963 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
12964 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
12965 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
12966 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
12967 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
12968 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
12969 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
12970 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
12971 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
12972 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
12973 s,@config_shell@,$config_shell,;t t
12974 s,@YACC@,$YACC,;t t
12975 s,@BISON@,$BISON,;t t
12976 s,@M4@,$M4,;t t
12977 s,@LEX@,$LEX,;t t
12978 s,@FLEX@,$FLEX,;t t
12979 s,@MAKEINFO@,$MAKEINFO,;t t
12980 s,@EXPECT@,$EXPECT,;t t
12981 s,@RUNTEST@,$RUNTEST,;t t
12982 s,@AR@,$AR,;t t
12983 s,@AS@,$AS,;t t
12984 s,@DLLTOOL@,$DLLTOOL,;t t
12985 s,@LD@,$LD,;t t
12986 s,@LIPO@,$LIPO,;t t
12987 s,@NM@,$NM,;t t
12988 s,@RANLIB@,$RANLIB,;t t
12989 s,@STRIP@,$STRIP,;t t
12990 s,@WINDRES@,$WINDRES,;t t
12991 s,@WINDMC@,$WINDMC,;t t
12992 s,@OBJCOPY@,$OBJCOPY,;t t
12993 s,@OBJDUMP@,$OBJDUMP,;t t
12994 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12995 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12996 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12997 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12998 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12999 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
13000 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
13001 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
13002 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
13003 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
13004 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
13005 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
13006 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
13007 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
13008 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
13009 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
13010 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
13011 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
13012 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13013 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13014 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13015 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13016 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13017 s,@MAINT@,$MAINT,;t t
13018 s,@stage1_cflags@,$stage1_cflags,;t t
13019 s,@stage1_checking@,$stage1_checking,;t t
13020 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13021 s,@datarootdir@,$datarootdir,;t t
13022 s,@docdir@,$docdir,;t t
13023 s,@pdfdir@,$pdfdir,;t t
13024 s,@htmldir@,$htmldir,;t t
13025 s,@LIBOBJS@,$LIBOBJS,;t t
13026 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13027 /@serialization_dependencies@/r $serialization_dependencies
13028 s,@serialization_dependencies@,,;t t
13029 /@host_makefile_frag@/r $host_makefile_frag
13030 s,@host_makefile_frag@,,;t t
13031 /@target_makefile_frag@/r $target_makefile_frag
13032 s,@target_makefile_frag@,,;t t
13033 /@alphaieee_frag@/r $alphaieee_frag
13034 s,@alphaieee_frag@,,;t t
13035 /@ospace_frag@/r $ospace_frag
13036 s,@ospace_frag@,,;t t
13037 CEOF
13038
13039 _ACEOF
13040
13041   cat >>$CONFIG_STATUS <<\_ACEOF
13042   # Split the substitutions into bite-sized pieces for seds with
13043   # small command number limits, like on Digital OSF/1 and HP-UX.
13044   ac_max_sed_lines=48
13045   ac_sed_frag=1 # Number of current file.
13046   ac_beg=1 # First line for current file.
13047   ac_end=$ac_max_sed_lines # Line after last line for current file.
13048   ac_more_lines=:
13049   ac_sed_cmds=
13050   while $ac_more_lines; do
13051     if test $ac_beg -gt 1; then
13052       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13053     else
13054       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13055     fi
13056     if test ! -s $tmp/subs.frag; then
13057       ac_more_lines=false
13058     else
13059       # The purpose of the label and of the branching condition is to
13060       # speed up the sed processing (if there are no `@' at all, there
13061       # is no need to browse any of the substitutions).
13062       # These are the two extra sed commands mentioned above.
13063       (echo ':t
13064   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13065       if test -z "$ac_sed_cmds"; then
13066         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13067       else
13068         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13069       fi
13070       ac_sed_frag=`expr $ac_sed_frag + 1`
13071       ac_beg=$ac_end
13072       ac_end=`expr $ac_end + $ac_max_sed_lines`
13073     fi
13074   done
13075   if test -z "$ac_sed_cmds"; then
13076     ac_sed_cmds=cat
13077   fi
13078 fi # test -n "$CONFIG_FILES"
13079
13080 _ACEOF
13081 cat >>$CONFIG_STATUS <<\_ACEOF
13082 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13083   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13084   case $ac_file in
13085   - | *:- | *:-:* ) # input from stdin
13086         cat >$tmp/stdin
13087         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13088         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13089   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13090         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13091   * )   ac_file_in=$ac_file.in ;;
13092   esac
13093
13094   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13095   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13096 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13097          X"$ac_file" : 'X\(//\)[^/]' \| \
13098          X"$ac_file" : 'X\(//\)$' \| \
13099          X"$ac_file" : 'X\(/\)' \| \
13100          .     : '\(.\)' 2>/dev/null ||
13101 echo X"$ac_file" |
13102     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13103           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13104           /^X\(\/\/\)$/{ s//\1/; q; }
13105           /^X\(\/\).*/{ s//\1/; q; }
13106           s/.*/./; q'`
13107   { if $as_mkdir_p; then
13108     mkdir -p "$ac_dir"
13109   else
13110     as_dir="$ac_dir"
13111     as_dirs=
13112     while test ! -d "$as_dir"; do
13113       as_dirs="$as_dir $as_dirs"
13114       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13115 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13116          X"$as_dir" : 'X\(//\)[^/]' \| \
13117          X"$as_dir" : 'X\(//\)$' \| \
13118          X"$as_dir" : 'X\(/\)' \| \
13119          .     : '\(.\)' 2>/dev/null ||
13120 echo X"$as_dir" |
13121     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13122           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13123           /^X\(\/\/\)$/{ s//\1/; q; }
13124           /^X\(\/\).*/{ s//\1/; q; }
13125           s/.*/./; q'`
13126     done
13127     test ! -n "$as_dirs" || mkdir $as_dirs
13128   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13129 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13130    { (exit 1); exit 1; }; }; }
13131
13132   ac_builddir=.
13133
13134 if test "$ac_dir" != .; then
13135   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13136   # A "../" for each directory in $ac_dir_suffix.
13137   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13138 else
13139   ac_dir_suffix= ac_top_builddir=
13140 fi
13141
13142 case $srcdir in
13143   .)  # No --srcdir option.  We are building in place.
13144     ac_srcdir=.
13145     if test -z "$ac_top_builddir"; then
13146        ac_top_srcdir=.
13147     else
13148        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13149     fi ;;
13150   [\\/]* | ?:[\\/]* )  # Absolute path.
13151     ac_srcdir=$srcdir$ac_dir_suffix;
13152     ac_top_srcdir=$srcdir ;;
13153   *) # Relative path.
13154     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13155     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13156 esac
13157
13158 # Do not use `cd foo && pwd` to compute absolute paths, because
13159 # the directories may not exist.
13160 case `pwd` in
13161 .) ac_abs_builddir="$ac_dir";;
13162 *)
13163   case "$ac_dir" in
13164   .) ac_abs_builddir=`pwd`;;
13165   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13166   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13167   esac;;
13168 esac
13169 case $ac_abs_builddir in
13170 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13171 *)
13172   case ${ac_top_builddir}. in
13173   .) ac_abs_top_builddir=$ac_abs_builddir;;
13174   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13175   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13176   esac;;
13177 esac
13178 case $ac_abs_builddir in
13179 .) ac_abs_srcdir=$ac_srcdir;;
13180 *)
13181   case $ac_srcdir in
13182   .) ac_abs_srcdir=$ac_abs_builddir;;
13183   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13184   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13185   esac;;
13186 esac
13187 case $ac_abs_builddir in
13188 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13189 *)
13190   case $ac_top_srcdir in
13191   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13192   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13193   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13194   esac;;
13195 esac
13196
13197
13198   case $INSTALL in
13199   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13200   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13201   esac
13202
13203   if test x"$ac_file" != x-; then
13204     { echo "$as_me:$LINENO: creating $ac_file" >&5
13205 echo "$as_me: creating $ac_file" >&6;}
13206     rm -f "$ac_file"
13207   fi
13208   # Let's still pretend it is `configure' which instantiates (i.e., don't
13209   # use $as_me), people would be surprised to read:
13210   #    /* config.h.  Generated by config.status.  */
13211   if test x"$ac_file" = x-; then
13212     configure_input=
13213   else
13214     configure_input="$ac_file.  "
13215   fi
13216   configure_input=$configure_input"Generated from `echo $ac_file_in |
13217                                      sed 's,.*/,,'` by configure."
13218
13219   # First look for the input files in the build tree, otherwise in the
13220   # src tree.
13221   ac_file_inputs=`IFS=:
13222     for f in $ac_file_in; do
13223       case $f in
13224       -) echo $tmp/stdin ;;
13225       [\\/$]*)
13226          # Absolute (can't be DOS-style, as IFS=:)
13227          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13228 echo "$as_me: error: cannot find input file: $f" >&2;}
13229    { (exit 1); exit 1; }; }
13230          echo "$f";;
13231       *) # Relative
13232          if test -f "$f"; then
13233            # Build tree
13234            echo "$f"
13235          elif test -f "$srcdir/$f"; then
13236            # Source tree
13237            echo "$srcdir/$f"
13238          else
13239            # /dev/null tree
13240            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13241 echo "$as_me: error: cannot find input file: $f" >&2;}
13242    { (exit 1); exit 1; }; }
13243          fi;;
13244       esac
13245     done` || { (exit 1); exit 1; }
13246 _ACEOF
13247 cat >>$CONFIG_STATUS <<_ACEOF
13248   sed "$ac_vpsub
13249 $extrasub
13250 _ACEOF
13251 cat >>$CONFIG_STATUS <<\_ACEOF
13252 :t
13253 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13254 s,@configure_input@,$configure_input,;t t
13255 s,@srcdir@,$ac_srcdir,;t t
13256 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13257 s,@top_srcdir@,$ac_top_srcdir,;t t
13258 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13259 s,@builddir@,$ac_builddir,;t t
13260 s,@abs_builddir@,$ac_abs_builddir,;t t
13261 s,@top_builddir@,$ac_top_builddir,;t t
13262 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13263 s,@INSTALL@,$ac_INSTALL,;t t
13264 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13265   rm -f $tmp/stdin
13266   if test x"$ac_file" != x-; then
13267     mv $tmp/out $ac_file
13268   else
13269     cat $tmp/out
13270     rm -f $tmp/out
13271   fi
13272
13273 done
13274 _ACEOF
13275
13276 cat >>$CONFIG_STATUS <<\_ACEOF
13277
13278 { (exit 0); exit 0; }
13279 _ACEOF
13280 chmod +x $CONFIG_STATUS
13281 ac_clean_files=$ac_clean_files_save
13282
13283
13284 # configure is writing to config.log, and then calls config.status.
13285 # config.status does its own redirection, appending to config.log.
13286 # Unfortunately, on DOS this fails, as config.log is still kept open
13287 # by configure, so config.status won't be able to write to it; its
13288 # output is simply discarded.  So we exec the FD to /dev/null,
13289 # effectively closing config.log, so it can be properly (re)opened and
13290 # appended to by config.status.  When coming back to configure, we
13291 # need to make the FD available again.
13292 if test "$no_create" != yes; then
13293   ac_cs_success=:
13294   ac_config_status_args=
13295   test "$silent" = yes &&
13296     ac_config_status_args="$ac_config_status_args --quiet"
13297   exec 5>/dev/null
13298   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13299   exec 5>>config.log
13300   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13301   # would make configure fail if this is the last instruction.
13302   $ac_cs_success || { (exit 1); exit 1; }
13303 fi
13304