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         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1419 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1420         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1421 echo "$as_me:   former value:  $ac_old_val" >&2;}
1422         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1423 echo "$as_me:   current value: $ac_new_val" >&2;}
1424         ac_cache_corrupted=:
1425       fi;;
1426   esac
1427   # Pass precious variables to config.status.
1428   if test "$ac_new_set" = set; then
1429     case $ac_new_val in
1430     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1431       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1432     *) ac_arg=$ac_var=$ac_new_val ;;
1433     esac
1434     case " $ac_configure_args " in
1435       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1436       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1437     esac
1438   fi
1439 done
1440 if $ac_cache_corrupted; then
1441   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1442 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1443   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1444 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1445    { (exit 1); exit 1; }; }
1446 fi
1447
1448 ac_ext=c
1449 ac_cpp='$CPP $CPPFLAGS'
1450 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1451 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1452 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474 # Find the build, host, and target systems.
1475 ac_aux_dir=
1476 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1477   if test -f $ac_dir/install-sh; then
1478     ac_aux_dir=$ac_dir
1479     ac_install_sh="$ac_aux_dir/install-sh -c"
1480     break
1481   elif test -f $ac_dir/install.sh; then
1482     ac_aux_dir=$ac_dir
1483     ac_install_sh="$ac_aux_dir/install.sh -c"
1484     break
1485   elif test -f $ac_dir/shtool; then
1486     ac_aux_dir=$ac_dir
1487     ac_install_sh="$ac_aux_dir/shtool install -c"
1488     break
1489   fi
1490 done
1491 if test -z "$ac_aux_dir"; then
1492   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1493 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1494    { (exit 1); exit 1; }; }
1495 fi
1496 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1497 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1498 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1499
1500 # Make sure we can run config.sub.
1501 $ac_config_sub sun4 >/dev/null 2>&1 ||
1502   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1503 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1504    { (exit 1); exit 1; }; }
1505
1506 echo "$as_me:$LINENO: checking build system type" >&5
1507 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1508 if test "${ac_cv_build+set}" = set; then
1509   echo $ECHO_N "(cached) $ECHO_C" >&6
1510 else
1511   ac_cv_build_alias=$build_alias
1512 test -z "$ac_cv_build_alias" &&
1513   ac_cv_build_alias=`$ac_config_guess`
1514 test -z "$ac_cv_build_alias" &&
1515   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1516 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1517    { (exit 1); exit 1; }; }
1518 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1519   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1520 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1521    { (exit 1); exit 1; }; }
1522
1523 fi
1524 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1525 echo "${ECHO_T}$ac_cv_build" >&6
1526 build=$ac_cv_build
1527 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1528 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1529 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1530
1531
1532  case ${build_alias} in
1533   "") build_noncanonical=${build} ;;
1534   *) build_noncanonical=${build_alias} ;;
1535 esac
1536
1537
1538
1539  case ${host_alias} in
1540   "") host_noncanonical=${build_noncanonical} ;;
1541   *) host_noncanonical=${host_alias} ;;
1542 esac
1543
1544
1545
1546  case ${target_alias} in
1547   "") target_noncanonical=${host_noncanonical} ;;
1548   *) target_noncanonical=${target_alias} ;;
1549 esac
1550
1551
1552
1553
1554 test "$host_noncanonical" = "$target_noncanonical" &&
1555   test "$program_prefix$program_suffix$program_transform_name" = \
1556     NONENONEs,x,x, &&
1557   program_transform_name=s,y,y,
1558
1559 echo "$as_me:$LINENO: checking host system type" >&5
1560 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1561 if test "${ac_cv_host+set}" = set; then
1562   echo $ECHO_N "(cached) $ECHO_C" >&6
1563 else
1564   ac_cv_host_alias=$host_alias
1565 test -z "$ac_cv_host_alias" &&
1566   ac_cv_host_alias=$ac_cv_build_alias
1567 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1568   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1569 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1570    { (exit 1); exit 1; }; }
1571
1572 fi
1573 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1574 echo "${ECHO_T}$ac_cv_host" >&6
1575 host=$ac_cv_host
1576 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1577 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1578 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1579
1580
1581 echo "$as_me:$LINENO: checking target system type" >&5
1582 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1583 if test "${ac_cv_target+set}" = set; then
1584   echo $ECHO_N "(cached) $ECHO_C" >&6
1585 else
1586   ac_cv_target_alias=$target_alias
1587 test "x$ac_cv_target_alias" = "x" &&
1588   ac_cv_target_alias=$ac_cv_host_alias
1589 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1590   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1591 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1592    { (exit 1); exit 1; }; }
1593
1594 fi
1595 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1596 echo "${ECHO_T}$ac_cv_target" >&6
1597 target=$ac_cv_target
1598 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1599 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1600 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1601
1602
1603 # The aliases save the names the user supplied, while $host etc.
1604 # will get canonicalized.
1605 test -n "$target_alias" &&
1606   test "$program_prefix$program_suffix$program_transform_name" = \
1607     NONENONEs,x,x, &&
1608   program_prefix=${target_alias}-
1609 test "$program_prefix" != NONE &&
1610   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1611 # Use a double $ so make ignores it.
1612 test "$program_suffix" != NONE &&
1613   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1614 # Double any \ or $.  echo might interpret backslashes.
1615 # By default was `s,x,x', remove it if useless.
1616 cat <<\_ACEOF >conftest.sed
1617 s/[\\$]/&&/g;s/;s,x,x,$//
1618 _ACEOF
1619 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1620 rm conftest.sed
1621
1622
1623
1624 # Get 'install' or 'install-sh' and its variants.
1625 # Find a good install program.  We prefer a C program (faster),
1626 # so one script is as good as another.  But avoid the broken or
1627 # incompatible versions:
1628 # SysV /etc/install, /usr/sbin/install
1629 # SunOS /usr/etc/install
1630 # IRIX /sbin/install
1631 # AIX /bin/install
1632 # AmigaOS /C/install, which installs bootblocks on floppy discs
1633 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1634 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1635 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1636 # OS/2's system install, which has a completely different semantic
1637 # ./install, which can be erroneously created by make from ./install.sh.
1638 # Reject install programs that cannot install multiple files.
1639 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1640 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1641 if test -z "$INSTALL"; then
1642 if test "${ac_cv_path_install+set}" = set; then
1643   echo $ECHO_N "(cached) $ECHO_C" >&6
1644 else
1645   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1646 for as_dir in $PATH
1647 do
1648   IFS=$as_save_IFS
1649   test -z "$as_dir" && as_dir=.
1650   # Account for people who put trailing slashes in PATH elements.
1651 case $as_dir/ in
1652   ./ | .// | /cC/* | \
1653   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1654   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1655   /usr/ucb/* ) ;;
1656   *)
1657     # OSF1 and SCO ODT 3.0 have their own names for install.
1658     # Don't use installbsd from OSF since it installs stuff as root
1659     # by default.
1660     for ac_prog in ginstall scoinst install; do
1661       for ac_exec_ext in '' $ac_executable_extensions; do
1662         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1663           if test $ac_prog = install &&
1664             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1665             # AIX install.  It has an incompatible calling convention.
1666             :
1667           elif test $ac_prog = install &&
1668             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1669             # program-specific install script used by HP pwplus--don't use.
1670             :
1671           else
1672             rm -rf conftest.one conftest.two conftest.dir
1673             echo one > conftest.one
1674             echo two > conftest.two
1675             mkdir conftest.dir
1676             if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
1677               test -s conftest.one && test -s conftest.two &&
1678               test -s conftest.dir/conftest.one &&
1679               test -s conftest.dir/conftest.two
1680             then
1681               ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1682               break 3
1683             fi
1684           fi
1685         fi
1686       done
1687     done
1688     ;;
1689 esac
1690 done
1691
1692 rm -rf conftest.one conftest.two conftest.dir
1693
1694 fi
1695   if test "${ac_cv_path_install+set}" = set; then
1696     INSTALL=$ac_cv_path_install
1697   else
1698     # As a last resort, use the slow shell script.  Don't cache a
1699     # value for INSTALL within a source directory, because that will
1700     # break other packages using the cache if that directory is
1701     # removed, or if the value is a relative name.
1702     INSTALL=$ac_install_sh
1703   fi
1704 fi
1705 echo "$as_me:$LINENO: result: $INSTALL" >&5
1706 echo "${ECHO_T}$INSTALL" >&6
1707
1708 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1709 # It thinks the first close brace ends the variable substitution.
1710 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1711
1712 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1713
1714 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1715
1716 echo "$as_me:$LINENO: checking whether ln works" >&5
1717 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1718 if test "${acx_cv_prog_LN+set}" = set; then
1719   echo $ECHO_N "(cached) $ECHO_C" >&6
1720 else
1721   rm -f conftestdata_t
1722 echo >conftestdata_f
1723 if ln conftestdata_f conftestdata_t 2>/dev/null
1724 then
1725   acx_cv_prog_LN=ln
1726 else
1727   acx_cv_prog_LN=no
1728 fi
1729 rm -f conftestdata_f conftestdata_t
1730
1731 fi
1732 if test $acx_cv_prog_LN = no; then
1733   LN="cp"
1734   echo "$as_me:$LINENO: result: no, using $LN" >&5
1735 echo "${ECHO_T}no, using $LN" >&6
1736 else
1737   LN="$acx_cv_prog_LN"
1738   echo "$as_me:$LINENO: result: yes" >&5
1739 echo "${ECHO_T}yes" >&6
1740 fi
1741
1742 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1743 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1744 LN_S=$as_ln_s
1745 if test "$LN_S" = "ln -s"; then
1746   echo "$as_me:$LINENO: result: yes" >&5
1747 echo "${ECHO_T}yes" >&6
1748 else
1749   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1750 echo "${ECHO_T}no, using $LN_S" >&6
1751 fi
1752
1753
1754 ### we might need to use some other shell than /bin/sh for running subshells
1755 ### If we are on Windows, search for the shell.  This will permit people
1756 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1757 ### without also having to set CONFIG_SHELL.  This code will work when
1758 ### using bash, which sets OSTYPE.
1759 case "${OSTYPE}" in
1760 *win32*)
1761   if test x${CONFIG_SHELL} = x ; then
1762     if test ! -f /bin/sh ; then
1763       if test x${SHELL} != x && test -f ${SHELL} ; then
1764         CONFIG_SHELL=${SHELL}
1765         export CONFIG_SHELL
1766       else
1767         for prog in sh sh.exe bash bash.exe; do
1768           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1769           for dir in $PATH; do
1770             test -z "$dir" && dir=.
1771             if test -f $dir/$prog; then
1772               CONFIG_SHELL=$dir/$prog
1773               export CONFIG_SHELL
1774               break
1775             fi
1776           done
1777           IFS="$save_ifs"
1778           test -n "${CONFIG_SHELL}" && break
1779         done
1780       fi
1781     fi
1782   fi
1783   ;;
1784 esac
1785
1786 config_shell=${CONFIG_SHELL-/bin/sh}
1787
1788 progname=$0
1789 # if PWD already has a value, it is probably wrong.
1790 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1791
1792 # Export original configure arguments for use by sub-configures.
1793 # Quote arguments with shell meta charatcers.
1794 TOPLEVEL_CONFIGURE_ARGUMENTS=
1795 set -- "$progname" "$@"
1796 for ac_arg
1797 do
1798   case "$ac_arg" in
1799   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1800     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1801     # if the argument is of the form -foo=baz, quote the baz part only
1802     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1803   *) ;;
1804   esac
1805   # Add the quoted argument to the list.
1806   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1807 done
1808 if test "$silent" = yes; then
1809   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1810 fi
1811 # Remove the initial space we just introduced and, as these will be
1812 # expanded by make, quote '$'.
1813 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1814
1815
1816 moveifchange=${srcdir}/move-if-change
1817
1818 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1819
1820 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1821 # a relative path.
1822 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1823   INSTALL="${srcpwd}/install-sh -c"
1824 fi
1825
1826 # Set srcdir to "." if that's what it is.
1827 # This is important for multilib support.
1828 pwd=`${PWDCMD-pwd}`
1829 if test "${pwd}" = "${srcpwd}" ; then
1830   srcdir=.
1831 fi
1832
1833 topsrcdir=$srcpwd
1834
1835 extra_host_args=
1836
1837 ### To add a new directory to the tree, first choose whether it is a target
1838 ### or a host dependent tool.  Then put it into the appropriate list
1839 ### (library or tools, host or target), doing a dependency sort.
1840
1841 # Subdirs will be configured in the order listed in build_configdirs,
1842 # configdirs, or target_configdirs; see the serialization section below.
1843
1844 # Dependency sorting is only needed when *configuration* must be done in
1845 # a particular order.  In all cases a dependency should be specified in
1846 # the Makefile, whether or not it's implicitly specified here.
1847
1848 # Double entries in build_configdirs, configdirs, or target_configdirs may
1849 # cause circular dependencies and break everything horribly.
1850
1851 # these library is used by various programs built for the build
1852 # environment
1853 #
1854 build_libs="build-libiberty"
1855
1856 # these tools are built for the build environment
1857 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1858
1859 # these libraries are used by various programs built for the host environment
1860 #
1861 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1862
1863 # these tools are built for the host environment
1864 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1865 # know that we are building the simulator.
1866 # binutils, gas and ld appear in that order because it makes sense to run
1867 # "make check" in that particular order.
1868 # If --enable-gold is used, "gold" will replace "ld".
1869 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"
1870
1871 # libgcj represents the runtime libraries only used by gcj.
1872 libgcj="target-libffi \
1873         target-zlib \
1874         target-qthreads \
1875         target-libjava"
1876
1877 # these libraries are built for the target environment, and are built after
1878 # the host libraries and the host tools (which may be a cross compiler)
1879 #
1880 target_libraries="target-libgcc \
1881                 target-libiberty \
1882                 target-libgloss \
1883                 target-newlib \
1884                 target-libgomp \
1885                 target-libstdc++-v3 \
1886                 target-libmudflap \
1887                 target-libssp \
1888                 target-libgfortran \
1889                 target-boehm-gc \
1890                 ${libgcj} \
1891                 target-libobjc \
1892                 target-libada"
1893
1894 # these tools are built using the target libraries, and are intended to
1895 # run only in the target environment
1896 #
1897 # note: any program that *uses* libraries that are in the "target_libraries"
1898 # list belongs in this list.  those programs are also very likely
1899 # candidates for the "native_only" list which follows
1900 #
1901 target_tools="target-examples target-groff target-gperf target-rda"
1902
1903 ################################################################################
1904
1905 ## All tools belong in one of the four categories, and are assigned above
1906 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1907 ## is important because configure will choke if they ever get through.
1908 ## ${configdirs} is directories we build using the host tools.
1909 ## ${target_configdirs} is directories we build using the target tools.
1910 configdirs=`echo ${host_libs} ${host_tools}`
1911 target_configdirs=`echo ${target_libraries} ${target_tools}`
1912 build_configdirs=`echo ${build_libs} ${build_tools}`
1913
1914
1915
1916 ################################################################################
1917
1918 srcname="gnu development package"
1919
1920 # This gets set non-empty for some net releases of packages.
1921 appdirs=""
1922
1923 # Define is_cross_compiler to save on calls to 'test'.
1924 is_cross_compiler=
1925 if test x"${host}" = x"${target}" ; then
1926   is_cross_compiler=no
1927 else
1928   is_cross_compiler=yes
1929 fi
1930
1931 # Find the build and target subdir names.
1932
1933 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1934 # have matching libraries, they should use host libraries: Makefile.tpl
1935 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1936 # However, they still use the build modules, because the corresponding
1937 # host modules (e.g. bison) are only built for the host when bootstrap
1938 # finishes. So:
1939 # - build_subdir is where we find build modules, and never changes.
1940 # - build_libsubdir is where we find build libraries, and can be overridden.
1941
1942 # Prefix 'build-' so this never conflicts with target_subdir.
1943 build_subdir="build-${build_noncanonical}"
1944
1945 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1946 if test "${with_build_libsubdir+set}" = set; then
1947   withval="$with_build_libsubdir"
1948   build_libsubdir="$withval"
1949 else
1950   build_libsubdir="$build_subdir"
1951 fi;
1952 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1953 if ( test $srcdir = . && test -d gcc ) \
1954    || test -d $srcdir/../host-${host_noncanonical}; then
1955   host_subdir="host-${host_noncanonical}"
1956 else
1957   host_subdir=.
1958 fi
1959 # No prefix.
1960 target_subdir=${target_noncanonical}
1961
1962
1963 # Skipdirs are removed silently.
1964 skipdirs=
1965 # Noconfigdirs are removed loudly.
1966 noconfigdirs=""
1967
1968 use_gnu_ld=
1969 # Make sure we don't let GNU ld be added if we didn't want it.
1970 if test x$with_gnu_ld = xno ; then
1971   use_gnu_ld=no
1972   noconfigdirs="$noconfigdirs ld gold"
1973 fi
1974
1975 use_gnu_as=
1976 # Make sure we don't let GNU as be added if we didn't want it.
1977 if test x$with_gnu_as = xno ; then
1978   use_gnu_as=no
1979   noconfigdirs="$noconfigdirs gas"
1980 fi
1981
1982 # some tools are so dependent upon X11 that if we're not building with X,
1983 # it's not even worth trying to configure, much less build, that tool.
1984
1985 case ${with_x} in
1986   yes | "") ;; # the default value for this tree is that X11 is available
1987   no)
1988     skipdirs="${skipdirs} tk itcl libgui"
1989     # We won't be able to build gdbtk without X.
1990     enable_gdbtk=no
1991     ;;
1992   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1993 esac
1994
1995 # Some tools are only suitable for building in a "native" situation.
1996 # Remove these if host!=target.
1997 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"
1998
1999 # Similarly, some are only suitable for cross toolchains.
2000 # Remove these if host=target.
2001 cross_only="target-libgloss target-newlib target-opcodes"
2002
2003 case $is_cross_compiler in
2004   no) skipdirs="${skipdirs} ${cross_only}" ;;
2005   yes) skipdirs="${skipdirs} ${native_only}" ;;
2006 esac
2007
2008 # If both --with-headers and --with-libs are specified, default to
2009 # --without-newlib.
2010 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
2011    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
2012   if test x"${with_newlib}" = x ; then
2013     with_newlib=no
2014   fi
2015 fi
2016
2017 # Recognize --with-newlib/--without-newlib.
2018 case ${with_newlib} in
2019   no) skipdirs="${skipdirs} target-newlib" ;;
2020   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2021 esac
2022
2023 # Handle --enable-gold.
2024
2025 # Check whether --enable-gold or --disable-gold was given.
2026 if test "${enable_gold+set}" = set; then
2027   enableval="$enable_gold"
2028   ENABLE_GOLD=$enableval
2029 else
2030   ENABLE_GOLD=no
2031 fi;
2032 if test "${ENABLE_GOLD}" = "yes"; then
2033   # Check for ELF target.
2034   is_elf=no
2035   case "${target}" in
2036     *-*-elf* | *-*-sysv4* | *-*-unixware* | *-*-eabi* | hppa*64*-*-hpux* \
2037     | *-*-linux* | frv-*-uclinux* | *-*-irix5* | *-*-irix6* \
2038     | *-*-netbsd* | *-*-openbsd* | *-*-freebsd* | *-*-solaris2*)
2039       case "${target}" in
2040         *-*-linux*aout* | *-*-linux*oldld*)
2041           ;;
2042         *)
2043           is_elf=yes
2044           ;;
2045       esac
2046   esac
2047
2048   if test "$is_elf" = "yes"; then
2049     # Check for target supported by gold.
2050     case "${target}" in
2051       i?86-*-* | x86_64-*-*)
2052         configdirs="`echo " ${configdirs} " | sed -e 's/ ld / gold /'`"
2053         ;;
2054     esac
2055   fi
2056 fi
2057
2058 # Configure extra directories which are host specific
2059
2060 case "${host}" in
2061   *-cygwin*)
2062     configdirs="$configdirs libtermcap" ;;
2063 esac
2064
2065 # A target can indicate whether a language isn't supported for some reason.
2066 # Only spaces may be used in this macro; not newlines or tabs.
2067 unsupported_languages=
2068
2069 # Remove more programs from consideration, based on the host or
2070 # target this usually means that a port of the program doesn't
2071 # exist yet.
2072
2073 case "${host}" in
2074   hppa*64*-*-*)
2075     noconfigdirs="$noconfigdirs byacc"
2076     ;;
2077   i[3456789]86-*-vsta)
2078     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2079     ;;
2080   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2081     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2082     ;;
2083   x86_64-*-mingw*)
2084     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2085     ;;
2086   i[3456789]86-*-mingw32*)
2087     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2088     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2089     ;;
2090   i[3456789]86-*-beos*)
2091     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2092     ;;
2093   *-*-cygwin*)
2094     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2095     ;;
2096   *-*-netbsd*)
2097     noconfigdirs="$noconfigdirs rcs"
2098     ;;
2099   ppc*-*-pe)
2100     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2101     ;;
2102   powerpc-*-beos*)
2103     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2104     ;;
2105 esac
2106
2107
2108 # Check whether --enable-libada or --disable-libada was given.
2109 if test "${enable_libada+set}" = set; then
2110   enableval="$enable_libada"
2111   ENABLE_LIBADA=$enableval
2112 else
2113   ENABLE_LIBADA=yes
2114 fi;
2115 if test "${ENABLE_LIBADA}" != "yes" ; then
2116   noconfigdirs="$noconfigdirs gnattools"
2117 fi
2118
2119 # Check whether --enable-libssp or --disable-libssp was given.
2120 if test "${enable_libssp+set}" = set; then
2121   enableval="$enable_libssp"
2122   ENABLE_LIBSSP=$enableval
2123 else
2124   ENABLE_LIBSSP=yes
2125 fi;
2126
2127 # Save it here so that, even in case of --enable-libgcj, if the Java
2128 # front-end isn't enabled, we still get libgcj disabled.
2129 libgcj_saved=$libgcj
2130 case $enable_libgcj in
2131 yes)
2132   # If we reset it here, it won't get added to noconfigdirs in the
2133   # target-specific build rules, so it will be forcibly enabled
2134   # (unless the Java language itself isn't enabled).
2135   libgcj=
2136   ;;
2137 no)
2138   # Make sure we get it printed in the list of not supported target libs.
2139   noconfigdirs="$noconfigdirs ${libgcj}"
2140   ;;
2141 esac
2142
2143
2144 # Disable libmudflap on some systems.
2145 if test x$enable_libmudflap = x ; then
2146     case "${target}" in
2147     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2148         # Enable libmudflap by default in GNU and friends.
2149         ;;
2150     *-*-freebsd*)
2151         # Enable libmudflap by default in FreeBSD.
2152         ;;
2153     *)
2154         # Disable it by default everywhere else.
2155         noconfigdirs="$noconfigdirs target-libmudflap"
2156         ;;
2157     esac
2158 fi
2159
2160 # Disable libgomp on non POSIX hosted systems.
2161 if test x$enable_libgomp = x ; then
2162     # Enable libgomp by default on hosted POSIX systems.
2163     case "${target}" in
2164     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2165         ;;
2166     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2167         ;;
2168     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2169         ;;
2170     *-*-darwin* | *-*-aix*)
2171         ;;
2172     *)
2173         noconfigdirs="$noconfigdirs target-libgomp"
2174         ;;
2175     esac
2176 fi
2177
2178 # Default libgloss CPU subdirectory.
2179 libgloss_dir="$target_cpu"
2180
2181 case "${target}" in
2182   *-*-chorusos)
2183     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2184     ;;
2185   powerpc-*-darwin* | i[3456789]86-*-darwin* | x86_64-*-darwin9*)
2186     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2187     noconfigdirs="$noconfigdirs sim target-rda"
2188     ;;
2189   *-*-darwin*)
2190     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2191     noconfigdirs="$noconfigdirs sim target-rda"
2192     noconfigdirs="$noconfigdirs ${libgcj}"
2193     ;;
2194   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2195     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2196     ;;
2197   *-*-freebsd*)
2198     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2199     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2200         && test -f /usr/local/include/gmp.h; then
2201       with_gmp=/usr/local
2202     fi
2203
2204     # Skip some stuff that's unsupported on some FreeBSD configurations.
2205     case "${target}" in
2206       i*86-*-*) ;;
2207       alpha*-*-*) ;;
2208       *)
2209         noconfigdirs="$noconfigdirs ${libgcj}"
2210         ;;
2211     esac
2212     ;;
2213   *-*-kaos*)
2214     # Remove unsupported stuff on all kaOS configurations.
2215     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2216     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2217     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2218     noconfigdirs="$noconfigdirs target-libgloss"
2219     ;;
2220   *-*-netbsd*)
2221     # Skip some stuff on all NetBSD configurations.
2222     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2223
2224     # Skip some stuff that's unsupported on some NetBSD configurations.
2225     case "${target}" in
2226       i*86-*-netbsdelf*) ;;
2227       arm*-*-netbsdelf*) ;;
2228       *)
2229         noconfigdirs="$noconfigdirs ${libgcj}"
2230         ;;
2231     esac
2232     ;;
2233   *-*-netware*)
2234     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2235     ;;
2236   *-*-rtems*)
2237     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2238     ;;
2239     # The tpf target doesn't support gdb yet.
2240   *-*-tpf*)
2241     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2242     ;;
2243   *-*-uclinux*)
2244     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2245     ;;
2246   *-*-vxworks*)
2247     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2248     ;;
2249   alpha*-dec-osf*)
2250     # ld works, but does not support shared libraries.
2251     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2252     # gas doesn't generate exception information.
2253     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2254     ;;
2255   alpha*-*-*vms*)
2256     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2257     ;;
2258   alpha*-*-linux*)
2259     # newlib is not 64 bit ready
2260     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2261     ;;
2262   alpha*-*-*)
2263     # newlib is not 64 bit ready
2264     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2265     ;;
2266   am33_2.0-*-linux*)
2267     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2268     ;;
2269   sh-*-linux*)
2270     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2271     ;;
2272   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2273     noconfigdirs="$noconfigdirs ${libgcj}"
2274     noconfigdirs="$noconfigdirs target-examples"
2275     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2276     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2277     noconfigdirs="$noconfigdirs expect dejagnu"
2278     # the C++ libraries don't build on top of CE's C libraries
2279     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2280     noconfigdirs="$noconfigdirs target-newlib"
2281     case "${host}" in
2282       *-*-cygwin*) ;; # keep gdb and readline
2283       *) noconfigdirs="$noconfigdirs gdb readline"
2284          ;;
2285     esac
2286     libgloss_dir=wince
2287     ;;
2288   arc-*-*)
2289     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2290     ;;
2291   arm-semi-aof )
2292     ;;
2293   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2294     noconfigdirs="$noconfigdirs ${libgcj}"
2295     libgloss_dir=arm
2296     ;;
2297   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2298     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2299     libgloss_dir=arm
2300     ;;
2301   arm*-*-linux-gnueabi)
2302     noconfigdirs="$noconfigdirs target-qthreads"
2303     noconfigdirs="$noconfigdirs target-libobjc"
2304     case ${with_newlib} in
2305       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2306     esac
2307     libgloss_dir=arm
2308     ;;
2309   arm*-*-symbianelf*)
2310     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2311     libgloss_dir=arm
2312     ;;
2313   arm-*-pe*)
2314     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2315     ;;
2316   thumb-*-coff)
2317     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2318     ;;
2319   thumb-*-elf)
2320     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2321     ;;
2322   thumb-*-pe)
2323     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2324     ;;
2325   arm-*-riscix*)
2326     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2327     ;;
2328   avr-*-*)
2329     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2330     ;;
2331   bfin-*-*)
2332     noconfigdirs="$noconfigdirs gdb"
2333     if test x${is_cross_compiler} != xno ; then
2334       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2335     fi
2336     ;;
2337   c4x-*-* | tic4x-*-*)
2338     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2339     ;;
2340   c54x*-*-* | tic54x-*-*)
2341     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2342     ;;
2343   cris-*-* | crisv32-*-*)
2344     unsupported_languages="$unsupported_languages java"
2345     case "${target}" in
2346       *-*-aout)
2347         unsupported_languages="$unsupported_languages fortran"
2348         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2349       *-*-elf)
2350         noconfigdirs="$noconfigdirs target-boehm-gc";;
2351       *-*-linux*)
2352         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2353       *)
2354         unsupported_languages="$unsupported_languages fortran"
2355         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2356     esac
2357     libgloss_dir=cris
2358     ;;
2359   crx-*-*)
2360     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2361     ;;
2362   d10v-*-*)
2363     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2364     ;;
2365   d30v-*-*)
2366     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2367     ;;
2368   ep9312-*-elf | ep9312-*-coff)
2369     libgloss_dir=arm
2370     ;;
2371   fr30-*-elf*)
2372     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2373     ;;
2374   frv-*-*)
2375     noconfigdirs="$noconfigdirs ${libgcj}"
2376     ;;
2377   h8300*-*-*)
2378     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2379     ;;
2380   h8500-*-*)
2381     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2382     ;;
2383   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2384     ;;
2385   hppa*64*-*-linux* | parisc*64*-*-linux*)
2386     # In this case, it's because the hppa64-linux target is for
2387     # the kernel only at this point and has no libc, and thus no
2388     # headers, crt*.o, etc., all of which are needed by these.
2389     noconfigdirs="$noconfigdirs target-zlib"
2390     ;;
2391   parisc*-*-linux* | hppa*-*-linux*)
2392     ;;
2393   hppa*-*-*elf* | \
2394   hppa*-*-lites* | \
2395   hppa*-*-openbsd* | \
2396   hppa*64*-*-*)
2397     noconfigdirs="$noconfigdirs ${libgcj}"
2398     ;;
2399   hppa*-hp-hpux11*)
2400     noconfigdirs="$noconfigdirs ld shellutils"
2401     ;;
2402   hppa*-*-pro*)
2403     libgloss_dir=pa
2404     ;;
2405   hppa*-*-*)
2406     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2407     # build on HP-UX 10.20.
2408     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2409     ;;
2410   i960-*-*)
2411     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2412     ;;
2413   ia64*-*-elf*)
2414     # No gdb support yet.
2415     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2416     ;;
2417   ia64*-**-hpux*)
2418     # No gdb or ld support yet.
2419     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2420     ;;
2421   i370-*-opened*)
2422     ;;
2423   i[3456789]86-*-coff | i[3456789]86-*-elf)
2424     noconfigdirs="$noconfigdirs ${libgcj}"
2425     libgloss_dir=i386
2426     ;;
2427   i[3456789]86-*-linux*)
2428     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2429     # not build java stuff by default.
2430     case "${target}" in
2431       *-*-*libc1*)
2432         noconfigdirs="$noconfigdirs ${libgcj}";;
2433     esac
2434
2435     # This section makes it possible to build newlib natively on linux.
2436     # If we are using a cross compiler then don't configure newlib.
2437     if test x${is_cross_compiler} != xno ; then
2438       noconfigdirs="$noconfigdirs target-newlib"
2439     fi
2440     noconfigdirs="$noconfigdirs target-libgloss"
2441     # If we are not using a cross compiler, do configure newlib.
2442     # Note however, that newlib will only be configured in this situation
2443     # if the --with-newlib option has been given, because otherwise
2444     # 'target-newlib' will appear in skipdirs.
2445     ;;
2446   i[3456789]86-*-mingw32*)
2447     target_configdirs="$target_configdirs target-winsup"
2448     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2449     ;;
2450   x86_64-*-mingw*)
2451     target_configdirs="$target_configdirs target-winsup"
2452     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2453     ;;
2454   *-*-cygwin*)
2455     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2456     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2457     # always build newlib if winsup directory is present.
2458     if test -d "$srcdir/winsup/cygwin"; then
2459       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2460     elif test -d "$srcdir/newlib"; then
2461       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2462     fi
2463     ;;
2464   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2465   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2466     ;;
2467   i[3456789]86-*-pe)
2468     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2469     ;;
2470   i[3456789]86-*-sco3.2v5*)
2471     # The linker does not yet know about weak symbols in COFF,
2472     # and is not configured to handle mixed ELF and COFF.
2473     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2474     ;;
2475   i[3456789]86-*-sco*)
2476     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2477     ;;
2478   i[3456789]86-*-solaris2*)
2479     noconfigdirs="$noconfigdirs target-libgloss"
2480     ;;
2481   i[3456789]86-*-sysv4*)
2482     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2483     ;;
2484   i[3456789]86-*-beos*)
2485     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2486     ;;
2487   i[3456789]86-*-rdos*)
2488     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2489     ;;
2490   m32r-*-*)
2491     noconfigdirs="$noconfigdirs ${libgcj}"
2492     ;;
2493   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2494     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2495     libgloss_dir=m68hc11
2496     ;;
2497   m68k-*-elf*)
2498     noconfigdirs="$noconfigdirs ${libgcj}"
2499     ;;
2500   m68k-*-coff*)
2501     noconfigdirs="$noconfigdirs ${libgcj}"
2502     ;;
2503   m68*-*-* | fido-*-*)
2504     libgloss_dir=m68k
2505     ;;
2506   mcore-*-pe*)
2507   # The EPOC C++ environment does not support exceptions or rtti,
2508   # and so building libstdc++-v3 tends not to always work.
2509     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2510     ;;
2511   mmix-*-*)
2512     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2513     unsupported_languages="$unsupported_languages fortran java"
2514     ;;
2515   mn10200-*-*)
2516     noconfigdirs="$noconfigdirs ${libgcj}"
2517     ;;
2518   mn10300-*-*)
2519     noconfigdirs="$noconfigdirs ${libgcj}"
2520     ;;
2521   mt-*-*)
2522     noconfigdirs="$noconfigdirs sim"
2523     ;;
2524   powerpc-*-aix*)
2525     # copied from rs6000-*-* entry
2526     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2527     ;;
2528   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2529     target_configdirs="$target_configdirs target-winsup"
2530     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2531     # always build newlib.
2532     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2533     ;;
2534     # This is temporary until we can link against shared libraries
2535   powerpcle-*-solaris*)
2536     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2537     libgloss_dir=rs6000
2538     ;;
2539   powerpc-*-beos*)
2540     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2541     ;;
2542   powerpc-*-eabi)
2543     noconfigdirs="$noconfigdirs ${libgcj}"
2544     libgloss_dir=rs6000
2545     ;;
2546   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2547     libgloss_dir=rs6000
2548     ;;
2549   rs6000-*-lynxos*)
2550     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2551     ;;
2552   rs6000-*-aix*)
2553     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2554     ;;
2555   rs6000-*-*)
2556     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2557     ;;
2558   m68k-apollo-*)
2559     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2560     ;;
2561   mips*-sde-elf*)
2562     skipdirs="$skipdirs target-libiberty"
2563     noconfigdirs="$noconfigdirs ${libgcj}"
2564     if test x$with_newlib = xyes; then
2565       noconfigdirs="$noconfigdirs gprof"
2566     fi
2567     libgloss_dir=mips
2568     ;;
2569   mips*-*-irix5*)
2570     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2571     ;;
2572   mips*-*-irix6*)
2573     # Linking libjava exceeds command-line length limits on at least
2574     # IRIX 6.2, but not on IRIX 6.5.
2575     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2576     # <oldham@codesourcery.com>
2577     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2578     ;;
2579   mips*-*-bsd*)
2580     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2581     ;;
2582   mips*-*-linux*)
2583     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2584     ;;
2585   mips*-*-*)
2586     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2587     libgloss_dir=mips
2588     ;;
2589   romp-*-*)
2590     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2591     ;;
2592   sh-*-* | sh64-*-*)
2593     case "${host}" in
2594       i[3456789]86-*-vsta) ;; # don't add gprof back in
2595       i[3456789]86-*-go32*) ;; # don't add gprof back in
2596       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2597       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2598     esac
2599     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2600     ;;
2601   sparclet-*-aout* | sparc86x-*-*)
2602     libgloss_dir=sparc
2603     ;;
2604   sparc-*-elf*)
2605     noconfigdirs="$noconfigdirs ${libgcj}"
2606     ;;
2607   sparc64-*-elf*)
2608     noconfigdirs="$noconfigdirs ${libgcj}"
2609     libgloss_dir=sparc
2610     ;;
2611   sparclite-*-*)
2612     noconfigdirs="$noconfigdirs ${libgcj}"
2613     libgloss_dir=sparc
2614     ;;
2615   sparc-*-sunos4*)
2616     noconfigdirs="$noconfigdirs ${libgcj}"
2617     if test x${is_cross_compiler} != xno ; then
2618            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2619     else
2620            use_gnu_ld=no
2621     fi
2622     ;;
2623   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2624     noconfigdirs="$noconfigdirs ${libgcj}"
2625     ;;
2626   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2627     ;;
2628   spu-*-*)
2629     skipdirs="target-libssp"
2630     ;;
2631   v810-*-*)
2632     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2633     ;;
2634   v850-*-*)
2635     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2636     ;;
2637   v850e-*-*)
2638     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2639     ;;
2640   v850ea-*-*)
2641     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2642     ;;
2643   vax-*-vms)
2644     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2645     ;;
2646   vax-*-*)
2647     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2648     ;;
2649   xtensa*-*-*)
2650     noconfigdirs="$noconfigdirs ${libgcj}"
2651     ;;
2652   ip2k-*-*)
2653     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2654     ;;
2655   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2656     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2657     ;;
2658   *-*-lynxos*)
2659     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2660     ;;
2661   *-*-*)
2662     noconfigdirs="$noconfigdirs ${libgcj}"
2663     ;;
2664 esac
2665
2666 # If we aren't building newlib, then don't build libgloss, since libgloss
2667 # depends upon some newlib header files.
2668 case "${noconfigdirs}" in
2669   *target-libgloss*) ;;
2670   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2671 esac
2672
2673 # Work in distributions that contain no compiler tools, like Autoconf.
2674 tentative_cc=""
2675 host_makefile_frag=/dev/null
2676 if test -d ${srcdir}/config ; then
2677 case "${host}" in
2678   m68k-hp-hpux*)
2679     # Avoid "too much defining" errors from HPUX compiler.
2680     tentative_cc="cc -Wp,-H256000"
2681     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2682     # If it's HP/UX ar, this should be harmless.
2683     RANLIB="ar ts"
2684     ;;
2685   m68k-apollo-sysv*)
2686     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2687     ;;
2688   m68k-apollo-bsd*)
2689     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2690     # chokes on bfd, the compiler won't let you assign integers to enums, and
2691     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2692     # the apollo compiler" (the preferred version of GCC could be called cc,
2693     # or whatever), but I'm not sure leaving CC as cc is any better...
2694     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2695     # Used to have BISON=yacc.
2696     tentative_cc=gcc
2697     ;;
2698   m88k-dg-dgux*)
2699     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2700     ;;
2701   m88k-harris-cxux*)
2702     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2703     tentative_cc="cc -Xa"
2704     host_makefile_frag="config/mh-cxux"
2705     ;;
2706   m88k-motorola-sysv*)
2707     ;;
2708   mips*-dec-ultrix*)
2709     tentative_cc="cc -Wf,-XNg1000"
2710     host_makefile_frag="config/mh-decstation"
2711     ;;
2712   mips*-nec-sysv4*)
2713     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2714     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2715     host_makefile_frag="config/mh-necv4"
2716     ;;
2717   mips*-sgi-irix4*)
2718     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2719     # environment.  Also bump switch table size so that cp-parse will
2720     # compile.  Bump string length limit so linker builds.
2721     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2722     ;;
2723   mips*-*-sysv4*)
2724     host_makefile_frag="config/mh-sysv4"
2725     ;;
2726   mips*-*-sysv*)
2727     # This is for a MIPS running RISC/os 4.52C.
2728
2729     # This is needed for GDB, but needs to be in the top-level make because
2730     # if a library is compiled with the bsd headers and gets linked with the
2731     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2732     # a different size).
2733     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2734     # known except to select the sysv environment.  Could we use /proc instead?
2735     # These "sysv environments" and "bsd environments" often end up being a pain.
2736     #
2737     # This is not part of CFLAGS because perhaps not all C compilers have this
2738     # option.
2739     tentative_cc="cc -systype sysv"
2740     ;;
2741   i370-ibm-opened*)
2742     tentative_cc="c89"
2743     ;;
2744   i[3456789]86-*-sysv5*)
2745     host_makefile_frag="config/mh-sysv5"
2746     ;;
2747   i[3456789]86-*-dgux*)
2748     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2749     host_makefile_frag="config/mh-dgux386"
2750     ;;
2751   i[3456789]86-ncr-sysv4.3*)
2752     # The MetaWare compiler will generate a copyright message unless you
2753     # turn it off by adding the -Hnocopyr flag.
2754     tentative_cc="cc -Hnocopyr"
2755     ;;
2756   i[3456789]86-ncr-sysv4*)
2757     # for an NCR 3000 (i486/SVR4) system.
2758     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2759     # This compiler not only emits obnoxious copyright messages every time
2760     # you run it, but it chokes and dies on a whole bunch of GNU source
2761     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2762     tentative_cc="/usr/ccs/ATT/cc"
2763     host_makefile_frag="config/mh-ncr3000"
2764     ;;
2765   i[3456789]86-*-sco3.2v5*)
2766     ;;
2767   i[3456789]86-*-sco*)
2768     # The native C compiler botches some simple uses of const.  Unfortunately,
2769     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2770     tentative_cc="cc -Dconst="
2771     host_makefile_frag="config/mh-sco"
2772     ;;
2773   i[3456789]86-*-udk*)
2774     host_makefile_frag="config/mh-sysv5"
2775     ;;
2776   i[3456789]86-*-solaris2*)
2777     host_makefile_frag="config/mh-sysv4"
2778     ;;
2779   i[3456789]86-*-msdosdjgpp*)
2780     host_makefile_frag="config/mh-djgpp"
2781     ;;
2782   *-cygwin*)
2783
2784 echo "$as_me:$LINENO: checking to see if cat works as expected" >&5
2785 echo $ECHO_N "checking to see if cat works as expected... $ECHO_C" >&6
2786 echo a >cygwin-cat-check
2787 if test `cat cygwin-cat-check` == a ; then
2788   echo "$as_me:$LINENO: result: yes" >&5
2789 echo "${ECHO_T}yes" >&6
2790 else
2791   echo "$as_me:$LINENO: result: no" >&5
2792 echo "${ECHO_T}no" >&6
2793   { { echo "$as_me:$LINENO: error: The cat command does not ignore carriage return characters.
2794   Please either mount the build directory in binary mode or run the following
2795   commands before running any configure script:
2796 set -o igncr
2797 export SHELLOPTS
2798   " >&5
2799 echo "$as_me: error: The cat command does not ignore carriage return characters.
2800   Please either mount the build directory in binary mode or run the following
2801   commands before running any configure script:
2802 set -o igncr
2803 export SHELLOPTS
2804   " >&2;}
2805    { (exit 1); exit 1; }; }
2806 fi
2807 rm cygwin-cat-check
2808
2809     host_makefile_frag="config/mh-cygwin"
2810     ;;
2811   *-mingw*)
2812     host_makefile_frag="config/mh-mingw"
2813     ;;
2814   *-interix*)
2815     host_makefile_frag="config/mh-interix"
2816     ;;
2817   vax-*-ultrix2*)
2818     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2819     tentative_cc=gcc
2820     ;;
2821   *-*-solaris2*)
2822     host_makefile_frag="config/mh-solaris"
2823     ;;
2824   m68k-sun-sunos*)
2825     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2826     # without overflowing the jump tables (-J says to use a 32 bit table)
2827     tentative_cc="cc -J"
2828     ;;
2829   *-hp-hpux*)
2830     tentative_cc="cc -Wp,-H256000"
2831     ;;
2832   *-*-hiux*)
2833     tentative_cc="cc -Wp,-H256000"
2834     ;;
2835   rs6000-*-lynxos*)
2836     # /bin/cc is less than useful for our purposes.  Always use GCC
2837     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2838     host_makefile_frag="config/mh-lynxrs6k"
2839     ;;
2840   powerpc-*-darwin*)
2841     host_makefile_frag="config/mh-ppc-darwin"
2842     ;;
2843   powerpc-*-aix*)
2844     host_makefile_frag="config/mh-ppc-aix"
2845     ;;
2846   rs6000-*-aix*)
2847     host_makefile_frag="config/mh-ppc-aix"
2848     ;;
2849   *-*-lynxos*)
2850     # /bin/cc is less than useful for our purposes.  Always use GCC
2851     tentative_cc="/bin/gcc"
2852     ;;
2853   *-*-sysv4*)
2854     host_makefile_frag="config/mh-sysv4"
2855     ;;
2856   # This is placed last to prevent interfering with the cases above.
2857   i[3456789]86-*-*)
2858     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2859     host_makefile_frag="config/mh-x86omitfp"
2860     ;;
2861 esac
2862 fi
2863
2864 # If we aren't going to be using gcc, see if we can extract a definition
2865 # of CC from the fragment.
2866 # Actually, use the 'pre-extracted' version above.
2867 if test -z "${CC}" && test "${build}" = "${host}" ; then
2868   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2869   found=
2870   for dir in $PATH; do
2871     test -z "$dir" && dir=.
2872     if test -f $dir/gcc; then
2873       found=yes
2874       break
2875     fi
2876   done
2877   IFS="$save_ifs"
2878   if test -z "${found}" && test -n "${tentative_cc}" ; then
2879     CC=$tentative_cc
2880   fi
2881 fi
2882
2883 if test "${build}" != "${host}" ; then
2884   AR_FOR_BUILD=${AR_FOR_BUILD-ar}
2885   AS_FOR_BUILD=${AS_FOR_BUILD-as}
2886   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2887   CXX_FOR_BUILD=${CXX_FOR_BUILD-g++}
2888   GCJ_FOR_BUILD=${GCJ_FOR_BUILD-gcj}
2889   GFORTRAN_FOR_BUILD=${GFORTRAN_FOR_BUILD-gfortran}
2890   DLLTOOL_FOR_BUILD=${DLLTOOL_FOR_BUILD-dlltool}
2891   LD_FOR_BUILD=${LD_FOR_BUILD-ld}
2892   NM_FOR_BUILD=${NM_FOR_BUILD-nm}
2893   RANLIB_FOR_BUILD=${RANLIB_FOR_BUILD-ranlib}
2894   WINDRES_FOR_BUILD=${WINDRES_FOR_BUILD-windres}
2895   WINDMC_FOR_BUILD=${WINDMC_FOR_BUILD-windmc}
2896 else
2897   AR_FOR_BUILD="\$(AR)"
2898   AS_FOR_BUILD="\$(AS)"
2899   CC_FOR_BUILD="\$(CC)"
2900   CXX_FOR_BUILD="\$(CXX)"
2901   GCJ_FOR_BUILD="\$(GCJ)"
2902   GFORTRAN_FOR_BUILD="\$(GFORTRAN)"
2903   DLLTOOL_FOR_BUILD="\$(DLLTOOL)"
2904   LD_FOR_BUILD="\$(LD)"
2905   NM_FOR_BUILD="\$(NM)"
2906   RANLIB_FOR_BUILD="\$(RANLIB)"
2907   WINDRES_FOR_BUILD="\$(WINDRES)"
2908   WINDMC_FOR_BUILD="\$(WINDMC)"
2909 fi
2910
2911 ac_ext=c
2912 ac_cpp='$CPP $CPPFLAGS'
2913 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2914 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2915 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2916 if test -n "$ac_tool_prefix"; then
2917   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2918 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2919 echo "$as_me:$LINENO: checking for $ac_word" >&5
2920 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2921 if test "${ac_cv_prog_CC+set}" = set; then
2922   echo $ECHO_N "(cached) $ECHO_C" >&6
2923 else
2924   if test -n "$CC"; then
2925   ac_cv_prog_CC="$CC" # Let the user override the test.
2926 else
2927 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2928 for as_dir in $PATH
2929 do
2930   IFS=$as_save_IFS
2931   test -z "$as_dir" && as_dir=.
2932   for ac_exec_ext in '' $ac_executable_extensions; do
2933   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2934     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2935     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2936     break 2
2937   fi
2938 done
2939 done
2940
2941 fi
2942 fi
2943 CC=$ac_cv_prog_CC
2944 if test -n "$CC"; then
2945   echo "$as_me:$LINENO: result: $CC" >&5
2946 echo "${ECHO_T}$CC" >&6
2947 else
2948   echo "$as_me:$LINENO: result: no" >&5
2949 echo "${ECHO_T}no" >&6
2950 fi
2951
2952 fi
2953 if test -z "$ac_cv_prog_CC"; then
2954   ac_ct_CC=$CC
2955   # Extract the first word of "gcc", so it can be a program name with args.
2956 set dummy gcc; ac_word=$2
2957 echo "$as_me:$LINENO: checking for $ac_word" >&5
2958 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2959 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2960   echo $ECHO_N "(cached) $ECHO_C" >&6
2961 else
2962   if test -n "$ac_ct_CC"; then
2963   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2964 else
2965 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2966 for as_dir in $PATH
2967 do
2968   IFS=$as_save_IFS
2969   test -z "$as_dir" && as_dir=.
2970   for ac_exec_ext in '' $ac_executable_extensions; do
2971   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2972     ac_cv_prog_ac_ct_CC="gcc"
2973     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2974     break 2
2975   fi
2976 done
2977 done
2978
2979 fi
2980 fi
2981 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2982 if test -n "$ac_ct_CC"; then
2983   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2984 echo "${ECHO_T}$ac_ct_CC" >&6
2985 else
2986   echo "$as_me:$LINENO: result: no" >&5
2987 echo "${ECHO_T}no" >&6
2988 fi
2989
2990   CC=$ac_ct_CC
2991 else
2992   CC="$ac_cv_prog_CC"
2993 fi
2994
2995 if test -z "$CC"; then
2996   if test -n "$ac_tool_prefix"; then
2997   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2998 set dummy ${ac_tool_prefix}cc; ac_word=$2
2999 echo "$as_me:$LINENO: checking for $ac_word" >&5
3000 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3001 if test "${ac_cv_prog_CC+set}" = set; then
3002   echo $ECHO_N "(cached) $ECHO_C" >&6
3003 else
3004   if test -n "$CC"; then
3005   ac_cv_prog_CC="$CC" # Let the user override the test.
3006 else
3007 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3008 for as_dir in $PATH
3009 do
3010   IFS=$as_save_IFS
3011   test -z "$as_dir" && as_dir=.
3012   for ac_exec_ext in '' $ac_executable_extensions; do
3013   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3014     ac_cv_prog_CC="${ac_tool_prefix}cc"
3015     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3016     break 2
3017   fi
3018 done
3019 done
3020
3021 fi
3022 fi
3023 CC=$ac_cv_prog_CC
3024 if test -n "$CC"; then
3025   echo "$as_me:$LINENO: result: $CC" >&5
3026 echo "${ECHO_T}$CC" >&6
3027 else
3028   echo "$as_me:$LINENO: result: no" >&5
3029 echo "${ECHO_T}no" >&6
3030 fi
3031
3032 fi
3033 if test -z "$ac_cv_prog_CC"; then
3034   ac_ct_CC=$CC
3035   # Extract the first word of "cc", so it can be a program name with args.
3036 set dummy cc; ac_word=$2
3037 echo "$as_me:$LINENO: checking for $ac_word" >&5
3038 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3039 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3040   echo $ECHO_N "(cached) $ECHO_C" >&6
3041 else
3042   if test -n "$ac_ct_CC"; then
3043   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3044 else
3045 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3046 for as_dir in $PATH
3047 do
3048   IFS=$as_save_IFS
3049   test -z "$as_dir" && as_dir=.
3050   for ac_exec_ext in '' $ac_executable_extensions; do
3051   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3052     ac_cv_prog_ac_ct_CC="cc"
3053     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3054     break 2
3055   fi
3056 done
3057 done
3058
3059 fi
3060 fi
3061 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3062 if test -n "$ac_ct_CC"; then
3063   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3064 echo "${ECHO_T}$ac_ct_CC" >&6
3065 else
3066   echo "$as_me:$LINENO: result: no" >&5
3067 echo "${ECHO_T}no" >&6
3068 fi
3069
3070   CC=$ac_ct_CC
3071 else
3072   CC="$ac_cv_prog_CC"
3073 fi
3074
3075 fi
3076 if test -z "$CC"; then
3077   # Extract the first word of "cc", so it can be a program name with args.
3078 set dummy cc; ac_word=$2
3079 echo "$as_me:$LINENO: checking for $ac_word" >&5
3080 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3081 if test "${ac_cv_prog_CC+set}" = set; then
3082   echo $ECHO_N "(cached) $ECHO_C" >&6
3083 else
3084   if test -n "$CC"; then
3085   ac_cv_prog_CC="$CC" # Let the user override the test.
3086 else
3087   ac_prog_rejected=no
3088 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3089 for as_dir in $PATH
3090 do
3091   IFS=$as_save_IFS
3092   test -z "$as_dir" && as_dir=.
3093   for ac_exec_ext in '' $ac_executable_extensions; do
3094   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3095     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3096        ac_prog_rejected=yes
3097        continue
3098      fi
3099     ac_cv_prog_CC="cc"
3100     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3101     break 2
3102   fi
3103 done
3104 done
3105
3106 if test $ac_prog_rejected = yes; then
3107   # We found a bogon in the path, so make sure we never use it.
3108   set dummy $ac_cv_prog_CC
3109   shift
3110   if test $# != 0; then
3111     # We chose a different compiler from the bogus one.
3112     # However, it has the same basename, so the bogon will be chosen
3113     # first if we set CC to just the basename; use the full file name.
3114     shift
3115     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3116   fi
3117 fi
3118 fi
3119 fi
3120 CC=$ac_cv_prog_CC
3121 if test -n "$CC"; then
3122   echo "$as_me:$LINENO: result: $CC" >&5
3123 echo "${ECHO_T}$CC" >&6
3124 else
3125   echo "$as_me:$LINENO: result: no" >&5
3126 echo "${ECHO_T}no" >&6
3127 fi
3128
3129 fi
3130 if test -z "$CC"; then
3131   if test -n "$ac_tool_prefix"; then
3132   for ac_prog in cl
3133   do
3134     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3135 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3136 echo "$as_me:$LINENO: checking for $ac_word" >&5
3137 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3138 if test "${ac_cv_prog_CC+set}" = set; then
3139   echo $ECHO_N "(cached) $ECHO_C" >&6
3140 else
3141   if test -n "$CC"; then
3142   ac_cv_prog_CC="$CC" # Let the user override the test.
3143 else
3144 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3145 for as_dir in $PATH
3146 do
3147   IFS=$as_save_IFS
3148   test -z "$as_dir" && as_dir=.
3149   for ac_exec_ext in '' $ac_executable_extensions; do
3150   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3151     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3152     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3153     break 2
3154   fi
3155 done
3156 done
3157
3158 fi
3159 fi
3160 CC=$ac_cv_prog_CC
3161 if test -n "$CC"; then
3162   echo "$as_me:$LINENO: result: $CC" >&5
3163 echo "${ECHO_T}$CC" >&6
3164 else
3165   echo "$as_me:$LINENO: result: no" >&5
3166 echo "${ECHO_T}no" >&6
3167 fi
3168
3169     test -n "$CC" && break
3170   done
3171 fi
3172 if test -z "$CC"; then
3173   ac_ct_CC=$CC
3174   for ac_prog in cl
3175 do
3176   # Extract the first word of "$ac_prog", so it can be a program name with args.
3177 set dummy $ac_prog; ac_word=$2
3178 echo "$as_me:$LINENO: checking for $ac_word" >&5
3179 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3180 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3181   echo $ECHO_N "(cached) $ECHO_C" >&6
3182 else
3183   if test -n "$ac_ct_CC"; then
3184   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3185 else
3186 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3187 for as_dir in $PATH
3188 do
3189   IFS=$as_save_IFS
3190   test -z "$as_dir" && as_dir=.
3191   for ac_exec_ext in '' $ac_executable_extensions; do
3192   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3193     ac_cv_prog_ac_ct_CC="$ac_prog"
3194     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3195     break 2
3196   fi
3197 done
3198 done
3199
3200 fi
3201 fi
3202 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3203 if test -n "$ac_ct_CC"; then
3204   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3205 echo "${ECHO_T}$ac_ct_CC" >&6
3206 else
3207   echo "$as_me:$LINENO: result: no" >&5
3208 echo "${ECHO_T}no" >&6
3209 fi
3210
3211   test -n "$ac_ct_CC" && break
3212 done
3213
3214   CC=$ac_ct_CC
3215 fi
3216
3217 fi
3218
3219
3220 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3221 See \`config.log' for more details." >&5
3222 echo "$as_me: error: no acceptable C compiler found in \$PATH
3223 See \`config.log' for more details." >&2;}
3224    { (exit 1); exit 1; }; }
3225
3226 # Provide some information about the compiler.
3227 echo "$as_me:$LINENO:" \
3228      "checking for C compiler version" >&5
3229 ac_compiler=`set X $ac_compile; echo $2`
3230 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3231   (eval $ac_compiler --version </dev/null >&5) 2>&5
3232   ac_status=$?
3233   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3234   (exit $ac_status); }
3235 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3236   (eval $ac_compiler -v </dev/null >&5) 2>&5
3237   ac_status=$?
3238   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3239   (exit $ac_status); }
3240 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3241   (eval $ac_compiler -V </dev/null >&5) 2>&5
3242   ac_status=$?
3243   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3244   (exit $ac_status); }
3245
3246 cat >conftest.$ac_ext <<_ACEOF
3247 /* confdefs.h.  */
3248 _ACEOF
3249 cat confdefs.h >>conftest.$ac_ext
3250 cat >>conftest.$ac_ext <<_ACEOF
3251 /* end confdefs.h.  */
3252
3253 int
3254 main ()
3255 {
3256
3257   ;
3258   return 0;
3259 }
3260 _ACEOF
3261 ac_clean_files_save=$ac_clean_files
3262 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3263 # Try to create an executable without -o first, disregard a.out.
3264 # It will help us diagnose broken compilers, and finding out an intuition
3265 # of exeext.
3266 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3267 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3268 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3269 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3270   (eval $ac_link_default) 2>&5
3271   ac_status=$?
3272   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3273   (exit $ac_status); }; then
3274   # Find the output, starting from the most likely.  This scheme is
3275 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3276 # resort.
3277
3278 # Be careful to initialize this variable, since it used to be cached.
3279 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3280 ac_cv_exeext=
3281 # b.out is created by i960 compilers.
3282 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3283 do
3284   test -f "$ac_file" || continue
3285   case $ac_file in
3286     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3287         ;;
3288     conftest.$ac_ext )
3289         # This is the source file.
3290         ;;
3291     [ab].out )
3292         # We found the default executable, but exeext='' is most
3293         # certainly right.
3294         break;;
3295     *.* )
3296         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3297         # FIXME: I believe we export ac_cv_exeext for Libtool,
3298         # but it would be cool to find out if it's true.  Does anybody
3299         # maintain Libtool? --akim.
3300         export ac_cv_exeext
3301         break;;
3302     * )
3303         break;;
3304   esac
3305 done
3306 else
3307   echo "$as_me: failed program was:" >&5
3308 sed 's/^/| /' conftest.$ac_ext >&5
3309
3310 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3311 See \`config.log' for more details." >&5
3312 echo "$as_me: error: C compiler cannot create executables
3313 See \`config.log' for more details." >&2;}
3314    { (exit 77); exit 77; }; }
3315 fi
3316
3317 ac_exeext=$ac_cv_exeext
3318 echo "$as_me:$LINENO: result: $ac_file" >&5
3319 echo "${ECHO_T}$ac_file" >&6
3320
3321 # Check the compiler produces executables we can run.  If not, either
3322 # the compiler is broken, or we cross compile.
3323 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3324 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3325 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3326 # If not cross compiling, check that we can run a simple program.
3327 if test "$cross_compiling" != yes; then
3328   if { ac_try='./$ac_file'
3329   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3330   (eval $ac_try) 2>&5
3331   ac_status=$?
3332   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3333   (exit $ac_status); }; }; then
3334     cross_compiling=no
3335   else
3336     if test "$cross_compiling" = maybe; then
3337         cross_compiling=yes
3338     else
3339         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3340 If you meant to cross compile, use \`--host'.
3341 See \`config.log' for more details." >&5
3342 echo "$as_me: error: cannot run C compiled programs.
3343 If you meant to cross compile, use \`--host'.
3344 See \`config.log' for more details." >&2;}
3345    { (exit 1); exit 1; }; }
3346     fi
3347   fi
3348 fi
3349 echo "$as_me:$LINENO: result: yes" >&5
3350 echo "${ECHO_T}yes" >&6
3351
3352 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3353 ac_clean_files=$ac_clean_files_save
3354 # Check the compiler produces executables we can run.  If not, either
3355 # the compiler is broken, or we cross compile.
3356 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3357 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3358 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3359 echo "${ECHO_T}$cross_compiling" >&6
3360
3361 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3362 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3363 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3364   (eval $ac_link) 2>&5
3365   ac_status=$?
3366   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3367   (exit $ac_status); }; then
3368   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3369 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3370 # work properly (i.e., refer to `conftest.exe'), while it won't with
3371 # `rm'.
3372 for ac_file in conftest.exe conftest conftest.*; do
3373   test -f "$ac_file" || continue
3374   case $ac_file in
3375     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3376     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3377           export ac_cv_exeext
3378           break;;
3379     * ) break;;
3380   esac
3381 done
3382 else
3383   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3384 See \`config.log' for more details." >&5
3385 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3386 See \`config.log' for more details." >&2;}
3387    { (exit 1); exit 1; }; }
3388 fi
3389
3390 rm -f conftest$ac_cv_exeext
3391 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3392 echo "${ECHO_T}$ac_cv_exeext" >&6
3393
3394 rm -f conftest.$ac_ext
3395 EXEEXT=$ac_cv_exeext
3396 ac_exeext=$EXEEXT
3397 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3398 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3399 if test "${ac_cv_objext+set}" = set; then
3400   echo $ECHO_N "(cached) $ECHO_C" >&6
3401 else
3402   cat >conftest.$ac_ext <<_ACEOF
3403 /* confdefs.h.  */
3404 _ACEOF
3405 cat confdefs.h >>conftest.$ac_ext
3406 cat >>conftest.$ac_ext <<_ACEOF
3407 /* end confdefs.h.  */
3408
3409 int
3410 main ()
3411 {
3412
3413   ;
3414   return 0;
3415 }
3416 _ACEOF
3417 rm -f conftest.o conftest.obj
3418 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3419   (eval $ac_compile) 2>&5
3420   ac_status=$?
3421   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3422   (exit $ac_status); }; then
3423   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3424   case $ac_file in
3425     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3426     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3427        break;;
3428   esac
3429 done
3430 else
3431   echo "$as_me: failed program was:" >&5
3432 sed 's/^/| /' conftest.$ac_ext >&5
3433
3434 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3435 See \`config.log' for more details." >&5
3436 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3437 See \`config.log' for more details." >&2;}
3438    { (exit 1); exit 1; }; }
3439 fi
3440
3441 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3442 fi
3443 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3444 echo "${ECHO_T}$ac_cv_objext" >&6
3445 OBJEXT=$ac_cv_objext
3446 ac_objext=$OBJEXT
3447 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3448 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3449 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3450   echo $ECHO_N "(cached) $ECHO_C" >&6
3451 else
3452   cat >conftest.$ac_ext <<_ACEOF
3453 /* confdefs.h.  */
3454 _ACEOF
3455 cat confdefs.h >>conftest.$ac_ext
3456 cat >>conftest.$ac_ext <<_ACEOF
3457 /* end confdefs.h.  */
3458
3459 int
3460 main ()
3461 {
3462 #ifndef __GNUC__
3463        choke me
3464 #endif
3465
3466   ;
3467   return 0;
3468 }
3469 _ACEOF
3470 rm -f conftest.$ac_objext
3471 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3472   (eval $ac_compile) 2>conftest.er1
3473   ac_status=$?
3474   grep -v '^ *+' conftest.er1 >conftest.err
3475   rm -f conftest.er1
3476   cat conftest.err >&5
3477   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3478   (exit $ac_status); } &&
3479          { ac_try='test -z "$ac_c_werror_flag"
3480                          || test ! -s conftest.err'
3481   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3482   (eval $ac_try) 2>&5
3483   ac_status=$?
3484   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3485   (exit $ac_status); }; } &&
3486          { ac_try='test -s conftest.$ac_objext'
3487   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3488   (eval $ac_try) 2>&5
3489   ac_status=$?
3490   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3491   (exit $ac_status); }; }; then
3492   ac_compiler_gnu=yes
3493 else
3494   echo "$as_me: failed program was:" >&5
3495 sed 's/^/| /' conftest.$ac_ext >&5
3496
3497 ac_compiler_gnu=no
3498 fi
3499 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3500 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3501
3502 fi
3503 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3504 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3505 GCC=`test $ac_compiler_gnu = yes && echo yes`
3506 ac_test_CFLAGS=${CFLAGS+set}
3507 ac_save_CFLAGS=$CFLAGS
3508 CFLAGS="-g"
3509 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3510 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3511 if test "${ac_cv_prog_cc_g+set}" = set; then
3512   echo $ECHO_N "(cached) $ECHO_C" >&6
3513 else
3514   cat >conftest.$ac_ext <<_ACEOF
3515 /* confdefs.h.  */
3516 _ACEOF
3517 cat confdefs.h >>conftest.$ac_ext
3518 cat >>conftest.$ac_ext <<_ACEOF
3519 /* end confdefs.h.  */
3520
3521 int
3522 main ()
3523 {
3524
3525   ;
3526   return 0;
3527 }
3528 _ACEOF
3529 rm -f conftest.$ac_objext
3530 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3531   (eval $ac_compile) 2>conftest.er1
3532   ac_status=$?
3533   grep -v '^ *+' conftest.er1 >conftest.err
3534   rm -f conftest.er1
3535   cat conftest.err >&5
3536   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3537   (exit $ac_status); } &&
3538          { ac_try='test -z "$ac_c_werror_flag"
3539                          || test ! -s conftest.err'
3540   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3541   (eval $ac_try) 2>&5
3542   ac_status=$?
3543   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3544   (exit $ac_status); }; } &&
3545          { ac_try='test -s conftest.$ac_objext'
3546   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3547   (eval $ac_try) 2>&5
3548   ac_status=$?
3549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3550   (exit $ac_status); }; }; then
3551   ac_cv_prog_cc_g=yes
3552 else
3553   echo "$as_me: failed program was:" >&5
3554 sed 's/^/| /' conftest.$ac_ext >&5
3555
3556 ac_cv_prog_cc_g=no
3557 fi
3558 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3559 fi
3560 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3561 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3562 if test "$ac_test_CFLAGS" = set; then
3563   CFLAGS=$ac_save_CFLAGS
3564 elif test $ac_cv_prog_cc_g = yes; then
3565   if test "$GCC" = yes; then
3566     CFLAGS="-g -O2"
3567   else
3568     CFLAGS="-g"
3569   fi
3570 else
3571   if test "$GCC" = yes; then
3572     CFLAGS="-O2"
3573   else
3574     CFLAGS=
3575   fi
3576 fi
3577 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3578 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3579 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3580   echo $ECHO_N "(cached) $ECHO_C" >&6
3581 else
3582   ac_cv_prog_cc_stdc=no
3583 ac_save_CC=$CC
3584 cat >conftest.$ac_ext <<_ACEOF
3585 /* confdefs.h.  */
3586 _ACEOF
3587 cat confdefs.h >>conftest.$ac_ext
3588 cat >>conftest.$ac_ext <<_ACEOF
3589 /* end confdefs.h.  */
3590 #include <stdarg.h>
3591 #include <stdio.h>
3592 #include <sys/types.h>
3593 #include <sys/stat.h>
3594 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3595 struct buf { int x; };
3596 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3597 static char *e (p, i)
3598      char **p;
3599      int i;
3600 {
3601   return p[i];
3602 }
3603 static char *f (char * (*g) (char **, int), char **p, ...)
3604 {
3605   char *s;
3606   va_list v;
3607   va_start (v,p);
3608   s = g (p, va_arg (v,int));
3609   va_end (v);
3610   return s;
3611 }
3612
3613 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3614    function prototypes and stuff, but not '\xHH' hex character constants.
3615    These don't provoke an error unfortunately, instead are silently treated
3616    as 'x'.  The following induces an error, until -std1 is added to get
3617    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3618    array size at least.  It's necessary to write '\x00'==0 to get something
3619    that's true only with -std1.  */
3620 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3621
3622 int test (int i, double x);
3623 struct s1 {int (*f) (int a);};
3624 struct s2 {int (*f) (double a);};
3625 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3626 int argc;
3627 char **argv;
3628 int
3629 main ()
3630 {
3631 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3632   ;
3633   return 0;
3634 }
3635 _ACEOF
3636 # Don't try gcc -ansi; that turns off useful extensions and
3637 # breaks some systems' header files.
3638 # AIX                   -qlanglvl=ansi
3639 # Ultrix and OSF/1      -std1
3640 # HP-UX 10.20 and later -Ae
3641 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3642 # SVR4                  -Xc -D__EXTENSIONS__
3643 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3644 do
3645   CC="$ac_save_CC $ac_arg"
3646   rm -f conftest.$ac_objext
3647 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3648   (eval $ac_compile) 2>conftest.er1
3649   ac_status=$?
3650   grep -v '^ *+' conftest.er1 >conftest.err
3651   rm -f conftest.er1
3652   cat conftest.err >&5
3653   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3654   (exit $ac_status); } &&
3655          { ac_try='test -z "$ac_c_werror_flag"
3656                          || test ! -s conftest.err'
3657   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3658   (eval $ac_try) 2>&5
3659   ac_status=$?
3660   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3661   (exit $ac_status); }; } &&
3662          { ac_try='test -s conftest.$ac_objext'
3663   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3664   (eval $ac_try) 2>&5
3665   ac_status=$?
3666   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3667   (exit $ac_status); }; }; then
3668   ac_cv_prog_cc_stdc=$ac_arg
3669 break
3670 else
3671   echo "$as_me: failed program was:" >&5
3672 sed 's/^/| /' conftest.$ac_ext >&5
3673
3674 fi
3675 rm -f conftest.err conftest.$ac_objext
3676 done
3677 rm -f conftest.$ac_ext conftest.$ac_objext
3678 CC=$ac_save_CC
3679
3680 fi
3681
3682 case "x$ac_cv_prog_cc_stdc" in
3683   x|xno)
3684     echo "$as_me:$LINENO: result: none needed" >&5
3685 echo "${ECHO_T}none needed" >&6 ;;
3686   *)
3687     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3688 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3689     CC="$CC $ac_cv_prog_cc_stdc" ;;
3690 esac
3691
3692 # Some people use a C++ compiler to compile C.  Since we use `exit',
3693 # in C++ we need to declare it.  In case someone uses the same compiler
3694 # for both compiling C and C++ we need to have the C++ compiler decide
3695 # the declaration of exit, since it's the most demanding environment.
3696 cat >conftest.$ac_ext <<_ACEOF
3697 #ifndef __cplusplus
3698   choke me
3699 #endif
3700 _ACEOF
3701 rm -f conftest.$ac_objext
3702 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3703   (eval $ac_compile) 2>conftest.er1
3704   ac_status=$?
3705   grep -v '^ *+' conftest.er1 >conftest.err
3706   rm -f conftest.er1
3707   cat conftest.err >&5
3708   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3709   (exit $ac_status); } &&
3710          { ac_try='test -z "$ac_c_werror_flag"
3711                          || test ! -s conftest.err'
3712   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3713   (eval $ac_try) 2>&5
3714   ac_status=$?
3715   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3716   (exit $ac_status); }; } &&
3717          { ac_try='test -s conftest.$ac_objext'
3718   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3719   (eval $ac_try) 2>&5
3720   ac_status=$?
3721   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3722   (exit $ac_status); }; }; then
3723   for ac_declaration in \
3724    '' \
3725    'extern "C" void std::exit (int) throw (); using std::exit;' \
3726    'extern "C" void std::exit (int); using std::exit;' \
3727    'extern "C" void exit (int) throw ();' \
3728    'extern "C" void exit (int);' \
3729    'void exit (int);'
3730 do
3731   cat >conftest.$ac_ext <<_ACEOF
3732 /* confdefs.h.  */
3733 _ACEOF
3734 cat confdefs.h >>conftest.$ac_ext
3735 cat >>conftest.$ac_ext <<_ACEOF
3736 /* end confdefs.h.  */
3737 $ac_declaration
3738 #include <stdlib.h>
3739 int
3740 main ()
3741 {
3742 exit (42);
3743   ;
3744   return 0;
3745 }
3746 _ACEOF
3747 rm -f conftest.$ac_objext
3748 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3749   (eval $ac_compile) 2>conftest.er1
3750   ac_status=$?
3751   grep -v '^ *+' conftest.er1 >conftest.err
3752   rm -f conftest.er1
3753   cat conftest.err >&5
3754   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3755   (exit $ac_status); } &&
3756          { ac_try='test -z "$ac_c_werror_flag"
3757                          || test ! -s conftest.err'
3758   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3759   (eval $ac_try) 2>&5
3760   ac_status=$?
3761   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3762   (exit $ac_status); }; } &&
3763          { ac_try='test -s conftest.$ac_objext'
3764   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3765   (eval $ac_try) 2>&5
3766   ac_status=$?
3767   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3768   (exit $ac_status); }; }; then
3769   :
3770 else
3771   echo "$as_me: failed program was:" >&5
3772 sed 's/^/| /' conftest.$ac_ext >&5
3773
3774 continue
3775 fi
3776 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3777   cat >conftest.$ac_ext <<_ACEOF
3778 /* confdefs.h.  */
3779 _ACEOF
3780 cat confdefs.h >>conftest.$ac_ext
3781 cat >>conftest.$ac_ext <<_ACEOF
3782 /* end confdefs.h.  */
3783 $ac_declaration
3784 int
3785 main ()
3786 {
3787 exit (42);
3788   ;
3789   return 0;
3790 }
3791 _ACEOF
3792 rm -f conftest.$ac_objext
3793 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3794   (eval $ac_compile) 2>conftest.er1
3795   ac_status=$?
3796   grep -v '^ *+' conftest.er1 >conftest.err
3797   rm -f conftest.er1
3798   cat conftest.err >&5
3799   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3800   (exit $ac_status); } &&
3801          { ac_try='test -z "$ac_c_werror_flag"
3802                          || test ! -s conftest.err'
3803   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3804   (eval $ac_try) 2>&5
3805   ac_status=$?
3806   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3807   (exit $ac_status); }; } &&
3808          { ac_try='test -s conftest.$ac_objext'
3809   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3810   (eval $ac_try) 2>&5
3811   ac_status=$?
3812   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3813   (exit $ac_status); }; }; then
3814   break
3815 else
3816   echo "$as_me: failed program was:" >&5
3817 sed 's/^/| /' conftest.$ac_ext >&5
3818
3819 fi
3820 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3821 done
3822 rm -f conftest*
3823 if test -n "$ac_declaration"; then
3824   echo '#ifdef __cplusplus' >>confdefs.h
3825   echo $ac_declaration      >>confdefs.h
3826   echo '#endif'             >>confdefs.h
3827 fi
3828
3829 else
3830   echo "$as_me: failed program was:" >&5
3831 sed 's/^/| /' conftest.$ac_ext >&5
3832
3833 fi
3834 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3835 ac_ext=c
3836 ac_cpp='$CPP $CPPFLAGS'
3837 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3838 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3839 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3840
3841 ac_ext=cc
3842 ac_cpp='$CXXCPP $CPPFLAGS'
3843 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3844 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3845 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3846 if test -n "$ac_tool_prefix"; then
3847   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3848   do
3849     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3850 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3851 echo "$as_me:$LINENO: checking for $ac_word" >&5
3852 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3853 if test "${ac_cv_prog_CXX+set}" = set; then
3854   echo $ECHO_N "(cached) $ECHO_C" >&6
3855 else
3856   if test -n "$CXX"; then
3857   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3858 else
3859 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3860 for as_dir in $PATH
3861 do
3862   IFS=$as_save_IFS
3863   test -z "$as_dir" && as_dir=.
3864   for ac_exec_ext in '' $ac_executable_extensions; do
3865   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3866     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3867     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3868     break 2
3869   fi
3870 done
3871 done
3872
3873 fi
3874 fi
3875 CXX=$ac_cv_prog_CXX
3876 if test -n "$CXX"; then
3877   echo "$as_me:$LINENO: result: $CXX" >&5
3878 echo "${ECHO_T}$CXX" >&6
3879 else
3880   echo "$as_me:$LINENO: result: no" >&5
3881 echo "${ECHO_T}no" >&6
3882 fi
3883
3884     test -n "$CXX" && break
3885   done
3886 fi
3887 if test -z "$CXX"; then
3888   ac_ct_CXX=$CXX
3889   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3890 do
3891   # Extract the first word of "$ac_prog", so it can be a program name with args.
3892 set dummy $ac_prog; ac_word=$2
3893 echo "$as_me:$LINENO: checking for $ac_word" >&5
3894 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3895 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3896   echo $ECHO_N "(cached) $ECHO_C" >&6
3897 else
3898   if test -n "$ac_ct_CXX"; then
3899   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3900 else
3901 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3902 for as_dir in $PATH
3903 do
3904   IFS=$as_save_IFS
3905   test -z "$as_dir" && as_dir=.
3906   for ac_exec_ext in '' $ac_executable_extensions; do
3907   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3908     ac_cv_prog_ac_ct_CXX="$ac_prog"
3909     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3910     break 2
3911   fi
3912 done
3913 done
3914
3915 fi
3916 fi
3917 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3918 if test -n "$ac_ct_CXX"; then
3919   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3920 echo "${ECHO_T}$ac_ct_CXX" >&6
3921 else
3922   echo "$as_me:$LINENO: result: no" >&5
3923 echo "${ECHO_T}no" >&6
3924 fi
3925
3926   test -n "$ac_ct_CXX" && break
3927 done
3928 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3929
3930   CXX=$ac_ct_CXX
3931 fi
3932
3933
3934 # Provide some information about the compiler.
3935 echo "$as_me:$LINENO:" \
3936      "checking for C++ compiler version" >&5
3937 ac_compiler=`set X $ac_compile; echo $2`
3938 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3939   (eval $ac_compiler --version </dev/null >&5) 2>&5
3940   ac_status=$?
3941   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3942   (exit $ac_status); }
3943 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3944   (eval $ac_compiler -v </dev/null >&5) 2>&5
3945   ac_status=$?
3946   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3947   (exit $ac_status); }
3948 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3949   (eval $ac_compiler -V </dev/null >&5) 2>&5
3950   ac_status=$?
3951   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3952   (exit $ac_status); }
3953
3954 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3955 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3956 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3957   echo $ECHO_N "(cached) $ECHO_C" >&6
3958 else
3959   cat >conftest.$ac_ext <<_ACEOF
3960 /* confdefs.h.  */
3961 _ACEOF
3962 cat confdefs.h >>conftest.$ac_ext
3963 cat >>conftest.$ac_ext <<_ACEOF
3964 /* end confdefs.h.  */
3965
3966 int
3967 main ()
3968 {
3969 #ifndef __GNUC__
3970        choke me
3971 #endif
3972
3973   ;
3974   return 0;
3975 }
3976 _ACEOF
3977 rm -f conftest.$ac_objext
3978 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3979   (eval $ac_compile) 2>conftest.er1
3980   ac_status=$?
3981   grep -v '^ *+' conftest.er1 >conftest.err
3982   rm -f conftest.er1
3983   cat conftest.err >&5
3984   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3985   (exit $ac_status); } &&
3986          { ac_try='test -z "$ac_cxx_werror_flag"
3987                          || test ! -s conftest.err'
3988   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3989   (eval $ac_try) 2>&5
3990   ac_status=$?
3991   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3992   (exit $ac_status); }; } &&
3993          { ac_try='test -s conftest.$ac_objext'
3994   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3995   (eval $ac_try) 2>&5
3996   ac_status=$?
3997   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3998   (exit $ac_status); }; }; then
3999   ac_compiler_gnu=yes
4000 else
4001   echo "$as_me: failed program was:" >&5
4002 sed 's/^/| /' conftest.$ac_ext >&5
4003
4004 ac_compiler_gnu=no
4005 fi
4006 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4007 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
4008
4009 fi
4010 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
4011 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
4012 GXX=`test $ac_compiler_gnu = yes && echo yes`
4013 ac_test_CXXFLAGS=${CXXFLAGS+set}
4014 ac_save_CXXFLAGS=$CXXFLAGS
4015 CXXFLAGS="-g"
4016 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
4017 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
4018 if test "${ac_cv_prog_cxx_g+set}" = set; then
4019   echo $ECHO_N "(cached) $ECHO_C" >&6
4020 else
4021   cat >conftest.$ac_ext <<_ACEOF
4022 /* confdefs.h.  */
4023 _ACEOF
4024 cat confdefs.h >>conftest.$ac_ext
4025 cat >>conftest.$ac_ext <<_ACEOF
4026 /* end confdefs.h.  */
4027
4028 int
4029 main ()
4030 {
4031
4032   ;
4033   return 0;
4034 }
4035 _ACEOF
4036 rm -f conftest.$ac_objext
4037 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4038   (eval $ac_compile) 2>conftest.er1
4039   ac_status=$?
4040   grep -v '^ *+' conftest.er1 >conftest.err
4041   rm -f conftest.er1
4042   cat conftest.err >&5
4043   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4044   (exit $ac_status); } &&
4045          { ac_try='test -z "$ac_cxx_werror_flag"
4046                          || test ! -s conftest.err'
4047   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4048   (eval $ac_try) 2>&5
4049   ac_status=$?
4050   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4051   (exit $ac_status); }; } &&
4052          { ac_try='test -s conftest.$ac_objext'
4053   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4054   (eval $ac_try) 2>&5
4055   ac_status=$?
4056   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4057   (exit $ac_status); }; }; then
4058   ac_cv_prog_cxx_g=yes
4059 else
4060   echo "$as_me: failed program was:" >&5
4061 sed 's/^/| /' conftest.$ac_ext >&5
4062
4063 ac_cv_prog_cxx_g=no
4064 fi
4065 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4066 fi
4067 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
4068 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
4069 if test "$ac_test_CXXFLAGS" = set; then
4070   CXXFLAGS=$ac_save_CXXFLAGS
4071 elif test $ac_cv_prog_cxx_g = yes; then
4072   if test "$GXX" = yes; then
4073     CXXFLAGS="-g -O2"
4074   else
4075     CXXFLAGS="-g"
4076   fi
4077 else
4078   if test "$GXX" = yes; then
4079     CXXFLAGS="-O2"
4080   else
4081     CXXFLAGS=
4082   fi
4083 fi
4084 for ac_declaration in \
4085    '' \
4086    'extern "C" void std::exit (int) throw (); using std::exit;' \
4087    'extern "C" void std::exit (int); using std::exit;' \
4088    'extern "C" void exit (int) throw ();' \
4089    'extern "C" void exit (int);' \
4090    'void exit (int);'
4091 do
4092   cat >conftest.$ac_ext <<_ACEOF
4093 /* confdefs.h.  */
4094 _ACEOF
4095 cat confdefs.h >>conftest.$ac_ext
4096 cat >>conftest.$ac_ext <<_ACEOF
4097 /* end confdefs.h.  */
4098 $ac_declaration
4099 #include <stdlib.h>
4100 int
4101 main ()
4102 {
4103 exit (42);
4104   ;
4105   return 0;
4106 }
4107 _ACEOF
4108 rm -f conftest.$ac_objext
4109 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4110   (eval $ac_compile) 2>conftest.er1
4111   ac_status=$?
4112   grep -v '^ *+' conftest.er1 >conftest.err
4113   rm -f conftest.er1
4114   cat conftest.err >&5
4115   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4116   (exit $ac_status); } &&
4117          { ac_try='test -z "$ac_cxx_werror_flag"
4118                          || test ! -s conftest.err'
4119   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4120   (eval $ac_try) 2>&5
4121   ac_status=$?
4122   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4123   (exit $ac_status); }; } &&
4124          { ac_try='test -s conftest.$ac_objext'
4125   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4126   (eval $ac_try) 2>&5
4127   ac_status=$?
4128   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4129   (exit $ac_status); }; }; then
4130   :
4131 else
4132   echo "$as_me: failed program was:" >&5
4133 sed 's/^/| /' conftest.$ac_ext >&5
4134
4135 continue
4136 fi
4137 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4138   cat >conftest.$ac_ext <<_ACEOF
4139 /* confdefs.h.  */
4140 _ACEOF
4141 cat confdefs.h >>conftest.$ac_ext
4142 cat >>conftest.$ac_ext <<_ACEOF
4143 /* end confdefs.h.  */
4144 $ac_declaration
4145 int
4146 main ()
4147 {
4148 exit (42);
4149   ;
4150   return 0;
4151 }
4152 _ACEOF
4153 rm -f conftest.$ac_objext
4154 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4155   (eval $ac_compile) 2>conftest.er1
4156   ac_status=$?
4157   grep -v '^ *+' conftest.er1 >conftest.err
4158   rm -f conftest.er1
4159   cat conftest.err >&5
4160   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4161   (exit $ac_status); } &&
4162          { ac_try='test -z "$ac_cxx_werror_flag"
4163                          || test ! -s conftest.err'
4164   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4165   (eval $ac_try) 2>&5
4166   ac_status=$?
4167   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4168   (exit $ac_status); }; } &&
4169          { ac_try='test -s conftest.$ac_objext'
4170   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4171   (eval $ac_try) 2>&5
4172   ac_status=$?
4173   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4174   (exit $ac_status); }; }; then
4175   break
4176 else
4177   echo "$as_me: failed program was:" >&5
4178 sed 's/^/| /' conftest.$ac_ext >&5
4179
4180 fi
4181 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4182 done
4183 rm -f conftest*
4184 if test -n "$ac_declaration"; then
4185   echo '#ifdef __cplusplus' >>confdefs.h
4186   echo $ac_declaration      >>confdefs.h
4187   echo '#endif'             >>confdefs.h
4188 fi
4189
4190 ac_ext=c
4191 ac_cpp='$CPP $CPPFLAGS'
4192 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4193 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4194 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4195
4196
4197 # We must set the default linker to the linker used by gcc for the correct
4198 # operation of libtool.  If LD is not defined and we are using gcc, try to
4199 # set the LD default to the ld used by gcc.
4200 if test -z "$LD"; then
4201   if test "$GCC" = yes; then
4202     case $build in
4203     *-*-mingw*)
4204       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4205     *)
4206       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4207     esac
4208     case $gcc_prog_ld in
4209     # Accept absolute paths.
4210     [\\/]* | [A-Za-z]:[\\/]*)
4211       LD="$gcc_prog_ld" ;;
4212     esac
4213   fi
4214 fi
4215
4216
4217
4218
4219 if test -n "$ac_tool_prefix"; then
4220   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4221 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4222 echo "$as_me:$LINENO: checking for $ac_word" >&5
4223 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4224 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4225   echo $ECHO_N "(cached) $ECHO_C" >&6
4226 else
4227   if test -n "$GNATBIND"; then
4228   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4229 else
4230 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4231 for as_dir in $PATH
4232 do
4233   IFS=$as_save_IFS
4234   test -z "$as_dir" && as_dir=.
4235   for ac_exec_ext in '' $ac_executable_extensions; do
4236   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4237     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4238     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4239     break 2
4240   fi
4241 done
4242 done
4243
4244 fi
4245 fi
4246 GNATBIND=$ac_cv_prog_GNATBIND
4247 if test -n "$GNATBIND"; then
4248   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4249 echo "${ECHO_T}$GNATBIND" >&6
4250 else
4251   echo "$as_me:$LINENO: result: no" >&5
4252 echo "${ECHO_T}no" >&6
4253 fi
4254
4255 fi
4256 if test -z "$ac_cv_prog_GNATBIND"; then
4257   ac_ct_GNATBIND=$GNATBIND
4258   # Extract the first word of "gnatbind", so it can be a program name with args.
4259 set dummy gnatbind; ac_word=$2
4260 echo "$as_me:$LINENO: checking for $ac_word" >&5
4261 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4262 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4263   echo $ECHO_N "(cached) $ECHO_C" >&6
4264 else
4265   if test -n "$ac_ct_GNATBIND"; then
4266   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4267 else
4268 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4269 for as_dir in $PATH
4270 do
4271   IFS=$as_save_IFS
4272   test -z "$as_dir" && as_dir=.
4273   for ac_exec_ext in '' $ac_executable_extensions; do
4274   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4275     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4276     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4277     break 2
4278   fi
4279 done
4280 done
4281
4282   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4283 fi
4284 fi
4285 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4286 if test -n "$ac_ct_GNATBIND"; then
4287   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4288 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4289 else
4290   echo "$as_me:$LINENO: result: no" >&5
4291 echo "${ECHO_T}no" >&6
4292 fi
4293
4294   GNATBIND=$ac_ct_GNATBIND
4295 else
4296   GNATBIND="$ac_cv_prog_GNATBIND"
4297 fi
4298
4299 if test -n "$ac_tool_prefix"; then
4300   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4301 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4302 echo "$as_me:$LINENO: checking for $ac_word" >&5
4303 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4304 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4305   echo $ECHO_N "(cached) $ECHO_C" >&6
4306 else
4307   if test -n "$GNATMAKE"; then
4308   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4309 else
4310 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4311 for as_dir in $PATH
4312 do
4313   IFS=$as_save_IFS
4314   test -z "$as_dir" && as_dir=.
4315   for ac_exec_ext in '' $ac_executable_extensions; do
4316   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4317     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4318     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4319     break 2
4320   fi
4321 done
4322 done
4323
4324 fi
4325 fi
4326 GNATMAKE=$ac_cv_prog_GNATMAKE
4327 if test -n "$GNATMAKE"; then
4328   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4329 echo "${ECHO_T}$GNATMAKE" >&6
4330 else
4331   echo "$as_me:$LINENO: result: no" >&5
4332 echo "${ECHO_T}no" >&6
4333 fi
4334
4335 fi
4336 if test -z "$ac_cv_prog_GNATMAKE"; then
4337   ac_ct_GNATMAKE=$GNATMAKE
4338   # Extract the first word of "gnatmake", so it can be a program name with args.
4339 set dummy gnatmake; ac_word=$2
4340 echo "$as_me:$LINENO: checking for $ac_word" >&5
4341 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4342 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4343   echo $ECHO_N "(cached) $ECHO_C" >&6
4344 else
4345   if test -n "$ac_ct_GNATMAKE"; then
4346   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4347 else
4348 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4349 for as_dir in $PATH
4350 do
4351   IFS=$as_save_IFS
4352   test -z "$as_dir" && as_dir=.
4353   for ac_exec_ext in '' $ac_executable_extensions; do
4354   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4355     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4356     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4357     break 2
4358   fi
4359 done
4360 done
4361
4362   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4363 fi
4364 fi
4365 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4366 if test -n "$ac_ct_GNATMAKE"; then
4367   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4368 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4369 else
4370   echo "$as_me:$LINENO: result: no" >&5
4371 echo "${ECHO_T}no" >&6
4372 fi
4373
4374   GNATMAKE=$ac_ct_GNATMAKE
4375 else
4376   GNATMAKE="$ac_cv_prog_GNATMAKE"
4377 fi
4378
4379 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4380 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4381 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4382   echo $ECHO_N "(cached) $ECHO_C" >&6
4383 else
4384   cat >conftest.adb <<EOF
4385 procedure conftest is begin null; end conftest;
4386 EOF
4387 acx_cv_cc_gcc_supports_ada=no
4388 # There is a bug in old released versions of GCC which causes the
4389 # driver to exit successfully when the appropriate language module
4390 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4391 # Therefore we must check for the error message as well as an
4392 # unsuccessful exit.
4393 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4394 # given a .adb file, but produce no object file.  So we must check
4395 # if an object file was really produced to guard against this.
4396 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4397 if test x"$errors" = x && test -f conftest.$ac_objext; then
4398   acx_cv_cc_gcc_supports_ada=yes
4399 fi
4400 rm -f conftest.*
4401 fi
4402 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4403 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4404
4405 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4406   have_gnat=yes
4407 else
4408   have_gnat=no
4409 fi
4410
4411 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4412 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4413 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4414   echo $ECHO_N "(cached) $ECHO_C" >&6
4415 else
4416    echo abfoo >t1
4417   echo cdfoo >t2
4418   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4419   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4420     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4421       :
4422     else
4423       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4424     fi
4425   fi
4426   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4427     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4428       :
4429     else
4430       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4431     fi
4432   fi
4433   rm t1 t2
4434
4435 fi
4436 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4437 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4438 do_compare="$gcc_cv_prog_cmp_skip"
4439
4440
4441
4442 # Check for GMP and MPFR
4443 gmplibs="-lmpfr -lgmp"
4444 gmpinc=
4445 have_gmp=no
4446
4447 # Specify a location for mpfr
4448 # check for this first so it ends up on the link line before gmp.
4449
4450 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4451 if test "${with_mpfr_dir+set}" = set; then
4452   withval="$with_mpfr_dir"
4453   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4454 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4455 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4456 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4457    { (exit 1); exit 1; }; }
4458 fi;
4459
4460
4461 # Check whether --with-mpfr or --without-mpfr was given.
4462 if test "${with_mpfr+set}" = set; then
4463   withval="$with_mpfr"
4464
4465 fi;
4466
4467 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4468 if test "${with_mpfr_include+set}" = set; then
4469   withval="$with_mpfr_include"
4470
4471 fi;
4472
4473 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4474 if test "${with_mpfr_lib+set}" = set; then
4475   withval="$with_mpfr_lib"
4476
4477 fi;
4478
4479 if test "x$with_mpfr" != x; then
4480   gmplibs="-L$with_mpfr/lib $gmplibs"
4481   gmpinc="-I$with_mpfr/include"
4482 fi
4483 if test "x$with_mpfr_include" != x; then
4484   gmpinc="-I$with_mpfr_include"
4485 fi
4486 if test "x$with_mpfr_lib" != x; then
4487   gmplibs="-L$with_mpfr_lib $gmplibs"
4488 fi
4489 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4490   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4491   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4492   # Do not test the mpfr version.  Assume that it is sufficient, since
4493   # it is in the source tree, and the library has not been built yet
4494   # but it would be included on the link line in the version check below
4495   # hence making the test fail.
4496   have_gmp=yes
4497 fi
4498
4499 # Specify a location for gmp
4500
4501 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4502 if test "${with_gmp_dir+set}" = set; then
4503   withval="$with_gmp_dir"
4504   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4505 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4506 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4507 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4508    { (exit 1); exit 1; }; }
4509 fi;
4510
4511
4512 # Check whether --with-gmp or --without-gmp was given.
4513 if test "${with_gmp+set}" = set; then
4514   withval="$with_gmp"
4515
4516 fi;
4517
4518 # Check whether --with-gmp_include or --without-gmp_include was given.
4519 if test "${with_gmp_include+set}" = set; then
4520   withval="$with_gmp_include"
4521
4522 fi;
4523
4524 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4525 if test "${with_gmp_lib+set}" = set; then
4526   withval="$with_gmp_lib"
4527
4528 fi;
4529
4530
4531 if test "x$with_gmp" != x; then
4532   gmplibs="-L$with_gmp/lib $gmplibs"
4533   gmpinc="-I$with_gmp/include $gmpinc"
4534 fi
4535 if test "x$with_gmp_include" != x; then
4536   gmpinc="-I$with_gmp_include $gmpinc"
4537 fi
4538 if test "x$with_gmp_lib" != x; then
4539   gmplibs="-L$with_gmp_lib $gmplibs"
4540 fi
4541 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4542   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4543   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4544   # Do not test the gmp version.  Assume that it is sufficient, since
4545   # it is in the source tree, and the library has not been built yet
4546   # but it would be included on the link line in the version check below
4547   # hence making the test fail.
4548   have_gmp=yes
4549 fi
4550
4551 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4552   have_gmp=yes
4553   saved_CFLAGS="$CFLAGS"
4554   CFLAGS="$CFLAGS $gmpinc"
4555   # Check GMP actually works
4556   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4557 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4558
4559 cat >conftest.$ac_ext <<_ACEOF
4560 /* confdefs.h.  */
4561 _ACEOF
4562 cat confdefs.h >>conftest.$ac_ext
4563 cat >>conftest.$ac_ext <<_ACEOF
4564 /* end confdefs.h.  */
4565 #include "gmp.h"
4566 int
4567 main ()
4568 {
4569
4570   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4571   choke me
4572   #endif
4573
4574   ;
4575   return 0;
4576 }
4577 _ACEOF
4578 rm -f conftest.$ac_objext
4579 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4580   (eval $ac_compile) 2>conftest.er1
4581   ac_status=$?
4582   grep -v '^ *+' conftest.er1 >conftest.err
4583   rm -f conftest.er1
4584   cat conftest.err >&5
4585   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4586   (exit $ac_status); } &&
4587          { ac_try='test -z "$ac_c_werror_flag"
4588                          || test ! -s conftest.err'
4589   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4590   (eval $ac_try) 2>&5
4591   ac_status=$?
4592   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4593   (exit $ac_status); }; } &&
4594          { ac_try='test -s conftest.$ac_objext'
4595   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4596   (eval $ac_try) 2>&5
4597   ac_status=$?
4598   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4599   (exit $ac_status); }; }; then
4600   echo "$as_me:$LINENO: result: yes" >&5
4601 echo "${ECHO_T}yes" >&6
4602 else
4603   echo "$as_me: failed program was:" >&5
4604 sed 's/^/| /' conftest.$ac_ext >&5
4605
4606 echo "$as_me:$LINENO: result: no" >&5
4607 echo "${ECHO_T}no" >&6; have_gmp=no
4608 fi
4609 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4610
4611   if test x"$have_gmp" = xyes; then
4612     saved_LIBS="$LIBS"
4613     LIBS="$LIBS $gmplibs"
4614         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4615 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4616     cat >conftest.$ac_ext <<_ACEOF
4617 /* confdefs.h.  */
4618 _ACEOF
4619 cat confdefs.h >>conftest.$ac_ext
4620 cat >>conftest.$ac_ext <<_ACEOF
4621 /* end confdefs.h.  */
4622 #include <gmp.h>
4623     #include <mpfr.h>
4624 int
4625 main ()
4626 {
4627
4628     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4629     choke me
4630     #endif
4631     mpfr_t n;
4632     mpfr_t x;
4633     int t;
4634     mpfr_init (n);
4635     mpfr_init (x);
4636     mpfr_atan2 (n, n, x, GMP_RNDN);
4637     mpfr_erfc (n, x, GMP_RNDN);
4638     mpfr_subnormalize (x, t, GMP_RNDN);
4639
4640   ;
4641   return 0;
4642 }
4643 _ACEOF
4644 rm -f conftest.$ac_objext conftest$ac_exeext
4645 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4646   (eval $ac_link) 2>conftest.er1
4647   ac_status=$?
4648   grep -v '^ *+' conftest.er1 >conftest.err
4649   rm -f conftest.er1
4650   cat conftest.err >&5
4651   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4652   (exit $ac_status); } &&
4653          { ac_try='test -z "$ac_c_werror_flag"
4654                          || test ! -s conftest.err'
4655   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4656   (eval $ac_try) 2>&5
4657   ac_status=$?
4658   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4659   (exit $ac_status); }; } &&
4660          { ac_try='test -s conftest$ac_exeext'
4661   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4662   (eval $ac_try) 2>&5
4663   ac_status=$?
4664   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4665   (exit $ac_status); }; }; then
4666   cat >conftest.$ac_ext <<_ACEOF
4667 /* confdefs.h.  */
4668 _ACEOF
4669 cat confdefs.h >>conftest.$ac_ext
4670 cat >>conftest.$ac_ext <<_ACEOF
4671 /* end confdefs.h.  */
4672 #include <gmp.h>
4673     #include <mpfr.h>
4674 int
4675 main ()
4676 {
4677
4678     #if MPFR_VERSION < MPFR_VERSION_NUM(2,3,0)
4679     choke me
4680     #endif
4681     mpfr_t n; mpfr_init(n);
4682
4683   ;
4684   return 0;
4685 }
4686 _ACEOF
4687 rm -f conftest.$ac_objext conftest$ac_exeext
4688 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4689   (eval $ac_link) 2>conftest.er1
4690   ac_status=$?
4691   grep -v '^ *+' conftest.er1 >conftest.err
4692   rm -f conftest.er1
4693   cat conftest.err >&5
4694   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4695   (exit $ac_status); } &&
4696          { ac_try='test -z "$ac_c_werror_flag"
4697                          || test ! -s conftest.err'
4698   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4699   (eval $ac_try) 2>&5
4700   ac_status=$?
4701   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4702   (exit $ac_status); }; } &&
4703          { ac_try='test -s conftest$ac_exeext'
4704   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4705   (eval $ac_try) 2>&5
4706   ac_status=$?
4707   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4708   (exit $ac_status); }; }; then
4709   echo "$as_me:$LINENO: result: yes" >&5
4710 echo "${ECHO_T}yes" >&6
4711 else
4712   echo "$as_me: failed program was:" >&5
4713 sed 's/^/| /' conftest.$ac_ext >&5
4714
4715 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4716 echo "${ECHO_T}buggy but acceptable" >&6
4717 fi
4718 rm -f conftest.err conftest.$ac_objext \
4719       conftest$ac_exeext conftest.$ac_ext
4720 else
4721   echo "$as_me: failed program was:" >&5
4722 sed 's/^/| /' conftest.$ac_ext >&5
4723
4724 echo "$as_me:$LINENO: result: no" >&5
4725 echo "${ECHO_T}no" >&6; have_gmp=no
4726 fi
4727 rm -f conftest.err conftest.$ac_objext \
4728       conftest$ac_exeext conftest.$ac_ext
4729       LIBS="$saved_LIBS"
4730   fi
4731   CFLAGS="$saved_CFLAGS"
4732
4733   if test x$have_gmp != xyes; then
4734     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4735 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4736 Copies of these libraries' source code can be found at their respective
4737 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4738 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4739 If you obtained GMP and/or MPFR from a vendor distribution package, make
4740 sure that you have installed both the libraries and the header files.
4741 They may be located in separate packages." >&5
4742 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.3.0+.
4743 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4744 Copies of these libraries' source code can be found at their respective
4745 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4746 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4747 If you obtained GMP and/or MPFR from a vendor distribution package, make
4748 sure that you have installed both the libraries and the header files.
4749 They may be located in separate packages." >&2;}
4750    { (exit 1); exit 1; }; }
4751   fi
4752 fi
4753
4754 # Flags needed for both GMP and/or MPFR
4755
4756
4757
4758 # By default, C is the only stage 1 language.
4759 stage1_languages=,c,
4760
4761 # Figure out what language subdirectories are present.
4762 # Look if the user specified --enable-languages="..."; if not, use
4763 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4764 # go away some day.
4765 # NB:  embedded tabs in this IF block -- do not untabify
4766 if test -d ${srcdir}/gcc; then
4767   if test x"${enable_languages+set}" != xset; then
4768     if test x"${LANGUAGES+set}" = xset; then
4769       enable_languages="${LANGUAGES}"
4770         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4771     else
4772       enable_languages=all
4773     fi
4774   else
4775     if test x"${enable_languages}" = x ||
4776        test x"${enable_languages}" = xyes;
4777        then
4778       echo configure.in: --enable-languages needs at least one language argument 1>&2
4779       exit 1
4780     fi
4781   fi
4782   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4783
4784   # 'f95' is the old name for the 'fortran' language. We issue a warning
4785   # and make the substitution.
4786   case ,${enable_languages}, in
4787     *,f95,*)
4788       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4789       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4790       ;;
4791   esac
4792
4793   # First scan to see if an enabled language requires some other language.
4794   # We assume that a given config-lang.in will list all the language
4795   # front ends it requires, even if some are required indirectly.
4796   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4797     case ${lang_frag} in
4798       ..) ;;
4799       # The odd quoting in the next line works around
4800       # an apparent bug in bash 1.12 on linux.
4801       ${srcdir}/gcc/[*]/config-lang.in) ;;
4802       *)
4803         # From the config-lang.in, get $language, $lang_requires
4804         language=
4805         lang_requires=
4806         . ${lang_frag}
4807         for other in ${lang_requires} ; do
4808           case ,${enable_languages}, in
4809             *,$other,*) ;;
4810             *,all,*) ;;
4811             *,$language,*)
4812               echo " \`$other' language required by \`$language'; enabling" 1>&2
4813               enable_languages="${enable_languages},${other}"
4814               ;;
4815           esac
4816         done
4817         ;;
4818     esac
4819   done
4820
4821   new_enable_languages=,c,
4822   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4823   potential_languages=,c,
4824
4825   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4826     case ${lang_frag} in
4827       ..) ;;
4828       # The odd quoting in the next line works around
4829       # an apparent bug in bash 1.12 on linux.
4830       ${srcdir}/gcc/[*]/config-lang.in) ;;
4831       *)
4832         # From the config-lang.in, get $language, $target_libs,
4833         # $lang_dirs, $boot_language, and $build_by_default
4834         language=
4835         target_libs=
4836         lang_dirs=
4837         subdir_requires=
4838         boot_language=no
4839         build_by_default=yes
4840         . ${lang_frag}
4841         if test x${language} = x; then
4842           echo "${lang_frag} doesn't set \$language." 1>&2
4843           exit 1
4844         fi
4845
4846         case ,${enable_languages}, in
4847           *,${language},*)
4848             # Language was explicitly selected; include it.
4849             add_this_lang=yes
4850             ;;
4851           *,all,*)
4852             # 'all' was selected, select it if it is a default language
4853             add_this_lang=${build_by_default}
4854             ;;
4855           *)
4856             add_this_lang=no
4857             ;;
4858         esac
4859
4860         # Disable languages that need other directories if these aren't available.
4861         for i in $subdir_requires; do
4862           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4863           case ,${enable_languages}, in
4864             *,${language},*)
4865               # Specifically requested language; tell them.
4866               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4867 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4868    { (exit 1); exit 1; }; }
4869               ;;
4870             *)
4871               # Silently disable.
4872               add_this_lang=unsupported
4873               ;;
4874           esac
4875         done
4876
4877         # Disable Ada if no preexisting GNAT is available.
4878         case ,${enable_languages},:${language}:${have_gnat} in
4879           *,${language},*:ada:no)
4880             # Specifically requested language; tell them.
4881             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4882 echo "$as_me: error: GNAT is required to build $language" >&2;}
4883    { (exit 1); exit 1; }; }
4884             ;;
4885           *:ada:no)
4886             # Silently disable.
4887             add_this_lang=unsupported
4888             ;;
4889         esac
4890
4891         # Disable a language that is unsupported by the target.
4892         case " $unsupported_languages " in
4893           *" $language "*)
4894             add_this_lang=unsupported
4895             ;;
4896         esac
4897
4898         case $add_this_lang in
4899           unsupported)
4900             # Remove language-dependent dirs.
4901             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4902             ;;
4903           no)
4904             # Remove language-dependent dirs; still show language as supported.
4905             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4906             potential_languages="${potential_languages}${language},"
4907             ;;
4908           yes)
4909             new_enable_languages="${new_enable_languages}${language},"
4910             potential_languages="${potential_languages}${language},"
4911             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4912             case ${boot_language} in
4913               yes)
4914                 # Add to (comma-separated) list of stage 1 languages.
4915                 stage1_languages="${stage1_languages}${language},"
4916                 ;;
4917             esac
4918             ;;
4919         esac
4920         ;;
4921     esac
4922   done
4923
4924   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4925 if test "${enable_stage1_languages+set}" = set; then
4926   enableval="$enable_stage1_languages"
4927   case ,${enable_stage1_languages}, in
4928     ,no,|,,)
4929       # Set it to something that will have no effect in the loop below
4930       enable_stage1_languages=c ;;
4931     ,yes,)
4932       enable_stage1_languages=`echo $new_enable_languages | \
4933         sed -e "s/^,//" -e "s/,$//" ` ;;
4934     *,all,*)
4935       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4936         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4937   esac
4938
4939   # Add "good" languages from enable_stage1_languages to stage1_languages,
4940   # while "bad" languages go in missing_languages.  Leave no duplicates.
4941   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4942     case $potential_languages in
4943       *,$i,*)
4944         case $stage1_languages in
4945           *,$i,*) ;;
4946           *) stage1_languages="$stage1_languages$i," ;;
4947         esac ;;
4948       *)
4949         case $missing_languages in
4950           *,$i,*) ;;
4951           *) missing_languages="$missing_languages$i," ;;
4952         esac ;;
4953      esac
4954   done
4955 fi;
4956
4957   # Remove leading/trailing commas that were added for simplicity
4958   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4959   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4960   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4961   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4962
4963   if test "x$missing_languages" != x; then
4964     { { echo "$as_me:$LINENO: error:
4965 The following requested languages could not be built: ${missing_languages}
4966 Supported languages are: ${potential_languages}" >&5
4967 echo "$as_me: error:
4968 The following requested languages could not be built: ${missing_languages}
4969 Supported languages are: ${potential_languages}" >&2;}
4970    { (exit 1); exit 1; }; }
4971   fi
4972   if test "x$new_enable_languages" != "x$enable_languages"; then
4973     echo The following languages will be built: ${new_enable_languages}
4974     enable_languages="$new_enable_languages"
4975   fi
4976
4977
4978   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4979 fi
4980
4981 # Handle --disable-<component> generically.
4982 for dir in $configdirs $build_configdirs $target_configdirs ; do
4983   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4984   varname=`echo $dirname | sed -e s/+/_/g`
4985   if eval test x\${enable_${varname}} "=" xno ; then
4986     noconfigdirs="$noconfigdirs $dir"
4987   fi
4988 done
4989
4990 # Check for Boehm's garbage collector
4991 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4992 if test "${enable_objc_gc+set}" = set; then
4993   enableval="$enable_objc_gc"
4994   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4995   *,objc,*:*:yes:*target-boehm-gc*)
4996     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4997 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4998    { (exit 1); exit 1; }; }
4999     ;;
5000 esac
5001 fi;
5002
5003 # Make sure we only build Boehm's garbage collector if required.
5004 case ,${enable_languages},:${enable_objc_gc} in
5005   *,objc,*:yes)
5006     # Keep target-boehm-gc if requested for Objective-C.
5007     ;;
5008   *)
5009     # Otherwise remove target-boehm-gc depending on target-libjava.
5010     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
5011       noconfigdirs="$noconfigdirs target-boehm-gc"
5012     fi
5013     ;;
5014 esac
5015
5016 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
5017 # $build_configdirs and $target_configdirs.
5018 # If we have the source for $noconfigdirs entries, add them to $notsupp.
5019
5020 notsupp=""
5021 for dir in . $skipdirs $noconfigdirs ; do
5022   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
5023   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5024     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
5025     if test -r $srcdir/$dirname/configure ; then
5026       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5027         true
5028       else
5029         notsupp="$notsupp $dir"
5030       fi
5031     fi
5032   fi
5033   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5034     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
5035     if test -r $srcdir/$dirname/configure ; then
5036       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5037         true
5038       else
5039         notsupp="$notsupp $dir"
5040       fi
5041     fi
5042   fi
5043   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5044     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
5045     if test -r $srcdir/$dirname/configure ; then
5046       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5047         true
5048       else
5049         notsupp="$notsupp $dir"
5050       fi
5051     fi
5052   fi
5053 done
5054
5055 # Sometimes the tools are distributed with libiberty but with no other
5056 # libraries.  In that case, we don't want to build target-libiberty.
5057 # Don't let libgcc imply libiberty either.
5058 if test -n "${target_configdirs}" ; then
5059   libgcc=
5060   others=
5061   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
5062     if test "$i" = "libgcc"; then
5063       libgcc=target-libgcc
5064     elif test "$i" != "libiberty" ; then
5065       if test -r $srcdir/$i/configure ; then
5066         others=yes;
5067         break;
5068       fi
5069     fi
5070   done
5071   if test -z "${others}" ; then
5072     target_configdirs=$libgcc
5073   fi
5074 fi
5075
5076 # Quietly strip out all directories which aren't configurable in this tree.
5077 # This relies on all configurable subdirectories being autoconfiscated, which
5078 # is now the case.
5079 build_configdirs_all="$build_configdirs"
5080 build_configdirs=
5081 for i in ${build_configdirs_all} ; do
5082   j=`echo $i | sed -e s/build-//g`
5083   if test -f ${srcdir}/$j/configure ; then
5084     build_configdirs="${build_configdirs} $i"
5085   fi
5086 done
5087
5088 configdirs_all="$configdirs"
5089 configdirs=
5090 for i in ${configdirs_all} ; do
5091   if test -f ${srcdir}/$i/configure ; then
5092     configdirs="${configdirs} $i"
5093   fi
5094 done
5095
5096 target_configdirs_all="$target_configdirs"
5097 target_configdirs=
5098 for i in ${target_configdirs_all} ; do
5099   j=`echo $i | sed -e s/target-//g`
5100   if test -f ${srcdir}/$j/configure ; then
5101     target_configdirs="${target_configdirs} $i"
5102   fi
5103 done
5104
5105 # Produce a warning message for the subdirs we can't configure.
5106 # This isn't especially interesting in the Cygnus tree, but in the individual
5107 # FSF releases, it's important to let people know when their machine isn't
5108 # supported by the one or two programs in a package.
5109
5110 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5111   # If $appdirs is non-empty, at least one of those directories must still
5112   # be configured, or we error out.  (E.g., if the gas release supports a
5113   # specified target in some subdirs but not the gas subdir, we shouldn't
5114   # pretend that all is well.)
5115   if test -n "$appdirs" ; then
5116     for dir in $appdirs ; do
5117       if test -r $dir/Makefile.in ; then
5118         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5119           appdirs=""
5120           break
5121         fi
5122         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5123           appdirs=""
5124           break
5125         fi
5126       fi
5127     done
5128     if test -n "$appdirs" ; then
5129       echo "*** This configuration is not supported by this package." 1>&2
5130       exit 1
5131     fi
5132   fi
5133   # Okay, some application will build, or we don't care to check.  Still
5134   # notify of subdirs not getting built.
5135   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5136   echo "    ${notsupp}" 1>&2
5137   echo "    (Any other directories should still work fine.)" 1>&2
5138 fi
5139
5140 case "$host" in
5141   *msdosdjgpp*)
5142     enable_gdbtk=no ;;
5143 esac
5144
5145 # To find our prefix, in gcc_cv_tool_prefix.
5146
5147 # The user is always right.
5148 if test "${PATH_SEPARATOR+set}" != set; then
5149   echo "#! /bin/sh" >conf$$.sh
5150   echo  "exit 0"   >>conf$$.sh
5151   chmod +x conf$$.sh
5152   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5153     PATH_SEPARATOR=';'
5154   else
5155     PATH_SEPARATOR=:
5156   fi
5157   rm -f conf$$.sh
5158 fi
5159
5160
5161
5162 if test "x$exec_prefix" = xNONE; then
5163         if test "x$prefix" = xNONE; then
5164                 gcc_cv_tool_prefix=$ac_default_prefix
5165         else
5166                 gcc_cv_tool_prefix=$prefix
5167         fi
5168 else
5169         gcc_cv_tool_prefix=$exec_prefix
5170 fi
5171
5172 # If there is no compiler in the tree, use the PATH only.  In any
5173 # case, if there is no compiler in the tree nobody should use
5174 # AS_FOR_TARGET and LD_FOR_TARGET.
5175 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5176     gcc_version=`cat $srcdir/gcc/BASE-VER`
5177     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5178     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5179     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5180     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5181     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5182     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5183 else
5184     gcc_cv_tool_dirs=
5185 fi
5186
5187 if test x$build = x$target && test -n "$md_exec_prefix"; then
5188         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5189 fi
5190
5191
5192
5193 copy_dirs=
5194
5195
5196 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5197 if test "${with_build_sysroot+set}" = set; then
5198   withval="$with_build_sysroot"
5199   if test x"$withval" != x ; then
5200      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5201    fi
5202 else
5203   SYSROOT_CFLAGS_FOR_TARGET=
5204 fi;
5205
5206
5207
5208 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5209 if test "${with_debug_prefix_map+set}" = set; then
5210   withval="$with_debug_prefix_map"
5211   if test x"$withval" != x; then
5212      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5213      for debug_map in $withval; do
5214        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5215      done
5216    fi
5217 else
5218   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5219 fi;
5220
5221
5222 # During gcc bootstrap, if we use some random cc for stage1 then CFLAGS
5223 # might be empty or "-g".  We don't require a C++ compiler, so CXXFLAGS
5224 # might also be empty (or "-g", if a non-GCC C++ compiler is in the path).
5225 # We want to ensure that TARGET libraries (which we know are built with
5226 # gcc) are built with "-O2 -g", so include those options when setting
5227 # CFLAGS_FOR_TARGET and CXXFLAGS_FOR_TARGET.
5228 if test "x$CFLAGS_FOR_TARGET" = x; then
5229   CFLAGS_FOR_TARGET=$CFLAGS
5230   case " $CFLAGS " in
5231     *" -O2 "*) ;;
5232     *) CFLAGS_FOR_TARGET="-O2 $CFLAGS" ;;
5233   esac
5234   case " $CFLAGS " in
5235     *" -g "* | *" -g3 "*) ;;
5236     *) CFLAGS_FOR_TARGET="-g $CFLAGS" ;;
5237   esac
5238 fi
5239
5240
5241 if test "x$CXXFLAGS_FOR_TARGET" = x; then
5242   CXXFLAGS_FOR_TARGET=$CXXFLAGS
5243   case " $CXXFLAGS " in
5244     *" -O2 "*) ;;
5245     *) CXXFLAGS_FOR_TARGET="-O2 $CXXFLAGS" ;;
5246   esac
5247   case " $CXXFLAGS " in
5248     *" -g "* | *" -g3 "*) ;;
5249     *) CXXFLAGS_FOR_TARGET="-g $CXXFLAGS" ;;
5250   esac
5251 fi
5252
5253
5254 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5255 # the named directory are copied to $(tooldir)/sys-include.
5256 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5257   if test x${is_cross_compiler} = xno ; then
5258     echo 1>&2 '***' --with-headers is only supported when cross compiling
5259     exit 1
5260   fi
5261   if test x"${with_headers}" != xyes ; then
5262     x=${gcc_cv_tool_prefix}
5263     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5264   fi
5265 fi
5266
5267 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5268 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5269 # are permitted.
5270 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5271   if test x${is_cross_compiler} = xno ; then
5272     echo 1>&2 '***' --with-libs is only supported when cross compiling
5273     exit 1
5274   fi
5275   if test x"${with_libs}" != xyes ; then
5276     # Copy the libraries in reverse order, so that files in the first named
5277     # library override files in subsequent libraries.
5278     x=${gcc_cv_tool_prefix}
5279     for l in ${with_libs}; do
5280       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5281     done
5282   fi
5283 fi
5284
5285 # Set with_gnu_as and with_gnu_ld as appropriate.
5286 #
5287 # This is done by determining whether or not the appropriate directory
5288 # is available, and by checking whether or not specific configurations
5289 # have requested that this magic not happen.
5290 #
5291 # The command line options always override the explicit settings in
5292 # configure.in, and the settings in configure.in override this magic.
5293 #
5294 # If the default for a toolchain is to use GNU as and ld, and you don't
5295 # want to do that, then you should use the --without-gnu-as and
5296 # --without-gnu-ld options for the configure script.
5297
5298 if test x${use_gnu_as} = x &&
5299    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5300   with_gnu_as=yes
5301   extra_host_args="$extra_host_args --with-gnu-as"
5302 fi
5303
5304 if test x${use_gnu_ld} = x &&
5305    echo " ${configdirs} " | egrep " (go)?ld " > /dev/null 2>&1 ; then
5306   with_gnu_ld=yes
5307   extra_host_args="$extra_host_args --with-gnu-ld"
5308 fi
5309
5310 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5311 # can detect this case.
5312
5313 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5314   with_newlib=yes
5315   extra_host_args="$extra_host_args --with-newlib"
5316 fi
5317
5318 # Handle ${copy_dirs}
5319 set fnord ${copy_dirs}
5320 shift
5321 while test $# != 0 ; do
5322   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5323     :
5324   else
5325     echo Copying $1 to $2
5326
5327     # Use the install script to create the directory and all required
5328     # parent directories.
5329     if test -d $2 ; then
5330       :
5331     else
5332       echo >config.temp
5333       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5334     fi
5335
5336     # Copy the directory, assuming we have tar.
5337     # FIXME: Should we use B in the second tar?  Not all systems support it.
5338     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5339
5340     # It is the responsibility of the user to correctly adjust all
5341     # symlinks.  If somebody can figure out how to handle them correctly
5342     # here, feel free to add the code.
5343
5344     echo $1 > $2/COPIED
5345   fi
5346   shift; shift
5347 done
5348
5349 # Determine a target-dependent exec_prefix that the installed
5350 # gcc will search in.  Keep this list sorted by triplet, with
5351 # the *-*-osname triplets last.
5352 md_exec_prefix=
5353 case "${target}" in
5354   alpha*-*-*vms*)
5355     md_exec_prefix=/gnu/lib/gcc-lib
5356     ;;
5357   i[34567]86-pc-msdosdjgpp*)
5358     md_exec_prefix=/dev/env/DJDIR/bin
5359     ;;
5360   i[34567]86-*-sco3.2v5*)
5361     if test $with_gnu_as = yes; then
5362       md_exec_prefix=/usr/gnu/bin
5363     else
5364       md_exec_prefix=/usr/ccs/bin/elf
5365     fi
5366     ;;
5367
5368   mn10300-*-* | \
5369   powerpc-*-chorusos* | \
5370   powerpc*-*-eabi* | \
5371   powerpc*-*-sysv* | \
5372   powerpc*-*-kaos* | \
5373   s390x-ibm-tpf*)
5374     md_exec_prefix=/usr/ccs/bin
5375     ;;
5376   sparc64-*-elf*)
5377     ;;
5378   v850*-*-*)
5379     md_exec_prefix=/usr/ccs/bin
5380     ;;
5381   xtensa*-*-elf*)
5382     ;;
5383
5384   *-*-beos* | \
5385   *-*-elf* | \
5386   *-*-hpux* | \
5387   *-*-netware* | \
5388   *-*-nto-qnx* | \
5389   *-*-rtems* | \
5390   *-*-solaris2* | \
5391   *-*-sysv[45]* | \
5392   *-*-vxworks* | \
5393   *-wrs-windiss)
5394     md_exec_prefix=/usr/ccs/bin
5395     ;;
5396 esac
5397
5398 extra_arflags_for_target=
5399 extra_nmflags_for_target=
5400 extra_ranlibflags_for_target=
5401 target_makefile_frag=/dev/null
5402 case "${target}" in
5403   mep*-*-*)
5404     target_makefile_frag="config/mt-mep"
5405     ;;
5406   spu-*-*)
5407     target_makefile_frag="config/mt-spu"
5408     ;;
5409   mips*-sde-elf*)
5410     target_makefile_frag="config/mt-sde"
5411     ;;
5412   mipsisa*-*-elfoabi*)
5413     target_makefile_frag="config/mt-mips-elfoabi"
5414     ;;
5415   *-*-netware*)
5416     target_makefile_frag="config/mt-netware"
5417     ;;
5418   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5419     target_makefile_frag="config/mt-gnu"
5420     ;;
5421   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5422     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5423     # commands to handle both 32-bit and 64-bit objects.  These flags are
5424     # harmless if we're using GNU nm or ar.
5425     extra_arflags_for_target=" -X32_64"
5426     extra_nmflags_for_target=" -B -X32_64"
5427     ;;
5428   *-*-darwin*)
5429     # ranlib from Darwin requires the -c flag to look at common symbols.
5430     extra_ranlibflags_for_target=" -c"
5431     ;;
5432   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5433     target_makefile_frag="config/mt-wince"
5434     ;;
5435 esac
5436
5437 alphaieee_frag=/dev/null
5438 case $target in
5439   alpha*-*-*)
5440     # This just makes sure to use the -mieee option to build target libs.
5441     # This should probably be set individually by each library.
5442     alphaieee_frag="config/mt-alphaieee"
5443     ;;
5444 esac
5445
5446 # If --enable-target-optspace always use -Os instead of -O2 to build
5447 # the target libraries, similarly if it is not specified, use -Os
5448 # on selected platforms.
5449 ospace_frag=/dev/null
5450 case "${enable_target_optspace}:${target}" in
5451   yes:*)
5452     ospace_frag="config/mt-ospace"
5453     ;;
5454   :d30v-*)
5455     ospace_frag="config/mt-d30v"
5456     ;;
5457   :m32r-* | :d10v-* | :fr30-*)
5458     ospace_frag="config/mt-ospace"
5459     ;;
5460   no:* | :*)
5461     ;;
5462   *)
5463     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5464     ;;
5465 esac
5466
5467 # Default to using --with-stabs for certain targets.
5468 if test x${with_stabs} = x ; then
5469   case "${target}" in
5470   mips*-*-irix[56]*)
5471     ;;
5472   mips*-*-* | alpha*-*-osf*)
5473     with_stabs=yes;
5474     extra_host_args="${extra_host_args} --with-stabs"
5475     ;;
5476   esac
5477 fi
5478
5479 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5480 # them automatically.
5481 case "${host}" in
5482   hppa*64*-*-hpux11*)
5483     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5484     ;;
5485 esac
5486
5487 # Some systems (e.g., one of the i386-aix systems the gas testers are
5488 # using) don't handle "\$" correctly, so don't use it here.
5489 tooldir='${exec_prefix}'/${target_noncanonical}
5490 build_tooldir=${tooldir}
5491
5492 # Create a .gdbinit file which runs the one in srcdir
5493 # and tells GDB to look there for source files.
5494
5495 if test -r ${srcdir}/.gdbinit ; then
5496   case ${srcdir} in
5497     .) ;;
5498     *) cat > ./.gdbinit <<EOF
5499 # ${NO_EDIT}
5500 dir ${srcdir}
5501 dir .
5502 source ${srcdir}/.gdbinit
5503 EOF
5504     ;;
5505   esac
5506 fi
5507
5508 # Make sure that the compiler is able to generate an executable.  If it
5509 # can't, we are probably in trouble.  We don't care whether we can run the
5510 # executable--we might be using a cross compiler--we only care whether it
5511 # can be created.  At this point the main configure script has set CC.
5512 we_are_ok=no
5513 echo "int main () { return 0; }" > conftest.c
5514 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5515 if test $? = 0 ; then
5516   if test -s conftest || test -s conftest.exe ; then
5517     we_are_ok=yes
5518   fi
5519 fi
5520 case $we_are_ok in
5521   no)
5522     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5523     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5524     rm -f conftest*
5525     exit 1
5526     ;;
5527 esac
5528 rm -f conftest*
5529
5530 # The Solaris /usr/ucb/cc compiler does not appear to work.
5531 case "${host}" in
5532   sparc-sun-solaris2*)
5533       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5534       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5535           could_use=
5536           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5537           if test -d /opt/cygnus/bin ; then
5538               if test "$could_use" = "" ; then
5539                   could_use="/opt/cygnus/bin"
5540               else
5541                   could_use="$could_use or /opt/cygnus/bin"
5542               fi
5543           fi
5544         if test "$could_use" = "" ; then
5545             echo "Warning: compilation may fail because you're using"
5546             echo "/usr/ucb/cc.  You should change your PATH or CC "
5547             echo "variable and rerun configure."
5548         else
5549             echo "Warning: compilation may fail because you're using"
5550             echo "/usr/ucb/cc, when you should use the C compiler from"
5551             echo "$could_use.  You should change your"
5552             echo "PATH or CC variable and rerun configure."
5553         fi
5554       fi
5555   ;;
5556 esac
5557
5558 case "${host}" in
5559   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5560   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5561   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5562 esac
5563
5564 # Record target_configdirs and the configure arguments for target and
5565 # build configuration in Makefile.
5566 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5567 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5568
5569 # Determine whether gdb needs tk/tcl or not.
5570 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5571 # and in that case we want gdb to be built without tk.  Ugh!
5572 # In fact I believe gdb is the *only* package directly dependent on tk,
5573 # so we should be able to put the 'maybe's in unconditionally and
5574 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5575 # 100% sure that that's safe though.
5576
5577 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5578 case "$enable_gdbtk" in
5579   no)
5580     GDB_TK="" ;;
5581   yes)
5582     GDB_TK="${gdb_tk}" ;;
5583   *)
5584     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5585     # distro.  Eventually someone will fix this and move Insight, nee
5586     # gdbtk to a separate directory.
5587     if test -d ${srcdir}/gdb/gdbtk ; then
5588       GDB_TK="${gdb_tk}"
5589     else
5590       GDB_TK=""
5591     fi
5592     ;;
5593 esac
5594 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5595 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5596
5597 # Strip out unwanted targets.
5598
5599 # While at that, we remove Makefiles if we were started for recursive
5600 # configuration, so that the top-level Makefile reconfigures them,
5601 # like we used to do when configure itself was recursive.
5602
5603 # Loop over modules.  $extrasub must be used with care, limiting as
5604 # much as possible the usage of range addresses.  That's because autoconf
5605 # splits the sed script to overcome limits in the number of commands,
5606 # and relying on carefully-timed sed passes may turn out to be very hard
5607 # to maintain later.  In this particular case, you just have to be careful
5608 # not to nest @if/@endif pairs, because configure will not warn you at all.
5609
5610 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5611 if test "${enable_bootstrap+set}" = set; then
5612   enableval="$enable_bootstrap"
5613
5614 else
5615   enable_bootstrap=default
5616 fi;
5617
5618 # Issue errors and warnings for invalid/strange bootstrap combinations.
5619 case "$configdirs" in
5620   *gcc*) have_compiler=yes ;;
5621   *) have_compiler=no ;;
5622 esac
5623
5624 case "$have_compiler:$host:$target:$enable_bootstrap" in
5625   *:*:*:no) ;;
5626
5627   # Default behavior.  Enable bootstrap if we have a compiler
5628   # and we are in a native configuration.
5629   yes:$build:$build:default)
5630     enable_bootstrap=yes ;;
5631
5632   *:*:*:default)
5633     enable_bootstrap=no ;;
5634
5635   # We have a compiler and we are in a native configuration, bootstrap is ok
5636   yes:$build:$build:yes)
5637     ;;
5638
5639   # Other configurations, but we have a compiler.  Assume the user knows
5640   # what he's doing.
5641   yes:*:*:yes)
5642     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5643 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5644     ;;
5645
5646   # No compiler: if they passed --enable-bootstrap explicitly, fail
5647   no:*:*:yes)
5648     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5649 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5650    { (exit 1); exit 1; }; } ;;
5651
5652   # Fail if wrong command line
5653   *)
5654     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5655 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5656    { (exit 1); exit 1; }; }
5657     ;;
5658 esac
5659
5660 # Adjust the toplevel makefile according to whether bootstrap was selected.
5661 case "$enable_bootstrap" in
5662   yes)
5663     bootstrap_suffix=bootstrap ;;
5664   no)
5665     bootstrap_suffix=no-bootstrap ;;
5666 esac
5667
5668 for module in ${build_configdirs} ; do
5669   if test -z "${no_recursion}" \
5670      && test -f ${build_subdir}/${module}/Makefile; then
5671     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5672     rm -f ${build_subdir}/${module}/Makefile
5673   fi
5674   extrasub="$extrasub
5675 /^@if build-$module\$/d
5676 /^@endif build-$module\$/d
5677 /^@if build-$module-$bootstrap_suffix\$/d
5678 /^@endif build-$module-$bootstrap_suffix\$/d"
5679 done
5680 for module in ${configdirs} ; do
5681   if test -z "${no_recursion}"; then
5682     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5683       if test -f ${file}; then
5684         echo 1>&2 "*** removing ${file} to force reconfigure"
5685         rm -f ${file}
5686       fi
5687     done
5688   fi
5689   extrasub="$extrasub
5690 /^@if $module\$/d
5691 /^@endif $module\$/d
5692 /^@if $module-$bootstrap_suffix\$/d
5693 /^@endif $module-$bootstrap_suffix\$/d"
5694 done
5695 for module in ${target_configdirs} ; do
5696   if test -z "${no_recursion}" \
5697      && test -f ${target_subdir}/${module}/Makefile; then
5698     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5699     rm -f ${target_subdir}/${module}/Makefile
5700   fi
5701   extrasub="$extrasub
5702 /^@if target-$module\$/d
5703 /^@endif target-$module\$/d
5704 /^@if target-$module-$bootstrap_suffix\$/d
5705 /^@endif target-$module-$bootstrap_suffix\$/d"
5706 done
5707
5708 extrasub="$extrasub
5709 /^@if /,/^@endif /d"
5710
5711 # Create the serialization dependencies.  This uses a temporary file.
5712
5713 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5714 if test "${enable_serial_configure+set}" = set; then
5715   enableval="$enable_serial_configure"
5716
5717 fi;
5718
5719 case ${enable_serial_configure} in
5720   yes)
5721     enable_serial_build_configure=yes
5722     enable_serial_host_configure=yes
5723     enable_serial_target_configure=yes
5724     ;;
5725 esac
5726
5727 # These force 'configure's to be done one at a time, to avoid problems
5728 # with contention over a shared config.cache.
5729 rm -f serdep.tmp
5730 echo '# serdep.tmp' > serdep.tmp
5731 olditem=
5732 test "x${enable_serial_build_configure}" = xyes &&
5733 for item in ${build_configdirs} ; do
5734   case ${olditem} in
5735     "") ;;
5736     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5737   esac
5738   olditem=${item}
5739 done
5740 olditem=
5741 test "x${enable_serial_host_configure}" = xyes &&
5742 for item in ${configdirs} ; do
5743   case ${olditem} in
5744     "") ;;
5745     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5746   esac
5747   olditem=${item}
5748 done
5749 olditem=
5750 test "x${enable_serial_target_configure}" = xyes &&
5751 for item in ${target_configdirs} ; do
5752   case ${olditem} in
5753     "") ;;
5754     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5755   esac
5756   olditem=${item}
5757 done
5758 serialization_dependencies=serdep.tmp
5759
5760
5761 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5762 # target, nonopt, and variable assignments.  These are the ones we
5763 # might not want to pass down to subconfigures.  Also strip
5764 # program-prefix, program-suffix, and program-transform-name, so that
5765 # we can pass down a consistent program-transform-name.
5766 baseargs=
5767 keep_next=no
5768 skip_next=no
5769 eval "set -- $ac_configure_args"
5770 for ac_arg
5771 do
5772   if test X"$skip_next" = X"yes"; then
5773     skip_next=no
5774     continue
5775   fi
5776   if test X"$keep_next" = X"yes"; then
5777     case $ac_arg in
5778       *\'*)
5779         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5780     esac
5781     baseargs="$baseargs '$ac_arg'"
5782     keep_next=no
5783     continue
5784   fi
5785
5786   # Handle separated arguments.  Based on the logic generated by
5787   # autoconf 2.59.
5788   case $ac_arg in
5789     *=* | --config-cache | -C | -disable-* | --disable-* \
5790       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5791       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5792       | -with-* | --with-* | -without-* | --without-* | --x)
5793       separate_arg=no
5794       ;;
5795     -*)
5796       separate_arg=yes
5797       ;;
5798     *)
5799       separate_arg=no
5800       ;;
5801   esac
5802
5803   case "$ac_arg" in
5804     --no*)
5805       continue
5806       ;;
5807     --c* | \
5808     --sr* | \
5809     --ho* | \
5810     --bu* | \
5811     --t* | \
5812     --program-* | \
5813     -cache_file* | \
5814     -srcdir* | \
5815     -host* | \
5816     -build* | \
5817     -target* | \
5818     -program-prefix* | \
5819     -program-suffix* | \
5820     -program-transform-name* )
5821       skip_next=$separate_arg
5822       continue
5823       ;;
5824     -*)
5825       # An option.  Add it.
5826       case $ac_arg in
5827         *\'*)
5828           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5829       esac
5830       baseargs="$baseargs '$ac_arg'"
5831       keep_next=$separate_arg
5832       ;;
5833     *)
5834       # Either a variable assignment, or a nonopt (triplet).  Don't
5835       # pass it down; let the Makefile handle this.
5836       continue
5837       ;;
5838   esac
5839 done
5840 # Remove the initial space we just introduced and, as these will be
5841 # expanded by make, quote '$'.
5842 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5843
5844 # Add in --program-transform-name, after --program-prefix and
5845 # --program-suffix have been applied to it.  Autoconf has already
5846 # doubled dollar signs and backslashes in program_transform_name; we want
5847 # the backslashes un-doubled, and then the entire thing wrapped in single
5848 # quotes, because this will be expanded first by make and then by the shell.
5849 # Also, because we want to override the logic in subdir configure scripts to
5850 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5851 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5852 ${program_transform_name}
5853 EOF_SED
5854 gcc_transform_name=`cat conftestsed.out`
5855 rm -f conftestsed.out
5856 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5857 if test "$silent" = yes; then
5858   baseargs="$baseargs --silent"
5859 fi
5860
5861 # For the build-side libraries, we just need to pretend we're native,
5862 # and not use the same cache file.  Multilibs are neither needed nor
5863 # desired.
5864 build_configargs="--cache-file=../config.cache ${baseargs}"
5865
5866 # For host modules, accept cache file option, or specification as blank.
5867 case "${cache_file}" in
5868 "") # empty
5869   cache_file_option="" ;;
5870 /* | [A-Za-z]:[\\/]* ) # absolute path
5871   cache_file_option="--cache-file=${cache_file}" ;;
5872 *) # relative path
5873   cache_file_option="--cache-file=../${cache_file}" ;;
5874 esac
5875
5876 # Host dirs don't like to share a cache file either, horribly enough.
5877 # This seems to be due to autoconf 2.5x stupidity.
5878 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5879
5880 target_configargs=${baseargs}
5881
5882 # Passing a --with-cross-host argument lets the target libraries know
5883 # whether they are being built with a cross-compiler or being built
5884 # native.  However, it would be better to use other mechanisms to make the
5885 # sorts of decisions they want to make on this basis.  Please consider
5886 # this option to be deprecated.  FIXME.
5887 if test x${is_cross_compiler} = xyes ; then
5888   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5889 fi
5890
5891 # Default to --enable-multilib.
5892 if test x${enable_multilib} = x ; then
5893   target_configargs="--enable-multilib ${target_configargs}"
5894 fi
5895
5896 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5897 # changed from the earlier setting of with_newlib.
5898 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5899   target_configargs="--with-newlib ${target_configargs}"
5900 fi
5901
5902 # Different target subdirs use different values of certain variables
5903 # (notably CXX).  Worse, multilibs use *lots* of different values.
5904 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5905 # it doesn't automatically accept command-line overrides of them.
5906 # This means it's not safe for target subdirs to share a cache file,
5907 # which is disgusting, but there you have it.  Hopefully this can be
5908 # fixed in future.  It's still worthwhile to use a cache file for each
5909 # directory.  I think.
5910
5911 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5912 # We need to pass --target, as newer autoconf's requires consistency
5913 # for target_alias and gcc doesn't manage it consistently.
5914 target_configargs="--cache-file=./config.cache ${target_configargs}"
5915
5916 FLAGS_FOR_TARGET=
5917 case " $target_configdirs " in
5918  *" newlib "*)
5919   case " $target_configargs " in
5920   *" --with-newlib "*)
5921    case "$target" in
5922    *-cygwin*)
5923      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' ;;
5924    esac
5925
5926    # If we're not building GCC, don't discard standard headers.
5927    if test -d ${srcdir}/gcc; then
5928      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5929
5930      if test "${build}" != "${host}"; then
5931        # On Canadian crosses, CC_FOR_TARGET will have already been set
5932        # by `configure', so we won't have an opportunity to add -Bgcc/
5933        # to it.  This is right: we don't want to search that directory
5934        # for binaries, but we want the header files in there, so add
5935        # them explicitly.
5936        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5937
5938        # Someone might think of using the pre-installed headers on
5939        # Canadian crosses, in case the installed compiler is not fully
5940        # compatible with the compiler being built.  In this case, it
5941        # would be better to flag an error than risking having
5942        # incompatible object files being constructed.  We can't
5943        # guarantee that an error will be flagged, but let's hope the
5944        # compiler will do it, when presented with incompatible header
5945        # files.
5946      fi
5947    fi
5948
5949    case "${target}-${is_cross_compiler}" in
5950    i[3456789]86-*-linux*-no)
5951       # Here host == target, so we don't need to build gcc,
5952       # so we don't want to discard standard headers.
5953       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5954       ;;
5955    *)
5956       # If we're building newlib, use its generic headers last, but search
5957       # for any libc-related directories first (so make it the last -B
5958       # switch).
5959       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5960
5961       # If we're building libgloss, find the startup file, simulator library
5962       # and linker script.
5963       case " $target_configdirs " in
5964         *" libgloss "*)
5965         # Look for startup file, simulator library and maybe linker script.
5966         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
5967         # Look for libnosys.a in case the target needs it.
5968         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5969         # Most targets have the linker script in the source directory.
5970         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
5971         ;;
5972       esac
5973       ;;
5974    esac
5975    ;;
5976   esac
5977   ;;
5978 esac
5979 case "$target" in
5980 *-mingw*)
5981   # Can't be handled as Cygwin above since Mingw does not use newlib.
5982   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' ;;
5983 esac
5984
5985 # Allow the user to override the flags for
5986 # our build compiler if desired.
5987 if test x"${build}" = x"${host}" ; then
5988   CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5989   CXXFLAGS_FOR_BUILD=${CXXFLAGS_FOR_BUILD-${CXXFLAGS}}
5990   LDFLAGS_FOR_BUILD=${LDFLAGS_FOR_BUILD-${LDFLAGS}}
5991 fi
5992
5993 # On Canadian crosses, we'll be searching the right directories for
5994 # the previously-installed cross compiler, so don't bother to add
5995 # flags for directories within the install tree of the compiler
5996 # being built; programs in there won't even run.
5997 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5998   # Search for pre-installed headers if nothing else fits.
5999   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
6000 fi
6001
6002 if test "x${use_gnu_ld}" = x &&
6003    echo " ${configdirs} " | grep " ld " > /dev/null ; then
6004   # Arrange for us to find uninstalled linker scripts.
6005   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
6006 fi
6007
6008 # Search for other target-specific linker scripts and such.
6009 case "${target}" in
6010   mep*)
6011     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
6012     ;;
6013 esac
6014
6015 # Makefile fragments.
6016 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
6017 do
6018   eval fragval=\$$frag
6019   if test $fragval != /dev/null; then
6020     eval $frag=${srcdir}/$fragval
6021   fi
6022 done
6023
6024
6025
6026
6027
6028 # Miscellanea: directories, flags, etc.
6029
6030
6031
6032
6033
6034
6035
6036 # Build module lists & subconfigure args.
6037
6038
6039
6040 # Host module lists & subconfigure args.
6041
6042
6043
6044 # Target module lists & subconfigure args.
6045
6046
6047
6048 # Build tools.
6049
6050
6051
6052
6053
6054
6055
6056
6057
6058
6059
6060
6061
6062
6063
6064
6065
6066 # Generate default definitions for YACC, M4, LEX and other programs that run
6067 # on the build machine.  These are used if the Makefile can't locate these
6068 # programs in objdir.
6069 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
6070
6071 for ac_prog in 'bison -y' byacc yacc
6072 do
6073   # Extract the first word of "$ac_prog", so it can be a program name with args.
6074 set dummy $ac_prog; ac_word=$2
6075 echo "$as_me:$LINENO: checking for $ac_word" >&5
6076 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6077 if test "${ac_cv_prog_YACC+set}" = set; then
6078   echo $ECHO_N "(cached) $ECHO_C" >&6
6079 else
6080   if test -n "$YACC"; then
6081   ac_cv_prog_YACC="$YACC" # Let the user override the test.
6082 else
6083 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6084 for as_dir in $PATH
6085 do
6086   IFS=$as_save_IFS
6087   test -z "$as_dir" && as_dir=.
6088   for ac_exec_ext in '' $ac_executable_extensions; do
6089   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6090     ac_cv_prog_YACC="$ac_prog"
6091     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6092     break 2
6093   fi
6094 done
6095 done
6096
6097 fi
6098 fi
6099 YACC=$ac_cv_prog_YACC
6100 if test -n "$YACC"; then
6101   echo "$as_me:$LINENO: result: $YACC" >&5
6102 echo "${ECHO_T}$YACC" >&6
6103 else
6104   echo "$as_me:$LINENO: result: no" >&5
6105 echo "${ECHO_T}no" >&6
6106 fi
6107
6108   test -n "$YACC" && break
6109 done
6110 test -n "$YACC" || YACC="$MISSING bison -y"
6111
6112 case " $build_configdirs " in
6113   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
6114   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
6115 esac
6116
6117 for ac_prog in bison
6118 do
6119   # Extract the first word of "$ac_prog", so it can be a program name with args.
6120 set dummy $ac_prog; ac_word=$2
6121 echo "$as_me:$LINENO: checking for $ac_word" >&5
6122 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6123 if test "${ac_cv_prog_BISON+set}" = set; then
6124   echo $ECHO_N "(cached) $ECHO_C" >&6
6125 else
6126   if test -n "$BISON"; then
6127   ac_cv_prog_BISON="$BISON" # Let the user override the test.
6128 else
6129 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6130 for as_dir in $PATH
6131 do
6132   IFS=$as_save_IFS
6133   test -z "$as_dir" && as_dir=.
6134   for ac_exec_ext in '' $ac_executable_extensions; do
6135   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6136     ac_cv_prog_BISON="$ac_prog"
6137     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6138     break 2
6139   fi
6140 done
6141 done
6142
6143 fi
6144 fi
6145 BISON=$ac_cv_prog_BISON
6146 if test -n "$BISON"; then
6147   echo "$as_me:$LINENO: result: $BISON" >&5
6148 echo "${ECHO_T}$BISON" >&6
6149 else
6150   echo "$as_me:$LINENO: result: no" >&5
6151 echo "${ECHO_T}no" >&6
6152 fi
6153
6154   test -n "$BISON" && break
6155 done
6156 test -n "$BISON" || BISON="$MISSING bison"
6157
6158 case " $build_configdirs " in
6159   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6160 esac
6161
6162 for ac_prog in gm4 gnum4 m4
6163 do
6164   # Extract the first word of "$ac_prog", so it can be a program name with args.
6165 set dummy $ac_prog; ac_word=$2
6166 echo "$as_me:$LINENO: checking for $ac_word" >&5
6167 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6168 if test "${ac_cv_prog_M4+set}" = set; then
6169   echo $ECHO_N "(cached) $ECHO_C" >&6
6170 else
6171   if test -n "$M4"; then
6172   ac_cv_prog_M4="$M4" # Let the user override the test.
6173 else
6174 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6175 for as_dir in $PATH
6176 do
6177   IFS=$as_save_IFS
6178   test -z "$as_dir" && as_dir=.
6179   for ac_exec_ext in '' $ac_executable_extensions; do
6180   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6181     ac_cv_prog_M4="$ac_prog"
6182     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6183     break 2
6184   fi
6185 done
6186 done
6187
6188 fi
6189 fi
6190 M4=$ac_cv_prog_M4
6191 if test -n "$M4"; then
6192   echo "$as_me:$LINENO: result: $M4" >&5
6193 echo "${ECHO_T}$M4" >&6
6194 else
6195   echo "$as_me:$LINENO: result: no" >&5
6196 echo "${ECHO_T}no" >&6
6197 fi
6198
6199   test -n "$M4" && break
6200 done
6201 test -n "$M4" || M4="$MISSING m4"
6202
6203 case " $build_configdirs " in
6204   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6205 esac
6206
6207 for ac_prog in flex lex
6208 do
6209   # Extract the first word of "$ac_prog", so it can be a program name with args.
6210 set dummy $ac_prog; ac_word=$2
6211 echo "$as_me:$LINENO: checking for $ac_word" >&5
6212 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6213 if test "${ac_cv_prog_LEX+set}" = set; then
6214   echo $ECHO_N "(cached) $ECHO_C" >&6
6215 else
6216   if test -n "$LEX"; then
6217   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6218 else
6219 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6220 for as_dir in $PATH
6221 do
6222   IFS=$as_save_IFS
6223   test -z "$as_dir" && as_dir=.
6224   for ac_exec_ext in '' $ac_executable_extensions; do
6225   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6226     ac_cv_prog_LEX="$ac_prog"
6227     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6228     break 2
6229   fi
6230 done
6231 done
6232
6233 fi
6234 fi
6235 LEX=$ac_cv_prog_LEX
6236 if test -n "$LEX"; then
6237   echo "$as_me:$LINENO: result: $LEX" >&5
6238 echo "${ECHO_T}$LEX" >&6
6239 else
6240   echo "$as_me:$LINENO: result: no" >&5
6241 echo "${ECHO_T}no" >&6
6242 fi
6243
6244   test -n "$LEX" && break
6245 done
6246 test -n "$LEX" || LEX="$MISSING flex"
6247
6248 case " $build_configdirs " in
6249   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6250   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6251 esac
6252
6253 for ac_prog in flex
6254 do
6255   # Extract the first word of "$ac_prog", so it can be a program name with args.
6256 set dummy $ac_prog; ac_word=$2
6257 echo "$as_me:$LINENO: checking for $ac_word" >&5
6258 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6259 if test "${ac_cv_prog_FLEX+set}" = set; then
6260   echo $ECHO_N "(cached) $ECHO_C" >&6
6261 else
6262   if test -n "$FLEX"; then
6263   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6264 else
6265 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6266 for as_dir in $PATH
6267 do
6268   IFS=$as_save_IFS
6269   test -z "$as_dir" && as_dir=.
6270   for ac_exec_ext in '' $ac_executable_extensions; do
6271   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6272     ac_cv_prog_FLEX="$ac_prog"
6273     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6274     break 2
6275   fi
6276 done
6277 done
6278
6279 fi
6280 fi
6281 FLEX=$ac_cv_prog_FLEX
6282 if test -n "$FLEX"; then
6283   echo "$as_me:$LINENO: result: $FLEX" >&5
6284 echo "${ECHO_T}$FLEX" >&6
6285 else
6286   echo "$as_me:$LINENO: result: no" >&5
6287 echo "${ECHO_T}no" >&6
6288 fi
6289
6290   test -n "$FLEX" && break
6291 done
6292 test -n "$FLEX" || FLEX="$MISSING flex"
6293
6294 case " $build_configdirs " in
6295   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6296 esac
6297
6298 for ac_prog in makeinfo
6299 do
6300   # Extract the first word of "$ac_prog", so it can be a program name with args.
6301 set dummy $ac_prog; ac_word=$2
6302 echo "$as_me:$LINENO: checking for $ac_word" >&5
6303 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6304 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6305   echo $ECHO_N "(cached) $ECHO_C" >&6
6306 else
6307   if test -n "$MAKEINFO"; then
6308   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6309 else
6310 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6311 for as_dir in $PATH
6312 do
6313   IFS=$as_save_IFS
6314   test -z "$as_dir" && as_dir=.
6315   for ac_exec_ext in '' $ac_executable_extensions; do
6316   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6317     ac_cv_prog_MAKEINFO="$ac_prog"
6318     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6319     break 2
6320   fi
6321 done
6322 done
6323
6324 fi
6325 fi
6326 MAKEINFO=$ac_cv_prog_MAKEINFO
6327 if test -n "$MAKEINFO"; then
6328   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6329 echo "${ECHO_T}$MAKEINFO" >&6
6330 else
6331   echo "$as_me:$LINENO: result: no" >&5
6332 echo "${ECHO_T}no" >&6
6333 fi
6334
6335   test -n "$MAKEINFO" && break
6336 done
6337 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6338
6339 case " $build_configdirs " in
6340   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6341   *)
6342
6343     # For an installed makeinfo, we require it to be from texinfo 4.6 or
6344     # higher, else we use the "missing" dummy.
6345     if ${MAKEINFO} --version \
6346        | egrep 'texinfo[^0-9]*(4\.([6-9]|[1-9][0-9])|[5-9]|[1-9][0-9])' >/dev/null 2>&1; then
6347       :
6348     else
6349       MAKEINFO="$MISSING makeinfo"
6350     fi
6351     ;;
6352
6353 esac
6354
6355 # FIXME: expect and dejagnu may become build tools?
6356
6357 for ac_prog in expect
6358 do
6359   # Extract the first word of "$ac_prog", so it can be a program name with args.
6360 set dummy $ac_prog; ac_word=$2
6361 echo "$as_me:$LINENO: checking for $ac_word" >&5
6362 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6363 if test "${ac_cv_prog_EXPECT+set}" = set; then
6364   echo $ECHO_N "(cached) $ECHO_C" >&6
6365 else
6366   if test -n "$EXPECT"; then
6367   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6368 else
6369 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6370 for as_dir in $PATH
6371 do
6372   IFS=$as_save_IFS
6373   test -z "$as_dir" && as_dir=.
6374   for ac_exec_ext in '' $ac_executable_extensions; do
6375   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6376     ac_cv_prog_EXPECT="$ac_prog"
6377     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6378     break 2
6379   fi
6380 done
6381 done
6382
6383 fi
6384 fi
6385 EXPECT=$ac_cv_prog_EXPECT
6386 if test -n "$EXPECT"; then
6387   echo "$as_me:$LINENO: result: $EXPECT" >&5
6388 echo "${ECHO_T}$EXPECT" >&6
6389 else
6390   echo "$as_me:$LINENO: result: no" >&5
6391 echo "${ECHO_T}no" >&6
6392 fi
6393
6394   test -n "$EXPECT" && break
6395 done
6396 test -n "$EXPECT" || EXPECT="expect"
6397
6398 case " $configdirs " in
6399   *" expect "*)
6400     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6401     ;;
6402 esac
6403
6404 for ac_prog in runtest
6405 do
6406   # Extract the first word of "$ac_prog", so it can be a program name with args.
6407 set dummy $ac_prog; ac_word=$2
6408 echo "$as_me:$LINENO: checking for $ac_word" >&5
6409 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6410 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6411   echo $ECHO_N "(cached) $ECHO_C" >&6
6412 else
6413   if test -n "$RUNTEST"; then
6414   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6415 else
6416 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6417 for as_dir in $PATH
6418 do
6419   IFS=$as_save_IFS
6420   test -z "$as_dir" && as_dir=.
6421   for ac_exec_ext in '' $ac_executable_extensions; do
6422   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6423     ac_cv_prog_RUNTEST="$ac_prog"
6424     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6425     break 2
6426   fi
6427 done
6428 done
6429
6430 fi
6431 fi
6432 RUNTEST=$ac_cv_prog_RUNTEST
6433 if test -n "$RUNTEST"; then
6434   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6435 echo "${ECHO_T}$RUNTEST" >&6
6436 else
6437   echo "$as_me:$LINENO: result: no" >&5
6438 echo "${ECHO_T}no" >&6
6439 fi
6440
6441   test -n "$RUNTEST" && break
6442 done
6443 test -n "$RUNTEST" || RUNTEST="runtest"
6444
6445 case " $configdirs " in
6446   *" dejagnu "*)
6447     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6448     ;;
6449 esac
6450
6451
6452 # Host tools.
6453 ncn_tool_prefix=
6454 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6455 ncn_target_tool_prefix=
6456 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6457
6458
6459
6460 if test -n "$AR"; then
6461   ac_cv_prog_AR=$AR
6462 elif test -n "$ac_cv_prog_AR"; then
6463   AR=$ac_cv_prog_AR
6464 fi
6465
6466 if test -n "$ac_cv_prog_AR"; then
6467   for ncn_progname in ar; do
6468     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6469 set dummy ${ncn_progname}; ac_word=$2
6470 echo "$as_me:$LINENO: checking for $ac_word" >&5
6471 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6472 if test "${ac_cv_prog_AR+set}" = set; then
6473   echo $ECHO_N "(cached) $ECHO_C" >&6
6474 else
6475   if test -n "$AR"; then
6476   ac_cv_prog_AR="$AR" # Let the user override the test.
6477 else
6478 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6479 for as_dir in $PATH
6480 do
6481   IFS=$as_save_IFS
6482   test -z "$as_dir" && as_dir=.
6483   for ac_exec_ext in '' $ac_executable_extensions; do
6484   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6485     ac_cv_prog_AR="${ncn_progname}"
6486     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6487     break 2
6488   fi
6489 done
6490 done
6491
6492 fi
6493 fi
6494 AR=$ac_cv_prog_AR
6495 if test -n "$AR"; then
6496   echo "$as_me:$LINENO: result: $AR" >&5
6497 echo "${ECHO_T}$AR" >&6
6498 else
6499   echo "$as_me:$LINENO: result: no" >&5
6500 echo "${ECHO_T}no" >&6
6501 fi
6502
6503   done
6504 fi
6505
6506 for ncn_progname in ar; do
6507   if test -n "$ncn_tool_prefix"; then
6508     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6509 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6510 echo "$as_me:$LINENO: checking for $ac_word" >&5
6511 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6512 if test "${ac_cv_prog_AR+set}" = set; then
6513   echo $ECHO_N "(cached) $ECHO_C" >&6
6514 else
6515   if test -n "$AR"; then
6516   ac_cv_prog_AR="$AR" # Let the user override the test.
6517 else
6518 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6519 for as_dir in $PATH
6520 do
6521   IFS=$as_save_IFS
6522   test -z "$as_dir" && as_dir=.
6523   for ac_exec_ext in '' $ac_executable_extensions; do
6524   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6525     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6526     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6527     break 2
6528   fi
6529 done
6530 done
6531
6532 fi
6533 fi
6534 AR=$ac_cv_prog_AR
6535 if test -n "$AR"; then
6536   echo "$as_me:$LINENO: result: $AR" >&5
6537 echo "${ECHO_T}$AR" >&6
6538 else
6539   echo "$as_me:$LINENO: result: no" >&5
6540 echo "${ECHO_T}no" >&6
6541 fi
6542
6543   fi
6544   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6545     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6546 set dummy ${ncn_progname}; ac_word=$2
6547 echo "$as_me:$LINENO: checking for $ac_word" >&5
6548 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6549 if test "${ac_cv_prog_AR+set}" = set; then
6550   echo $ECHO_N "(cached) $ECHO_C" >&6
6551 else
6552   if test -n "$AR"; then
6553   ac_cv_prog_AR="$AR" # Let the user override the test.
6554 else
6555 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6556 for as_dir in $PATH
6557 do
6558   IFS=$as_save_IFS
6559   test -z "$as_dir" && as_dir=.
6560   for ac_exec_ext in '' $ac_executable_extensions; do
6561   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6562     ac_cv_prog_AR="${ncn_progname}"
6563     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6564     break 2
6565   fi
6566 done
6567 done
6568
6569 fi
6570 fi
6571 AR=$ac_cv_prog_AR
6572 if test -n "$AR"; then
6573   echo "$as_me:$LINENO: result: $AR" >&5
6574 echo "${ECHO_T}$AR" >&6
6575 else
6576   echo "$as_me:$LINENO: result: no" >&5
6577 echo "${ECHO_T}no" >&6
6578 fi
6579
6580   fi
6581   test -n "$ac_cv_prog_AR" && break
6582 done
6583
6584 if test -z "$ac_cv_prog_AR" ; then
6585   set dummy ar
6586   if test $build = $host ; then
6587     AR="$2"
6588   else
6589     AR="${ncn_tool_prefix}$2"
6590   fi
6591 fi
6592
6593
6594
6595 if test -n "$AS"; then
6596   ac_cv_prog_AS=$AS
6597 elif test -n "$ac_cv_prog_AS"; then
6598   AS=$ac_cv_prog_AS
6599 fi
6600
6601 if test -n "$ac_cv_prog_AS"; then
6602   for ncn_progname in as; do
6603     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6604 set dummy ${ncn_progname}; ac_word=$2
6605 echo "$as_me:$LINENO: checking for $ac_word" >&5
6606 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6607 if test "${ac_cv_prog_AS+set}" = set; then
6608   echo $ECHO_N "(cached) $ECHO_C" >&6
6609 else
6610   if test -n "$AS"; then
6611   ac_cv_prog_AS="$AS" # Let the user override the test.
6612 else
6613 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6614 for as_dir in $PATH
6615 do
6616   IFS=$as_save_IFS
6617   test -z "$as_dir" && as_dir=.
6618   for ac_exec_ext in '' $ac_executable_extensions; do
6619   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6620     ac_cv_prog_AS="${ncn_progname}"
6621     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6622     break 2
6623   fi
6624 done
6625 done
6626
6627 fi
6628 fi
6629 AS=$ac_cv_prog_AS
6630 if test -n "$AS"; then
6631   echo "$as_me:$LINENO: result: $AS" >&5
6632 echo "${ECHO_T}$AS" >&6
6633 else
6634   echo "$as_me:$LINENO: result: no" >&5
6635 echo "${ECHO_T}no" >&6
6636 fi
6637
6638   done
6639 fi
6640
6641 for ncn_progname in as; do
6642   if test -n "$ncn_tool_prefix"; then
6643     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6644 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6645 echo "$as_me:$LINENO: checking for $ac_word" >&5
6646 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6647 if test "${ac_cv_prog_AS+set}" = set; then
6648   echo $ECHO_N "(cached) $ECHO_C" >&6
6649 else
6650   if test -n "$AS"; then
6651   ac_cv_prog_AS="$AS" # Let the user override the test.
6652 else
6653 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6654 for as_dir in $PATH
6655 do
6656   IFS=$as_save_IFS
6657   test -z "$as_dir" && as_dir=.
6658   for ac_exec_ext in '' $ac_executable_extensions; do
6659   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6660     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6661     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6662     break 2
6663   fi
6664 done
6665 done
6666
6667 fi
6668 fi
6669 AS=$ac_cv_prog_AS
6670 if test -n "$AS"; then
6671   echo "$as_me:$LINENO: result: $AS" >&5
6672 echo "${ECHO_T}$AS" >&6
6673 else
6674   echo "$as_me:$LINENO: result: no" >&5
6675 echo "${ECHO_T}no" >&6
6676 fi
6677
6678   fi
6679   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6680     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6681 set dummy ${ncn_progname}; ac_word=$2
6682 echo "$as_me:$LINENO: checking for $ac_word" >&5
6683 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6684 if test "${ac_cv_prog_AS+set}" = set; then
6685   echo $ECHO_N "(cached) $ECHO_C" >&6
6686 else
6687   if test -n "$AS"; then
6688   ac_cv_prog_AS="$AS" # Let the user override the test.
6689 else
6690 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6691 for as_dir in $PATH
6692 do
6693   IFS=$as_save_IFS
6694   test -z "$as_dir" && as_dir=.
6695   for ac_exec_ext in '' $ac_executable_extensions; do
6696   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6697     ac_cv_prog_AS="${ncn_progname}"
6698     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6699     break 2
6700   fi
6701 done
6702 done
6703
6704 fi
6705 fi
6706 AS=$ac_cv_prog_AS
6707 if test -n "$AS"; then
6708   echo "$as_me:$LINENO: result: $AS" >&5
6709 echo "${ECHO_T}$AS" >&6
6710 else
6711   echo "$as_me:$LINENO: result: no" >&5
6712 echo "${ECHO_T}no" >&6
6713 fi
6714
6715   fi
6716   test -n "$ac_cv_prog_AS" && break
6717 done
6718
6719 if test -z "$ac_cv_prog_AS" ; then
6720   set dummy as
6721   if test $build = $host ; then
6722     AS="$2"
6723   else
6724     AS="${ncn_tool_prefix}$2"
6725   fi
6726 fi
6727
6728
6729
6730 if test -n "$DLLTOOL"; then
6731   ac_cv_prog_DLLTOOL=$DLLTOOL
6732 elif test -n "$ac_cv_prog_DLLTOOL"; then
6733   DLLTOOL=$ac_cv_prog_DLLTOOL
6734 fi
6735
6736 if test -n "$ac_cv_prog_DLLTOOL"; then
6737   for ncn_progname in dlltool; do
6738     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6739 set dummy ${ncn_progname}; ac_word=$2
6740 echo "$as_me:$LINENO: checking for $ac_word" >&5
6741 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6742 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6743   echo $ECHO_N "(cached) $ECHO_C" >&6
6744 else
6745   if test -n "$DLLTOOL"; then
6746   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6747 else
6748 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6749 for as_dir in $PATH
6750 do
6751   IFS=$as_save_IFS
6752   test -z "$as_dir" && as_dir=.
6753   for ac_exec_ext in '' $ac_executable_extensions; do
6754   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6755     ac_cv_prog_DLLTOOL="${ncn_progname}"
6756     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6757     break 2
6758   fi
6759 done
6760 done
6761
6762 fi
6763 fi
6764 DLLTOOL=$ac_cv_prog_DLLTOOL
6765 if test -n "$DLLTOOL"; then
6766   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6767 echo "${ECHO_T}$DLLTOOL" >&6
6768 else
6769   echo "$as_me:$LINENO: result: no" >&5
6770 echo "${ECHO_T}no" >&6
6771 fi
6772
6773   done
6774 fi
6775
6776 for ncn_progname in dlltool; do
6777   if test -n "$ncn_tool_prefix"; then
6778     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6779 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6780 echo "$as_me:$LINENO: checking for $ac_word" >&5
6781 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6782 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6783   echo $ECHO_N "(cached) $ECHO_C" >&6
6784 else
6785   if test -n "$DLLTOOL"; then
6786   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6787 else
6788 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6789 for as_dir in $PATH
6790 do
6791   IFS=$as_save_IFS
6792   test -z "$as_dir" && as_dir=.
6793   for ac_exec_ext in '' $ac_executable_extensions; do
6794   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6795     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6796     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6797     break 2
6798   fi
6799 done
6800 done
6801
6802 fi
6803 fi
6804 DLLTOOL=$ac_cv_prog_DLLTOOL
6805 if test -n "$DLLTOOL"; then
6806   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6807 echo "${ECHO_T}$DLLTOOL" >&6
6808 else
6809   echo "$as_me:$LINENO: result: no" >&5
6810 echo "${ECHO_T}no" >&6
6811 fi
6812
6813   fi
6814   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6815     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6816 set dummy ${ncn_progname}; ac_word=$2
6817 echo "$as_me:$LINENO: checking for $ac_word" >&5
6818 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6819 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6820   echo $ECHO_N "(cached) $ECHO_C" >&6
6821 else
6822   if test -n "$DLLTOOL"; then
6823   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6824 else
6825 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6826 for as_dir in $PATH
6827 do
6828   IFS=$as_save_IFS
6829   test -z "$as_dir" && as_dir=.
6830   for ac_exec_ext in '' $ac_executable_extensions; do
6831   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6832     ac_cv_prog_DLLTOOL="${ncn_progname}"
6833     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6834     break 2
6835   fi
6836 done
6837 done
6838
6839 fi
6840 fi
6841 DLLTOOL=$ac_cv_prog_DLLTOOL
6842 if test -n "$DLLTOOL"; then
6843   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6844 echo "${ECHO_T}$DLLTOOL" >&6
6845 else
6846   echo "$as_me:$LINENO: result: no" >&5
6847 echo "${ECHO_T}no" >&6
6848 fi
6849
6850   fi
6851   test -n "$ac_cv_prog_DLLTOOL" && break
6852 done
6853
6854 if test -z "$ac_cv_prog_DLLTOOL" ; then
6855   set dummy dlltool
6856   if test $build = $host ; then
6857     DLLTOOL="$2"
6858   else
6859     DLLTOOL="${ncn_tool_prefix}$2"
6860   fi
6861 fi
6862
6863
6864
6865 if test -n "$LD"; then
6866   ac_cv_prog_LD=$LD
6867 elif test -n "$ac_cv_prog_LD"; then
6868   LD=$ac_cv_prog_LD
6869 fi
6870
6871 if test -n "$ac_cv_prog_LD"; then
6872   for ncn_progname in ld; do
6873     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6874 set dummy ${ncn_progname}; ac_word=$2
6875 echo "$as_me:$LINENO: checking for $ac_word" >&5
6876 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6877 if test "${ac_cv_prog_LD+set}" = set; then
6878   echo $ECHO_N "(cached) $ECHO_C" >&6
6879 else
6880   if test -n "$LD"; then
6881   ac_cv_prog_LD="$LD" # Let the user override the test.
6882 else
6883 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6884 for as_dir in $PATH
6885 do
6886   IFS=$as_save_IFS
6887   test -z "$as_dir" && as_dir=.
6888   for ac_exec_ext in '' $ac_executable_extensions; do
6889   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6890     ac_cv_prog_LD="${ncn_progname}"
6891     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6892     break 2
6893   fi
6894 done
6895 done
6896
6897 fi
6898 fi
6899 LD=$ac_cv_prog_LD
6900 if test -n "$LD"; then
6901   echo "$as_me:$LINENO: result: $LD" >&5
6902 echo "${ECHO_T}$LD" >&6
6903 else
6904   echo "$as_me:$LINENO: result: no" >&5
6905 echo "${ECHO_T}no" >&6
6906 fi
6907
6908   done
6909 fi
6910
6911 for ncn_progname in ld; do
6912   if test -n "$ncn_tool_prefix"; then
6913     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6914 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6915 echo "$as_me:$LINENO: checking for $ac_word" >&5
6916 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6917 if test "${ac_cv_prog_LD+set}" = set; then
6918   echo $ECHO_N "(cached) $ECHO_C" >&6
6919 else
6920   if test -n "$LD"; then
6921   ac_cv_prog_LD="$LD" # Let the user override the test.
6922 else
6923 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6924 for as_dir in $PATH
6925 do
6926   IFS=$as_save_IFS
6927   test -z "$as_dir" && as_dir=.
6928   for ac_exec_ext in '' $ac_executable_extensions; do
6929   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6930     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6931     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6932     break 2
6933   fi
6934 done
6935 done
6936
6937 fi
6938 fi
6939 LD=$ac_cv_prog_LD
6940 if test -n "$LD"; then
6941   echo "$as_me:$LINENO: result: $LD" >&5
6942 echo "${ECHO_T}$LD" >&6
6943 else
6944   echo "$as_me:$LINENO: result: no" >&5
6945 echo "${ECHO_T}no" >&6
6946 fi
6947
6948   fi
6949   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6950     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6951 set dummy ${ncn_progname}; ac_word=$2
6952 echo "$as_me:$LINENO: checking for $ac_word" >&5
6953 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6954 if test "${ac_cv_prog_LD+set}" = set; then
6955   echo $ECHO_N "(cached) $ECHO_C" >&6
6956 else
6957   if test -n "$LD"; then
6958   ac_cv_prog_LD="$LD" # Let the user override the test.
6959 else
6960 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6961 for as_dir in $PATH
6962 do
6963   IFS=$as_save_IFS
6964   test -z "$as_dir" && as_dir=.
6965   for ac_exec_ext in '' $ac_executable_extensions; do
6966   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6967     ac_cv_prog_LD="${ncn_progname}"
6968     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6969     break 2
6970   fi
6971 done
6972 done
6973
6974 fi
6975 fi
6976 LD=$ac_cv_prog_LD
6977 if test -n "$LD"; then
6978   echo "$as_me:$LINENO: result: $LD" >&5
6979 echo "${ECHO_T}$LD" >&6
6980 else
6981   echo "$as_me:$LINENO: result: no" >&5
6982 echo "${ECHO_T}no" >&6
6983 fi
6984
6985   fi
6986   test -n "$ac_cv_prog_LD" && break
6987 done
6988
6989 if test -z "$ac_cv_prog_LD" ; then
6990   set dummy ld
6991   if test $build = $host ; then
6992     LD="$2"
6993   else
6994     LD="${ncn_tool_prefix}$2"
6995   fi
6996 fi
6997
6998
6999
7000 if test -n "$LIPO"; then
7001   ac_cv_prog_LIPO=$LIPO
7002 elif test -n "$ac_cv_prog_LIPO"; then
7003   LIPO=$ac_cv_prog_LIPO
7004 fi
7005
7006 if test -n "$ac_cv_prog_LIPO"; then
7007   for ncn_progname in lipo; do
7008     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7009 set dummy ${ncn_progname}; ac_word=$2
7010 echo "$as_me:$LINENO: checking for $ac_word" >&5
7011 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7012 if test "${ac_cv_prog_LIPO+set}" = set; then
7013   echo $ECHO_N "(cached) $ECHO_C" >&6
7014 else
7015   if test -n "$LIPO"; then
7016   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7017 else
7018 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7019 for as_dir in $PATH
7020 do
7021   IFS=$as_save_IFS
7022   test -z "$as_dir" && as_dir=.
7023   for ac_exec_ext in '' $ac_executable_extensions; do
7024   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7025     ac_cv_prog_LIPO="${ncn_progname}"
7026     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7027     break 2
7028   fi
7029 done
7030 done
7031
7032 fi
7033 fi
7034 LIPO=$ac_cv_prog_LIPO
7035 if test -n "$LIPO"; then
7036   echo "$as_me:$LINENO: result: $LIPO" >&5
7037 echo "${ECHO_T}$LIPO" >&6
7038 else
7039   echo "$as_me:$LINENO: result: no" >&5
7040 echo "${ECHO_T}no" >&6
7041 fi
7042
7043   done
7044 fi
7045
7046 for ncn_progname in lipo; do
7047   if test -n "$ncn_tool_prefix"; then
7048     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7049 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7050 echo "$as_me:$LINENO: checking for $ac_word" >&5
7051 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7052 if test "${ac_cv_prog_LIPO+set}" = set; then
7053   echo $ECHO_N "(cached) $ECHO_C" >&6
7054 else
7055   if test -n "$LIPO"; then
7056   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7057 else
7058 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7059 for as_dir in $PATH
7060 do
7061   IFS=$as_save_IFS
7062   test -z "$as_dir" && as_dir=.
7063   for ac_exec_ext in '' $ac_executable_extensions; do
7064   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7065     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
7066     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7067     break 2
7068   fi
7069 done
7070 done
7071
7072 fi
7073 fi
7074 LIPO=$ac_cv_prog_LIPO
7075 if test -n "$LIPO"; then
7076   echo "$as_me:$LINENO: result: $LIPO" >&5
7077 echo "${ECHO_T}$LIPO" >&6
7078 else
7079   echo "$as_me:$LINENO: result: no" >&5
7080 echo "${ECHO_T}no" >&6
7081 fi
7082
7083   fi
7084   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
7085     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7086 set dummy ${ncn_progname}; ac_word=$2
7087 echo "$as_me:$LINENO: checking for $ac_word" >&5
7088 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7089 if test "${ac_cv_prog_LIPO+set}" = set; then
7090   echo $ECHO_N "(cached) $ECHO_C" >&6
7091 else
7092   if test -n "$LIPO"; then
7093   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
7094 else
7095 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7096 for as_dir in $PATH
7097 do
7098   IFS=$as_save_IFS
7099   test -z "$as_dir" && as_dir=.
7100   for ac_exec_ext in '' $ac_executable_extensions; do
7101   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7102     ac_cv_prog_LIPO="${ncn_progname}"
7103     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7104     break 2
7105   fi
7106 done
7107 done
7108
7109 fi
7110 fi
7111 LIPO=$ac_cv_prog_LIPO
7112 if test -n "$LIPO"; then
7113   echo "$as_me:$LINENO: result: $LIPO" >&5
7114 echo "${ECHO_T}$LIPO" >&6
7115 else
7116   echo "$as_me:$LINENO: result: no" >&5
7117 echo "${ECHO_T}no" >&6
7118 fi
7119
7120   fi
7121   test -n "$ac_cv_prog_LIPO" && break
7122 done
7123
7124 if test -z "$ac_cv_prog_LIPO" ; then
7125   set dummy lipo
7126   if test $build = $host ; then
7127     LIPO="$2"
7128   else
7129     LIPO="${ncn_tool_prefix}$2"
7130   fi
7131 fi
7132
7133
7134
7135 if test -n "$NM"; then
7136   ac_cv_prog_NM=$NM
7137 elif test -n "$ac_cv_prog_NM"; then
7138   NM=$ac_cv_prog_NM
7139 fi
7140
7141 if test -n "$ac_cv_prog_NM"; then
7142   for ncn_progname in nm; do
7143     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7144 set dummy ${ncn_progname}; ac_word=$2
7145 echo "$as_me:$LINENO: checking for $ac_word" >&5
7146 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7147 if test "${ac_cv_prog_NM+set}" = set; then
7148   echo $ECHO_N "(cached) $ECHO_C" >&6
7149 else
7150   if test -n "$NM"; then
7151   ac_cv_prog_NM="$NM" # Let the user override the test.
7152 else
7153 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7154 for as_dir in $PATH
7155 do
7156   IFS=$as_save_IFS
7157   test -z "$as_dir" && as_dir=.
7158   for ac_exec_ext in '' $ac_executable_extensions; do
7159   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7160     ac_cv_prog_NM="${ncn_progname}"
7161     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7162     break 2
7163   fi
7164 done
7165 done
7166
7167 fi
7168 fi
7169 NM=$ac_cv_prog_NM
7170 if test -n "$NM"; then
7171   echo "$as_me:$LINENO: result: $NM" >&5
7172 echo "${ECHO_T}$NM" >&6
7173 else
7174   echo "$as_me:$LINENO: result: no" >&5
7175 echo "${ECHO_T}no" >&6
7176 fi
7177
7178   done
7179 fi
7180
7181 for ncn_progname in nm; do
7182   if test -n "$ncn_tool_prefix"; then
7183     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7184 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7185 echo "$as_me:$LINENO: checking for $ac_word" >&5
7186 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7187 if test "${ac_cv_prog_NM+set}" = set; then
7188   echo $ECHO_N "(cached) $ECHO_C" >&6
7189 else
7190   if test -n "$NM"; then
7191   ac_cv_prog_NM="$NM" # Let the user override the test.
7192 else
7193 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7194 for as_dir in $PATH
7195 do
7196   IFS=$as_save_IFS
7197   test -z "$as_dir" && as_dir=.
7198   for ac_exec_ext in '' $ac_executable_extensions; do
7199   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7200     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7201     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7202     break 2
7203   fi
7204 done
7205 done
7206
7207 fi
7208 fi
7209 NM=$ac_cv_prog_NM
7210 if test -n "$NM"; then
7211   echo "$as_me:$LINENO: result: $NM" >&5
7212 echo "${ECHO_T}$NM" >&6
7213 else
7214   echo "$as_me:$LINENO: result: no" >&5
7215 echo "${ECHO_T}no" >&6
7216 fi
7217
7218   fi
7219   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7220     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7221 set dummy ${ncn_progname}; ac_word=$2
7222 echo "$as_me:$LINENO: checking for $ac_word" >&5
7223 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7224 if test "${ac_cv_prog_NM+set}" = set; then
7225   echo $ECHO_N "(cached) $ECHO_C" >&6
7226 else
7227   if test -n "$NM"; then
7228   ac_cv_prog_NM="$NM" # Let the user override the test.
7229 else
7230 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7231 for as_dir in $PATH
7232 do
7233   IFS=$as_save_IFS
7234   test -z "$as_dir" && as_dir=.
7235   for ac_exec_ext in '' $ac_executable_extensions; do
7236   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7237     ac_cv_prog_NM="${ncn_progname}"
7238     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7239     break 2
7240   fi
7241 done
7242 done
7243
7244 fi
7245 fi
7246 NM=$ac_cv_prog_NM
7247 if test -n "$NM"; then
7248   echo "$as_me:$LINENO: result: $NM" >&5
7249 echo "${ECHO_T}$NM" >&6
7250 else
7251   echo "$as_me:$LINENO: result: no" >&5
7252 echo "${ECHO_T}no" >&6
7253 fi
7254
7255   fi
7256   test -n "$ac_cv_prog_NM" && break
7257 done
7258
7259 if test -z "$ac_cv_prog_NM" ; then
7260   set dummy nm
7261   if test $build = $host ; then
7262     NM="$2"
7263   else
7264     NM="${ncn_tool_prefix}$2"
7265   fi
7266 fi
7267
7268
7269
7270 if test -n "$RANLIB"; then
7271   ac_cv_prog_RANLIB=$RANLIB
7272 elif test -n "$ac_cv_prog_RANLIB"; then
7273   RANLIB=$ac_cv_prog_RANLIB
7274 fi
7275
7276 if test -n "$ac_cv_prog_RANLIB"; then
7277   for ncn_progname in ranlib; do
7278     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7279 set dummy ${ncn_progname}; ac_word=$2
7280 echo "$as_me:$LINENO: checking for $ac_word" >&5
7281 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7282 if test "${ac_cv_prog_RANLIB+set}" = set; then
7283   echo $ECHO_N "(cached) $ECHO_C" >&6
7284 else
7285   if test -n "$RANLIB"; then
7286   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7287 else
7288 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7289 for as_dir in $PATH
7290 do
7291   IFS=$as_save_IFS
7292   test -z "$as_dir" && as_dir=.
7293   for ac_exec_ext in '' $ac_executable_extensions; do
7294   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7295     ac_cv_prog_RANLIB="${ncn_progname}"
7296     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7297     break 2
7298   fi
7299 done
7300 done
7301
7302 fi
7303 fi
7304 RANLIB=$ac_cv_prog_RANLIB
7305 if test -n "$RANLIB"; then
7306   echo "$as_me:$LINENO: result: $RANLIB" >&5
7307 echo "${ECHO_T}$RANLIB" >&6
7308 else
7309   echo "$as_me:$LINENO: result: no" >&5
7310 echo "${ECHO_T}no" >&6
7311 fi
7312
7313   done
7314 fi
7315
7316 for ncn_progname in ranlib; do
7317   if test -n "$ncn_tool_prefix"; then
7318     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7319 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7320 echo "$as_me:$LINENO: checking for $ac_word" >&5
7321 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7322 if test "${ac_cv_prog_RANLIB+set}" = set; then
7323   echo $ECHO_N "(cached) $ECHO_C" >&6
7324 else
7325   if test -n "$RANLIB"; then
7326   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7327 else
7328 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7329 for as_dir in $PATH
7330 do
7331   IFS=$as_save_IFS
7332   test -z "$as_dir" && as_dir=.
7333   for ac_exec_ext in '' $ac_executable_extensions; do
7334   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7335     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7336     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7337     break 2
7338   fi
7339 done
7340 done
7341
7342 fi
7343 fi
7344 RANLIB=$ac_cv_prog_RANLIB
7345 if test -n "$RANLIB"; then
7346   echo "$as_me:$LINENO: result: $RANLIB" >&5
7347 echo "${ECHO_T}$RANLIB" >&6
7348 else
7349   echo "$as_me:$LINENO: result: no" >&5
7350 echo "${ECHO_T}no" >&6
7351 fi
7352
7353   fi
7354   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7355     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7356 set dummy ${ncn_progname}; ac_word=$2
7357 echo "$as_me:$LINENO: checking for $ac_word" >&5
7358 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7359 if test "${ac_cv_prog_RANLIB+set}" = set; then
7360   echo $ECHO_N "(cached) $ECHO_C" >&6
7361 else
7362   if test -n "$RANLIB"; then
7363   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7364 else
7365 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7366 for as_dir in $PATH
7367 do
7368   IFS=$as_save_IFS
7369   test -z "$as_dir" && as_dir=.
7370   for ac_exec_ext in '' $ac_executable_extensions; do
7371   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7372     ac_cv_prog_RANLIB="${ncn_progname}"
7373     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7374     break 2
7375   fi
7376 done
7377 done
7378
7379 fi
7380 fi
7381 RANLIB=$ac_cv_prog_RANLIB
7382 if test -n "$RANLIB"; then
7383   echo "$as_me:$LINENO: result: $RANLIB" >&5
7384 echo "${ECHO_T}$RANLIB" >&6
7385 else
7386   echo "$as_me:$LINENO: result: no" >&5
7387 echo "${ECHO_T}no" >&6
7388 fi
7389
7390   fi
7391   test -n "$ac_cv_prog_RANLIB" && break
7392 done
7393
7394 if test -z "$ac_cv_prog_RANLIB" ; then
7395   RANLIB=":"
7396 fi
7397
7398
7399
7400 if test -n "$STRIP"; then
7401   ac_cv_prog_STRIP=$STRIP
7402 elif test -n "$ac_cv_prog_STRIP"; then
7403   STRIP=$ac_cv_prog_STRIP
7404 fi
7405
7406 if test -n "$ac_cv_prog_STRIP"; then
7407   for ncn_progname in strip; do
7408     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7409 set dummy ${ncn_progname}; ac_word=$2
7410 echo "$as_me:$LINENO: checking for $ac_word" >&5
7411 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7412 if test "${ac_cv_prog_STRIP+set}" = set; then
7413   echo $ECHO_N "(cached) $ECHO_C" >&6
7414 else
7415   if test -n "$STRIP"; then
7416   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7417 else
7418 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7419 for as_dir in $PATH
7420 do
7421   IFS=$as_save_IFS
7422   test -z "$as_dir" && as_dir=.
7423   for ac_exec_ext in '' $ac_executable_extensions; do
7424   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7425     ac_cv_prog_STRIP="${ncn_progname}"
7426     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7427     break 2
7428   fi
7429 done
7430 done
7431
7432 fi
7433 fi
7434 STRIP=$ac_cv_prog_STRIP
7435 if test -n "$STRIP"; then
7436   echo "$as_me:$LINENO: result: $STRIP" >&5
7437 echo "${ECHO_T}$STRIP" >&6
7438 else
7439   echo "$as_me:$LINENO: result: no" >&5
7440 echo "${ECHO_T}no" >&6
7441 fi
7442
7443   done
7444 fi
7445
7446 for ncn_progname in strip; do
7447   if test -n "$ncn_tool_prefix"; then
7448     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7449 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7450 echo "$as_me:$LINENO: checking for $ac_word" >&5
7451 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7452 if test "${ac_cv_prog_STRIP+set}" = set; then
7453   echo $ECHO_N "(cached) $ECHO_C" >&6
7454 else
7455   if test -n "$STRIP"; then
7456   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7457 else
7458 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7459 for as_dir in $PATH
7460 do
7461   IFS=$as_save_IFS
7462   test -z "$as_dir" && as_dir=.
7463   for ac_exec_ext in '' $ac_executable_extensions; do
7464   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7465     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7466     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7467     break 2
7468   fi
7469 done
7470 done
7471
7472 fi
7473 fi
7474 STRIP=$ac_cv_prog_STRIP
7475 if test -n "$STRIP"; then
7476   echo "$as_me:$LINENO: result: $STRIP" >&5
7477 echo "${ECHO_T}$STRIP" >&6
7478 else
7479   echo "$as_me:$LINENO: result: no" >&5
7480 echo "${ECHO_T}no" >&6
7481 fi
7482
7483   fi
7484   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7485     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7486 set dummy ${ncn_progname}; ac_word=$2
7487 echo "$as_me:$LINENO: checking for $ac_word" >&5
7488 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7489 if test "${ac_cv_prog_STRIP+set}" = set; then
7490   echo $ECHO_N "(cached) $ECHO_C" >&6
7491 else
7492   if test -n "$STRIP"; then
7493   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7494 else
7495 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7496 for as_dir in $PATH
7497 do
7498   IFS=$as_save_IFS
7499   test -z "$as_dir" && as_dir=.
7500   for ac_exec_ext in '' $ac_executable_extensions; do
7501   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7502     ac_cv_prog_STRIP="${ncn_progname}"
7503     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7504     break 2
7505   fi
7506 done
7507 done
7508
7509 fi
7510 fi
7511 STRIP=$ac_cv_prog_STRIP
7512 if test -n "$STRIP"; then
7513   echo "$as_me:$LINENO: result: $STRIP" >&5
7514 echo "${ECHO_T}$STRIP" >&6
7515 else
7516   echo "$as_me:$LINENO: result: no" >&5
7517 echo "${ECHO_T}no" >&6
7518 fi
7519
7520   fi
7521   test -n "$ac_cv_prog_STRIP" && break
7522 done
7523
7524 if test -z "$ac_cv_prog_STRIP" ; then
7525   STRIP=":"
7526 fi
7527
7528
7529
7530 if test -n "$WINDRES"; then
7531   ac_cv_prog_WINDRES=$WINDRES
7532 elif test -n "$ac_cv_prog_WINDRES"; then
7533   WINDRES=$ac_cv_prog_WINDRES
7534 fi
7535
7536 if test -n "$ac_cv_prog_WINDRES"; then
7537   for ncn_progname in windres; do
7538     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7539 set dummy ${ncn_progname}; ac_word=$2
7540 echo "$as_me:$LINENO: checking for $ac_word" >&5
7541 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7542 if test "${ac_cv_prog_WINDRES+set}" = set; then
7543   echo $ECHO_N "(cached) $ECHO_C" >&6
7544 else
7545   if test -n "$WINDRES"; then
7546   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7547 else
7548 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7549 for as_dir in $PATH
7550 do
7551   IFS=$as_save_IFS
7552   test -z "$as_dir" && as_dir=.
7553   for ac_exec_ext in '' $ac_executable_extensions; do
7554   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7555     ac_cv_prog_WINDRES="${ncn_progname}"
7556     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7557     break 2
7558   fi
7559 done
7560 done
7561
7562 fi
7563 fi
7564 WINDRES=$ac_cv_prog_WINDRES
7565 if test -n "$WINDRES"; then
7566   echo "$as_me:$LINENO: result: $WINDRES" >&5
7567 echo "${ECHO_T}$WINDRES" >&6
7568 else
7569   echo "$as_me:$LINENO: result: no" >&5
7570 echo "${ECHO_T}no" >&6
7571 fi
7572
7573   done
7574 fi
7575
7576 for ncn_progname in windres; do
7577   if test -n "$ncn_tool_prefix"; then
7578     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7579 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7580 echo "$as_me:$LINENO: checking for $ac_word" >&5
7581 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7582 if test "${ac_cv_prog_WINDRES+set}" = set; then
7583   echo $ECHO_N "(cached) $ECHO_C" >&6
7584 else
7585   if test -n "$WINDRES"; then
7586   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7587 else
7588 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7589 for as_dir in $PATH
7590 do
7591   IFS=$as_save_IFS
7592   test -z "$as_dir" && as_dir=.
7593   for ac_exec_ext in '' $ac_executable_extensions; do
7594   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7595     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7596     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7597     break 2
7598   fi
7599 done
7600 done
7601
7602 fi
7603 fi
7604 WINDRES=$ac_cv_prog_WINDRES
7605 if test -n "$WINDRES"; then
7606   echo "$as_me:$LINENO: result: $WINDRES" >&5
7607 echo "${ECHO_T}$WINDRES" >&6
7608 else
7609   echo "$as_me:$LINENO: result: no" >&5
7610 echo "${ECHO_T}no" >&6
7611 fi
7612
7613   fi
7614   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7615     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7616 set dummy ${ncn_progname}; ac_word=$2
7617 echo "$as_me:$LINENO: checking for $ac_word" >&5
7618 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7619 if test "${ac_cv_prog_WINDRES+set}" = set; then
7620   echo $ECHO_N "(cached) $ECHO_C" >&6
7621 else
7622   if test -n "$WINDRES"; then
7623   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7624 else
7625 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7626 for as_dir in $PATH
7627 do
7628   IFS=$as_save_IFS
7629   test -z "$as_dir" && as_dir=.
7630   for ac_exec_ext in '' $ac_executable_extensions; do
7631   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7632     ac_cv_prog_WINDRES="${ncn_progname}"
7633     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7634     break 2
7635   fi
7636 done
7637 done
7638
7639 fi
7640 fi
7641 WINDRES=$ac_cv_prog_WINDRES
7642 if test -n "$WINDRES"; then
7643   echo "$as_me:$LINENO: result: $WINDRES" >&5
7644 echo "${ECHO_T}$WINDRES" >&6
7645 else
7646   echo "$as_me:$LINENO: result: no" >&5
7647 echo "${ECHO_T}no" >&6
7648 fi
7649
7650   fi
7651   test -n "$ac_cv_prog_WINDRES" && break
7652 done
7653
7654 if test -z "$ac_cv_prog_WINDRES" ; then
7655   set dummy windres
7656   if test $build = $host ; then
7657     WINDRES="$2"
7658   else
7659     WINDRES="${ncn_tool_prefix}$2"
7660   fi
7661 fi
7662
7663
7664
7665 if test -n "$WINDMC"; then
7666   ac_cv_prog_WINDMC=$WINDMC
7667 elif test -n "$ac_cv_prog_WINDMC"; then
7668   WINDMC=$ac_cv_prog_WINDMC
7669 fi
7670
7671 if test -n "$ac_cv_prog_WINDMC"; then
7672   for ncn_progname in windmc; do
7673     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7674 set dummy ${ncn_progname}; ac_word=$2
7675 echo "$as_me:$LINENO: checking for $ac_word" >&5
7676 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7677 if test "${ac_cv_prog_WINDMC+set}" = set; then
7678   echo $ECHO_N "(cached) $ECHO_C" >&6
7679 else
7680   if test -n "$WINDMC"; then
7681   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7682 else
7683 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7684 for as_dir in $PATH
7685 do
7686   IFS=$as_save_IFS
7687   test -z "$as_dir" && as_dir=.
7688   for ac_exec_ext in '' $ac_executable_extensions; do
7689   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7690     ac_cv_prog_WINDMC="${ncn_progname}"
7691     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7692     break 2
7693   fi
7694 done
7695 done
7696
7697 fi
7698 fi
7699 WINDMC=$ac_cv_prog_WINDMC
7700 if test -n "$WINDMC"; then
7701   echo "$as_me:$LINENO: result: $WINDMC" >&5
7702 echo "${ECHO_T}$WINDMC" >&6
7703 else
7704   echo "$as_me:$LINENO: result: no" >&5
7705 echo "${ECHO_T}no" >&6
7706 fi
7707
7708   done
7709 fi
7710
7711 for ncn_progname in windmc; do
7712   if test -n "$ncn_tool_prefix"; then
7713     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7714 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7715 echo "$as_me:$LINENO: checking for $ac_word" >&5
7716 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7717 if test "${ac_cv_prog_WINDMC+set}" = set; then
7718   echo $ECHO_N "(cached) $ECHO_C" >&6
7719 else
7720   if test -n "$WINDMC"; then
7721   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7722 else
7723 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7724 for as_dir in $PATH
7725 do
7726   IFS=$as_save_IFS
7727   test -z "$as_dir" && as_dir=.
7728   for ac_exec_ext in '' $ac_executable_extensions; do
7729   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7730     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7731     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7732     break 2
7733   fi
7734 done
7735 done
7736
7737 fi
7738 fi
7739 WINDMC=$ac_cv_prog_WINDMC
7740 if test -n "$WINDMC"; then
7741   echo "$as_me:$LINENO: result: $WINDMC" >&5
7742 echo "${ECHO_T}$WINDMC" >&6
7743 else
7744   echo "$as_me:$LINENO: result: no" >&5
7745 echo "${ECHO_T}no" >&6
7746 fi
7747
7748   fi
7749   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7750     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7751 set dummy ${ncn_progname}; ac_word=$2
7752 echo "$as_me:$LINENO: checking for $ac_word" >&5
7753 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7754 if test "${ac_cv_prog_WINDMC+set}" = set; then
7755   echo $ECHO_N "(cached) $ECHO_C" >&6
7756 else
7757   if test -n "$WINDMC"; then
7758   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7759 else
7760 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7761 for as_dir in $PATH
7762 do
7763   IFS=$as_save_IFS
7764   test -z "$as_dir" && as_dir=.
7765   for ac_exec_ext in '' $ac_executable_extensions; do
7766   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7767     ac_cv_prog_WINDMC="${ncn_progname}"
7768     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7769     break 2
7770   fi
7771 done
7772 done
7773
7774 fi
7775 fi
7776 WINDMC=$ac_cv_prog_WINDMC
7777 if test -n "$WINDMC"; then
7778   echo "$as_me:$LINENO: result: $WINDMC" >&5
7779 echo "${ECHO_T}$WINDMC" >&6
7780 else
7781   echo "$as_me:$LINENO: result: no" >&5
7782 echo "${ECHO_T}no" >&6
7783 fi
7784
7785   fi
7786   test -n "$ac_cv_prog_WINDMC" && break
7787 done
7788
7789 if test -z "$ac_cv_prog_WINDMC" ; then
7790   set dummy windmc
7791   if test $build = $host ; then
7792     WINDMC="$2"
7793   else
7794     WINDMC="${ncn_tool_prefix}$2"
7795   fi
7796 fi
7797
7798
7799
7800 if test -n "$OBJCOPY"; then
7801   ac_cv_prog_OBJCOPY=$OBJCOPY
7802 elif test -n "$ac_cv_prog_OBJCOPY"; then
7803   OBJCOPY=$ac_cv_prog_OBJCOPY
7804 fi
7805
7806 if test -n "$ac_cv_prog_OBJCOPY"; then
7807   for ncn_progname in objcopy; do
7808     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7809 set dummy ${ncn_progname}; ac_word=$2
7810 echo "$as_me:$LINENO: checking for $ac_word" >&5
7811 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7812 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7813   echo $ECHO_N "(cached) $ECHO_C" >&6
7814 else
7815   if test -n "$OBJCOPY"; then
7816   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7817 else
7818 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7819 for as_dir in $PATH
7820 do
7821   IFS=$as_save_IFS
7822   test -z "$as_dir" && as_dir=.
7823   for ac_exec_ext in '' $ac_executable_extensions; do
7824   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7825     ac_cv_prog_OBJCOPY="${ncn_progname}"
7826     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7827     break 2
7828   fi
7829 done
7830 done
7831
7832 fi
7833 fi
7834 OBJCOPY=$ac_cv_prog_OBJCOPY
7835 if test -n "$OBJCOPY"; then
7836   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7837 echo "${ECHO_T}$OBJCOPY" >&6
7838 else
7839   echo "$as_me:$LINENO: result: no" >&5
7840 echo "${ECHO_T}no" >&6
7841 fi
7842
7843   done
7844 fi
7845
7846 for ncn_progname in objcopy; do
7847   if test -n "$ncn_tool_prefix"; then
7848     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7849 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7850 echo "$as_me:$LINENO: checking for $ac_word" >&5
7851 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7852 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7853   echo $ECHO_N "(cached) $ECHO_C" >&6
7854 else
7855   if test -n "$OBJCOPY"; then
7856   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7857 else
7858 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7859 for as_dir in $PATH
7860 do
7861   IFS=$as_save_IFS
7862   test -z "$as_dir" && as_dir=.
7863   for ac_exec_ext in '' $ac_executable_extensions; do
7864   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7865     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7866     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7867     break 2
7868   fi
7869 done
7870 done
7871
7872 fi
7873 fi
7874 OBJCOPY=$ac_cv_prog_OBJCOPY
7875 if test -n "$OBJCOPY"; then
7876   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7877 echo "${ECHO_T}$OBJCOPY" >&6
7878 else
7879   echo "$as_me:$LINENO: result: no" >&5
7880 echo "${ECHO_T}no" >&6
7881 fi
7882
7883   fi
7884   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7885     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7886 set dummy ${ncn_progname}; ac_word=$2
7887 echo "$as_me:$LINENO: checking for $ac_word" >&5
7888 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7889 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7890   echo $ECHO_N "(cached) $ECHO_C" >&6
7891 else
7892   if test -n "$OBJCOPY"; then
7893   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7894 else
7895 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7896 for as_dir in $PATH
7897 do
7898   IFS=$as_save_IFS
7899   test -z "$as_dir" && as_dir=.
7900   for ac_exec_ext in '' $ac_executable_extensions; do
7901   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7902     ac_cv_prog_OBJCOPY="${ncn_progname}"
7903     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7904     break 2
7905   fi
7906 done
7907 done
7908
7909 fi
7910 fi
7911 OBJCOPY=$ac_cv_prog_OBJCOPY
7912 if test -n "$OBJCOPY"; then
7913   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7914 echo "${ECHO_T}$OBJCOPY" >&6
7915 else
7916   echo "$as_me:$LINENO: result: no" >&5
7917 echo "${ECHO_T}no" >&6
7918 fi
7919
7920   fi
7921   test -n "$ac_cv_prog_OBJCOPY" && break
7922 done
7923
7924 if test -z "$ac_cv_prog_OBJCOPY" ; then
7925   set dummy objcopy
7926   if test $build = $host ; then
7927     OBJCOPY="$2"
7928   else
7929     OBJCOPY="${ncn_tool_prefix}$2"
7930   fi
7931 fi
7932
7933
7934
7935 if test -n "$OBJDUMP"; then
7936   ac_cv_prog_OBJDUMP=$OBJDUMP
7937 elif test -n "$ac_cv_prog_OBJDUMP"; then
7938   OBJDUMP=$ac_cv_prog_OBJDUMP
7939 fi
7940
7941 if test -n "$ac_cv_prog_OBJDUMP"; then
7942   for ncn_progname in objdump; do
7943     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7944 set dummy ${ncn_progname}; ac_word=$2
7945 echo "$as_me:$LINENO: checking for $ac_word" >&5
7946 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7947 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7948   echo $ECHO_N "(cached) $ECHO_C" >&6
7949 else
7950   if test -n "$OBJDUMP"; then
7951   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7952 else
7953 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7954 for as_dir in $PATH
7955 do
7956   IFS=$as_save_IFS
7957   test -z "$as_dir" && as_dir=.
7958   for ac_exec_ext in '' $ac_executable_extensions; do
7959   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7960     ac_cv_prog_OBJDUMP="${ncn_progname}"
7961     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7962     break 2
7963   fi
7964 done
7965 done
7966
7967 fi
7968 fi
7969 OBJDUMP=$ac_cv_prog_OBJDUMP
7970 if test -n "$OBJDUMP"; then
7971   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7972 echo "${ECHO_T}$OBJDUMP" >&6
7973 else
7974   echo "$as_me:$LINENO: result: no" >&5
7975 echo "${ECHO_T}no" >&6
7976 fi
7977
7978   done
7979 fi
7980
7981 for ncn_progname in objdump; do
7982   if test -n "$ncn_tool_prefix"; then
7983     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7984 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7985 echo "$as_me:$LINENO: checking for $ac_word" >&5
7986 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7987 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7988   echo $ECHO_N "(cached) $ECHO_C" >&6
7989 else
7990   if test -n "$OBJDUMP"; then
7991   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7992 else
7993 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7994 for as_dir in $PATH
7995 do
7996   IFS=$as_save_IFS
7997   test -z "$as_dir" && as_dir=.
7998   for ac_exec_ext in '' $ac_executable_extensions; do
7999   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8000     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
8001     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8002     break 2
8003   fi
8004 done
8005 done
8006
8007 fi
8008 fi
8009 OBJDUMP=$ac_cv_prog_OBJDUMP
8010 if test -n "$OBJDUMP"; then
8011   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8012 echo "${ECHO_T}$OBJDUMP" >&6
8013 else
8014   echo "$as_me:$LINENO: result: no" >&5
8015 echo "${ECHO_T}no" >&6
8016 fi
8017
8018   fi
8019   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
8020     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8021 set dummy ${ncn_progname}; ac_word=$2
8022 echo "$as_me:$LINENO: checking for $ac_word" >&5
8023 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8024 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
8025   echo $ECHO_N "(cached) $ECHO_C" >&6
8026 else
8027   if test -n "$OBJDUMP"; then
8028   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
8029 else
8030 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8031 for as_dir in $PATH
8032 do
8033   IFS=$as_save_IFS
8034   test -z "$as_dir" && as_dir=.
8035   for ac_exec_ext in '' $ac_executable_extensions; do
8036   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8037     ac_cv_prog_OBJDUMP="${ncn_progname}"
8038     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8039     break 2
8040   fi
8041 done
8042 done
8043
8044 fi
8045 fi
8046 OBJDUMP=$ac_cv_prog_OBJDUMP
8047 if test -n "$OBJDUMP"; then
8048   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
8049 echo "${ECHO_T}$OBJDUMP" >&6
8050 else
8051   echo "$as_me:$LINENO: result: no" >&5
8052 echo "${ECHO_T}no" >&6
8053 fi
8054
8055   fi
8056   test -n "$ac_cv_prog_OBJDUMP" && break
8057 done
8058
8059 if test -z "$ac_cv_prog_OBJDUMP" ; then
8060   set dummy objdump
8061   if test $build = $host ; then
8062     OBJDUMP="$2"
8063   else
8064     OBJDUMP="${ncn_tool_prefix}$2"
8065   fi
8066 fi
8067
8068
8069
8070
8071
8072
8073 # Target tools.
8074
8075 # Check whether --with-build-time-tools or --without-build-time-tools was given.
8076 if test "${with_build_time_tools+set}" = set; then
8077   withval="$with_build_time_tools"
8078   case x"$withval" in
8079      x/*) ;;
8080      *)
8081        with_build_time_tools=
8082        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
8083 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
8084        ;;
8085    esac
8086 else
8087   with_build_time_tools=
8088 fi;
8089
8090
8091
8092 if test -n "$CC_FOR_TARGET"; then
8093   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
8094 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8095   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8096 fi
8097
8098 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
8099   for ncn_progname in cc gcc; do
8100     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8101 set dummy ${ncn_progname}; ac_word=$2
8102 echo "$as_me:$LINENO: checking for $ac_word" >&5
8103 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8104 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8105   echo $ECHO_N "(cached) $ECHO_C" >&6
8106 else
8107   if test -n "$CC_FOR_TARGET"; then
8108   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8109 else
8110 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8111 for as_dir in $PATH
8112 do
8113   IFS=$as_save_IFS
8114   test -z "$as_dir" && as_dir=.
8115   for ac_exec_ext in '' $ac_executable_extensions; do
8116   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8117     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8118     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8119     break 2
8120   fi
8121 done
8122 done
8123
8124 fi
8125 fi
8126 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8127 if test -n "$CC_FOR_TARGET"; then
8128   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8129 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8130 else
8131   echo "$as_me:$LINENO: result: no" >&5
8132 echo "${ECHO_T}no" >&6
8133 fi
8134
8135   done
8136 fi
8137
8138 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8139   for ncn_progname in cc gcc; do
8140     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8141 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8142     if test -x $with_build_time_tools/${ncn_progname}; then
8143       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8144       echo "$as_me:$LINENO: result: yes" >&5
8145 echo "${ECHO_T}yes" >&6
8146       break
8147     else
8148       echo "$as_me:$LINENO: result: no" >&5
8149 echo "${ECHO_T}no" >&6
8150     fi
8151   done
8152 fi
8153
8154 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
8155   for ncn_progname in cc gcc; do
8156     if test -n "$ncn_target_tool_prefix"; then
8157       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8158 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8159 echo "$as_me:$LINENO: checking for $ac_word" >&5
8160 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8161 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8162   echo $ECHO_N "(cached) $ECHO_C" >&6
8163 else
8164   if test -n "$CC_FOR_TARGET"; then
8165   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8166 else
8167 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8168 for as_dir in $PATH
8169 do
8170   IFS=$as_save_IFS
8171   test -z "$as_dir" && as_dir=.
8172   for ac_exec_ext in '' $ac_executable_extensions; do
8173   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8174     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8175     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8176     break 2
8177   fi
8178 done
8179 done
8180
8181 fi
8182 fi
8183 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8184 if test -n "$CC_FOR_TARGET"; then
8185   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8186 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8187 else
8188   echo "$as_me:$LINENO: result: no" >&5
8189 echo "${ECHO_T}no" >&6
8190 fi
8191
8192     fi
8193     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8194       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8195 set dummy ${ncn_progname}; ac_word=$2
8196 echo "$as_me:$LINENO: checking for $ac_word" >&5
8197 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8198 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8199   echo $ECHO_N "(cached) $ECHO_C" >&6
8200 else
8201   if test -n "$CC_FOR_TARGET"; then
8202   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8203 else
8204 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8205 for as_dir in $PATH
8206 do
8207   IFS=$as_save_IFS
8208   test -z "$as_dir" && as_dir=.
8209   for ac_exec_ext in '' $ac_executable_extensions; do
8210   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8211     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8212     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8213     break 2
8214   fi
8215 done
8216 done
8217
8218 fi
8219 fi
8220 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8221 if test -n "$CC_FOR_TARGET"; then
8222   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8223 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8224 else
8225   echo "$as_me:$LINENO: result: no" >&5
8226 echo "${ECHO_T}no" >&6
8227 fi
8228
8229     fi
8230     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8231   done
8232 fi
8233
8234 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8235   set dummy cc gcc
8236   if test $build = $target ; then
8237     CC_FOR_TARGET="$2"
8238   else
8239     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8240   fi
8241 else
8242   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8243 fi
8244
8245
8246
8247 if test -n "$CXX_FOR_TARGET"; then
8248   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8249 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8250   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8251 fi
8252
8253 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8254   for ncn_progname in c++ g++ cxx gxx; do
8255     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8256 set dummy ${ncn_progname}; ac_word=$2
8257 echo "$as_me:$LINENO: checking for $ac_word" >&5
8258 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8259 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8260   echo $ECHO_N "(cached) $ECHO_C" >&6
8261 else
8262   if test -n "$CXX_FOR_TARGET"; then
8263   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8264 else
8265 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8266 for as_dir in $PATH
8267 do
8268   IFS=$as_save_IFS
8269   test -z "$as_dir" && as_dir=.
8270   for ac_exec_ext in '' $ac_executable_extensions; do
8271   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8272     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8273     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8274     break 2
8275   fi
8276 done
8277 done
8278
8279 fi
8280 fi
8281 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8282 if test -n "$CXX_FOR_TARGET"; then
8283   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8284 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8285 else
8286   echo "$as_me:$LINENO: result: no" >&5
8287 echo "${ECHO_T}no" >&6
8288 fi
8289
8290   done
8291 fi
8292
8293 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8294   for ncn_progname in c++ g++ cxx gxx; do
8295     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8296 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8297     if test -x $with_build_time_tools/${ncn_progname}; then
8298       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8299       echo "$as_me:$LINENO: result: yes" >&5
8300 echo "${ECHO_T}yes" >&6
8301       break
8302     else
8303       echo "$as_me:$LINENO: result: no" >&5
8304 echo "${ECHO_T}no" >&6
8305     fi
8306   done
8307 fi
8308
8309 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8310   for ncn_progname in c++ g++ cxx gxx; do
8311     if test -n "$ncn_target_tool_prefix"; then
8312       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8313 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8314 echo "$as_me:$LINENO: checking for $ac_word" >&5
8315 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8316 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8317   echo $ECHO_N "(cached) $ECHO_C" >&6
8318 else
8319   if test -n "$CXX_FOR_TARGET"; then
8320   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8321 else
8322 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8323 for as_dir in $PATH
8324 do
8325   IFS=$as_save_IFS
8326   test -z "$as_dir" && as_dir=.
8327   for ac_exec_ext in '' $ac_executable_extensions; do
8328   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8329     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8330     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8331     break 2
8332   fi
8333 done
8334 done
8335
8336 fi
8337 fi
8338 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8339 if test -n "$CXX_FOR_TARGET"; then
8340   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8341 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8342 else
8343   echo "$as_me:$LINENO: result: no" >&5
8344 echo "${ECHO_T}no" >&6
8345 fi
8346
8347     fi
8348     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8349       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8350 set dummy ${ncn_progname}; ac_word=$2
8351 echo "$as_me:$LINENO: checking for $ac_word" >&5
8352 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8353 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8354   echo $ECHO_N "(cached) $ECHO_C" >&6
8355 else
8356   if test -n "$CXX_FOR_TARGET"; then
8357   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8358 else
8359 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8360 for as_dir in $PATH
8361 do
8362   IFS=$as_save_IFS
8363   test -z "$as_dir" && as_dir=.
8364   for ac_exec_ext in '' $ac_executable_extensions; do
8365   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8366     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8367     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8368     break 2
8369   fi
8370 done
8371 done
8372
8373 fi
8374 fi
8375 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8376 if test -n "$CXX_FOR_TARGET"; then
8377   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8378 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8379 else
8380   echo "$as_me:$LINENO: result: no" >&5
8381 echo "${ECHO_T}no" >&6
8382 fi
8383
8384     fi
8385     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8386   done
8387 fi
8388
8389 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8390   set dummy c++ g++ cxx gxx
8391   if test $build = $target ; then
8392     CXX_FOR_TARGET="$2"
8393   else
8394     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8395   fi
8396 else
8397   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8398 fi
8399
8400
8401
8402 if test -n "$GCC_FOR_TARGET"; then
8403   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8404 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8405   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8406 fi
8407
8408 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8409   for ncn_progname in gcc; do
8410     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8411 set dummy ${ncn_progname}; ac_word=$2
8412 echo "$as_me:$LINENO: checking for $ac_word" >&5
8413 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8414 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8415   echo $ECHO_N "(cached) $ECHO_C" >&6
8416 else
8417   if test -n "$GCC_FOR_TARGET"; then
8418   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8419 else
8420 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8421 for as_dir in $PATH
8422 do
8423   IFS=$as_save_IFS
8424   test -z "$as_dir" && as_dir=.
8425   for ac_exec_ext in '' $ac_executable_extensions; do
8426   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8427     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8428     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8429     break 2
8430   fi
8431 done
8432 done
8433
8434 fi
8435 fi
8436 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8437 if test -n "$GCC_FOR_TARGET"; then
8438   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8439 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8440 else
8441   echo "$as_me:$LINENO: result: no" >&5
8442 echo "${ECHO_T}no" >&6
8443 fi
8444
8445   done
8446 fi
8447
8448 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8449   for ncn_progname in gcc; do
8450     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8451 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8452     if test -x $with_build_time_tools/${ncn_progname}; then
8453       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8454       echo "$as_me:$LINENO: result: yes" >&5
8455 echo "${ECHO_T}yes" >&6
8456       break
8457     else
8458       echo "$as_me:$LINENO: result: no" >&5
8459 echo "${ECHO_T}no" >&6
8460     fi
8461   done
8462 fi
8463
8464 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8465   for ncn_progname in gcc; do
8466     if test -n "$ncn_target_tool_prefix"; then
8467       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8468 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8469 echo "$as_me:$LINENO: checking for $ac_word" >&5
8470 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8471 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8472   echo $ECHO_N "(cached) $ECHO_C" >&6
8473 else
8474   if test -n "$GCC_FOR_TARGET"; then
8475   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8476 else
8477 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8478 for as_dir in $PATH
8479 do
8480   IFS=$as_save_IFS
8481   test -z "$as_dir" && as_dir=.
8482   for ac_exec_ext in '' $ac_executable_extensions; do
8483   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8484     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8485     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8486     break 2
8487   fi
8488 done
8489 done
8490
8491 fi
8492 fi
8493 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8494 if test -n "$GCC_FOR_TARGET"; then
8495   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8496 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8497 else
8498   echo "$as_me:$LINENO: result: no" >&5
8499 echo "${ECHO_T}no" >&6
8500 fi
8501
8502     fi
8503     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8504       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8505 set dummy ${ncn_progname}; ac_word=$2
8506 echo "$as_me:$LINENO: checking for $ac_word" >&5
8507 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8508 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8509   echo $ECHO_N "(cached) $ECHO_C" >&6
8510 else
8511   if test -n "$GCC_FOR_TARGET"; then
8512   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8513 else
8514 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8515 for as_dir in $PATH
8516 do
8517   IFS=$as_save_IFS
8518   test -z "$as_dir" && as_dir=.
8519   for ac_exec_ext in '' $ac_executable_extensions; do
8520   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8521     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8522     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8523     break 2
8524   fi
8525 done
8526 done
8527
8528 fi
8529 fi
8530 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8531 if test -n "$GCC_FOR_TARGET"; then
8532   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8533 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8534 else
8535   echo "$as_me:$LINENO: result: no" >&5
8536 echo "${ECHO_T}no" >&6
8537 fi
8538
8539     fi
8540     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8541   done
8542 fi
8543
8544 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8545   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8546 else
8547   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8548 fi
8549
8550
8551
8552 if test -n "$GCJ_FOR_TARGET"; then
8553   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8554 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8555   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8556 fi
8557
8558 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8559   for ncn_progname in gcj; do
8560     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8561 set dummy ${ncn_progname}; ac_word=$2
8562 echo "$as_me:$LINENO: checking for $ac_word" >&5
8563 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8564 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8565   echo $ECHO_N "(cached) $ECHO_C" >&6
8566 else
8567   if test -n "$GCJ_FOR_TARGET"; then
8568   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8569 else
8570 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8571 for as_dir in $PATH
8572 do
8573   IFS=$as_save_IFS
8574   test -z "$as_dir" && as_dir=.
8575   for ac_exec_ext in '' $ac_executable_extensions; do
8576   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8577     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8578     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8579     break 2
8580   fi
8581 done
8582 done
8583
8584 fi
8585 fi
8586 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8587 if test -n "$GCJ_FOR_TARGET"; then
8588   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8589 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8590 else
8591   echo "$as_me:$LINENO: result: no" >&5
8592 echo "${ECHO_T}no" >&6
8593 fi
8594
8595   done
8596 fi
8597
8598 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8599   for ncn_progname in gcj; do
8600     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8601 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8602     if test -x $with_build_time_tools/${ncn_progname}; then
8603       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8604       echo "$as_me:$LINENO: result: yes" >&5
8605 echo "${ECHO_T}yes" >&6
8606       break
8607     else
8608       echo "$as_me:$LINENO: result: no" >&5
8609 echo "${ECHO_T}no" >&6
8610     fi
8611   done
8612 fi
8613
8614 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8615   for ncn_progname in gcj; do
8616     if test -n "$ncn_target_tool_prefix"; then
8617       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8618 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8619 echo "$as_me:$LINENO: checking for $ac_word" >&5
8620 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8621 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8622   echo $ECHO_N "(cached) $ECHO_C" >&6
8623 else
8624   if test -n "$GCJ_FOR_TARGET"; then
8625   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8626 else
8627 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8628 for as_dir in $PATH
8629 do
8630   IFS=$as_save_IFS
8631   test -z "$as_dir" && as_dir=.
8632   for ac_exec_ext in '' $ac_executable_extensions; do
8633   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8634     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8635     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8636     break 2
8637   fi
8638 done
8639 done
8640
8641 fi
8642 fi
8643 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8644 if test -n "$GCJ_FOR_TARGET"; then
8645   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8646 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8647 else
8648   echo "$as_me:$LINENO: result: no" >&5
8649 echo "${ECHO_T}no" >&6
8650 fi
8651
8652     fi
8653     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8654       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8655 set dummy ${ncn_progname}; ac_word=$2
8656 echo "$as_me:$LINENO: checking for $ac_word" >&5
8657 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8658 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8659   echo $ECHO_N "(cached) $ECHO_C" >&6
8660 else
8661   if test -n "$GCJ_FOR_TARGET"; then
8662   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8663 else
8664 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8665 for as_dir in $PATH
8666 do
8667   IFS=$as_save_IFS
8668   test -z "$as_dir" && as_dir=.
8669   for ac_exec_ext in '' $ac_executable_extensions; do
8670   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8671     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8672     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8673     break 2
8674   fi
8675 done
8676 done
8677
8678 fi
8679 fi
8680 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8681 if test -n "$GCJ_FOR_TARGET"; then
8682   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8683 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8684 else
8685   echo "$as_me:$LINENO: result: no" >&5
8686 echo "${ECHO_T}no" >&6
8687 fi
8688
8689     fi
8690     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8691   done
8692 fi
8693
8694 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8695   set dummy gcj
8696   if test $build = $target ; then
8697     GCJ_FOR_TARGET="$2"
8698   else
8699     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8700   fi
8701 else
8702   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8703 fi
8704
8705
8706
8707 if test -n "$GFORTRAN_FOR_TARGET"; then
8708   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8709 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8710   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8711 fi
8712
8713 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8714   for ncn_progname in gfortran; do
8715     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8716 set dummy ${ncn_progname}; ac_word=$2
8717 echo "$as_me:$LINENO: checking for $ac_word" >&5
8718 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8719 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8720   echo $ECHO_N "(cached) $ECHO_C" >&6
8721 else
8722   if test -n "$GFORTRAN_FOR_TARGET"; then
8723   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8724 else
8725 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8726 for as_dir in $PATH
8727 do
8728   IFS=$as_save_IFS
8729   test -z "$as_dir" && as_dir=.
8730   for ac_exec_ext in '' $ac_executable_extensions; do
8731   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8732     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8733     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8734     break 2
8735   fi
8736 done
8737 done
8738
8739 fi
8740 fi
8741 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8742 if test -n "$GFORTRAN_FOR_TARGET"; then
8743   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8744 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8745 else
8746   echo "$as_me:$LINENO: result: no" >&5
8747 echo "${ECHO_T}no" >&6
8748 fi
8749
8750   done
8751 fi
8752
8753 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8754   for ncn_progname in gfortran; do
8755     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8756 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8757     if test -x $with_build_time_tools/${ncn_progname}; then
8758       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8759       echo "$as_me:$LINENO: result: yes" >&5
8760 echo "${ECHO_T}yes" >&6
8761       break
8762     else
8763       echo "$as_me:$LINENO: result: no" >&5
8764 echo "${ECHO_T}no" >&6
8765     fi
8766   done
8767 fi
8768
8769 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8770   for ncn_progname in gfortran; do
8771     if test -n "$ncn_target_tool_prefix"; then
8772       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8773 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8774 echo "$as_me:$LINENO: checking for $ac_word" >&5
8775 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8776 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8777   echo $ECHO_N "(cached) $ECHO_C" >&6
8778 else
8779   if test -n "$GFORTRAN_FOR_TARGET"; then
8780   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8781 else
8782 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8783 for as_dir in $PATH
8784 do
8785   IFS=$as_save_IFS
8786   test -z "$as_dir" && as_dir=.
8787   for ac_exec_ext in '' $ac_executable_extensions; do
8788   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8789     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8790     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8791     break 2
8792   fi
8793 done
8794 done
8795
8796 fi
8797 fi
8798 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8799 if test -n "$GFORTRAN_FOR_TARGET"; then
8800   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8801 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8802 else
8803   echo "$as_me:$LINENO: result: no" >&5
8804 echo "${ECHO_T}no" >&6
8805 fi
8806
8807     fi
8808     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8809       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8810 set dummy ${ncn_progname}; ac_word=$2
8811 echo "$as_me:$LINENO: checking for $ac_word" >&5
8812 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8813 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8814   echo $ECHO_N "(cached) $ECHO_C" >&6
8815 else
8816   if test -n "$GFORTRAN_FOR_TARGET"; then
8817   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8818 else
8819 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8820 for as_dir in $PATH
8821 do
8822   IFS=$as_save_IFS
8823   test -z "$as_dir" && as_dir=.
8824   for ac_exec_ext in '' $ac_executable_extensions; do
8825   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8826     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8827     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8828     break 2
8829   fi
8830 done
8831 done
8832
8833 fi
8834 fi
8835 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8836 if test -n "$GFORTRAN_FOR_TARGET"; then
8837   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8838 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8839 else
8840   echo "$as_me:$LINENO: result: no" >&5
8841 echo "${ECHO_T}no" >&6
8842 fi
8843
8844     fi
8845     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8846   done
8847 fi
8848
8849 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8850   set dummy gfortran
8851   if test $build = $target ; then
8852     GFORTRAN_FOR_TARGET="$2"
8853   else
8854     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8855   fi
8856 else
8857   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8858 fi
8859
8860
8861
8862 cat > conftest.c << \EOF
8863 #ifdef __GNUC__
8864   gcc_yay;
8865 #endif
8866 EOF
8867 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8868   have_gcc_for_target=yes
8869 else
8870   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8871   have_gcc_for_target=no
8872 fi
8873 rm conftest.c
8874
8875
8876
8877
8878 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8879   if test -n "$with_build_time_tools"; then
8880     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8881 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8882     if test -x $with_build_time_tools/ar; then
8883       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8884       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8885       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8886 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8887     else
8888       echo "$as_me:$LINENO: result: no" >&5
8889 echo "${ECHO_T}no" >&6
8890     fi
8891   elif test $build != $host && test $have_gcc_for_target = yes; then
8892     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8893     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8894     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8895   fi
8896 fi
8897 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8898   # Extract the first word of "ar", so it can be a program name with args.
8899 set dummy ar; ac_word=$2
8900 echo "$as_me:$LINENO: checking for $ac_word" >&5
8901 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8902 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8903   echo $ECHO_N "(cached) $ECHO_C" >&6
8904 else
8905   case $AR_FOR_TARGET in
8906   [\\/]* | ?:[\\/]*)
8907   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8908   ;;
8909   *)
8910   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8911 for as_dir in $gcc_cv_tool_dirs
8912 do
8913   IFS=$as_save_IFS
8914   test -z "$as_dir" && as_dir=.
8915   for ac_exec_ext in '' $ac_executable_extensions; do
8916   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8917     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8918     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8919     break 2
8920   fi
8921 done
8922 done
8923
8924   ;;
8925 esac
8926 fi
8927 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8928
8929 if test -n "$AR_FOR_TARGET"; then
8930   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8931 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8932 else
8933   echo "$as_me:$LINENO: result: no" >&5
8934 echo "${ECHO_T}no" >&6
8935 fi
8936
8937 fi
8938 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8939
8940
8941 if test -n "$AR_FOR_TARGET"; then
8942   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8943 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8944   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8945 fi
8946
8947 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8948   for ncn_progname in ar; do
8949     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8950 set dummy ${ncn_progname}; ac_word=$2
8951 echo "$as_me:$LINENO: checking for $ac_word" >&5
8952 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8953 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8954   echo $ECHO_N "(cached) $ECHO_C" >&6
8955 else
8956   if test -n "$AR_FOR_TARGET"; then
8957   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8958 else
8959 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8960 for as_dir in $PATH
8961 do
8962   IFS=$as_save_IFS
8963   test -z "$as_dir" && as_dir=.
8964   for ac_exec_ext in '' $ac_executable_extensions; do
8965   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8966     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8967     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8968     break 2
8969   fi
8970 done
8971 done
8972
8973 fi
8974 fi
8975 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8976 if test -n "$AR_FOR_TARGET"; then
8977   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8978 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8979 else
8980   echo "$as_me:$LINENO: result: no" >&5
8981 echo "${ECHO_T}no" >&6
8982 fi
8983
8984   done
8985 fi
8986
8987 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8988   for ncn_progname in ar; do
8989     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8990 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8991     if test -x $with_build_time_tools/${ncn_progname}; then
8992       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8993       echo "$as_me:$LINENO: result: yes" >&5
8994 echo "${ECHO_T}yes" >&6
8995       break
8996     else
8997       echo "$as_me:$LINENO: result: no" >&5
8998 echo "${ECHO_T}no" >&6
8999     fi
9000   done
9001 fi
9002
9003 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
9004   for ncn_progname in ar; do
9005     if test -n "$ncn_target_tool_prefix"; then
9006       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9007 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9008 echo "$as_me:$LINENO: checking for $ac_word" >&5
9009 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9010 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9011   echo $ECHO_N "(cached) $ECHO_C" >&6
9012 else
9013   if test -n "$AR_FOR_TARGET"; then
9014   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9015 else
9016 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9017 for as_dir in $PATH
9018 do
9019   IFS=$as_save_IFS
9020   test -z "$as_dir" && as_dir=.
9021   for ac_exec_ext in '' $ac_executable_extensions; do
9022   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9023     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9024     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9025     break 2
9026   fi
9027 done
9028 done
9029
9030 fi
9031 fi
9032 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9033 if test -n "$AR_FOR_TARGET"; then
9034   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9035 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9036 else
9037   echo "$as_me:$LINENO: result: no" >&5
9038 echo "${ECHO_T}no" >&6
9039 fi
9040
9041     fi
9042     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
9043       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9044 set dummy ${ncn_progname}; ac_word=$2
9045 echo "$as_me:$LINENO: checking for $ac_word" >&5
9046 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9047 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
9048   echo $ECHO_N "(cached) $ECHO_C" >&6
9049 else
9050   if test -n "$AR_FOR_TARGET"; then
9051   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
9052 else
9053 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9054 for as_dir in $PATH
9055 do
9056   IFS=$as_save_IFS
9057   test -z "$as_dir" && as_dir=.
9058   for ac_exec_ext in '' $ac_executable_extensions; do
9059   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9060     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
9061     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9062     break 2
9063   fi
9064 done
9065 done
9066
9067 fi
9068 fi
9069 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
9070 if test -n "$AR_FOR_TARGET"; then
9071   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
9072 echo "${ECHO_T}$AR_FOR_TARGET" >&6
9073 else
9074   echo "$as_me:$LINENO: result: no" >&5
9075 echo "${ECHO_T}no" >&6
9076 fi
9077
9078     fi
9079     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
9080   done
9081 fi
9082
9083 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
9084   set dummy ar
9085   if test $build = $target ; then
9086     AR_FOR_TARGET="$2"
9087   else
9088     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
9089   fi
9090 else
9091   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
9092 fi
9093
9094 else
9095   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
9096 fi
9097
9098
9099
9100
9101 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9102   if test -n "$with_build_time_tools"; then
9103     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
9104 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
9105     if test -x $with_build_time_tools/as; then
9106       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
9107       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9108       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
9109 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
9110     else
9111       echo "$as_me:$LINENO: result: no" >&5
9112 echo "${ECHO_T}no" >&6
9113     fi
9114   elif test $build != $host && test $have_gcc_for_target = yes; then
9115     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
9116     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
9117     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
9118   fi
9119 fi
9120 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9121   # Extract the first word of "as", so it can be a program name with args.
9122 set dummy as; ac_word=$2
9123 echo "$as_me:$LINENO: checking for $ac_word" >&5
9124 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9125 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
9126   echo $ECHO_N "(cached) $ECHO_C" >&6
9127 else
9128   case $AS_FOR_TARGET in
9129   [\\/]* | ?:[\\/]*)
9130   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
9131   ;;
9132   *)
9133   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9134 for as_dir in $gcc_cv_tool_dirs
9135 do
9136   IFS=$as_save_IFS
9137   test -z "$as_dir" && as_dir=.
9138   for ac_exec_ext in '' $ac_executable_extensions; do
9139   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9140     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9141     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9142     break 2
9143   fi
9144 done
9145 done
9146
9147   ;;
9148 esac
9149 fi
9150 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9151
9152 if test -n "$AS_FOR_TARGET"; then
9153   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9154 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9155 else
9156   echo "$as_me:$LINENO: result: no" >&5
9157 echo "${ECHO_T}no" >&6
9158 fi
9159
9160 fi
9161 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9162
9163
9164 if test -n "$AS_FOR_TARGET"; then
9165   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9166 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9167   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9168 fi
9169
9170 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9171   for ncn_progname in as; do
9172     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9173 set dummy ${ncn_progname}; ac_word=$2
9174 echo "$as_me:$LINENO: checking for $ac_word" >&5
9175 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9176 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9177   echo $ECHO_N "(cached) $ECHO_C" >&6
9178 else
9179   if test -n "$AS_FOR_TARGET"; then
9180   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9181 else
9182 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9183 for as_dir in $PATH
9184 do
9185   IFS=$as_save_IFS
9186   test -z "$as_dir" && as_dir=.
9187   for ac_exec_ext in '' $ac_executable_extensions; do
9188   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9189     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9190     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9191     break 2
9192   fi
9193 done
9194 done
9195
9196 fi
9197 fi
9198 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9199 if test -n "$AS_FOR_TARGET"; then
9200   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9201 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9202 else
9203   echo "$as_me:$LINENO: result: no" >&5
9204 echo "${ECHO_T}no" >&6
9205 fi
9206
9207   done
9208 fi
9209
9210 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9211   for ncn_progname in as; do
9212     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9213 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9214     if test -x $with_build_time_tools/${ncn_progname}; then
9215       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9216       echo "$as_me:$LINENO: result: yes" >&5
9217 echo "${ECHO_T}yes" >&6
9218       break
9219     else
9220       echo "$as_me:$LINENO: result: no" >&5
9221 echo "${ECHO_T}no" >&6
9222     fi
9223   done
9224 fi
9225
9226 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9227   for ncn_progname in as; do
9228     if test -n "$ncn_target_tool_prefix"; then
9229       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9230 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9231 echo "$as_me:$LINENO: checking for $ac_word" >&5
9232 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9233 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9234   echo $ECHO_N "(cached) $ECHO_C" >&6
9235 else
9236   if test -n "$AS_FOR_TARGET"; then
9237   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9238 else
9239 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9240 for as_dir in $PATH
9241 do
9242   IFS=$as_save_IFS
9243   test -z "$as_dir" && as_dir=.
9244   for ac_exec_ext in '' $ac_executable_extensions; do
9245   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9246     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9247     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9248     break 2
9249   fi
9250 done
9251 done
9252
9253 fi
9254 fi
9255 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9256 if test -n "$AS_FOR_TARGET"; then
9257   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9258 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9259 else
9260   echo "$as_me:$LINENO: result: no" >&5
9261 echo "${ECHO_T}no" >&6
9262 fi
9263
9264     fi
9265     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9266       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9267 set dummy ${ncn_progname}; ac_word=$2
9268 echo "$as_me:$LINENO: checking for $ac_word" >&5
9269 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9270 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9271   echo $ECHO_N "(cached) $ECHO_C" >&6
9272 else
9273   if test -n "$AS_FOR_TARGET"; then
9274   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9275 else
9276 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9277 for as_dir in $PATH
9278 do
9279   IFS=$as_save_IFS
9280   test -z "$as_dir" && as_dir=.
9281   for ac_exec_ext in '' $ac_executable_extensions; do
9282   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9283     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9284     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9285     break 2
9286   fi
9287 done
9288 done
9289
9290 fi
9291 fi
9292 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9293 if test -n "$AS_FOR_TARGET"; then
9294   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9295 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9296 else
9297   echo "$as_me:$LINENO: result: no" >&5
9298 echo "${ECHO_T}no" >&6
9299 fi
9300
9301     fi
9302     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9303   done
9304 fi
9305
9306 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9307   set dummy as
9308   if test $build = $target ; then
9309     AS_FOR_TARGET="$2"
9310   else
9311     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9312   fi
9313 else
9314   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9315 fi
9316
9317 else
9318   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9319 fi
9320
9321
9322
9323
9324 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9325   if test -n "$with_build_time_tools"; then
9326     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9327 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9328     if test -x $with_build_time_tools/dlltool; then
9329       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9330       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9331       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9332 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9333     else
9334       echo "$as_me:$LINENO: result: no" >&5
9335 echo "${ECHO_T}no" >&6
9336     fi
9337   elif test $build != $host && test $have_gcc_for_target = yes; then
9338     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9339     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9340     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9341   fi
9342 fi
9343 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9344   # Extract the first word of "dlltool", so it can be a program name with args.
9345 set dummy dlltool; ac_word=$2
9346 echo "$as_me:$LINENO: checking for $ac_word" >&5
9347 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9348 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9349   echo $ECHO_N "(cached) $ECHO_C" >&6
9350 else
9351   case $DLLTOOL_FOR_TARGET in
9352   [\\/]* | ?:[\\/]*)
9353   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9354   ;;
9355   *)
9356   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9357 for as_dir in $gcc_cv_tool_dirs
9358 do
9359   IFS=$as_save_IFS
9360   test -z "$as_dir" && as_dir=.
9361   for ac_exec_ext in '' $ac_executable_extensions; do
9362   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9363     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9364     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9365     break 2
9366   fi
9367 done
9368 done
9369
9370   ;;
9371 esac
9372 fi
9373 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9374
9375 if test -n "$DLLTOOL_FOR_TARGET"; then
9376   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9377 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9378 else
9379   echo "$as_me:$LINENO: result: no" >&5
9380 echo "${ECHO_T}no" >&6
9381 fi
9382
9383 fi
9384 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9385
9386
9387 if test -n "$DLLTOOL_FOR_TARGET"; then
9388   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9389 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9390   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9391 fi
9392
9393 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9394   for ncn_progname in dlltool; do
9395     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9396 set dummy ${ncn_progname}; ac_word=$2
9397 echo "$as_me:$LINENO: checking for $ac_word" >&5
9398 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9399 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9400   echo $ECHO_N "(cached) $ECHO_C" >&6
9401 else
9402   if test -n "$DLLTOOL_FOR_TARGET"; then
9403   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9404 else
9405 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9406 for as_dir in $PATH
9407 do
9408   IFS=$as_save_IFS
9409   test -z "$as_dir" && as_dir=.
9410   for ac_exec_ext in '' $ac_executable_extensions; do
9411   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9412     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9413     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9414     break 2
9415   fi
9416 done
9417 done
9418
9419 fi
9420 fi
9421 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9422 if test -n "$DLLTOOL_FOR_TARGET"; then
9423   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9424 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9425 else
9426   echo "$as_me:$LINENO: result: no" >&5
9427 echo "${ECHO_T}no" >&6
9428 fi
9429
9430   done
9431 fi
9432
9433 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9434   for ncn_progname in dlltool; do
9435     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9436 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9437     if test -x $with_build_time_tools/${ncn_progname}; then
9438       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9439       echo "$as_me:$LINENO: result: yes" >&5
9440 echo "${ECHO_T}yes" >&6
9441       break
9442     else
9443       echo "$as_me:$LINENO: result: no" >&5
9444 echo "${ECHO_T}no" >&6
9445     fi
9446   done
9447 fi
9448
9449 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9450   for ncn_progname in dlltool; do
9451     if test -n "$ncn_target_tool_prefix"; then
9452       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9453 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9454 echo "$as_me:$LINENO: checking for $ac_word" >&5
9455 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9456 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9457   echo $ECHO_N "(cached) $ECHO_C" >&6
9458 else
9459   if test -n "$DLLTOOL_FOR_TARGET"; then
9460   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9461 else
9462 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9463 for as_dir in $PATH
9464 do
9465   IFS=$as_save_IFS
9466   test -z "$as_dir" && as_dir=.
9467   for ac_exec_ext in '' $ac_executable_extensions; do
9468   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9469     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9470     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9471     break 2
9472   fi
9473 done
9474 done
9475
9476 fi
9477 fi
9478 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9479 if test -n "$DLLTOOL_FOR_TARGET"; then
9480   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9481 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9482 else
9483   echo "$as_me:$LINENO: result: no" >&5
9484 echo "${ECHO_T}no" >&6
9485 fi
9486
9487     fi
9488     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9489       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9490 set dummy ${ncn_progname}; ac_word=$2
9491 echo "$as_me:$LINENO: checking for $ac_word" >&5
9492 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9493 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9494   echo $ECHO_N "(cached) $ECHO_C" >&6
9495 else
9496   if test -n "$DLLTOOL_FOR_TARGET"; then
9497   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9498 else
9499 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9500 for as_dir in $PATH
9501 do
9502   IFS=$as_save_IFS
9503   test -z "$as_dir" && as_dir=.
9504   for ac_exec_ext in '' $ac_executable_extensions; do
9505   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9506     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9507     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9508     break 2
9509   fi
9510 done
9511 done
9512
9513 fi
9514 fi
9515 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9516 if test -n "$DLLTOOL_FOR_TARGET"; then
9517   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9518 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9519 else
9520   echo "$as_me:$LINENO: result: no" >&5
9521 echo "${ECHO_T}no" >&6
9522 fi
9523
9524     fi
9525     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9526   done
9527 fi
9528
9529 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9530   set dummy dlltool
9531   if test $build = $target ; then
9532     DLLTOOL_FOR_TARGET="$2"
9533   else
9534     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9535   fi
9536 else
9537   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9538 fi
9539
9540 else
9541   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9542 fi
9543
9544
9545
9546
9547 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9548   if test -n "$with_build_time_tools"; then
9549     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9550 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9551     if test -x $with_build_time_tools/ld; then
9552       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9553       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9554       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9555 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9556     else
9557       echo "$as_me:$LINENO: result: no" >&5
9558 echo "${ECHO_T}no" >&6
9559     fi
9560   elif test $build != $host && test $have_gcc_for_target = yes; then
9561     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9562     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9563     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9564   fi
9565 fi
9566 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9567   # Extract the first word of "ld", so it can be a program name with args.
9568 set dummy ld; ac_word=$2
9569 echo "$as_me:$LINENO: checking for $ac_word" >&5
9570 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9571 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9572   echo $ECHO_N "(cached) $ECHO_C" >&6
9573 else
9574   case $LD_FOR_TARGET in
9575   [\\/]* | ?:[\\/]*)
9576   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9577   ;;
9578   *)
9579   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9580 for as_dir in $gcc_cv_tool_dirs
9581 do
9582   IFS=$as_save_IFS
9583   test -z "$as_dir" && as_dir=.
9584   for ac_exec_ext in '' $ac_executable_extensions; do
9585   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9586     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9587     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9588     break 2
9589   fi
9590 done
9591 done
9592
9593   ;;
9594 esac
9595 fi
9596 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9597
9598 if test -n "$LD_FOR_TARGET"; then
9599   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9600 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9601 else
9602   echo "$as_me:$LINENO: result: no" >&5
9603 echo "${ECHO_T}no" >&6
9604 fi
9605
9606 fi
9607 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9608
9609
9610 if test -n "$LD_FOR_TARGET"; then
9611   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9612 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9613   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9614 fi
9615
9616 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9617   for ncn_progname in ld; do
9618     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9619 set dummy ${ncn_progname}; ac_word=$2
9620 echo "$as_me:$LINENO: checking for $ac_word" >&5
9621 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9622 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9623   echo $ECHO_N "(cached) $ECHO_C" >&6
9624 else
9625   if test -n "$LD_FOR_TARGET"; then
9626   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9627 else
9628 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9629 for as_dir in $PATH
9630 do
9631   IFS=$as_save_IFS
9632   test -z "$as_dir" && as_dir=.
9633   for ac_exec_ext in '' $ac_executable_extensions; do
9634   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9635     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9636     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9637     break 2
9638   fi
9639 done
9640 done
9641
9642 fi
9643 fi
9644 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9645 if test -n "$LD_FOR_TARGET"; then
9646   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9647 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9648 else
9649   echo "$as_me:$LINENO: result: no" >&5
9650 echo "${ECHO_T}no" >&6
9651 fi
9652
9653   done
9654 fi
9655
9656 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9657   for ncn_progname in ld; do
9658     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9659 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9660     if test -x $with_build_time_tools/${ncn_progname}; then
9661       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9662       echo "$as_me:$LINENO: result: yes" >&5
9663 echo "${ECHO_T}yes" >&6
9664       break
9665     else
9666       echo "$as_me:$LINENO: result: no" >&5
9667 echo "${ECHO_T}no" >&6
9668     fi
9669   done
9670 fi
9671
9672 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9673   for ncn_progname in ld; do
9674     if test -n "$ncn_target_tool_prefix"; then
9675       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9676 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9677 echo "$as_me:$LINENO: checking for $ac_word" >&5
9678 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9679 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9680   echo $ECHO_N "(cached) $ECHO_C" >&6
9681 else
9682   if test -n "$LD_FOR_TARGET"; then
9683   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9684 else
9685 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9686 for as_dir in $PATH
9687 do
9688   IFS=$as_save_IFS
9689   test -z "$as_dir" && as_dir=.
9690   for ac_exec_ext in '' $ac_executable_extensions; do
9691   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9692     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9693     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9694     break 2
9695   fi
9696 done
9697 done
9698
9699 fi
9700 fi
9701 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9702 if test -n "$LD_FOR_TARGET"; then
9703   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9704 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9705 else
9706   echo "$as_me:$LINENO: result: no" >&5
9707 echo "${ECHO_T}no" >&6
9708 fi
9709
9710     fi
9711     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9712       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9713 set dummy ${ncn_progname}; ac_word=$2
9714 echo "$as_me:$LINENO: checking for $ac_word" >&5
9715 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9716 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9717   echo $ECHO_N "(cached) $ECHO_C" >&6
9718 else
9719   if test -n "$LD_FOR_TARGET"; then
9720   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9721 else
9722 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9723 for as_dir in $PATH
9724 do
9725   IFS=$as_save_IFS
9726   test -z "$as_dir" && as_dir=.
9727   for ac_exec_ext in '' $ac_executable_extensions; do
9728   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9729     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9730     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9731     break 2
9732   fi
9733 done
9734 done
9735
9736 fi
9737 fi
9738 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9739 if test -n "$LD_FOR_TARGET"; then
9740   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9741 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9742 else
9743   echo "$as_me:$LINENO: result: no" >&5
9744 echo "${ECHO_T}no" >&6
9745 fi
9746
9747     fi
9748     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9749   done
9750 fi
9751
9752 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9753   set dummy ld
9754   if test $build = $target ; then
9755     LD_FOR_TARGET="$2"
9756   else
9757     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9758   fi
9759 else
9760   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9761 fi
9762
9763 else
9764   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9765 fi
9766
9767
9768
9769
9770 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9771   if test -n "$with_build_time_tools"; then
9772     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9773 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9774     if test -x $with_build_time_tools/lipo; then
9775       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9776       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9777       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9778 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9779     else
9780       echo "$as_me:$LINENO: result: no" >&5
9781 echo "${ECHO_T}no" >&6
9782     fi
9783   elif test $build != $host && test $have_gcc_for_target = yes; then
9784     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9785     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9786     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9787   fi
9788 fi
9789 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9790   # Extract the first word of "lipo", so it can be a program name with args.
9791 set dummy lipo; ac_word=$2
9792 echo "$as_me:$LINENO: checking for $ac_word" >&5
9793 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9794 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9795   echo $ECHO_N "(cached) $ECHO_C" >&6
9796 else
9797   case $LIPO_FOR_TARGET in
9798   [\\/]* | ?:[\\/]*)
9799   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9800   ;;
9801   *)
9802   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9803 for as_dir in $gcc_cv_tool_dirs
9804 do
9805   IFS=$as_save_IFS
9806   test -z "$as_dir" && as_dir=.
9807   for ac_exec_ext in '' $ac_executable_extensions; do
9808   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9809     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9810     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9811     break 2
9812   fi
9813 done
9814 done
9815
9816   ;;
9817 esac
9818 fi
9819 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9820
9821 if test -n "$LIPO_FOR_TARGET"; then
9822   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9823 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9824 else
9825   echo "$as_me:$LINENO: result: no" >&5
9826 echo "${ECHO_T}no" >&6
9827 fi
9828
9829 fi
9830 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9831
9832
9833 if test -n "$LIPO_FOR_TARGET"; then
9834   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9835 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9836   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9837 fi
9838
9839 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9840   for ncn_progname in lipo; do
9841     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9842 set dummy ${ncn_progname}; ac_word=$2
9843 echo "$as_me:$LINENO: checking for $ac_word" >&5
9844 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9845 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9846   echo $ECHO_N "(cached) $ECHO_C" >&6
9847 else
9848   if test -n "$LIPO_FOR_TARGET"; then
9849   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9850 else
9851 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9852 for as_dir in $PATH
9853 do
9854   IFS=$as_save_IFS
9855   test -z "$as_dir" && as_dir=.
9856   for ac_exec_ext in '' $ac_executable_extensions; do
9857   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9858     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9859     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9860     break 2
9861   fi
9862 done
9863 done
9864
9865 fi
9866 fi
9867 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9868 if test -n "$LIPO_FOR_TARGET"; then
9869   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9870 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9871 else
9872   echo "$as_me:$LINENO: result: no" >&5
9873 echo "${ECHO_T}no" >&6
9874 fi
9875
9876   done
9877 fi
9878
9879 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9880   for ncn_progname in lipo; do
9881     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9882 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9883     if test -x $with_build_time_tools/${ncn_progname}; then
9884       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9885       echo "$as_me:$LINENO: result: yes" >&5
9886 echo "${ECHO_T}yes" >&6
9887       break
9888     else
9889       echo "$as_me:$LINENO: result: no" >&5
9890 echo "${ECHO_T}no" >&6
9891     fi
9892   done
9893 fi
9894
9895 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9896   for ncn_progname in lipo; do
9897     if test -n "$ncn_target_tool_prefix"; then
9898       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9899 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9900 echo "$as_me:$LINENO: checking for $ac_word" >&5
9901 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9902 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9903   echo $ECHO_N "(cached) $ECHO_C" >&6
9904 else
9905   if test -n "$LIPO_FOR_TARGET"; then
9906   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9907 else
9908 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9909 for as_dir in $PATH
9910 do
9911   IFS=$as_save_IFS
9912   test -z "$as_dir" && as_dir=.
9913   for ac_exec_ext in '' $ac_executable_extensions; do
9914   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9915     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9916     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9917     break 2
9918   fi
9919 done
9920 done
9921
9922 fi
9923 fi
9924 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9925 if test -n "$LIPO_FOR_TARGET"; then
9926   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9927 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9928 else
9929   echo "$as_me:$LINENO: result: no" >&5
9930 echo "${ECHO_T}no" >&6
9931 fi
9932
9933     fi
9934     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9935       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9936 set dummy ${ncn_progname}; ac_word=$2
9937 echo "$as_me:$LINENO: checking for $ac_word" >&5
9938 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9939 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9940   echo $ECHO_N "(cached) $ECHO_C" >&6
9941 else
9942   if test -n "$LIPO_FOR_TARGET"; then
9943   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9944 else
9945 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9946 for as_dir in $PATH
9947 do
9948   IFS=$as_save_IFS
9949   test -z "$as_dir" && as_dir=.
9950   for ac_exec_ext in '' $ac_executable_extensions; do
9951   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9952     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9953     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9954     break 2
9955   fi
9956 done
9957 done
9958
9959 fi
9960 fi
9961 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9962 if test -n "$LIPO_FOR_TARGET"; then
9963   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9964 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9965 else
9966   echo "$as_me:$LINENO: result: no" >&5
9967 echo "${ECHO_T}no" >&6
9968 fi
9969
9970     fi
9971     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9972   done
9973 fi
9974
9975 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9976   set dummy lipo
9977   if test $build = $target ; then
9978     LIPO_FOR_TARGET="$2"
9979   else
9980     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9981   fi
9982 else
9983   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9984 fi
9985
9986 else
9987   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9988 fi
9989
9990
9991
9992
9993 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9994   if test -n "$with_build_time_tools"; then
9995     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9996 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9997     if test -x $with_build_time_tools/nm; then
9998       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9999       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10000       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
10001 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
10002     else
10003       echo "$as_me:$LINENO: result: no" >&5
10004 echo "${ECHO_T}no" >&6
10005     fi
10006   elif test $build != $host && test $have_gcc_for_target = yes; then
10007     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
10008     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
10009     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
10010   fi
10011 fi
10012 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10013   # Extract the first word of "nm", so it can be a program name with args.
10014 set dummy nm; ac_word=$2
10015 echo "$as_me:$LINENO: checking for $ac_word" >&5
10016 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10017 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
10018   echo $ECHO_N "(cached) $ECHO_C" >&6
10019 else
10020   case $NM_FOR_TARGET in
10021   [\\/]* | ?:[\\/]*)
10022   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
10023   ;;
10024   *)
10025   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10026 for as_dir in $gcc_cv_tool_dirs
10027 do
10028   IFS=$as_save_IFS
10029   test -z "$as_dir" && as_dir=.
10030   for ac_exec_ext in '' $ac_executable_extensions; do
10031   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10032     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10033     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10034     break 2
10035   fi
10036 done
10037 done
10038
10039   ;;
10040 esac
10041 fi
10042 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10043
10044 if test -n "$NM_FOR_TARGET"; then
10045   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10046 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10047 else
10048   echo "$as_me:$LINENO: result: no" >&5
10049 echo "${ECHO_T}no" >&6
10050 fi
10051
10052 fi
10053 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
10054
10055
10056 if test -n "$NM_FOR_TARGET"; then
10057   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
10058 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10059   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10060 fi
10061
10062 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
10063   for ncn_progname in nm; do
10064     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10065 set dummy ${ncn_progname}; ac_word=$2
10066 echo "$as_me:$LINENO: checking for $ac_word" >&5
10067 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10068 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10069   echo $ECHO_N "(cached) $ECHO_C" >&6
10070 else
10071   if test -n "$NM_FOR_TARGET"; then
10072   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10073 else
10074 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10075 for as_dir in $PATH
10076 do
10077   IFS=$as_save_IFS
10078   test -z "$as_dir" && as_dir=.
10079   for ac_exec_ext in '' $ac_executable_extensions; do
10080   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10081     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10082     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10083     break 2
10084   fi
10085 done
10086 done
10087
10088 fi
10089 fi
10090 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10091 if test -n "$NM_FOR_TARGET"; then
10092   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10093 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10094 else
10095   echo "$as_me:$LINENO: result: no" >&5
10096 echo "${ECHO_T}no" >&6
10097 fi
10098
10099   done
10100 fi
10101
10102 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
10103   for ncn_progname in nm; do
10104     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10105 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10106     if test -x $with_build_time_tools/${ncn_progname}; then
10107       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10108       echo "$as_me:$LINENO: result: yes" >&5
10109 echo "${ECHO_T}yes" >&6
10110       break
10111     else
10112       echo "$as_me:$LINENO: result: no" >&5
10113 echo "${ECHO_T}no" >&6
10114     fi
10115   done
10116 fi
10117
10118 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
10119   for ncn_progname in nm; do
10120     if test -n "$ncn_target_tool_prefix"; then
10121       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10122 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10123 echo "$as_me:$LINENO: checking for $ac_word" >&5
10124 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10125 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10126   echo $ECHO_N "(cached) $ECHO_C" >&6
10127 else
10128   if test -n "$NM_FOR_TARGET"; then
10129   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10130 else
10131 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10132 for as_dir in $PATH
10133 do
10134   IFS=$as_save_IFS
10135   test -z "$as_dir" && as_dir=.
10136   for ac_exec_ext in '' $ac_executable_extensions; do
10137   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10138     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10139     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10140     break 2
10141   fi
10142 done
10143 done
10144
10145 fi
10146 fi
10147 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10148 if test -n "$NM_FOR_TARGET"; then
10149   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10150 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10151 else
10152   echo "$as_me:$LINENO: result: no" >&5
10153 echo "${ECHO_T}no" >&6
10154 fi
10155
10156     fi
10157     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10158       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10159 set dummy ${ncn_progname}; ac_word=$2
10160 echo "$as_me:$LINENO: checking for $ac_word" >&5
10161 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10162 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10163   echo $ECHO_N "(cached) $ECHO_C" >&6
10164 else
10165   if test -n "$NM_FOR_TARGET"; then
10166   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10167 else
10168 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10169 for as_dir in $PATH
10170 do
10171   IFS=$as_save_IFS
10172   test -z "$as_dir" && as_dir=.
10173   for ac_exec_ext in '' $ac_executable_extensions; do
10174   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10175     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10176     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10177     break 2
10178   fi
10179 done
10180 done
10181
10182 fi
10183 fi
10184 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10185 if test -n "$NM_FOR_TARGET"; then
10186   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10187 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10188 else
10189   echo "$as_me:$LINENO: result: no" >&5
10190 echo "${ECHO_T}no" >&6
10191 fi
10192
10193     fi
10194     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10195   done
10196 fi
10197
10198 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10199   set dummy nm
10200   if test $build = $target ; then
10201     NM_FOR_TARGET="$2"
10202   else
10203     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10204   fi
10205 else
10206   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10207 fi
10208
10209 else
10210   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10211 fi
10212
10213
10214
10215
10216 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10217   if test -n "$with_build_time_tools"; then
10218     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10219 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10220     if test -x $with_build_time_tools/objdump; then
10221       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10222       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10223       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10224 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10225     else
10226       echo "$as_me:$LINENO: result: no" >&5
10227 echo "${ECHO_T}no" >&6
10228     fi
10229   elif test $build != $host && test $have_gcc_for_target = yes; then
10230     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10231     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10232     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10233   fi
10234 fi
10235 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10236   # Extract the first word of "objdump", so it can be a program name with args.
10237 set dummy objdump; ac_word=$2
10238 echo "$as_me:$LINENO: checking for $ac_word" >&5
10239 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10240 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10241   echo $ECHO_N "(cached) $ECHO_C" >&6
10242 else
10243   case $OBJDUMP_FOR_TARGET in
10244   [\\/]* | ?:[\\/]*)
10245   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10246   ;;
10247   *)
10248   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10249 for as_dir in $gcc_cv_tool_dirs
10250 do
10251   IFS=$as_save_IFS
10252   test -z "$as_dir" && as_dir=.
10253   for ac_exec_ext in '' $ac_executable_extensions; do
10254   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10255     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10256     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10257     break 2
10258   fi
10259 done
10260 done
10261
10262   ;;
10263 esac
10264 fi
10265 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10266
10267 if test -n "$OBJDUMP_FOR_TARGET"; then
10268   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10269 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10270 else
10271   echo "$as_me:$LINENO: result: no" >&5
10272 echo "${ECHO_T}no" >&6
10273 fi
10274
10275 fi
10276 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10277
10278
10279 if test -n "$OBJDUMP_FOR_TARGET"; then
10280   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10281 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10282   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10283 fi
10284
10285 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10286   for ncn_progname in objdump; do
10287     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10288 set dummy ${ncn_progname}; ac_word=$2
10289 echo "$as_me:$LINENO: checking for $ac_word" >&5
10290 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10291 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10292   echo $ECHO_N "(cached) $ECHO_C" >&6
10293 else
10294   if test -n "$OBJDUMP_FOR_TARGET"; then
10295   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10296 else
10297 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10298 for as_dir in $PATH
10299 do
10300   IFS=$as_save_IFS
10301   test -z "$as_dir" && as_dir=.
10302   for ac_exec_ext in '' $ac_executable_extensions; do
10303   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10304     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10305     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10306     break 2
10307   fi
10308 done
10309 done
10310
10311 fi
10312 fi
10313 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10314 if test -n "$OBJDUMP_FOR_TARGET"; then
10315   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10316 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10317 else
10318   echo "$as_me:$LINENO: result: no" >&5
10319 echo "${ECHO_T}no" >&6
10320 fi
10321
10322   done
10323 fi
10324
10325 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10326   for ncn_progname in objdump; do
10327     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10328 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10329     if test -x $with_build_time_tools/${ncn_progname}; then
10330       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10331       echo "$as_me:$LINENO: result: yes" >&5
10332 echo "${ECHO_T}yes" >&6
10333       break
10334     else
10335       echo "$as_me:$LINENO: result: no" >&5
10336 echo "${ECHO_T}no" >&6
10337     fi
10338   done
10339 fi
10340
10341 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10342   for ncn_progname in objdump; do
10343     if test -n "$ncn_target_tool_prefix"; then
10344       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10345 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10346 echo "$as_me:$LINENO: checking for $ac_word" >&5
10347 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10348 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10349   echo $ECHO_N "(cached) $ECHO_C" >&6
10350 else
10351   if test -n "$OBJDUMP_FOR_TARGET"; then
10352   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10353 else
10354 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10355 for as_dir in $PATH
10356 do
10357   IFS=$as_save_IFS
10358   test -z "$as_dir" && as_dir=.
10359   for ac_exec_ext in '' $ac_executable_extensions; do
10360   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10361     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10362     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10363     break 2
10364   fi
10365 done
10366 done
10367
10368 fi
10369 fi
10370 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10371 if test -n "$OBJDUMP_FOR_TARGET"; then
10372   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10373 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10374 else
10375   echo "$as_me:$LINENO: result: no" >&5
10376 echo "${ECHO_T}no" >&6
10377 fi
10378
10379     fi
10380     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10381       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10382 set dummy ${ncn_progname}; ac_word=$2
10383 echo "$as_me:$LINENO: checking for $ac_word" >&5
10384 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10385 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10386   echo $ECHO_N "(cached) $ECHO_C" >&6
10387 else
10388   if test -n "$OBJDUMP_FOR_TARGET"; then
10389   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10390 else
10391 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10392 for as_dir in $PATH
10393 do
10394   IFS=$as_save_IFS
10395   test -z "$as_dir" && as_dir=.
10396   for ac_exec_ext in '' $ac_executable_extensions; do
10397   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10398     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10399     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10400     break 2
10401   fi
10402 done
10403 done
10404
10405 fi
10406 fi
10407 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10408 if test -n "$OBJDUMP_FOR_TARGET"; then
10409   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10410 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10411 else
10412   echo "$as_me:$LINENO: result: no" >&5
10413 echo "${ECHO_T}no" >&6
10414 fi
10415
10416     fi
10417     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10418   done
10419 fi
10420
10421 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10422   set dummy objdump
10423   if test $build = $target ; then
10424     OBJDUMP_FOR_TARGET="$2"
10425   else
10426     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10427   fi
10428 else
10429   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10430 fi
10431
10432 else
10433   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10434 fi
10435
10436
10437
10438
10439 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10440   if test -n "$with_build_time_tools"; then
10441     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10442 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10443     if test -x $with_build_time_tools/ranlib; then
10444       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10445       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10446       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10447 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10448     else
10449       echo "$as_me:$LINENO: result: no" >&5
10450 echo "${ECHO_T}no" >&6
10451     fi
10452   elif test $build != $host && test $have_gcc_for_target = yes; then
10453     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10454     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10455     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10456   fi
10457 fi
10458 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10459   # Extract the first word of "ranlib", so it can be a program name with args.
10460 set dummy ranlib; ac_word=$2
10461 echo "$as_me:$LINENO: checking for $ac_word" >&5
10462 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10463 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10464   echo $ECHO_N "(cached) $ECHO_C" >&6
10465 else
10466   case $RANLIB_FOR_TARGET in
10467   [\\/]* | ?:[\\/]*)
10468   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10469   ;;
10470   *)
10471   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10472 for as_dir in $gcc_cv_tool_dirs
10473 do
10474   IFS=$as_save_IFS
10475   test -z "$as_dir" && as_dir=.
10476   for ac_exec_ext in '' $ac_executable_extensions; do
10477   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10478     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10479     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10480     break 2
10481   fi
10482 done
10483 done
10484
10485   ;;
10486 esac
10487 fi
10488 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10489
10490 if test -n "$RANLIB_FOR_TARGET"; then
10491   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10492 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10493 else
10494   echo "$as_me:$LINENO: result: no" >&5
10495 echo "${ECHO_T}no" >&6
10496 fi
10497
10498 fi
10499 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10500
10501
10502 if test -n "$RANLIB_FOR_TARGET"; then
10503   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10504 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10505   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10506 fi
10507
10508 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10509   for ncn_progname in ranlib; do
10510     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10511 set dummy ${ncn_progname}; ac_word=$2
10512 echo "$as_me:$LINENO: checking for $ac_word" >&5
10513 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10514 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10515   echo $ECHO_N "(cached) $ECHO_C" >&6
10516 else
10517   if test -n "$RANLIB_FOR_TARGET"; then
10518   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10519 else
10520 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10521 for as_dir in $PATH
10522 do
10523   IFS=$as_save_IFS
10524   test -z "$as_dir" && as_dir=.
10525   for ac_exec_ext in '' $ac_executable_extensions; do
10526   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10527     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10528     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10529     break 2
10530   fi
10531 done
10532 done
10533
10534 fi
10535 fi
10536 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10537 if test -n "$RANLIB_FOR_TARGET"; then
10538   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10539 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10540 else
10541   echo "$as_me:$LINENO: result: no" >&5
10542 echo "${ECHO_T}no" >&6
10543 fi
10544
10545   done
10546 fi
10547
10548 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10549   for ncn_progname in ranlib; do
10550     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10551 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10552     if test -x $with_build_time_tools/${ncn_progname}; then
10553       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10554       echo "$as_me:$LINENO: result: yes" >&5
10555 echo "${ECHO_T}yes" >&6
10556       break
10557     else
10558       echo "$as_me:$LINENO: result: no" >&5
10559 echo "${ECHO_T}no" >&6
10560     fi
10561   done
10562 fi
10563
10564 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10565   for ncn_progname in ranlib; do
10566     if test -n "$ncn_target_tool_prefix"; then
10567       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10568 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10569 echo "$as_me:$LINENO: checking for $ac_word" >&5
10570 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10571 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10572   echo $ECHO_N "(cached) $ECHO_C" >&6
10573 else
10574   if test -n "$RANLIB_FOR_TARGET"; then
10575   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10576 else
10577 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10578 for as_dir in $PATH
10579 do
10580   IFS=$as_save_IFS
10581   test -z "$as_dir" && as_dir=.
10582   for ac_exec_ext in '' $ac_executable_extensions; do
10583   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10584     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10585     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10586     break 2
10587   fi
10588 done
10589 done
10590
10591 fi
10592 fi
10593 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10594 if test -n "$RANLIB_FOR_TARGET"; then
10595   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10596 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10597 else
10598   echo "$as_me:$LINENO: result: no" >&5
10599 echo "${ECHO_T}no" >&6
10600 fi
10601
10602     fi
10603     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10604       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10605 set dummy ${ncn_progname}; ac_word=$2
10606 echo "$as_me:$LINENO: checking for $ac_word" >&5
10607 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10608 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10609   echo $ECHO_N "(cached) $ECHO_C" >&6
10610 else
10611   if test -n "$RANLIB_FOR_TARGET"; then
10612   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10613 else
10614 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10615 for as_dir in $PATH
10616 do
10617   IFS=$as_save_IFS
10618   test -z "$as_dir" && as_dir=.
10619   for ac_exec_ext in '' $ac_executable_extensions; do
10620   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10621     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10622     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10623     break 2
10624   fi
10625 done
10626 done
10627
10628 fi
10629 fi
10630 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10631 if test -n "$RANLIB_FOR_TARGET"; then
10632   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10633 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10634 else
10635   echo "$as_me:$LINENO: result: no" >&5
10636 echo "${ECHO_T}no" >&6
10637 fi
10638
10639     fi
10640     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10641   done
10642 fi
10643
10644 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10645   set dummy ranlib
10646   if test $build = $target ; then
10647     RANLIB_FOR_TARGET="$2"
10648   else
10649     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10650   fi
10651 else
10652   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10653 fi
10654
10655 else
10656   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10657 fi
10658
10659
10660
10661
10662 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10663   if test -n "$with_build_time_tools"; then
10664     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10665 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10666     if test -x $with_build_time_tools/strip; then
10667       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10668       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10669       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10670 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10671     else
10672       echo "$as_me:$LINENO: result: no" >&5
10673 echo "${ECHO_T}no" >&6
10674     fi
10675   elif test $build != $host && test $have_gcc_for_target = yes; then
10676     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10677     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10678     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10679   fi
10680 fi
10681 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10682   # Extract the first word of "strip", so it can be a program name with args.
10683 set dummy strip; ac_word=$2
10684 echo "$as_me:$LINENO: checking for $ac_word" >&5
10685 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10686 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10687   echo $ECHO_N "(cached) $ECHO_C" >&6
10688 else
10689   case $STRIP_FOR_TARGET in
10690   [\\/]* | ?:[\\/]*)
10691   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10692   ;;
10693   *)
10694   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10695 for as_dir in $gcc_cv_tool_dirs
10696 do
10697   IFS=$as_save_IFS
10698   test -z "$as_dir" && as_dir=.
10699   for ac_exec_ext in '' $ac_executable_extensions; do
10700   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10701     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10702     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10703     break 2
10704   fi
10705 done
10706 done
10707
10708   ;;
10709 esac
10710 fi
10711 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10712
10713 if test -n "$STRIP_FOR_TARGET"; then
10714   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10715 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10716 else
10717   echo "$as_me:$LINENO: result: no" >&5
10718 echo "${ECHO_T}no" >&6
10719 fi
10720
10721 fi
10722 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10723
10724
10725 if test -n "$STRIP_FOR_TARGET"; then
10726   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10727 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10728   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10729 fi
10730
10731 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10732   for ncn_progname in strip; do
10733     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10734 set dummy ${ncn_progname}; ac_word=$2
10735 echo "$as_me:$LINENO: checking for $ac_word" >&5
10736 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10737 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10738   echo $ECHO_N "(cached) $ECHO_C" >&6
10739 else
10740   if test -n "$STRIP_FOR_TARGET"; then
10741   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10742 else
10743 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10744 for as_dir in $PATH
10745 do
10746   IFS=$as_save_IFS
10747   test -z "$as_dir" && as_dir=.
10748   for ac_exec_ext in '' $ac_executable_extensions; do
10749   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10750     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10751     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10752     break 2
10753   fi
10754 done
10755 done
10756
10757 fi
10758 fi
10759 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10760 if test -n "$STRIP_FOR_TARGET"; then
10761   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10762 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10763 else
10764   echo "$as_me:$LINENO: result: no" >&5
10765 echo "${ECHO_T}no" >&6
10766 fi
10767
10768   done
10769 fi
10770
10771 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10772   for ncn_progname in strip; do
10773     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10774 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10775     if test -x $with_build_time_tools/${ncn_progname}; then
10776       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10777       echo "$as_me:$LINENO: result: yes" >&5
10778 echo "${ECHO_T}yes" >&6
10779       break
10780     else
10781       echo "$as_me:$LINENO: result: no" >&5
10782 echo "${ECHO_T}no" >&6
10783     fi
10784   done
10785 fi
10786
10787 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10788   for ncn_progname in strip; do
10789     if test -n "$ncn_target_tool_prefix"; then
10790       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10791 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10792 echo "$as_me:$LINENO: checking for $ac_word" >&5
10793 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10794 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10795   echo $ECHO_N "(cached) $ECHO_C" >&6
10796 else
10797   if test -n "$STRIP_FOR_TARGET"; then
10798   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10799 else
10800 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10801 for as_dir in $PATH
10802 do
10803   IFS=$as_save_IFS
10804   test -z "$as_dir" && as_dir=.
10805   for ac_exec_ext in '' $ac_executable_extensions; do
10806   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10807     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10808     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10809     break 2
10810   fi
10811 done
10812 done
10813
10814 fi
10815 fi
10816 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10817 if test -n "$STRIP_FOR_TARGET"; then
10818   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10819 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10820 else
10821   echo "$as_me:$LINENO: result: no" >&5
10822 echo "${ECHO_T}no" >&6
10823 fi
10824
10825     fi
10826     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10827       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10828 set dummy ${ncn_progname}; ac_word=$2
10829 echo "$as_me:$LINENO: checking for $ac_word" >&5
10830 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10831 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10832   echo $ECHO_N "(cached) $ECHO_C" >&6
10833 else
10834   if test -n "$STRIP_FOR_TARGET"; then
10835   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10836 else
10837 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10838 for as_dir in $PATH
10839 do
10840   IFS=$as_save_IFS
10841   test -z "$as_dir" && as_dir=.
10842   for ac_exec_ext in '' $ac_executable_extensions; do
10843   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10844     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10845     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10846     break 2
10847   fi
10848 done
10849 done
10850
10851 fi
10852 fi
10853 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10854 if test -n "$STRIP_FOR_TARGET"; then
10855   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10856 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10857 else
10858   echo "$as_me:$LINENO: result: no" >&5
10859 echo "${ECHO_T}no" >&6
10860 fi
10861
10862     fi
10863     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10864   done
10865 fi
10866
10867 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10868   set dummy strip
10869   if test $build = $target ; then
10870     STRIP_FOR_TARGET="$2"
10871   else
10872     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10873   fi
10874 else
10875   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10876 fi
10877
10878 else
10879   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10880 fi
10881
10882
10883
10884
10885 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10886   if test -n "$with_build_time_tools"; then
10887     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10888 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10889     if test -x $with_build_time_tools/windres; then
10890       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10891       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10892       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10893 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10894     else
10895       echo "$as_me:$LINENO: result: no" >&5
10896 echo "${ECHO_T}no" >&6
10897     fi
10898   elif test $build != $host && test $have_gcc_for_target = yes; then
10899     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10900     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10901     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10902   fi
10903 fi
10904 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10905   # Extract the first word of "windres", so it can be a program name with args.
10906 set dummy windres; ac_word=$2
10907 echo "$as_me:$LINENO: checking for $ac_word" >&5
10908 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10909 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10910   echo $ECHO_N "(cached) $ECHO_C" >&6
10911 else
10912   case $WINDRES_FOR_TARGET in
10913   [\\/]* | ?:[\\/]*)
10914   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10915   ;;
10916   *)
10917   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10918 for as_dir in $gcc_cv_tool_dirs
10919 do
10920   IFS=$as_save_IFS
10921   test -z "$as_dir" && as_dir=.
10922   for ac_exec_ext in '' $ac_executable_extensions; do
10923   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10924     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10925     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10926     break 2
10927   fi
10928 done
10929 done
10930
10931   ;;
10932 esac
10933 fi
10934 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10935
10936 if test -n "$WINDRES_FOR_TARGET"; then
10937   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10938 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10939 else
10940   echo "$as_me:$LINENO: result: no" >&5
10941 echo "${ECHO_T}no" >&6
10942 fi
10943
10944 fi
10945 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10946
10947
10948 if test -n "$WINDRES_FOR_TARGET"; then
10949   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10950 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10951   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10952 fi
10953
10954 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10955   for ncn_progname in windres; do
10956     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10957 set dummy ${ncn_progname}; ac_word=$2
10958 echo "$as_me:$LINENO: checking for $ac_word" >&5
10959 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10960 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10961   echo $ECHO_N "(cached) $ECHO_C" >&6
10962 else
10963   if test -n "$WINDRES_FOR_TARGET"; then
10964   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10965 else
10966 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10967 for as_dir in $PATH
10968 do
10969   IFS=$as_save_IFS
10970   test -z "$as_dir" && as_dir=.
10971   for ac_exec_ext in '' $ac_executable_extensions; do
10972   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10973     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10974     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10975     break 2
10976   fi
10977 done
10978 done
10979
10980 fi
10981 fi
10982 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10983 if test -n "$WINDRES_FOR_TARGET"; then
10984   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10985 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10986 else
10987   echo "$as_me:$LINENO: result: no" >&5
10988 echo "${ECHO_T}no" >&6
10989 fi
10990
10991   done
10992 fi
10993
10994 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10995   for ncn_progname in windres; do
10996     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10997 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10998     if test -x $with_build_time_tools/${ncn_progname}; then
10999       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11000       echo "$as_me:$LINENO: result: yes" >&5
11001 echo "${ECHO_T}yes" >&6
11002       break
11003     else
11004       echo "$as_me:$LINENO: result: no" >&5
11005 echo "${ECHO_T}no" >&6
11006     fi
11007   done
11008 fi
11009
11010 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
11011   for ncn_progname in windres; do
11012     if test -n "$ncn_target_tool_prefix"; then
11013       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11014 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11015 echo "$as_me:$LINENO: checking for $ac_word" >&5
11016 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11017 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11018   echo $ECHO_N "(cached) $ECHO_C" >&6
11019 else
11020   if test -n "$WINDRES_FOR_TARGET"; then
11021   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11022 else
11023 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11024 for as_dir in $PATH
11025 do
11026   IFS=$as_save_IFS
11027   test -z "$as_dir" && as_dir=.
11028   for ac_exec_ext in '' $ac_executable_extensions; do
11029   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11030     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11031     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11032     break 2
11033   fi
11034 done
11035 done
11036
11037 fi
11038 fi
11039 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11040 if test -n "$WINDRES_FOR_TARGET"; then
11041   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11042 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11043 else
11044   echo "$as_me:$LINENO: result: no" >&5
11045 echo "${ECHO_T}no" >&6
11046 fi
11047
11048     fi
11049     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
11050       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11051 set dummy ${ncn_progname}; ac_word=$2
11052 echo "$as_me:$LINENO: checking for $ac_word" >&5
11053 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11054 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
11055   echo $ECHO_N "(cached) $ECHO_C" >&6
11056 else
11057   if test -n "$WINDRES_FOR_TARGET"; then
11058   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
11059 else
11060 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11061 for as_dir in $PATH
11062 do
11063   IFS=$as_save_IFS
11064   test -z "$as_dir" && as_dir=.
11065   for ac_exec_ext in '' $ac_executable_extensions; do
11066   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11067     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
11068     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11069     break 2
11070   fi
11071 done
11072 done
11073
11074 fi
11075 fi
11076 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
11077 if test -n "$WINDRES_FOR_TARGET"; then
11078   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
11079 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
11080 else
11081   echo "$as_me:$LINENO: result: no" >&5
11082 echo "${ECHO_T}no" >&6
11083 fi
11084
11085     fi
11086     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
11087   done
11088 fi
11089
11090 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
11091   set dummy windres
11092   if test $build = $target ; then
11093     WINDRES_FOR_TARGET="$2"
11094   else
11095     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
11096   fi
11097 else
11098   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
11099 fi
11100
11101 else
11102   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
11103 fi
11104
11105
11106
11107
11108 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11109   if test -n "$with_build_time_tools"; then
11110     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
11111 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
11112     if test -x $with_build_time_tools/windmc; then
11113       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
11114       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11115       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
11116 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
11117     else
11118       echo "$as_me:$LINENO: result: no" >&5
11119 echo "${ECHO_T}no" >&6
11120     fi
11121   elif test $build != $host && test $have_gcc_for_target = yes; then
11122     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
11123     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
11124     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11125   fi
11126 fi
11127 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
11128   # Extract the first word of "windmc", so it can be a program name with args.
11129 set dummy windmc; ac_word=$2
11130 echo "$as_me:$LINENO: checking for $ac_word" >&5
11131 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11132 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
11133   echo $ECHO_N "(cached) $ECHO_C" >&6
11134 else
11135   case $WINDMC_FOR_TARGET in
11136   [\\/]* | ?:[\\/]*)
11137   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
11138   ;;
11139   *)
11140   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11141 for as_dir in $gcc_cv_tool_dirs
11142 do
11143   IFS=$as_save_IFS
11144   test -z "$as_dir" && as_dir=.
11145   for ac_exec_ext in '' $ac_executable_extensions; do
11146   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11147     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
11148     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11149     break 2
11150   fi
11151 done
11152 done
11153
11154   ;;
11155 esac
11156 fi
11157 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11158
11159 if test -n "$WINDMC_FOR_TARGET"; then
11160   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11161 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11162 else
11163   echo "$as_me:$LINENO: result: no" >&5
11164 echo "${ECHO_T}no" >&6
11165 fi
11166
11167 fi
11168 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11169
11170
11171 if test -n "$WINDMC_FOR_TARGET"; then
11172   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11173 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11174   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11175 fi
11176
11177 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11178   for ncn_progname in windmc; do
11179     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11180 set dummy ${ncn_progname}; ac_word=$2
11181 echo "$as_me:$LINENO: checking for $ac_word" >&5
11182 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11183 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11184   echo $ECHO_N "(cached) $ECHO_C" >&6
11185 else
11186   if test -n "$WINDMC_FOR_TARGET"; then
11187   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11188 else
11189 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11190 for as_dir in $PATH
11191 do
11192   IFS=$as_save_IFS
11193   test -z "$as_dir" && as_dir=.
11194   for ac_exec_ext in '' $ac_executable_extensions; do
11195   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11196     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11197     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11198     break 2
11199   fi
11200 done
11201 done
11202
11203 fi
11204 fi
11205 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11206 if test -n "$WINDMC_FOR_TARGET"; then
11207   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11208 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11209 else
11210   echo "$as_me:$LINENO: result: no" >&5
11211 echo "${ECHO_T}no" >&6
11212 fi
11213
11214   done
11215 fi
11216
11217 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11218   for ncn_progname in windmc; do
11219     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11220 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11221     if test -x $with_build_time_tools/${ncn_progname}; then
11222       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11223       echo "$as_me:$LINENO: result: yes" >&5
11224 echo "${ECHO_T}yes" >&6
11225       break
11226     else
11227       echo "$as_me:$LINENO: result: no" >&5
11228 echo "${ECHO_T}no" >&6
11229     fi
11230   done
11231 fi
11232
11233 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11234   for ncn_progname in windmc; do
11235     if test -n "$ncn_target_tool_prefix"; then
11236       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11237 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11238 echo "$as_me:$LINENO: checking for $ac_word" >&5
11239 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11240 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11241   echo $ECHO_N "(cached) $ECHO_C" >&6
11242 else
11243   if test -n "$WINDMC_FOR_TARGET"; then
11244   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11245 else
11246 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11247 for as_dir in $PATH
11248 do
11249   IFS=$as_save_IFS
11250   test -z "$as_dir" && as_dir=.
11251   for ac_exec_ext in '' $ac_executable_extensions; do
11252   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11253     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11254     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11255     break 2
11256   fi
11257 done
11258 done
11259
11260 fi
11261 fi
11262 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11263 if test -n "$WINDMC_FOR_TARGET"; then
11264   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11265 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11266 else
11267   echo "$as_me:$LINENO: result: no" >&5
11268 echo "${ECHO_T}no" >&6
11269 fi
11270
11271     fi
11272     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11273       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11274 set dummy ${ncn_progname}; ac_word=$2
11275 echo "$as_me:$LINENO: checking for $ac_word" >&5
11276 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11277 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11278   echo $ECHO_N "(cached) $ECHO_C" >&6
11279 else
11280   if test -n "$WINDMC_FOR_TARGET"; then
11281   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11282 else
11283 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11284 for as_dir in $PATH
11285 do
11286   IFS=$as_save_IFS
11287   test -z "$as_dir" && as_dir=.
11288   for ac_exec_ext in '' $ac_executable_extensions; do
11289   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11290     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11291     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11292     break 2
11293   fi
11294 done
11295 done
11296
11297 fi
11298 fi
11299 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11300 if test -n "$WINDMC_FOR_TARGET"; then
11301   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11302 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11303 else
11304   echo "$as_me:$LINENO: result: no" >&5
11305 echo "${ECHO_T}no" >&6
11306 fi
11307
11308     fi
11309     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11310   done
11311 fi
11312
11313 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11314   set dummy windmc
11315   if test $build = $target ; then
11316     WINDMC_FOR_TARGET="$2"
11317   else
11318     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11319   fi
11320 else
11321   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11322 fi
11323
11324 else
11325   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11326 fi
11327
11328
11329 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11330
11331 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11332 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11333 if test "x${build}" != "x${host}" ; then
11334   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11335     # We already found the complete path
11336     ac_dir=`dirname $AR_FOR_TARGET`
11337     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11338 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11339   else
11340     # Canadian cross, just use what we found
11341     echo "$as_me:$LINENO: result: pre-installed" >&5
11342 echo "${ECHO_T}pre-installed" >&6
11343   fi
11344 else
11345   ok=yes
11346   case " ${configdirs} " in
11347     *" binutils "*) ;;
11348     *) ok=no ;;
11349   esac
11350
11351   if test $ok = yes; then
11352     # An in-tree tool is available and we can use it
11353     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11354     echo "$as_me:$LINENO: result: just compiled" >&5
11355 echo "${ECHO_T}just compiled" >&6
11356   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11357     # We already found the complete path
11358     ac_dir=`dirname $AR_FOR_TARGET`
11359     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11360 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11361   elif test "x$target" = "x$host"; then
11362     # We can use an host tool
11363     AR_FOR_TARGET='$(AR)'
11364     echo "$as_me:$LINENO: result: host tool" >&5
11365 echo "${ECHO_T}host tool" >&6
11366   else
11367     # We need a cross tool
11368     echo "$as_me:$LINENO: result: pre-installed" >&5
11369 echo "${ECHO_T}pre-installed" >&6
11370   fi
11371 fi
11372
11373 echo "$as_me:$LINENO: checking where to find the target as" >&5
11374 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11375 if test "x${build}" != "x${host}" ; then
11376   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11377     # We already found the complete path
11378     ac_dir=`dirname $AS_FOR_TARGET`
11379     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11380 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11381   else
11382     # Canadian cross, just use what we found
11383     echo "$as_me:$LINENO: result: pre-installed" >&5
11384 echo "${ECHO_T}pre-installed" >&6
11385   fi
11386 else
11387   ok=yes
11388   case " ${configdirs} " in
11389     *" gas "*) ;;
11390     *) ok=no ;;
11391   esac
11392
11393   if test $ok = yes; then
11394     # An in-tree tool is available and we can use it
11395     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11396     echo "$as_me:$LINENO: result: just compiled" >&5
11397 echo "${ECHO_T}just compiled" >&6
11398   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11399     # We already found the complete path
11400     ac_dir=`dirname $AS_FOR_TARGET`
11401     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11402 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11403   elif test "x$target" = "x$host"; then
11404     # We can use an host tool
11405     AS_FOR_TARGET='$(AS)'
11406     echo "$as_me:$LINENO: result: host tool" >&5
11407 echo "${ECHO_T}host tool" >&6
11408   else
11409     # We need a cross tool
11410     echo "$as_me:$LINENO: result: pre-installed" >&5
11411 echo "${ECHO_T}pre-installed" >&6
11412   fi
11413 fi
11414
11415 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11416 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11417 if test "x${build}" != "x${host}" ; then
11418   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11419     # We already found the complete path
11420     ac_dir=`dirname $CC_FOR_TARGET`
11421     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11422 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11423   else
11424     # Canadian cross, just use what we found
11425     echo "$as_me:$LINENO: result: pre-installed" >&5
11426 echo "${ECHO_T}pre-installed" >&6
11427   fi
11428 else
11429   ok=yes
11430   case " ${configdirs} " in
11431     *" gcc "*) ;;
11432     *) ok=no ;;
11433   esac
11434
11435   if test $ok = yes; then
11436     # An in-tree tool is available and we can use it
11437     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11438     echo "$as_me:$LINENO: result: just compiled" >&5
11439 echo "${ECHO_T}just compiled" >&6
11440   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11441     # We already found the complete path
11442     ac_dir=`dirname $CC_FOR_TARGET`
11443     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11444 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11445   elif test "x$target" = "x$host"; then
11446     # We can use an host tool
11447     CC_FOR_TARGET='$(CC)'
11448     echo "$as_me:$LINENO: result: host tool" >&5
11449 echo "${ECHO_T}host tool" >&6
11450   else
11451     # We need a cross tool
11452     echo "$as_me:$LINENO: result: pre-installed" >&5
11453 echo "${ECHO_T}pre-installed" >&6
11454   fi
11455 fi
11456
11457 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11458 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11459 if test "x${build}" != "x${host}" ; then
11460   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11461     # We already found the complete path
11462     ac_dir=`dirname $CXX_FOR_TARGET`
11463     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11464 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11465   else
11466     # Canadian cross, just use what we found
11467     echo "$as_me:$LINENO: result: pre-installed" >&5
11468 echo "${ECHO_T}pre-installed" >&6
11469   fi
11470 else
11471   ok=yes
11472   case " ${configdirs} " in
11473     *" gcc "*) ;;
11474     *) ok=no ;;
11475   esac
11476   case ,${enable_languages}, in
11477     *,c++,*) ;;
11478     *) ok=no ;;
11479   esac
11480   if test $ok = yes; then
11481     # An in-tree tool is available and we can use it
11482     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'
11483     echo "$as_me:$LINENO: result: just compiled" >&5
11484 echo "${ECHO_T}just compiled" >&6
11485   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11486     # We already found the complete path
11487     ac_dir=`dirname $CXX_FOR_TARGET`
11488     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11489 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11490   elif test "x$target" = "x$host"; then
11491     # We can use an host tool
11492     CXX_FOR_TARGET='$(CXX)'
11493     echo "$as_me:$LINENO: result: host tool" >&5
11494 echo "${ECHO_T}host tool" >&6
11495   else
11496     # We need a cross tool
11497     echo "$as_me:$LINENO: result: pre-installed" >&5
11498 echo "${ECHO_T}pre-installed" >&6
11499   fi
11500 fi
11501
11502 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11503 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11504 if test "x${build}" != "x${host}" ; then
11505   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11506     # We already found the complete path
11507     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11508     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11509 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11510   else
11511     # Canadian cross, just use what we found
11512     echo "$as_me:$LINENO: result: pre-installed" >&5
11513 echo "${ECHO_T}pre-installed" >&6
11514   fi
11515 else
11516   ok=yes
11517   case " ${configdirs} " in
11518     *" gcc "*) ;;
11519     *) ok=no ;;
11520   esac
11521   case ,${enable_languages}, in
11522     *,c++,*) ;;
11523     *) ok=no ;;
11524   esac
11525   if test $ok = yes; then
11526     # An in-tree tool is available and we can use it
11527     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'
11528     echo "$as_me:$LINENO: result: just compiled" >&5
11529 echo "${ECHO_T}just compiled" >&6
11530   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11531     # We already found the complete path
11532     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11533     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11534 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11535   elif test "x$target" = "x$host"; then
11536     # We can use an host tool
11537     RAW_CXX_FOR_TARGET='$(CXX)'
11538     echo "$as_me:$LINENO: result: host tool" >&5
11539 echo "${ECHO_T}host tool" >&6
11540   else
11541     # We need a cross tool
11542     echo "$as_me:$LINENO: result: pre-installed" >&5
11543 echo "${ECHO_T}pre-installed" >&6
11544   fi
11545 fi
11546
11547 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11548 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11549 if test "x${build}" != "x${host}" ; then
11550   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11551     # We already found the complete path
11552     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11553     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11554 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11555   else
11556     # Canadian cross, just use what we found
11557     echo "$as_me:$LINENO: result: pre-installed" >&5
11558 echo "${ECHO_T}pre-installed" >&6
11559   fi
11560 else
11561   ok=yes
11562   case " ${configdirs} " in
11563     *" binutils "*) ;;
11564     *) ok=no ;;
11565   esac
11566
11567   if test $ok = yes; then
11568     # An in-tree tool is available and we can use it
11569     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11570     echo "$as_me:$LINENO: result: just compiled" >&5
11571 echo "${ECHO_T}just compiled" >&6
11572   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11573     # We already found the complete path
11574     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11575     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11576 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11577   elif test "x$target" = "x$host"; then
11578     # We can use an host tool
11579     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11580     echo "$as_me:$LINENO: result: host tool" >&5
11581 echo "${ECHO_T}host tool" >&6
11582   else
11583     # We need a cross tool
11584     echo "$as_me:$LINENO: result: pre-installed" >&5
11585 echo "${ECHO_T}pre-installed" >&6
11586   fi
11587 fi
11588
11589 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11590 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11591 if test "x${build}" != "x${host}" ; then
11592   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11593     # We already found the complete path
11594     ac_dir=`dirname $GCC_FOR_TARGET`
11595     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11596 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11597   else
11598     # Canadian cross, just use what we found
11599     echo "$as_me:$LINENO: result: pre-installed" >&5
11600 echo "${ECHO_T}pre-installed" >&6
11601   fi
11602 else
11603   ok=yes
11604   case " ${configdirs} " in
11605     *" gcc "*) ;;
11606     *) ok=no ;;
11607   esac
11608
11609   if test $ok = yes; then
11610     # An in-tree tool is available and we can use it
11611     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11612     echo "$as_me:$LINENO: result: just compiled" >&5
11613 echo "${ECHO_T}just compiled" >&6
11614   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11615     # We already found the complete path
11616     ac_dir=`dirname $GCC_FOR_TARGET`
11617     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11618 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11619   elif test "x$target" = "x$host"; then
11620     # We can use an host tool
11621     GCC_FOR_TARGET='$()'
11622     echo "$as_me:$LINENO: result: host tool" >&5
11623 echo "${ECHO_T}host tool" >&6
11624   else
11625     # We need a cross tool
11626     echo "$as_me:$LINENO: result: pre-installed" >&5
11627 echo "${ECHO_T}pre-installed" >&6
11628   fi
11629 fi
11630
11631 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11632 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11633 if test "x${build}" != "x${host}" ; then
11634   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11635     # We already found the complete path
11636     ac_dir=`dirname $GCJ_FOR_TARGET`
11637     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11638 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11639   else
11640     # Canadian cross, just use what we found
11641     echo "$as_me:$LINENO: result: pre-installed" >&5
11642 echo "${ECHO_T}pre-installed" >&6
11643   fi
11644 else
11645   ok=yes
11646   case " ${configdirs} " in
11647     *" gcc "*) ;;
11648     *) ok=no ;;
11649   esac
11650   case ,${enable_languages}, in
11651     *,java,*) ;;
11652     *) ok=no ;;
11653   esac
11654   if test $ok = yes; then
11655     # An in-tree tool is available and we can use it
11656     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11657     echo "$as_me:$LINENO: result: just compiled" >&5
11658 echo "${ECHO_T}just compiled" >&6
11659   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11660     # We already found the complete path
11661     ac_dir=`dirname $GCJ_FOR_TARGET`
11662     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11663 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11664   elif test "x$target" = "x$host"; then
11665     # We can use an host tool
11666     GCJ_FOR_TARGET='$(GCJ)'
11667     echo "$as_me:$LINENO: result: host tool" >&5
11668 echo "${ECHO_T}host tool" >&6
11669   else
11670     # We need a cross tool
11671     echo "$as_me:$LINENO: result: pre-installed" >&5
11672 echo "${ECHO_T}pre-installed" >&6
11673   fi
11674 fi
11675
11676 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11677 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11678 if test "x${build}" != "x${host}" ; then
11679   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11680     # We already found the complete path
11681     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11682     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11683 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11684   else
11685     # Canadian cross, just use what we found
11686     echo "$as_me:$LINENO: result: pre-installed" >&5
11687 echo "${ECHO_T}pre-installed" >&6
11688   fi
11689 else
11690   ok=yes
11691   case " ${configdirs} " in
11692     *" gcc "*) ;;
11693     *) ok=no ;;
11694   esac
11695   case ,${enable_languages}, in
11696     *,fortran,*) ;;
11697     *) ok=no ;;
11698   esac
11699   if test $ok = yes; then
11700     # An in-tree tool is available and we can use it
11701     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11702     echo "$as_me:$LINENO: result: just compiled" >&5
11703 echo "${ECHO_T}just compiled" >&6
11704   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11705     # We already found the complete path
11706     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11707     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11708 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11709   elif test "x$target" = "x$host"; then
11710     # We can use an host tool
11711     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11712     echo "$as_me:$LINENO: result: host tool" >&5
11713 echo "${ECHO_T}host tool" >&6
11714   else
11715     # We need a cross tool
11716     echo "$as_me:$LINENO: result: pre-installed" >&5
11717 echo "${ECHO_T}pre-installed" >&6
11718   fi
11719 fi
11720
11721 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11722 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11723 if test "x${build}" != "x${host}" ; then
11724   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11725     # We already found the complete path
11726     ac_dir=`dirname $LD_FOR_TARGET`
11727     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11728 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11729   else
11730     # Canadian cross, just use what we found
11731     echo "$as_me:$LINENO: result: pre-installed" >&5
11732 echo "${ECHO_T}pre-installed" >&6
11733   fi
11734 else
11735   ok=yes
11736   case " ${configdirs} " in
11737     *" ld "*) ;;
11738     *) ok=no ;;
11739   esac
11740
11741   if test $ok = yes; then
11742     # An in-tree tool is available and we can use it
11743     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11744     echo "$as_me:$LINENO: result: just compiled" >&5
11745 echo "${ECHO_T}just compiled" >&6
11746   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11747     # We already found the complete path
11748     ac_dir=`dirname $LD_FOR_TARGET`
11749     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11750 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11751   elif test "x$target" = "x$host"; then
11752     # We can use an host tool
11753     LD_FOR_TARGET='$(LD)'
11754     echo "$as_me:$LINENO: result: host tool" >&5
11755 echo "${ECHO_T}host tool" >&6
11756   else
11757     # We need a cross tool
11758     echo "$as_me:$LINENO: result: pre-installed" >&5
11759 echo "${ECHO_T}pre-installed" >&6
11760   fi
11761 fi
11762
11763 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11764 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11765 if test "x${build}" != "x${host}" ; then
11766   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11767     # We already found the complete path
11768     ac_dir=`dirname $LIPO_FOR_TARGET`
11769     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11770 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11771   else
11772     # Canadian cross, just use what we found
11773     echo "$as_me:$LINENO: result: pre-installed" >&5
11774 echo "${ECHO_T}pre-installed" >&6
11775   fi
11776 else
11777   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11778     # We already found the complete path
11779     ac_dir=`dirname $LIPO_FOR_TARGET`
11780     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11781 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11782   elif test "x$target" = "x$host"; then
11783     # We can use an host tool
11784     LIPO_FOR_TARGET='$(LIPO)'
11785     echo "$as_me:$LINENO: result: host tool" >&5
11786 echo "${ECHO_T}host tool" >&6
11787   else
11788     # We need a cross tool
11789     echo "$as_me:$LINENO: result: pre-installed" >&5
11790 echo "${ECHO_T}pre-installed" >&6
11791   fi
11792 fi
11793
11794 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11795 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11796 if test "x${build}" != "x${host}" ; then
11797   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11798     # We already found the complete path
11799     ac_dir=`dirname $NM_FOR_TARGET`
11800     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11801 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11802   else
11803     # Canadian cross, just use what we found
11804     echo "$as_me:$LINENO: result: pre-installed" >&5
11805 echo "${ECHO_T}pre-installed" >&6
11806   fi
11807 else
11808   ok=yes
11809   case " ${configdirs} " in
11810     *" binutils "*) ;;
11811     *) ok=no ;;
11812   esac
11813
11814   if test $ok = yes; then
11815     # An in-tree tool is available and we can use it
11816     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11817     echo "$as_me:$LINENO: result: just compiled" >&5
11818 echo "${ECHO_T}just compiled" >&6
11819   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11820     # We already found the complete path
11821     ac_dir=`dirname $NM_FOR_TARGET`
11822     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11823 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11824   elif test "x$target" = "x$host"; then
11825     # We can use an host tool
11826     NM_FOR_TARGET='$(NM)'
11827     echo "$as_me:$LINENO: result: host tool" >&5
11828 echo "${ECHO_T}host tool" >&6
11829   else
11830     # We need a cross tool
11831     echo "$as_me:$LINENO: result: pre-installed" >&5
11832 echo "${ECHO_T}pre-installed" >&6
11833   fi
11834 fi
11835
11836 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11837 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11838 if test "x${build}" != "x${host}" ; then
11839   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11840     # We already found the complete path
11841     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11842     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11843 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11844   else
11845     # Canadian cross, just use what we found
11846     echo "$as_me:$LINENO: result: pre-installed" >&5
11847 echo "${ECHO_T}pre-installed" >&6
11848   fi
11849 else
11850   ok=yes
11851   case " ${configdirs} " in
11852     *" binutils "*) ;;
11853     *) ok=no ;;
11854   esac
11855
11856   if test $ok = yes; then
11857     # An in-tree tool is available and we can use it
11858     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11859     echo "$as_me:$LINENO: result: just compiled" >&5
11860 echo "${ECHO_T}just compiled" >&6
11861   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11862     # We already found the complete path
11863     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11864     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11865 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11866   elif test "x$target" = "x$host"; then
11867     # We can use an host tool
11868     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11869     echo "$as_me:$LINENO: result: host tool" >&5
11870 echo "${ECHO_T}host tool" >&6
11871   else
11872     # We need a cross tool
11873     echo "$as_me:$LINENO: result: pre-installed" >&5
11874 echo "${ECHO_T}pre-installed" >&6
11875   fi
11876 fi
11877
11878 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11879 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11880 if test "x${build}" != "x${host}" ; then
11881   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11882     # We already found the complete path
11883     ac_dir=`dirname $RANLIB_FOR_TARGET`
11884     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11885 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11886   else
11887     # Canadian cross, just use what we found
11888     echo "$as_me:$LINENO: result: pre-installed" >&5
11889 echo "${ECHO_T}pre-installed" >&6
11890   fi
11891 else
11892   ok=yes
11893   case " ${configdirs} " in
11894     *" binutils "*) ;;
11895     *) ok=no ;;
11896   esac
11897
11898   if test $ok = yes; then
11899     # An in-tree tool is available and we can use it
11900     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11901     echo "$as_me:$LINENO: result: just compiled" >&5
11902 echo "${ECHO_T}just compiled" >&6
11903   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11904     # We already found the complete path
11905     ac_dir=`dirname $RANLIB_FOR_TARGET`
11906     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11907 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11908   elif test "x$target" = "x$host"; then
11909     # We can use an host tool
11910     RANLIB_FOR_TARGET='$(RANLIB)'
11911     echo "$as_me:$LINENO: result: host tool" >&5
11912 echo "${ECHO_T}host tool" >&6
11913   else
11914     # We need a cross tool
11915     echo "$as_me:$LINENO: result: pre-installed" >&5
11916 echo "${ECHO_T}pre-installed" >&6
11917   fi
11918 fi
11919
11920 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11921 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11922 if test "x${build}" != "x${host}" ; then
11923   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11924     # We already found the complete path
11925     ac_dir=`dirname $STRIP_FOR_TARGET`
11926     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11927 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11928   else
11929     # Canadian cross, just use what we found
11930     echo "$as_me:$LINENO: result: pre-installed" >&5
11931 echo "${ECHO_T}pre-installed" >&6
11932   fi
11933 else
11934   ok=yes
11935   case " ${configdirs} " in
11936     *" binutils "*) ;;
11937     *) ok=no ;;
11938   esac
11939
11940   if test $ok = yes; then
11941     # An in-tree tool is available and we can use it
11942     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11943     echo "$as_me:$LINENO: result: just compiled" >&5
11944 echo "${ECHO_T}just compiled" >&6
11945   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11946     # We already found the complete path
11947     ac_dir=`dirname $STRIP_FOR_TARGET`
11948     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11949 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11950   elif test "x$target" = "x$host"; then
11951     # We can use an host tool
11952     STRIP_FOR_TARGET='$(STRIP)'
11953     echo "$as_me:$LINENO: result: host tool" >&5
11954 echo "${ECHO_T}host tool" >&6
11955   else
11956     # We need a cross tool
11957     echo "$as_me:$LINENO: result: pre-installed" >&5
11958 echo "${ECHO_T}pre-installed" >&6
11959   fi
11960 fi
11961
11962 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11963 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11964 if test "x${build}" != "x${host}" ; then
11965   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11966     # We already found the complete path
11967     ac_dir=`dirname $WINDRES_FOR_TARGET`
11968     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11969 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11970   else
11971     # Canadian cross, just use what we found
11972     echo "$as_me:$LINENO: result: pre-installed" >&5
11973 echo "${ECHO_T}pre-installed" >&6
11974   fi
11975 else
11976   ok=yes
11977   case " ${configdirs} " in
11978     *" binutils "*) ;;
11979     *) ok=no ;;
11980   esac
11981
11982   if test $ok = yes; then
11983     # An in-tree tool is available and we can use it
11984     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11985     echo "$as_me:$LINENO: result: just compiled" >&5
11986 echo "${ECHO_T}just compiled" >&6
11987   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11988     # We already found the complete path
11989     ac_dir=`dirname $WINDRES_FOR_TARGET`
11990     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11991 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11992   elif test "x$target" = "x$host"; then
11993     # We can use an host tool
11994     WINDRES_FOR_TARGET='$(WINDRES)'
11995     echo "$as_me:$LINENO: result: host tool" >&5
11996 echo "${ECHO_T}host tool" >&6
11997   else
11998     # We need a cross tool
11999     echo "$as_me:$LINENO: result: pre-installed" >&5
12000 echo "${ECHO_T}pre-installed" >&6
12001   fi
12002 fi
12003
12004 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
12005 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
12006 if test "x${build}" != "x${host}" ; then
12007   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12008     # We already found the complete path
12009     ac_dir=`dirname $WINDMC_FOR_TARGET`
12010     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12011 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12012   else
12013     # Canadian cross, just use what we found
12014     echo "$as_me:$LINENO: result: pre-installed" >&5
12015 echo "${ECHO_T}pre-installed" >&6
12016   fi
12017 else
12018   ok=yes
12019   case " ${configdirs} " in
12020     *" binutils "*) ;;
12021     *) ok=no ;;
12022   esac
12023
12024   if test $ok = yes; then
12025     # An in-tree tool is available and we can use it
12026     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
12027     echo "$as_me:$LINENO: result: just compiled" >&5
12028 echo "${ECHO_T}just compiled" >&6
12029   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
12030     # We already found the complete path
12031     ac_dir=`dirname $WINDMC_FOR_TARGET`
12032     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
12033 echo "${ECHO_T}pre-installed in $ac_dir" >&6
12034   elif test "x$target" = "x$host"; then
12035     # We can use an host tool
12036     WINDMC_FOR_TARGET='$(WINDMC)'
12037     echo "$as_me:$LINENO: result: host tool" >&5
12038 echo "${ECHO_T}host tool" >&6
12039   else
12040     # We need a cross tool
12041     echo "$as_me:$LINENO: result: pre-installed" >&5
12042 echo "${ECHO_T}pre-installed" >&6
12043   fi
12044 fi
12045
12046
12047
12048
12049
12050 # Certain tools may need extra flags.
12051 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
12052 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
12053 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
12054
12055 # When building target libraries, except in a Canadian cross, we use
12056 # the same toolchain as the compiler we just built.
12057 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
12058 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
12059 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
12060 if test $host = $build; then
12061   case " $configdirs " in
12062     *" gcc "*)
12063       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
12064       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
12065       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
12066       ;;
12067   esac
12068 fi
12069
12070
12071
12072
12073
12074 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
12075 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
12076 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
12077 if test "${enable_maintainer_mode+set}" = set; then
12078   enableval="$enable_maintainer_mode"
12079   USE_MAINTAINER_MODE=$enableval
12080 else
12081   USE_MAINTAINER_MODE=no
12082 fi;
12083 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
12084 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
12085
12086
12087 if test "$USE_MAINTAINER_MODE" = yes; then
12088   MAINTAINER_MODE_TRUE=
12089   MAINTAINER_MODE_FALSE='#'
12090 else
12091   MAINTAINER_MODE_TRUE='#'
12092   MAINTAINER_MODE_FALSE=
12093 fi
12094 MAINT=$MAINTAINER_MODE_TRUE
12095
12096 # ---------------------
12097 # GCC bootstrap support
12098 # ---------------------
12099
12100 # Stage specific cflags for build.
12101 stage1_cflags="-g"
12102 case $build in
12103   vax-*-*)
12104     case ${GCC} in
12105       yes) stage1_cflags="-g -Wa,-J" ;;
12106       *) stage1_cflags="-g -J" ;;
12107     esac ;;
12108 esac
12109
12110 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
12111 if test "$GCC" = yes; then
12112   saved_CFLAGS="$CFLAGS"
12113
12114   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
12115   CFLAGS="$CFLAGS -fkeep-inline-functions"
12116   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
12117 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
12118   cat >conftest.$ac_ext <<_ACEOF
12119 /* confdefs.h.  */
12120 _ACEOF
12121 cat confdefs.h >>conftest.$ac_ext
12122 cat >>conftest.$ac_ext <<_ACEOF
12123 /* end confdefs.h.  */
12124
12125 #if (__GNUC__ < 3) \
12126     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
12127                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
12128 #error http://gcc.gnu.org/PR29382
12129 #endif
12130
12131 int
12132 main ()
12133 {
12134
12135   ;
12136   return 0;
12137 }
12138 _ACEOF
12139 rm -f conftest.$ac_objext
12140 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
12141   (eval $ac_compile) 2>conftest.er1
12142   ac_status=$?
12143   grep -v '^ *+' conftest.er1 >conftest.err
12144   rm -f conftest.er1
12145   cat conftest.err >&5
12146   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12147   (exit $ac_status); } &&
12148          { ac_try='test -z "$ac_c_werror_flag"
12149                          || test ! -s conftest.err'
12150   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12151   (eval $ac_try) 2>&5
12152   ac_status=$?
12153   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12154   (exit $ac_status); }; } &&
12155          { ac_try='test -s conftest.$ac_objext'
12156   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12157   (eval $ac_try) 2>&5
12158   ac_status=$?
12159   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12160   (exit $ac_status); }; }; then
12161   echo "$as_me:$LINENO: result: yes" >&5
12162 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12163 else
12164   echo "$as_me: failed program was:" >&5
12165 sed 's/^/| /' conftest.$ac_ext >&5
12166
12167 echo "$as_me:$LINENO: result: no" >&5
12168 echo "${ECHO_T}no" >&6
12169 fi
12170 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12171
12172   CFLAGS="$saved_CFLAGS"
12173 fi
12174
12175
12176
12177 # Enable --enable-checking in stage1 of the compiler.
12178 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12179 if test "${enable_stage1_checking+set}" = set; then
12180   enableval="$enable_stage1_checking"
12181   stage1_checking=--enable-checking=${enable_stage1_checking}
12182 else
12183   if test "x$enable_checking" = xno || test "x$enable_checking" = x; then
12184   stage1_checking=--enable-checking=yes,types
12185 else
12186   stage1_checking=--enable-checking=$enable_checking,types
12187 fi
12188 fi;
12189
12190
12191 # Enable -Werror in bootstrap stage2 and later.
12192 # Check whether --enable-werror or --disable-werror was given.
12193 if test "${enable_werror+set}" = set; then
12194   enableval="$enable_werror"
12195
12196 else
12197   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12198   enable_werror=yes
12199 else
12200   enable_werror=no
12201 fi
12202 fi;
12203 case ${enable_werror} in
12204   yes) stage2_werror_flag="--enable-werror-always" ;;
12205   *) stage2_werror_flag="" ;;
12206 esac
12207
12208
12209 # Flags needed to enable html installing and building
12210
12211 # Check whether --with-datarootdir or --without-datarootdir was given.
12212 if test "${with_datarootdir+set}" = set; then
12213   withval="$with_datarootdir"
12214   datarootdir="\${prefix}/${withval}"
12215 else
12216   datarootdir="\${prefix}/share"
12217 fi;
12218
12219
12220 # Check whether --with-docdir or --without-docdir was given.
12221 if test "${with_docdir+set}" = set; then
12222   withval="$with_docdir"
12223   docdir="\${prefix}/${withval}"
12224 else
12225   docdir="\${datarootdir}/doc"
12226 fi;
12227
12228
12229 # Check whether --with-pdfdir or --without-pdfdir was given.
12230 if test "${with_pdfdir+set}" = set; then
12231   withval="$with_pdfdir"
12232   pdfdir="\${prefix}/${withval}"
12233 else
12234   pdfdir="\${docdir}"
12235 fi;
12236
12237
12238 # Check whether --with-htmldir or --without-htmldir was given.
12239 if test "${with_htmldir+set}" = set; then
12240   withval="$with_htmldir"
12241   htmldir="\${prefix}/${withval}"
12242 else
12243   htmldir="\${docdir}"
12244 fi;
12245
12246
12247
12248
12249
12250
12251           ac_config_files="$ac_config_files Makefile"
12252 cat >confcache <<\_ACEOF
12253 # This file is a shell script that caches the results of configure
12254 # tests run on this system so they can be shared between configure
12255 # scripts and configure runs, see configure's option --config-cache.
12256 # It is not useful on other systems.  If it contains results you don't
12257 # want to keep, you may remove or edit it.
12258 #
12259 # config.status only pays attention to the cache file if you give it
12260 # the --recheck option to rerun configure.
12261 #
12262 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12263 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12264 # following values.
12265
12266 _ACEOF
12267
12268 # The following way of writing the cache mishandles newlines in values,
12269 # but we know of no workaround that is simple, portable, and efficient.
12270 # So, don't put newlines in cache variables' values.
12271 # Ultrix sh set writes to stderr and can't be redirected directly,
12272 # and sets the high bit in the cache file unless we assign to the vars.
12273 {
12274   (set) 2>&1 |
12275     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12276     *ac_space=\ *)
12277       # `set' does not quote correctly, so add quotes (double-quote
12278       # substitution turns \\\\ into \\, and sed turns \\ into \).
12279       sed -n \
12280         "s/'/'\\\\''/g;
12281           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12282       ;;
12283     *)
12284       # `set' quotes correctly as required by POSIX, so do not add quotes.
12285       sed -n \
12286         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12287       ;;
12288     esac;
12289 } |
12290   sed '
12291      t clear
12292      : clear
12293      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12294      t end
12295      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12296      : end' >>confcache
12297 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12298   if test -w $cache_file; then
12299     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12300     cat confcache >$cache_file
12301   else
12302     echo "not updating unwritable cache $cache_file"
12303   fi
12304 fi
12305 rm -f confcache
12306
12307 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12308 # Let make expand exec_prefix.
12309 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12310
12311 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12312 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12313 # trailing colons and then remove the whole line if VPATH becomes empty
12314 # (actually we leave an empty line to preserve line numbers).
12315 if test "x$srcdir" = x.; then
12316   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12317 s/:*\$(srcdir):*/:/;
12318 s/:*\${srcdir}:*/:/;
12319 s/:*@srcdir@:*/:/;
12320 s/^\([^=]*=[     ]*\):*/\1/;
12321 s/:*$//;
12322 s/^[^=]*=[       ]*$//;
12323 }'
12324 fi
12325
12326 # Transform confdefs.h into DEFS.
12327 # Protect against shell expansion while executing Makefile rules.
12328 # Protect against Makefile macro expansion.
12329 #
12330 # If the first sed substitution is executed (which looks for macros that
12331 # take arguments), then we branch to the quote section.  Otherwise,
12332 # look for a macro that doesn't take arguments.
12333 cat >confdef2opt.sed <<\_ACEOF
12334 t clear
12335 : clear
12336 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12337 t quote
12338 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12339 t quote
12340 d
12341 : quote
12342 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12343 s,\[,\\&,g
12344 s,\],\\&,g
12345 s,\$,$$,g
12346 p
12347 _ACEOF
12348 # We use echo to avoid assuming a particular line-breaking character.
12349 # The extra dot is to prevent the shell from consuming trailing
12350 # line-breaks from the sub-command output.  A line-break within
12351 # single-quotes doesn't work because, if this script is created in a
12352 # platform that uses two characters for line-breaks (e.g., DOS), tr
12353 # would break.
12354 ac_LF_and_DOT=`echo; echo .`
12355 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12356 rm -f confdef2opt.sed
12357
12358
12359 ac_libobjs=
12360 ac_ltlibobjs=
12361 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12362   # 1. Remove the extension, and $U if already installed.
12363   ac_i=`echo "$ac_i" |
12364          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12365   # 2. Add them.
12366   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12367   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12368 done
12369 LIBOBJS=$ac_libobjs
12370
12371 LTLIBOBJS=$ac_ltlibobjs
12372
12373
12374
12375 : ${CONFIG_STATUS=./config.status}
12376 ac_clean_files_save=$ac_clean_files
12377 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12378 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12379 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12380 cat >$CONFIG_STATUS <<_ACEOF
12381 #! $SHELL
12382 # Generated by $as_me.
12383 # Run this file to recreate the current configuration.
12384 # Compiler output produced by configure, useful for debugging
12385 # configure, is in config.log if it exists.
12386
12387 debug=false
12388 ac_cs_recheck=false
12389 ac_cs_silent=false
12390 SHELL=\${CONFIG_SHELL-$SHELL}
12391 _ACEOF
12392
12393 cat >>$CONFIG_STATUS <<\_ACEOF
12394 ## --------------------- ##
12395 ## M4sh Initialization.  ##
12396 ## --------------------- ##
12397
12398 # Be Bourne compatible
12399 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12400   emulate sh
12401   NULLCMD=:
12402   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12403   # is contrary to our usage.  Disable this feature.
12404   alias -g '${1+"$@"}'='"$@"'
12405 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12406   set -o posix
12407 fi
12408 DUALCASE=1; export DUALCASE # for MKS sh
12409
12410 # Support unset when possible.
12411 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12412   as_unset=unset
12413 else
12414   as_unset=false
12415 fi
12416
12417
12418 # Work around bugs in pre-3.0 UWIN ksh.
12419 $as_unset ENV MAIL MAILPATH
12420 PS1='$ '
12421 PS2='> '
12422 PS4='+ '
12423
12424 # NLS nuisances.
12425 for as_var in \
12426   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12427   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12428   LC_TELEPHONE LC_TIME
12429 do
12430   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12431     eval $as_var=C; export $as_var
12432   else
12433     $as_unset $as_var
12434   fi
12435 done
12436
12437 # Required to use basename.
12438 if expr a : '\(a\)' >/dev/null 2>&1; then
12439   as_expr=expr
12440 else
12441   as_expr=false
12442 fi
12443
12444 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12445   as_basename=basename
12446 else
12447   as_basename=false
12448 fi
12449
12450
12451 # Name of the executable.
12452 as_me=`$as_basename "$0" ||
12453 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12454          X"$0" : 'X\(//\)$' \| \
12455          X"$0" : 'X\(/\)$' \| \
12456          .     : '\(.\)' 2>/dev/null ||
12457 echo X/"$0" |
12458     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12459           /^X\/\(\/\/\)$/{ s//\1/; q; }
12460           /^X\/\(\/\).*/{ s//\1/; q; }
12461           s/.*/./; q'`
12462
12463
12464 # PATH needs CR, and LINENO needs CR and PATH.
12465 # Avoid depending upon Character Ranges.
12466 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12467 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12468 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12469 as_cr_digits='0123456789'
12470 as_cr_alnum=$as_cr_Letters$as_cr_digits
12471
12472 # The user is always right.
12473 if test "${PATH_SEPARATOR+set}" != set; then
12474   echo "#! /bin/sh" >conf$$.sh
12475   echo  "exit 0"   >>conf$$.sh
12476   chmod +x conf$$.sh
12477   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12478     PATH_SEPARATOR=';'
12479   else
12480     PATH_SEPARATOR=:
12481   fi
12482   rm -f conf$$.sh
12483 fi
12484
12485
12486   as_lineno_1=$LINENO
12487   as_lineno_2=$LINENO
12488   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12489   test "x$as_lineno_1" != "x$as_lineno_2" &&
12490   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12491   # Find who we are.  Look in the path if we contain no path at all
12492   # relative or not.
12493   case $0 in
12494     *[\\/]* ) as_myself=$0 ;;
12495     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12496 for as_dir in $PATH
12497 do
12498   IFS=$as_save_IFS
12499   test -z "$as_dir" && as_dir=.
12500   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12501 done
12502
12503        ;;
12504   esac
12505   # We did not find ourselves, most probably we were run as `sh COMMAND'
12506   # in which case we are not to be found in the path.
12507   if test "x$as_myself" = x; then
12508     as_myself=$0
12509   fi
12510   if test ! -f "$as_myself"; then
12511     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12512 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12513    { (exit 1); exit 1; }; }
12514   fi
12515   case $CONFIG_SHELL in
12516   '')
12517     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12518 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12519 do
12520   IFS=$as_save_IFS
12521   test -z "$as_dir" && as_dir=.
12522   for as_base in sh bash ksh sh5; do
12523          case $as_dir in
12524          /*)
12525            if ("$as_dir/$as_base" -c '
12526   as_lineno_1=$LINENO
12527   as_lineno_2=$LINENO
12528   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12529   test "x$as_lineno_1" != "x$as_lineno_2" &&
12530   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12531              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12532              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12533              CONFIG_SHELL=$as_dir/$as_base
12534              export CONFIG_SHELL
12535              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12536            fi;;
12537          esac
12538        done
12539 done
12540 ;;
12541   esac
12542
12543   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12544   # uniformly replaced by the line number.  The first 'sed' inserts a
12545   # line-number line before each line; the second 'sed' does the real
12546   # work.  The second script uses 'N' to pair each line-number line
12547   # with the numbered line, and appends trailing '-' during
12548   # substitution so that $LINENO is not a special case at line end.
12549   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12550   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12551   sed '=' <$as_myself |
12552     sed '
12553       N
12554       s,$,-,
12555       : loop
12556       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12557       t loop
12558       s,-$,,
12559       s,^['$as_cr_digits']*\n,,
12560     ' >$as_me.lineno &&
12561   chmod +x $as_me.lineno ||
12562     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12563 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12564    { (exit 1); exit 1; }; }
12565
12566   # Don't try to exec as it changes $[0], causing all sort of problems
12567   # (the dirname of $[0] is not the place where we might find the
12568   # original and so on.  Autoconf is especially sensible to this).
12569   . ./$as_me.lineno
12570   # Exit status is that of the last command.
12571   exit
12572 }
12573
12574
12575 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12576   *c*,-n*) ECHO_N= ECHO_C='
12577 ' ECHO_T='      ' ;;
12578   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12579   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12580 esac
12581
12582 if expr a : '\(a\)' >/dev/null 2>&1; then
12583   as_expr=expr
12584 else
12585   as_expr=false
12586 fi
12587
12588 rm -f conf$$ conf$$.exe conf$$.file
12589 echo >conf$$.file
12590 if ln -s conf$$.file conf$$ 2>/dev/null; then
12591   # We could just check for DJGPP; but this test a) works b) is more generic
12592   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12593   if test -f conf$$.exe; then
12594     # Don't use ln at all; we don't have any links
12595     as_ln_s='cp -p'
12596   else
12597     as_ln_s='ln -s'
12598   fi
12599 elif ln conf$$.file conf$$ 2>/dev/null; then
12600   as_ln_s=ln
12601 else
12602   as_ln_s='cp -p'
12603 fi
12604 rm -f conf$$ conf$$.exe conf$$.file
12605
12606 if mkdir -p . 2>/dev/null; then
12607   as_mkdir_p=:
12608 else
12609   test -d ./-p && rmdir ./-p
12610   as_mkdir_p=false
12611 fi
12612
12613 as_executable_p="test -f"
12614
12615 # Sed expression to map a string onto a valid CPP name.
12616 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12617
12618 # Sed expression to map a string onto a valid variable name.
12619 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12620
12621
12622 # IFS
12623 # We need space, tab and new line, in precisely that order.
12624 as_nl='
12625 '
12626 IFS="   $as_nl"
12627
12628 # CDPATH.
12629 $as_unset CDPATH
12630
12631 exec 6>&1
12632
12633 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12634 # report actual input values of CONFIG_FILES etc. instead of their
12635 # values after options handling.  Logging --version etc. is OK.
12636 exec 5>>config.log
12637 {
12638   echo
12639   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12640 ## Running $as_me. ##
12641 _ASBOX
12642 } >&5
12643 cat >&5 <<_CSEOF
12644
12645 This file was extended by $as_me, which was
12646 generated by GNU Autoconf 2.59.  Invocation command line was
12647
12648   CONFIG_FILES    = $CONFIG_FILES
12649   CONFIG_HEADERS  = $CONFIG_HEADERS
12650   CONFIG_LINKS    = $CONFIG_LINKS
12651   CONFIG_COMMANDS = $CONFIG_COMMANDS
12652   $ $0 $@
12653
12654 _CSEOF
12655 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12656 echo >&5
12657 _ACEOF
12658
12659 # Files that config.status was made for.
12660 if test -n "$ac_config_files"; then
12661   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12662 fi
12663
12664 if test -n "$ac_config_headers"; then
12665   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12666 fi
12667
12668 if test -n "$ac_config_links"; then
12669   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12670 fi
12671
12672 if test -n "$ac_config_commands"; then
12673   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12674 fi
12675
12676 cat >>$CONFIG_STATUS <<\_ACEOF
12677
12678 ac_cs_usage="\
12679 \`$as_me' instantiates files from templates according to the
12680 current configuration.
12681
12682 Usage: $0 [OPTIONS] [FILE]...
12683
12684   -h, --help       print this help, then exit
12685   -V, --version    print version number, then exit
12686   -q, --quiet      do not print progress messages
12687   -d, --debug      don't remove temporary files
12688       --recheck    update $as_me by reconfiguring in the same conditions
12689   --file=FILE[:TEMPLATE]
12690                    instantiate the configuration file FILE
12691
12692 Configuration files:
12693 $config_files
12694
12695 Report bugs to <bug-autoconf@gnu.org>."
12696 _ACEOF
12697
12698 cat >>$CONFIG_STATUS <<_ACEOF
12699 ac_cs_version="\\
12700 config.status
12701 configured by $0, generated by GNU Autoconf 2.59,
12702   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12703
12704 Copyright (C) 2003 Free Software Foundation, Inc.
12705 This config.status script is free software; the Free Software Foundation
12706 gives unlimited permission to copy, distribute and modify it."
12707 srcdir=$srcdir
12708 INSTALL="$INSTALL"
12709 _ACEOF
12710
12711 cat >>$CONFIG_STATUS <<\_ACEOF
12712 # If no file are specified by the user, then we need to provide default
12713 # value.  By we need to know if files were specified by the user.
12714 ac_need_defaults=:
12715 while test $# != 0
12716 do
12717   case $1 in
12718   --*=*)
12719     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12720     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12721     ac_shift=:
12722     ;;
12723   -*)
12724     ac_option=$1
12725     ac_optarg=$2
12726     ac_shift=shift
12727     ;;
12728   *) # This is not an option, so the user has probably given explicit
12729      # arguments.
12730      ac_option=$1
12731      ac_need_defaults=false;;
12732   esac
12733
12734   case $ac_option in
12735   # Handling of the options.
12736 _ACEOF
12737 cat >>$CONFIG_STATUS <<\_ACEOF
12738   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12739     ac_cs_recheck=: ;;
12740   --version | --vers* | -V )
12741     echo "$ac_cs_version"; exit 0 ;;
12742   --he | --h)
12743     # Conflict between --help and --header
12744     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12745 Try \`$0 --help' for more information." >&5
12746 echo "$as_me: error: ambiguous option: $1
12747 Try \`$0 --help' for more information." >&2;}
12748    { (exit 1); exit 1; }; };;
12749   --help | --hel | -h )
12750     echo "$ac_cs_usage"; exit 0 ;;
12751   --debug | --d* | -d )
12752     debug=: ;;
12753   --file | --fil | --fi | --f )
12754     $ac_shift
12755     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12756     ac_need_defaults=false;;
12757   --header | --heade | --head | --hea )
12758     $ac_shift
12759     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12760     ac_need_defaults=false;;
12761   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12762   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12763     ac_cs_silent=: ;;
12764
12765   # This is an error.
12766   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12767 Try \`$0 --help' for more information." >&5
12768 echo "$as_me: error: unrecognized option: $1
12769 Try \`$0 --help' for more information." >&2;}
12770    { (exit 1); exit 1; }; } ;;
12771
12772   *) ac_config_targets="$ac_config_targets $1" ;;
12773
12774   esac
12775   shift
12776 done
12777
12778 ac_configure_extra_args=
12779
12780 if $ac_cs_silent; then
12781   exec 6>/dev/null
12782   ac_configure_extra_args="$ac_configure_extra_args --silent"
12783 fi
12784
12785 _ACEOF
12786 cat >>$CONFIG_STATUS <<_ACEOF
12787 if \$ac_cs_recheck; then
12788   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12789   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12790 fi
12791
12792 _ACEOF
12793
12794
12795
12796
12797
12798 cat >>$CONFIG_STATUS <<\_ACEOF
12799 for ac_config_target in $ac_config_targets
12800 do
12801   case "$ac_config_target" in
12802   # Handling of arguments.
12803   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12804   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12805 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12806    { (exit 1); exit 1; }; };;
12807   esac
12808 done
12809
12810 # If the user did not use the arguments to specify the items to instantiate,
12811 # then the envvar interface is used.  Set only those that are not.
12812 # We use the long form for the default assignment because of an extremely
12813 # bizarre bug on SunOS 4.1.3.
12814 if $ac_need_defaults; then
12815   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12816 fi
12817
12818 # Have a temporary directory for convenience.  Make it in the build tree
12819 # simply because there is no reason to put it here, and in addition,
12820 # creating and moving files from /tmp can sometimes cause problems.
12821 # Create a temporary directory, and hook for its removal unless debugging.
12822 $debug ||
12823 {
12824   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12825   trap '{ (exit 1); exit 1; }' 1 2 13 15
12826 }
12827
12828 # Create a (secure) tmp directory for tmp files.
12829
12830 {
12831   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12832   test -n "$tmp" && test -d "$tmp"
12833 }  ||
12834 {
12835   tmp=./confstat$$-$RANDOM
12836   (umask 077 && mkdir $tmp)
12837 } ||
12838 {
12839    echo "$me: cannot create a temporary directory in ." >&2
12840    { (exit 1); exit 1; }
12841 }
12842
12843 _ACEOF
12844
12845 cat >>$CONFIG_STATUS <<_ACEOF
12846
12847 #
12848 # CONFIG_FILES section.
12849 #
12850
12851 # No need to generate the scripts if there are no CONFIG_FILES.
12852 # This happens for instance when ./config.status config.h
12853 if test -n "\$CONFIG_FILES"; then
12854   # Protect against being on the right side of a sed subst in config.status.
12855   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12856    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12857 s,@SHELL@,$SHELL,;t t
12858 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12859 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12860 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12861 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12862 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12863 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12864 s,@exec_prefix@,$exec_prefix,;t t
12865 s,@prefix@,$prefix,;t t
12866 s,@program_transform_name@,$program_transform_name,;t t
12867 s,@bindir@,$bindir,;t t
12868 s,@sbindir@,$sbindir,;t t
12869 s,@libexecdir@,$libexecdir,;t t
12870 s,@datadir@,$datadir,;t t
12871 s,@sysconfdir@,$sysconfdir,;t t
12872 s,@sharedstatedir@,$sharedstatedir,;t t
12873 s,@localstatedir@,$localstatedir,;t t
12874 s,@libdir@,$libdir,;t t
12875 s,@includedir@,$includedir,;t t
12876 s,@oldincludedir@,$oldincludedir,;t t
12877 s,@infodir@,$infodir,;t t
12878 s,@mandir@,$mandir,;t t
12879 s,@build_alias@,$build_alias,;t t
12880 s,@host_alias@,$host_alias,;t t
12881 s,@target_alias@,$target_alias,;t t
12882 s,@DEFS@,$DEFS,;t t
12883 s,@ECHO_C@,$ECHO_C,;t t
12884 s,@ECHO_N@,$ECHO_N,;t t
12885 s,@ECHO_T@,$ECHO_T,;t t
12886 s,@LIBS@,$LIBS,;t t
12887 s,@build@,$build,;t t
12888 s,@build_cpu@,$build_cpu,;t t
12889 s,@build_vendor@,$build_vendor,;t t
12890 s,@build_os@,$build_os,;t t
12891 s,@build_noncanonical@,$build_noncanonical,;t t
12892 s,@host_noncanonical@,$host_noncanonical,;t t
12893 s,@target_noncanonical@,$target_noncanonical,;t t
12894 s,@host@,$host,;t t
12895 s,@host_cpu@,$host_cpu,;t t
12896 s,@host_vendor@,$host_vendor,;t t
12897 s,@host_os@,$host_os,;t t
12898 s,@target@,$target,;t t
12899 s,@target_cpu@,$target_cpu,;t t
12900 s,@target_vendor@,$target_vendor,;t t
12901 s,@target_os@,$target_os,;t t
12902 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12903 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12904 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12905 s,@LN@,$LN,;t t
12906 s,@LN_S@,$LN_S,;t t
12907 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12908 s,@build_libsubdir@,$build_libsubdir,;t t
12909 s,@build_subdir@,$build_subdir,;t t
12910 s,@host_subdir@,$host_subdir,;t t
12911 s,@target_subdir@,$target_subdir,;t t
12912 s,@CC@,$CC,;t t
12913 s,@CFLAGS@,$CFLAGS,;t t
12914 s,@LDFLAGS@,$LDFLAGS,;t t
12915 s,@CPPFLAGS@,$CPPFLAGS,;t t
12916 s,@ac_ct_CC@,$ac_ct_CC,;t t
12917 s,@EXEEXT@,$EXEEXT,;t t
12918 s,@OBJEXT@,$OBJEXT,;t t
12919 s,@CXX@,$CXX,;t t
12920 s,@CXXFLAGS@,$CXXFLAGS,;t t
12921 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12922 s,@GNATBIND@,$GNATBIND,;t t
12923 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12924 s,@GNATMAKE@,$GNATMAKE,;t t
12925 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12926 s,@do_compare@,$do_compare,;t t
12927 s,@gmplibs@,$gmplibs,;t t
12928 s,@gmpinc@,$gmpinc,;t t
12929 s,@stage1_languages@,$stage1_languages,;t t
12930 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12931 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12932 s,@CFLAGS_FOR_TARGET@,$CFLAGS_FOR_TARGET,;t t
12933 s,@CXXFLAGS_FOR_TARGET@,$CXXFLAGS_FOR_TARGET,;t t
12934 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12935 s,@tooldir@,$tooldir,;t t
12936 s,@build_tooldir@,$build_tooldir,;t t
12937 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12938 s,@GDB_TK@,$GDB_TK,;t t
12939 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12940 s,@build_configargs@,$build_configargs,;t t
12941 s,@build_configdirs@,$build_configdirs,;t t
12942 s,@host_configargs@,$host_configargs,;t t
12943 s,@configdirs@,$configdirs,;t t
12944 s,@target_configargs@,$target_configargs,;t t
12945 s,@AR_FOR_BUILD@,$AR_FOR_BUILD,;t t
12946 s,@AS_FOR_BUILD@,$AS_FOR_BUILD,;t t
12947 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12948 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12949 s,@CXXFLAGS_FOR_BUILD@,$CXXFLAGS_FOR_BUILD,;t t
12950 s,@CXX_FOR_BUILD@,$CXX_FOR_BUILD,;t t
12951 s,@DLLTOOL_FOR_BUILD@,$DLLTOOL_FOR_BUILD,;t t
12952 s,@GCJ_FOR_BUILD@,$GCJ_FOR_BUILD,;t t
12953 s,@GFORTRAN_FOR_BUILD@,$GFORTRAN_FOR_BUILD,;t t
12954 s,@LDFLAGS_FOR_BUILD@,$LDFLAGS_FOR_BUILD,;t t
12955 s,@LD_FOR_BUILD@,$LD_FOR_BUILD,;t t
12956 s,@NM_FOR_BUILD@,$NM_FOR_BUILD,;t t
12957 s,@RANLIB_FOR_BUILD@,$RANLIB_FOR_BUILD,;t t
12958 s,@WINDMC_FOR_BUILD@,$WINDMC_FOR_BUILD,;t t
12959 s,@WINDRES_FOR_BUILD@,$WINDRES_FOR_BUILD,;t t
12960 s,@config_shell@,$config_shell,;t t
12961 s,@YACC@,$YACC,;t t
12962 s,@BISON@,$BISON,;t t
12963 s,@M4@,$M4,;t t
12964 s,@LEX@,$LEX,;t t
12965 s,@FLEX@,$FLEX,;t t
12966 s,@MAKEINFO@,$MAKEINFO,;t t
12967 s,@EXPECT@,$EXPECT,;t t
12968 s,@RUNTEST@,$RUNTEST,;t t
12969 s,@AR@,$AR,;t t
12970 s,@AS@,$AS,;t t
12971 s,@DLLTOOL@,$DLLTOOL,;t t
12972 s,@LD@,$LD,;t t
12973 s,@LIPO@,$LIPO,;t t
12974 s,@NM@,$NM,;t t
12975 s,@RANLIB@,$RANLIB,;t t
12976 s,@STRIP@,$STRIP,;t t
12977 s,@WINDRES@,$WINDRES,;t t
12978 s,@WINDMC@,$WINDMC,;t t
12979 s,@OBJCOPY@,$OBJCOPY,;t t
12980 s,@OBJDUMP@,$OBJDUMP,;t t
12981 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12982 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12983 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12984 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12985 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12986 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12987 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12988 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12989 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12990 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12991 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12992 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12993 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12994 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12995 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12996 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12997 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12998 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12999 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
13000 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
13001 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
13002 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
13003 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
13004 s,@MAINT@,$MAINT,;t t
13005 s,@stage1_cflags@,$stage1_cflags,;t t
13006 s,@stage1_checking@,$stage1_checking,;t t
13007 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
13008 s,@datarootdir@,$datarootdir,;t t
13009 s,@docdir@,$docdir,;t t
13010 s,@pdfdir@,$pdfdir,;t t
13011 s,@htmldir@,$htmldir,;t t
13012 s,@LIBOBJS@,$LIBOBJS,;t t
13013 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
13014 /@serialization_dependencies@/r $serialization_dependencies
13015 s,@serialization_dependencies@,,;t t
13016 /@host_makefile_frag@/r $host_makefile_frag
13017 s,@host_makefile_frag@,,;t t
13018 /@target_makefile_frag@/r $target_makefile_frag
13019 s,@target_makefile_frag@,,;t t
13020 /@alphaieee_frag@/r $alphaieee_frag
13021 s,@alphaieee_frag@,,;t t
13022 /@ospace_frag@/r $ospace_frag
13023 s,@ospace_frag@,,;t t
13024 CEOF
13025
13026 _ACEOF
13027
13028   cat >>$CONFIG_STATUS <<\_ACEOF
13029   # Split the substitutions into bite-sized pieces for seds with
13030   # small command number limits, like on Digital OSF/1 and HP-UX.
13031   ac_max_sed_lines=48
13032   ac_sed_frag=1 # Number of current file.
13033   ac_beg=1 # First line for current file.
13034   ac_end=$ac_max_sed_lines # Line after last line for current file.
13035   ac_more_lines=:
13036   ac_sed_cmds=
13037   while $ac_more_lines; do
13038     if test $ac_beg -gt 1; then
13039       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13040     else
13041       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
13042     fi
13043     if test ! -s $tmp/subs.frag; then
13044       ac_more_lines=false
13045     else
13046       # The purpose of the label and of the branching condition is to
13047       # speed up the sed processing (if there are no `@' at all, there
13048       # is no need to browse any of the substitutions).
13049       # These are the two extra sed commands mentioned above.
13050       (echo ':t
13051   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
13052       if test -z "$ac_sed_cmds"; then
13053         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
13054       else
13055         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
13056       fi
13057       ac_sed_frag=`expr $ac_sed_frag + 1`
13058       ac_beg=$ac_end
13059       ac_end=`expr $ac_end + $ac_max_sed_lines`
13060     fi
13061   done
13062   if test -z "$ac_sed_cmds"; then
13063     ac_sed_cmds=cat
13064   fi
13065 fi # test -n "$CONFIG_FILES"
13066
13067 _ACEOF
13068 cat >>$CONFIG_STATUS <<\_ACEOF
13069 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
13070   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
13071   case $ac_file in
13072   - | *:- | *:-:* ) # input from stdin
13073         cat >$tmp/stdin
13074         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13075         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13076   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
13077         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
13078   * )   ac_file_in=$ac_file.in ;;
13079   esac
13080
13081   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
13082   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
13083 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13084          X"$ac_file" : 'X\(//\)[^/]' \| \
13085          X"$ac_file" : 'X\(//\)$' \| \
13086          X"$ac_file" : 'X\(/\)' \| \
13087          .     : '\(.\)' 2>/dev/null ||
13088 echo X"$ac_file" |
13089     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13090           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13091           /^X\(\/\/\)$/{ s//\1/; q; }
13092           /^X\(\/\).*/{ s//\1/; q; }
13093           s/.*/./; q'`
13094   { if $as_mkdir_p; then
13095     mkdir -p "$ac_dir"
13096   else
13097     as_dir="$ac_dir"
13098     as_dirs=
13099     while test ! -d "$as_dir"; do
13100       as_dirs="$as_dir $as_dirs"
13101       as_dir=`(dirname "$as_dir") 2>/dev/null ||
13102 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
13103          X"$as_dir" : 'X\(//\)[^/]' \| \
13104          X"$as_dir" : 'X\(//\)$' \| \
13105          X"$as_dir" : 'X\(/\)' \| \
13106          .     : '\(.\)' 2>/dev/null ||
13107 echo X"$as_dir" |
13108     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
13109           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
13110           /^X\(\/\/\)$/{ s//\1/; q; }
13111           /^X\(\/\).*/{ s//\1/; q; }
13112           s/.*/./; q'`
13113     done
13114     test ! -n "$as_dirs" || mkdir $as_dirs
13115   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
13116 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
13117    { (exit 1); exit 1; }; }; }
13118
13119   ac_builddir=.
13120
13121 if test "$ac_dir" != .; then
13122   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
13123   # A "../" for each directory in $ac_dir_suffix.
13124   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
13125 else
13126   ac_dir_suffix= ac_top_builddir=
13127 fi
13128
13129 case $srcdir in
13130   .)  # No --srcdir option.  We are building in place.
13131     ac_srcdir=.
13132     if test -z "$ac_top_builddir"; then
13133        ac_top_srcdir=.
13134     else
13135        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
13136     fi ;;
13137   [\\/]* | ?:[\\/]* )  # Absolute path.
13138     ac_srcdir=$srcdir$ac_dir_suffix;
13139     ac_top_srcdir=$srcdir ;;
13140   *) # Relative path.
13141     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
13142     ac_top_srcdir=$ac_top_builddir$srcdir ;;
13143 esac
13144
13145 # Do not use `cd foo && pwd` to compute absolute paths, because
13146 # the directories may not exist.
13147 case `pwd` in
13148 .) ac_abs_builddir="$ac_dir";;
13149 *)
13150   case "$ac_dir" in
13151   .) ac_abs_builddir=`pwd`;;
13152   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
13153   *) ac_abs_builddir=`pwd`/"$ac_dir";;
13154   esac;;
13155 esac
13156 case $ac_abs_builddir in
13157 .) ac_abs_top_builddir=${ac_top_builddir}.;;
13158 *)
13159   case ${ac_top_builddir}. in
13160   .) ac_abs_top_builddir=$ac_abs_builddir;;
13161   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
13162   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
13163   esac;;
13164 esac
13165 case $ac_abs_builddir in
13166 .) ac_abs_srcdir=$ac_srcdir;;
13167 *)
13168   case $ac_srcdir in
13169   .) ac_abs_srcdir=$ac_abs_builddir;;
13170   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
13171   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13172   esac;;
13173 esac
13174 case $ac_abs_builddir in
13175 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13176 *)
13177   case $ac_top_srcdir in
13178   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13179   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13180   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13181   esac;;
13182 esac
13183
13184
13185   case $INSTALL in
13186   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13187   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13188   esac
13189
13190   if test x"$ac_file" != x-; then
13191     { echo "$as_me:$LINENO: creating $ac_file" >&5
13192 echo "$as_me: creating $ac_file" >&6;}
13193     rm -f "$ac_file"
13194   fi
13195   # Let's still pretend it is `configure' which instantiates (i.e., don't
13196   # use $as_me), people would be surprised to read:
13197   #    /* config.h.  Generated by config.status.  */
13198   if test x"$ac_file" = x-; then
13199     configure_input=
13200   else
13201     configure_input="$ac_file.  "
13202   fi
13203   configure_input=$configure_input"Generated from `echo $ac_file_in |
13204                                      sed 's,.*/,,'` by configure."
13205
13206   # First look for the input files in the build tree, otherwise in the
13207   # src tree.
13208   ac_file_inputs=`IFS=:
13209     for f in $ac_file_in; do
13210       case $f in
13211       -) echo $tmp/stdin ;;
13212       [\\/$]*)
13213          # Absolute (can't be DOS-style, as IFS=:)
13214          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13215 echo "$as_me: error: cannot find input file: $f" >&2;}
13216    { (exit 1); exit 1; }; }
13217          echo "$f";;
13218       *) # Relative
13219          if test -f "$f"; then
13220            # Build tree
13221            echo "$f"
13222          elif test -f "$srcdir/$f"; then
13223            # Source tree
13224            echo "$srcdir/$f"
13225          else
13226            # /dev/null tree
13227            { { 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          fi;;
13231       esac
13232     done` || { (exit 1); exit 1; }
13233 _ACEOF
13234 cat >>$CONFIG_STATUS <<_ACEOF
13235   sed "$ac_vpsub
13236 $extrasub
13237 _ACEOF
13238 cat >>$CONFIG_STATUS <<\_ACEOF
13239 :t
13240 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13241 s,@configure_input@,$configure_input,;t t
13242 s,@srcdir@,$ac_srcdir,;t t
13243 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13244 s,@top_srcdir@,$ac_top_srcdir,;t t
13245 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13246 s,@builddir@,$ac_builddir,;t t
13247 s,@abs_builddir@,$ac_abs_builddir,;t t
13248 s,@top_builddir@,$ac_top_builddir,;t t
13249 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13250 s,@INSTALL@,$ac_INSTALL,;t t
13251 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13252   rm -f $tmp/stdin
13253   if test x"$ac_file" != x-; then
13254     mv $tmp/out $ac_file
13255   else
13256     cat $tmp/out
13257     rm -f $tmp/out
13258   fi
13259
13260 done
13261 _ACEOF
13262
13263 cat >>$CONFIG_STATUS <<\_ACEOF
13264
13265 { (exit 0); exit 0; }
13266 _ACEOF
13267 chmod +x $CONFIG_STATUS
13268 ac_clean_files=$ac_clean_files_save
13269
13270
13271 # configure is writing to config.log, and then calls config.status.
13272 # config.status does its own redirection, appending to config.log.
13273 # Unfortunately, on DOS this fails, as config.log is still kept open
13274 # by configure, so config.status won't be able to write to it; its
13275 # output is simply discarded.  So we exec the FD to /dev/null,
13276 # effectively closing config.log, so it can be properly (re)opened and
13277 # appended to by config.status.  When coming back to configure, we
13278 # need to make the FD available again.
13279 if test "$no_create" != yes; then
13280   ac_cs_success=:
13281   ac_config_status_args=
13282   test "$silent" = yes &&
13283     ac_config_status_args="$ac_config_status_args --quiet"
13284   exec 5>/dev/null
13285   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13286   exec 5>>config.log
13287   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13288   # would make configure fail if this is the last instruction.
13289   $ac_cs_success || { (exit 1); exit 1; }
13290 fi
13291