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 RPATH_ENVVAR tooldir build_tooldir CONFIGURE_GDB_TK GDB_TK INSTALL_GDB_TK build_configargs build_configdirs host_configargs configdirs target_configargs CC_FOR_BUILD config_shell YACC BISON M4 LEX FLEX MAKEINFO EXPECT RUNTEST AR AS DLLTOOL LD LIPO NM RANLIB STRIP WINDRES WINDMC OBJCOPY OBJDUMP CFLAGS_FOR_BUILD CC_FOR_TARGET CXX_FOR_TARGET GCC_FOR_TARGET GCJ_FOR_TARGET GFORTRAN_FOR_TARGET AR_FOR_TARGET AS_FOR_TARGET DLLTOOL_FOR_TARGET LD_FOR_TARGET LIPO_FOR_TARGET NM_FOR_TARGET OBJDUMP_FOR_TARGET RANLIB_FOR_TARGET STRIP_FOR_TARGET WINDRES_FOR_TARGET WINDMC_FOR_TARGET RAW_CXX_FOR_TARGET FLAGS_FOR_TARGET COMPILER_AS_FOR_TARGET COMPILER_LD_FOR_TARGET COMPILER_NM_FOR_TARGET MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT stage1_cflags stage1_checking stage2_werror_flag datarootdir docdir pdfdir htmldir LIBOBJS LTLIBOBJS'
 276 ac_subst_files='serialization_dependencies host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag'
 277
 278 # Initialize some variables set by options.
 279 ac_init_help=
 280 ac_init_version=false
 281 # The variables have the same names as the options, with
 282 # dashes changed to underlines.
 283 cache_file=/dev/null
 284 exec_prefix=NONE
 285 no_create=
 286 no_recursion=
 287 prefix=NONE
 288 program_prefix=NONE
 289 program_suffix=NONE
 290 program_transform_name=s,x,x,
 291 silent=
 292 site=
 293 srcdir=
 294 verbose=
 295 x_includes=NONE
 296 x_libraries=NONE
 297
 298 # Installation directory options.
 299 # These are left unexpanded so users can "make install exec_prefix=/foo"
 300 # and all the variables that are supposed to be based on exec_prefix
 301 # by default will actually change.
 302 # Use braces instead of parens because sh, perl, etc. also accept them.
 303 bindir='${exec_prefix}/bin'
 304 sbindir='${exec_prefix}/sbin'
 305 libexecdir='${exec_prefix}/libexec'
 306 datadir='${prefix}/share'
 307 sysconfdir='${prefix}/etc'
 308 sharedstatedir='${prefix}/com'
 309 localstatedir='${prefix}/var'
 310 libdir='${exec_prefix}/lib'
 311 includedir='${prefix}/include'
 312 oldincludedir='/usr/include'
 313 infodir='${prefix}/info'
 314 mandir='${prefix}/man'
 315
 316 ac_prev=
 317 for ac_option
 318 do
 319   # If the previous option needs an argument, assign it.
 320   if test -n "$ac_prev"; then
 321     eval "$ac_prev=\$ac_option"
 322     ac_prev=
 323     continue
 324   fi
 325
 326   ac_optarg=`expr "x$ac_option" : 'x[^=]*=\(.*\)'`
 327
 328   # Accept the important Cygnus configure options, so we can diagnose typos.
 329
 330   case $ac_option in
 331
 332   -bindir | --bindir | --bindi | --bind | --bin | --bi)
 333     ac_prev=bindir ;;
 334   -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
 335     bindir=$ac_optarg ;;
 336
 337   -build | --build | --buil | --bui | --bu)
 338     ac_prev=build_alias ;;
 339   -build=* | --build=* | --buil=* | --bui=* | --bu=*)
 340     build_alias=$ac_optarg ;;
 341
 342   -cache-file | --cache-file | --cache-fil | --cache-fi \
 343   | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
 344     ac_prev=cache_file ;;
 345   -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
 346   | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
 347     cache_file=$ac_optarg ;;
 348
 349   --config-cache | -C)
 350     cache_file=config.cache ;;
 351
 352   -datadir | --datadir | --datadi | --datad | --data | --dat | --da)
 353     ac_prev=datadir ;;
 354   -datadir=* | --datadir=* | --datadi=* | --datad=* | --data=* | --dat=* \
 355   | --da=*)
 356     datadir=$ac_optarg ;;
 357
 358   -disable-* | --disable-*)
 359     ac_feature=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
 360     # Reject names that are not valid shell variable names.
 361     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 362       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 363    { (exit 1); exit 1; }; }
 364     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 365     eval "enable_$ac_feature=no" ;;
 366
 367   -enable-* | --enable-*)
 368     ac_feature=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
 369     # Reject names that are not valid shell variable names.
 370     expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 371       { echo "$as_me: error: invalid feature name: $ac_feature" >&2
 372    { (exit 1); exit 1; }; }
 373     ac_feature=`echo $ac_feature | sed 's/-/_/g'`
 374     case $ac_option in
 375       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 376       *) ac_optarg=yes ;;
 377     esac
 378     eval "enable_$ac_feature='$ac_optarg'" ;;
 379
 380   -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
 381   | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
 382   | --exec | --exe | --ex)
 383     ac_prev=exec_prefix ;;
 384   -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
 385   | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
 386   | --exec=* | --exe=* | --ex=*)
 387     exec_prefix=$ac_optarg ;;
 388
 389   -gas | --gas | --ga | --g)
 390     # Obsolete; use --with-gas.
 391     with_gas=yes ;;
 392
 393   -help | --help | --hel | --he | -h)
 394     ac_init_help=long ;;
 395   -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
 396     ac_init_help=recursive ;;
 397   -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
 398     ac_init_help=short ;;
 399
 400   -host | --host | --hos | --ho)
 401     ac_prev=host_alias ;;
 402   -host=* | --host=* | --hos=* | --ho=*)
 403     host_alias=$ac_optarg ;;
 404
 405   -includedir | --includedir | --includedi | --included | --include \
 406   | --includ | --inclu | --incl | --inc)
 407     ac_prev=includedir ;;
 408   -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
 409   | --includ=* | --inclu=* | --incl=* | --inc=*)
 410     includedir=$ac_optarg ;;
 411
 412   -infodir | --infodir | --infodi | --infod | --info | --inf)
 413     ac_prev=infodir ;;
 414   -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
 415     infodir=$ac_optarg ;;
 416
 417   -libdir | --libdir | --libdi | --libd)
 418     ac_prev=libdir ;;
 419   -libdir=* | --libdir=* | --libdi=* | --libd=*)
 420     libdir=$ac_optarg ;;
 421
 422   -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
 423   | --libexe | --libex | --libe)
 424     ac_prev=libexecdir ;;
 425   -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
 426   | --libexe=* | --libex=* | --libe=*)
 427     libexecdir=$ac_optarg ;;
 428
 429   -localstatedir | --localstatedir | --localstatedi | --localstated \
 430   | --localstate | --localstat | --localsta | --localst \
 431   | --locals | --local | --loca | --loc | --lo)
 432     ac_prev=localstatedir ;;
 433   -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
 434   | --localstate=* | --localstat=* | --localsta=* | --localst=* \
 435   | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)
 436     localstatedir=$ac_optarg ;;
 437
 438   -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
 439     ac_prev=mandir ;;
 440   -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
 441     mandir=$ac_optarg ;;
 442
 443   -nfp | --nfp | --nf)
 444     # Obsolete; use --without-fp.
 445     with_fp=no ;;
 446
 447   -no-create | --no-create | --no-creat | --no-crea | --no-cre \
 448   | --no-cr | --no-c | -n)
 449     no_create=yes ;;
 450
 451   -no-recursion | --no-recursion | --no-recursio | --no-recursi \
 452   | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
 453     no_recursion=yes ;;
 454
 455   -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
 456   | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
 457   | --oldin | --oldi | --old | --ol | --o)
 458     ac_prev=oldincludedir ;;
 459   -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
 460   | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
 461   | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
 462     oldincludedir=$ac_optarg ;;
 463
 464   -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
 465     ac_prev=prefix ;;
 466   -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
 467     prefix=$ac_optarg ;;
 468
 469   -program-prefix | --program-prefix | --program-prefi | --program-pref \
 470   | --program-pre | --program-pr | --program-p)
 471     ac_prev=program_prefix ;;
 472   -program-prefix=* | --program-prefix=* | --program-prefi=* \
 473   | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
 474     program_prefix=$ac_optarg ;;
 475
 476   -program-suffix | --program-suffix | --program-suffi | --program-suff \
 477   | --program-suf | --program-su | --program-s)
 478     ac_prev=program_suffix ;;
 479   -program-suffix=* | --program-suffix=* | --program-suffi=* \
 480   | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
 481     program_suffix=$ac_optarg ;;
 482
 483   -program-transform-name | --program-transform-name \
 484   | --program-transform-nam | --program-transform-na \
 485   | --program-transform-n | --program-transform- \
 486   | --program-transform | --program-transfor \
 487   | --program-transfo | --program-transf \
 488   | --program-trans | --program-tran \
 489   | --progr-tra | --program-tr | --program-t)
 490     ac_prev=program_transform_name ;;
 491   -program-transform-name=* | --program-transform-name=* \
 492   | --program-transform-nam=* | --program-transform-na=* \
 493   | --program-transform-n=* | --program-transform-=* \
 494   | --program-transform=* | --program-transfor=* \
 495   | --program-transfo=* | --program-transf=* \
 496   | --program-trans=* | --program-tran=* \
 497   | --progr-tra=* | --program-tr=* | --program-t=*)
 498     program_transform_name=$ac_optarg ;;
 499
 500   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
 501   | -silent | --silent | --silen | --sile | --sil)
 502     silent=yes ;;
 503
 504   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
 505     ac_prev=sbindir ;;
 506   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
 507   | --sbi=* | --sb=*)
 508     sbindir=$ac_optarg ;;
 509
 510   -sharedstatedir | --sharedstatedir | --sharedstatedi \
 511   | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
 512   | --sharedst | --shareds | --shared | --share | --shar \
 513   | --sha | --sh)
 514     ac_prev=sharedstatedir ;;
 515   -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
 516   | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
 517   | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
 518   | --sha=* | --sh=*)
 519     sharedstatedir=$ac_optarg ;;
 520
 521   -site | --site | --sit)
 522     ac_prev=site ;;
 523   -site=* | --site=* | --sit=*)
 524     site=$ac_optarg ;;
 525
 526   -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
 527     ac_prev=srcdir ;;
 528   -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
 529     srcdir=$ac_optarg ;;
 530
 531   -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
 532   | --syscon | --sysco | --sysc | --sys | --sy)
 533     ac_prev=sysconfdir ;;
 534   -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
 535   | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
 536     sysconfdir=$ac_optarg ;;
 537
 538   -target | --target | --targe | --targ | --tar | --ta | --t)
 539     ac_prev=target_alias ;;
 540   -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
 541     target_alias=$ac_optarg ;;
 542
 543   -v | -verbose | --verbose | --verbos | --verbo | --verb)
 544     verbose=yes ;;
 545
 546   -version | --version | --versio | --versi | --vers | -V)
 547     ac_init_version=: ;;
 548
 549   -with-* | --with-*)
 550     ac_package=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
 551     # Reject names that are not valid shell variable names.
 552     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 553       { echo "$as_me: error: invalid package name: $ac_package" >&2
 554    { (exit 1); exit 1; }; }
 555     ac_package=`echo $ac_package| sed 's/-/_/g'`
 556     case $ac_option in
 557       *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;
 558       *) ac_optarg=yes ;;
 559     esac
 560     eval "with_$ac_package='$ac_optarg'" ;;
 561
 562   -without-* | --without-*)
 563     ac_package=`expr "x$ac_option" : 'x-*without-\(.*\)'`
 564     # Reject names that are not valid shell variable names.
 565     expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&
 566       { echo "$as_me: error: invalid package name: $ac_package" >&2
 567    { (exit 1); exit 1; }; }
 568     ac_package=`echo $ac_package | sed 's/-/_/g'`
 569     eval "with_$ac_package=no" ;;
 570
 571   --x)
 572     # Obsolete; use --with-x.
 573     with_x=yes ;;
 574
 575   -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
 576   | --x-incl | --x-inc | --x-in | --x-i)
 577     ac_prev=x_includes ;;
 578   -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
 579   | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
 580     x_includes=$ac_optarg ;;
 581
 582   -x-libraries | --x-libraries | --x-librarie | --x-librari \
 583   | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
 584     ac_prev=x_libraries ;;
 585   -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
 586   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
 587     x_libraries=$ac_optarg ;;
 588
 589   -*) { echo "$as_me: error: unrecognized option: $ac_option
 590 Try \`$0 --help' for more information." >&2
 591    { (exit 1); exit 1; }; }
 592     ;;
 593
 594   *=*)
 595     ac_envvar=`expr "x$ac_option" : 'x\([^=]*\)='`
 596     # Reject names that are not valid shell variable names.
 597     expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&
 598       { echo "$as_me: error: invalid variable name: $ac_envvar" >&2
 599    { (exit 1); exit 1; }; }
 600     ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`
 601     eval "$ac_envvar='$ac_optarg'"
 602     export $ac_envvar ;;
 603
 604   *)
 605     # FIXME: should be removed in autoconf 3.0.
 606     echo "$as_me: WARNING: you should use --build, --host, --target" >&2
 607     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
 608       echo "$as_me: WARNING: invalid host type: $ac_option" >&2
 609     : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}
 610     ;;
 611
 612   esac
 613 done
 614
 615 if test -n "$ac_prev"; then
 616   ac_option=--`echo $ac_prev | sed 's/_/-/g'`
 617   { echo "$as_me: error: missing argument to $ac_option" >&2
 618    { (exit 1); exit 1; }; }
 619 fi
 620
 621 # Be sure to have absolute paths.
 622 for ac_var in exec_prefix prefix
 623 do
 624   eval ac_val=$`echo $ac_var`
 625   case $ac_val in
 626     [\\/$]* | ?:[\\/]* | NONE | '' ) ;;
 627     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 628    { (exit 1); exit 1; }; };;
 629   esac
 630 done
 631
 632 # Be sure to have absolute paths.
 633 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \
 634               localstatedir libdir includedir oldincludedir infodir mandir
 635 do
 636   eval ac_val=$`echo $ac_var`
 637   case $ac_val in
 638     [\\/$]* | ?:[\\/]* ) ;;
 639     *)  { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2
 640    { (exit 1); exit 1; }; };;
 641   esac
 642 done
 643
 644 # There might be people who depend on the old broken behavior: `$host'
 645 # used to hold the argument of --host etc.
 646 # FIXME: To remove some day.
 647 build=$build_alias
 648 host=$host_alias
 649 target=$target_alias
 650
 651 # FIXME: To remove some day.
 652 if test "x$host_alias" != x; then
 653   if test "x$build_alias" = x; then
 654     cross_compiling=maybe
 655     echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.
 656     If a cross compiler is detected then cross compile mode will be used." >&2
 657   elif test "x$build_alias" != "x$host_alias"; then
 658     cross_compiling=yes
 659   fi
 660 fi
 661
 662 ac_tool_prefix=
 663 test -n "$host_alias" && ac_tool_prefix=$host_alias-
 664
 665 test "$silent" = yes && exec 6>/dev/null
 666
 667
 668 # Find the source files, if location was not specified.
 669 if test -z "$srcdir"; then
 670   ac_srcdir_defaulted=yes
 671   # Try the directory containing this script, then its parent.
 672   ac_confdir=`(dirname "$0") 2>/dev/null ||
 673 $as_expr X"$0" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
 674          X"$0" : 'X\(//\)[^/]' \| \
 675          X"$0" : 'X\(//\)$' \| \
 676          X"$0" : 'X\(/\)' \| \
 677          .     : '\(.\)' 2>/dev/null ||
 678 echo X"$0" |
 679     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
 680           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
 681           /^X\(\/\/\)$/{ s//\1/; q; }
 682           /^X\(\/\).*/{ s//\1/; q; }
 683           s/.*/./; q'`
 684   srcdir=$ac_confdir
 685   if test ! -r $srcdir/$ac_unique_file; then
 686     srcdir=..
 687   fi
 688 else
 689   ac_srcdir_defaulted=no
 690 fi
 691 if test ! -r $srcdir/$ac_unique_file; then
 692   if test "$ac_srcdir_defaulted" = yes; then
 693     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2
 694    { (exit 1); exit 1; }; }
 695   else
 696     { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2
 697    { (exit 1); exit 1; }; }
 698   fi
 699 fi
 700 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||
 701   { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2
 702    { (exit 1); exit 1; }; }
 703 srcdir=`echo "$srcdir" | sed 's%\([^\\/]\)[\\/]*$%\1%'`
 704 ac_env_build_alias_set=${build_alias+set}
 705 ac_env_build_alias_value=$build_alias
 706 ac_cv_env_build_alias_set=${build_alias+set}
 707 ac_cv_env_build_alias_value=$build_alias
 708 ac_env_host_alias_set=${host_alias+set}
 709 ac_env_host_alias_value=$host_alias
 710 ac_cv_env_host_alias_set=${host_alias+set}
 711 ac_cv_env_host_alias_value=$host_alias
 712 ac_env_target_alias_set=${target_alias+set}
 713 ac_env_target_alias_value=$target_alias
 714 ac_cv_env_target_alias_set=${target_alias+set}
 715 ac_cv_env_target_alias_value=$target_alias
 716 ac_env_CC_set=${CC+set}
 717 ac_env_CC_value=$CC
 718 ac_cv_env_CC_set=${CC+set}
 719 ac_cv_env_CC_value=$CC
 720 ac_env_CFLAGS_set=${CFLAGS+set}
 721 ac_env_CFLAGS_value=$CFLAGS
 722 ac_cv_env_CFLAGS_set=${CFLAGS+set}
 723 ac_cv_env_CFLAGS_value=$CFLAGS
 724 ac_env_LDFLAGS_set=${LDFLAGS+set}
 725 ac_env_LDFLAGS_value=$LDFLAGS
 726 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}
 727 ac_cv_env_LDFLAGS_value=$LDFLAGS
 728 ac_env_CPPFLAGS_set=${CPPFLAGS+set}
 729 ac_env_CPPFLAGS_value=$CPPFLAGS
 730 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}
 731 ac_cv_env_CPPFLAGS_value=$CPPFLAGS
 732 ac_env_CXX_set=${CXX+set}
 733 ac_env_CXX_value=$CXX
 734 ac_cv_env_CXX_set=${CXX+set}
 735 ac_cv_env_CXX_value=$CXX
 736 ac_env_CXXFLAGS_set=${CXXFLAGS+set}
 737 ac_env_CXXFLAGS_value=$CXXFLAGS
 738 ac_cv_env_CXXFLAGS_set=${CXXFLAGS+set}
 739 ac_cv_env_CXXFLAGS_value=$CXXFLAGS
 740 ac_env_AR_set=${AR+set}
 741 ac_env_AR_value=$AR
 742 ac_cv_env_AR_set=${AR+set}
 743 ac_cv_env_AR_value=$AR
 744 ac_env_AS_set=${AS+set}
 745 ac_env_AS_value=$AS
 746 ac_cv_env_AS_set=${AS+set}
 747 ac_cv_env_AS_value=$AS
 748 ac_env_DLLTOOL_set=${DLLTOOL+set}
 749 ac_env_DLLTOOL_value=$DLLTOOL
 750 ac_cv_env_DLLTOOL_set=${DLLTOOL+set}
 751 ac_cv_env_DLLTOOL_value=$DLLTOOL
 752 ac_env_LD_set=${LD+set}
 753 ac_env_LD_value=$LD
 754 ac_cv_env_LD_set=${LD+set}
 755 ac_cv_env_LD_value=$LD
 756 ac_env_LIPO_set=${LIPO+set}
 757 ac_env_LIPO_value=$LIPO
 758 ac_cv_env_LIPO_set=${LIPO+set}
 759 ac_cv_env_LIPO_value=$LIPO
 760 ac_env_NM_set=${NM+set}
 761 ac_env_NM_value=$NM
 762 ac_cv_env_NM_set=${NM+set}
 763 ac_cv_env_NM_value=$NM
 764 ac_env_RANLIB_set=${RANLIB+set}
 765 ac_env_RANLIB_value=$RANLIB
 766 ac_cv_env_RANLIB_set=${RANLIB+set}
 767 ac_cv_env_RANLIB_value=$RANLIB
 768 ac_env_STRIP_set=${STRIP+set}
 769 ac_env_STRIP_value=$STRIP
 770 ac_cv_env_STRIP_set=${STRIP+set}
 771 ac_cv_env_STRIP_value=$STRIP
 772 ac_env_WINDRES_set=${WINDRES+set}
 773 ac_env_WINDRES_value=$WINDRES
 774 ac_cv_env_WINDRES_set=${WINDRES+set}
 775 ac_cv_env_WINDRES_value=$WINDRES
 776 ac_env_WINDMC_set=${WINDMC+set}
 777 ac_env_WINDMC_value=$WINDMC
 778 ac_cv_env_WINDMC_set=${WINDMC+set}
 779 ac_cv_env_WINDMC_value=$WINDMC
 780 ac_env_OBJCOPY_set=${OBJCOPY+set}
 781 ac_env_OBJCOPY_value=$OBJCOPY
 782 ac_cv_env_OBJCOPY_set=${OBJCOPY+set}
 783 ac_cv_env_OBJCOPY_value=$OBJCOPY
 784 ac_env_OBJDUMP_set=${OBJDUMP+set}
 785 ac_env_OBJDUMP_value=$OBJDUMP
 786 ac_cv_env_OBJDUMP_set=${OBJDUMP+set}
 787 ac_cv_env_OBJDUMP_value=$OBJDUMP
 788 ac_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 789 ac_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 790 ac_cv_env_CC_FOR_TARGET_set=${CC_FOR_TARGET+set}
 791 ac_cv_env_CC_FOR_TARGET_value=$CC_FOR_TARGET
 792 ac_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 793 ac_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 794 ac_cv_env_CXX_FOR_TARGET_set=${CXX_FOR_TARGET+set}
 795 ac_cv_env_CXX_FOR_TARGET_value=$CXX_FOR_TARGET
 796 ac_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 797 ac_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 798 ac_cv_env_GCC_FOR_TARGET_set=${GCC_FOR_TARGET+set}
 799 ac_cv_env_GCC_FOR_TARGET_value=$GCC_FOR_TARGET
 800 ac_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 801 ac_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 802 ac_cv_env_GCJ_FOR_TARGET_set=${GCJ_FOR_TARGET+set}
 803 ac_cv_env_GCJ_FOR_TARGET_value=$GCJ_FOR_TARGET
 804 ac_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 805 ac_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 806 ac_cv_env_GFORTRAN_FOR_TARGET_set=${GFORTRAN_FOR_TARGET+set}
 807 ac_cv_env_GFORTRAN_FOR_TARGET_value=$GFORTRAN_FOR_TARGET
 808 ac_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 809 ac_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 810 ac_cv_env_AR_FOR_TARGET_set=${AR_FOR_TARGET+set}
 811 ac_cv_env_AR_FOR_TARGET_value=$AR_FOR_TARGET
 812 ac_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 813 ac_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 814 ac_cv_env_AS_FOR_TARGET_set=${AS_FOR_TARGET+set}
 815 ac_cv_env_AS_FOR_TARGET_value=$AS_FOR_TARGET
 816 ac_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 817 ac_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 818 ac_cv_env_DLLTOOL_FOR_TARGET_set=${DLLTOOL_FOR_TARGET+set}
 819 ac_cv_env_DLLTOOL_FOR_TARGET_value=$DLLTOOL_FOR_TARGET
 820 ac_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 821 ac_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 822 ac_cv_env_LD_FOR_TARGET_set=${LD_FOR_TARGET+set}
 823 ac_cv_env_LD_FOR_TARGET_value=$LD_FOR_TARGET
 824 ac_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 825 ac_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 826 ac_cv_env_LIPO_FOR_TARGET_set=${LIPO_FOR_TARGET+set}
 827 ac_cv_env_LIPO_FOR_TARGET_value=$LIPO_FOR_TARGET
 828 ac_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 829 ac_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 830 ac_cv_env_NM_FOR_TARGET_set=${NM_FOR_TARGET+set}
 831 ac_cv_env_NM_FOR_TARGET_value=$NM_FOR_TARGET
 832 ac_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 833 ac_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 834 ac_cv_env_OBJDUMP_FOR_TARGET_set=${OBJDUMP_FOR_TARGET+set}
 835 ac_cv_env_OBJDUMP_FOR_TARGET_value=$OBJDUMP_FOR_TARGET
 836 ac_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 837 ac_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 838 ac_cv_env_RANLIB_FOR_TARGET_set=${RANLIB_FOR_TARGET+set}
 839 ac_cv_env_RANLIB_FOR_TARGET_value=$RANLIB_FOR_TARGET
 840 ac_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 841 ac_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 842 ac_cv_env_STRIP_FOR_TARGET_set=${STRIP_FOR_TARGET+set}
 843 ac_cv_env_STRIP_FOR_TARGET_value=$STRIP_FOR_TARGET
 844 ac_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 845 ac_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 846 ac_cv_env_WINDRES_FOR_TARGET_set=${WINDRES_FOR_TARGET+set}
 847 ac_cv_env_WINDRES_FOR_TARGET_value=$WINDRES_FOR_TARGET
 848 ac_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 849 ac_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 850 ac_cv_env_WINDMC_FOR_TARGET_set=${WINDMC_FOR_TARGET+set}
 851 ac_cv_env_WINDMC_FOR_TARGET_value=$WINDMC_FOR_TARGET
 852
 853 #
 854 # Report the --help message.
 855 #
 856 if test "$ac_init_help" = "long"; then
 857   # Omit some internal or obsolete options to make the list less imposing.
 858   # This message is too long to be a string in the A/UX 3.1 sh.
 859   cat <<_ACEOF
 860 \`configure' configures this package to adapt to many kinds of systems.
 861
 862 Usage: $0 [OPTION]... [VAR=VALUE]...
 863
 864 To assign environment variables (e.g., CC, CFLAGS...), specify them as
 865 VAR=VALUE.  See below for descriptions of some of the useful variables.
 866
 867 Defaults for the options are specified in brackets.
 868
 869 Configuration:
 870   -h, --help              display this help and exit
 871       --help=short        display options specific to this package
 872       --help=recursive    display the short help of all the included packages
 873   -V, --version           display version information and exit
 874   -q, --quiet, --silent   do not print \`checking...' messages
 875       --cache-file=FILE   cache test results in FILE [disabled]
 876   -C, --config-cache      alias for \`--cache-file=config.cache'
 877   -n, --no-create         do not create output files
 878       --srcdir=DIR        find the sources in DIR [configure dir or \`..']
 879
 880 _ACEOF
 881
 882   cat <<_ACEOF
 883 Installation directories:
 884   --prefix=PREFIX         install architecture-independent files in PREFIX
 885                           [$ac_default_prefix]
 886   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
 887                           [PREFIX]
 888
 889 By default, \`make install' will install all the files in
 890 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
 891 an installation prefix other than \`$ac_default_prefix' using \`--prefix',
 892 for instance \`--prefix=\$HOME'.
 893
 894 For better control, use the options below.
 895
 896 Fine tuning of the installation directories:
 897   --bindir=DIR           user executables [EPREFIX/bin]
 898   --sbindir=DIR          system admin executables [EPREFIX/sbin]
 899   --libexecdir=DIR       program executables [EPREFIX/libexec]
 900   --datadir=DIR          read-only architecture-independent data [PREFIX/share]
 901   --sysconfdir=DIR       read-only single-machine data [PREFIX/etc]
 902   --sharedstatedir=DIR   modifiable architecture-independent data [PREFIX/com]
 903   --localstatedir=DIR    modifiable single-machine data [PREFIX/var]
 904   --libdir=DIR           object code libraries [EPREFIX/lib]
 905   --includedir=DIR       C header files [PREFIX/include]
 906   --oldincludedir=DIR    C header files for non-gcc [/usr/include]
 907   --infodir=DIR          info documentation [PREFIX/info]
 908   --mandir=DIR           man documentation [PREFIX/man]
 909 _ACEOF
 910
 911   cat <<\_ACEOF
 912
 913 Program names:
 914   --program-prefix=PREFIX            prepend PREFIX to installed program names
 915   --program-suffix=SUFFIX            append SUFFIX to installed program names
 916   --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
 917
 918 System types:
 919   --build=BUILD     configure for building on BUILD [guessed]
 920   --host=HOST       cross-compile to build programs to run on HOST [BUILD]
 921   --target=TARGET   configure for building compilers for TARGET [HOST]
 922 _ACEOF
 923 fi
 924
 925 if test -n "$ac_init_help"; then
 926
 927   cat <<\_ACEOF
 928
 929 Optional Features:
 930   --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 931   --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 932   --enable-libada         build libada directory
 933   --enable-libssp         build libssp directory
 934   --enable-stage1-languages[=all]   choose additional languages to build during
 935                           stage1.  Mostly useful for compiler development.
 936   --enable-objc-gc        enable use of Boehm's garbage collector with the
 937                           GNU Objective-C runtime
 938   --enable-bootstrap      enable bootstrapping [yes if native build]
 939   --enable-serial-[{host,target,build}-]configure
 940                           force sequential configuration of
 941                           sub-packages for the host, target or build
 942                           machine, or all sub-packages
 943   --enable-maintainer-mode enable make rules and dependencies not useful
 944                           (and sometimes confusing) to the casual installer
 945   --enable-stage1-checking[=all]   choose additional checking for stage1
 946                           of the compiler
 947   --enable-werror         enable -Werror in bootstrap stage2 and later
 948
 949 Optional Packages:
 950   --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
 951   --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
 952   --with-build-libsubdir=DIR  Directory where to find libraries for build system
 953   --with-mpfr-dir=PATH    this option has been REMOVED
 954   --with-mpfr=PATH        specify prefix directory for installed MPFR package.
 955                           Equivalent to --with-mpfr-include=PATH/include
 956                           plus --with-mpfr-lib=PATH/lib
 957   --with-mpfr-include=PATH
 958                           specify directory for installed MPFR include files
 959   --with-mpfr-lib=PATH    specify directory for the installed MPFR library
 960   --with-gmp-dir=PATH     this option has been REMOVED
 961   --with-gmp=PATH         specify prefix directory for the installed GMP package.
 962                           Equivalent to --with-gmp-include=PATH/include
 963                           plus --with-gmp-lib=PATH/lib
 964   --with-gmp-include=PATH specify directory for installed GMP include files
 965   --with-gmp-lib=PATH     specify directory for the installed GMP library
 966   --with-build-sysroot=SYSROOT
 967                           use sysroot as the system root during the build
 968   --with-debug-prefix-map='A=B C=D ...'
 969                              map A to B, C to D ... in debug information
 970   --with-build-time-tools=PATH
 971                           use given path to find target tools during the build
 972   --with-datarootdir      use datarootdir as the data root directory.
 973   --with-docdir           install documentation in this directory.
 974   --with-pdfdir           install pdf in this directory.
 975   --with-htmldir          install html in this directory.
 976
 977 Some influential environment variables:
 978   CC          C compiler command
 979   CFLAGS      C compiler flags
 980   LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
 981               nonstandard directory <lib dir>
 982   CPPFLAGS    C/C++ preprocessor flags, e.g. -I<include dir> if you have
 983               headers in a nonstandard directory <include dir>
 984   CXX         C++ compiler command
 985   CXXFLAGS    C++ compiler flags
 986   AR          AR for the host
 987   AS          AS for the host
 988   DLLTOOL     DLLTOOL for the host
 989   LD          LD for the host
 990   LIPO        LIPO for the host
 991   NM          NM for the host
 992   RANLIB      RANLIB for the host
 993   STRIP       STRIP for the host
 994   WINDRES     WINDRES for the host
 995   WINDMC      WINDMC for the host
 996   OBJCOPY     OBJCOPY for the host
 997   OBJDUMP     OBJDUMP for the host
 998   CC_FOR_TARGET
 999               CC for the target
1000   CXX_FOR_TARGET
1001               CXX for the target
1002   GCC_FOR_TARGET
1003               GCC for the target
1004   GCJ_FOR_TARGET
1005               GCJ for the target
1006   GFORTRAN_FOR_TARGET
1007               GFORTRAN for the target
1008   AR_FOR_TARGET
1009               AR for the target
1010   AS_FOR_TARGET
1011               AS for the target
1012   DLLTOOL_FOR_TARGET
1013               DLLTOOL for the target
1014   LD_FOR_TARGET
1015               LD for the target
1016   LIPO_FOR_TARGET
1017               LIPO for the target
1018   NM_FOR_TARGET
1019               NM for the target
1020   OBJDUMP_FOR_TARGET
1021               OBJDUMP for the target
1022   RANLIB_FOR_TARGET
1023               RANLIB for the target
1024   STRIP_FOR_TARGET
1025               STRIP for the target
1026   WINDRES_FOR_TARGET
1027               WINDRES for the target
1028   WINDMC_FOR_TARGET
1029               WINDMC for the target
1030
1031 Use these variables to override the choices made by `configure' or to help
1032 it to find libraries and programs with nonstandard names/locations.
1033
1034 _ACEOF
1035 fi
1036
1037 if test "$ac_init_help" = "recursive"; then
1038   # If there are subdirs, report their specific --help.
1039   ac_popdir=`pwd`
1040   for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
1041     test -d $ac_dir || continue
1042     ac_builddir=.
1043
1044 if test "$ac_dir" != .; then
1045   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
1046   # A "../" for each directory in $ac_dir_suffix.
1047   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
1048 else
1049   ac_dir_suffix= ac_top_builddir=
1050 fi
1051
1052 case $srcdir in
1053   .)  # No --srcdir option.  We are building in place.
1054     ac_srcdir=.
1055     if test -z "$ac_top_builddir"; then
1056        ac_top_srcdir=.
1057     else
1058        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
1059     fi ;;
1060   [\\/]* | ?:[\\/]* )  # Absolute path.
1061     ac_srcdir=$srcdir$ac_dir_suffix;
1062     ac_top_srcdir=$srcdir ;;
1063   *) # Relative path.
1064     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
1065     ac_top_srcdir=$ac_top_builddir$srcdir ;;
1066 esac
1067
1068 # Do not use `cd foo && pwd` to compute absolute paths, because
1069 # the directories may not exist.
1070 case `pwd` in
1071 .) ac_abs_builddir="$ac_dir";;
1072 *)
1073   case "$ac_dir" in
1074   .) ac_abs_builddir=`pwd`;;
1075   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
1076   *) ac_abs_builddir=`pwd`/"$ac_dir";;
1077   esac;;
1078 esac
1079 case $ac_abs_builddir in
1080 .) ac_abs_top_builddir=${ac_top_builddir}.;;
1081 *)
1082   case ${ac_top_builddir}. in
1083   .) ac_abs_top_builddir=$ac_abs_builddir;;
1084   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
1085   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
1086   esac;;
1087 esac
1088 case $ac_abs_builddir in
1089 .) ac_abs_srcdir=$ac_srcdir;;
1090 *)
1091   case $ac_srcdir in
1092   .) ac_abs_srcdir=$ac_abs_builddir;;
1093   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
1094   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
1095   esac;;
1096 esac
1097 case $ac_abs_builddir in
1098 .) ac_abs_top_srcdir=$ac_top_srcdir;;
1099 *)
1100   case $ac_top_srcdir in
1101   .) ac_abs_top_srcdir=$ac_abs_builddir;;
1102   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
1103   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
1104   esac;;
1105 esac
1106
1107     cd $ac_dir
1108     # Check for guested configure; otherwise get Cygnus style configure.
1109     if test -f $ac_srcdir/configure.gnu; then
1110       echo
1111       $SHELL $ac_srcdir/configure.gnu  --help=recursive
1112     elif test -f $ac_srcdir/configure; then
1113       echo
1114       $SHELL $ac_srcdir/configure  --help=recursive
1115     elif test -f $ac_srcdir/configure.ac ||
1116            test -f $ac_srcdir/configure.in; then
1117       echo
1118       $ac_configure --help
1119     else
1120       echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
1121     fi
1122     cd $ac_popdir
1123   done
1124 fi
1125
1126 test -n "$ac_init_help" && exit 0
1127 if $ac_init_version; then
1128   cat <<\_ACEOF
1129
1130 Copyright (C) 2003 Free Software Foundation, Inc.
1131 This configure script is free software; the Free Software Foundation
1132 gives unlimited permission to copy, distribute and modify it.
1133 _ACEOF
1134   exit 0
1135 fi
1136 exec 5>config.log
1137 cat >&5 <<_ACEOF
1138 This file contains any messages produced by compilers while
1139 running configure, to aid debugging if configure makes a mistake.
1140
1141 It was created by $as_me, which was
1142 generated by GNU Autoconf 2.59.  Invocation command line was
1143
1144   $ $0 $@
1145
1146 _ACEOF
1147 {
1148 cat <<_ASUNAME
1149 ## --------- ##
1150 ## Platform. ##
1151 ## --------- ##
1152
1153 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
1154 uname -m = `(uname -m) 2>/dev/null || echo unknown`
1155 uname -r = `(uname -r) 2>/dev/null || echo unknown`
1156 uname -s = `(uname -s) 2>/dev/null || echo unknown`
1157 uname -v = `(uname -v) 2>/dev/null || echo unknown`
1158
1159 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
1160 /bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
1161
1162 /bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
1163 /usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
1164 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
1165 hostinfo               = `(hostinfo) 2>/dev/null               || echo unknown`
1166 /bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
1167 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
1168 /bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
1169
1170 _ASUNAME
1171
1172 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1173 for as_dir in $PATH
1174 do
1175   IFS=$as_save_IFS
1176   test -z "$as_dir" && as_dir=.
1177   echo "PATH: $as_dir"
1178 done
1179
1180 } >&5
1181
1182 cat >&5 <<_ACEOF
1183
1184
1185 ## ----------- ##
1186 ## Core tests. ##
1187 ## ----------- ##
1188
1189 _ACEOF
1190
1191
1192 # Keep a trace of the command line.
1193 # Strip out --no-create and --no-recursion so they do not pile up.
1194 # Strip out --silent because we don't want to record it for future runs.
1195 # Also quote any args containing shell meta-characters.
1196 # Make two passes to allow for proper duplicate-argument suppression.
1197 ac_configure_args=
1198 ac_configure_args0=
1199 ac_configure_args1=
1200 ac_sep=
1201 ac_must_keep_next=false
1202 for ac_pass in 1 2
1203 do
1204   for ac_arg
1205   do
1206     case $ac_arg in
1207     -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
1208     -q | -quiet | --quiet | --quie | --qui | --qu | --q \
1209     | -silent | --silent | --silen | --sile | --sil)
1210       continue ;;
1211     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1212       ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
1213     esac
1214     case $ac_pass in
1215     1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;
1216     2)
1217       ac_configure_args1="$ac_configure_args1 '$ac_arg'"
1218       if test $ac_must_keep_next = true; then
1219         ac_must_keep_next=false # Got value, back to normal.
1220       else
1221         case $ac_arg in
1222           *=* | --config-cache | -C | -disable-* | --disable-* \
1223           | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
1224           | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
1225           | -with-* | --with-* | -without-* | --without-* | --x)
1226             case "$ac_configure_args0 " in
1227               "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
1228             esac
1229             ;;
1230           -* ) ac_must_keep_next=true ;;
1231         esac
1232       fi
1233       ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"
1234       # Get rid of the leading space.
1235       ac_sep=" "
1236       ;;
1237     esac
1238   done
1239 done
1240 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }
1241 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }
1242
1243 # When interrupted or exit'd, cleanup temporary files, and complete
1244 # config.log.  We remove comments because anyway the quotes in there
1245 # would cause problems or look ugly.
1246 # WARNING: Be sure not to use single quotes in there, as some shells,
1247 # such as our DU 5.0 friend, will then `close' the trap.
1248 trap 'exit_status=$?
1249   # Save into config.log some information that might help in debugging.
1250   {
1251     echo
1252
1253     cat <<\_ASBOX
1254 ## ---------------- ##
1255 ## Cache variables. ##
1256 ## ---------------- ##
1257 _ASBOX
1258     echo
1259     # The following way of writing the cache mishandles newlines in values,
1260 {
1261   (set) 2>&1 |
1262     case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in
1263     *ac_space=\ *)
1264       sed -n \
1265         "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;
1266           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='"'"'\\2'"'"'/p"
1267       ;;
1268     *)
1269       sed -n \
1270         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
1271       ;;
1272     esac;
1273 }
1274     echo
1275
1276     cat <<\_ASBOX
1277 ## ----------------- ##
1278 ## Output variables. ##
1279 ## ----------------- ##
1280 _ASBOX
1281     echo
1282     for ac_var in $ac_subst_vars
1283     do
1284       eval ac_val=$`echo $ac_var`
1285       echo "$ac_var='"'"'$ac_val'"'"'"
1286     done | sort
1287     echo
1288
1289     if test -n "$ac_subst_files"; then
1290       cat <<\_ASBOX
1291 ## ------------- ##
1292 ## Output files. ##
1293 ## ------------- ##
1294 _ASBOX
1295       echo
1296       for ac_var in $ac_subst_files
1297       do
1298         eval ac_val=$`echo $ac_var`
1299         echo "$ac_var='"'"'$ac_val'"'"'"
1300       done | sort
1301       echo
1302     fi
1303
1304     if test -s confdefs.h; then
1305       cat <<\_ASBOX
1306 ## ----------- ##
1307 ## confdefs.h. ##
1308 ## ----------- ##
1309 _ASBOX
1310       echo
1311       sed "/^$/d" confdefs.h | sort
1312       echo
1313     fi
1314     test "$ac_signal" != 0 &&
1315       echo "$as_me: caught signal $ac_signal"
1316     echo "$as_me: exit $exit_status"
1317   } >&5
1318   rm -f core *.core &&
1319   rm -rf conftest* confdefs* conf$$* $ac_clean_files &&
1320     exit $exit_status
1321      ' 0
1322 for ac_signal in 1 2 13 15; do
1323   trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal
1324 done
1325 ac_signal=0
1326
1327 # confdefs.h avoids OS command line length limits that DEFS can exceed.
1328 rm -rf conftest* confdefs.h
1329 # AIX cpp loses on an empty file, so make sure it contains at least a newline.
1330 echo >confdefs.h
1331
1332 # Predefined preprocessor variables.
1333
1334 cat >>confdefs.h <<_ACEOF
1335 #define PACKAGE_NAME "$PACKAGE_NAME"
1336 _ACEOF
1337
1338
1339 cat >>confdefs.h <<_ACEOF
1340 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"
1341 _ACEOF
1342
1343
1344 cat >>confdefs.h <<_ACEOF
1345 #define PACKAGE_VERSION "$PACKAGE_VERSION"
1346 _ACEOF
1347
1348
1349 cat >>confdefs.h <<_ACEOF
1350 #define PACKAGE_STRING "$PACKAGE_STRING"
1351 _ACEOF
1352
1353
1354 cat >>confdefs.h <<_ACEOF
1355 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
1356 _ACEOF
1357
1358
1359 # Let the site file select an alternate cache file if it wants to.
1360 # Prefer explicitly selected file to automatically selected ones.
1361 if test -z "$CONFIG_SITE"; then
1362   if test "x$prefix" != xNONE; then
1363     CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"
1364   else
1365     CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
1366   fi
1367 fi
1368 for ac_site_file in $CONFIG_SITE; do
1369   if test -r "$ac_site_file"; then
1370     { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5
1371 echo "$as_me: loading site script $ac_site_file" >&6;}
1372     sed 's/^/| /' "$ac_site_file" >&5
1373     . "$ac_site_file"
1374   fi
1375 done
1376
1377 if test -r "$cache_file"; then
1378   # Some versions of bash will fail to source /dev/null (special
1379   # files actually), so we avoid doing that.
1380   if test -f "$cache_file"; then
1381     { echo "$as_me:$LINENO: loading cache $cache_file" >&5
1382 echo "$as_me: loading cache $cache_file" >&6;}
1383     case $cache_file in
1384       [\\/]* | ?:[\\/]* ) . $cache_file;;
1385       *)                      . ./$cache_file;;
1386     esac
1387   fi
1388 else
1389   { echo "$as_me:$LINENO: creating cache $cache_file" >&5
1390 echo "$as_me: creating cache $cache_file" >&6;}
1391   >$cache_file
1392 fi
1393
1394 # Check that the precious variables saved in the cache have kept the same
1395 # value.
1396 ac_cache_corrupted=false
1397 for ac_var in `(set) 2>&1 |
1398                sed -n 's/^ac_env_\([a-zA-Z_0-9]*\)_set=.*/\1/p'`; do
1399   eval ac_old_set=\$ac_cv_env_${ac_var}_set
1400   eval ac_new_set=\$ac_env_${ac_var}_set
1401   eval ac_old_val="\$ac_cv_env_${ac_var}_value"
1402   eval ac_new_val="\$ac_env_${ac_var}_value"
1403   case $ac_old_set,$ac_new_set in
1404     set,)
1405       { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
1406 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
1407       ac_cache_corrupted=: ;;
1408     ,set)
1409       { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5
1410 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
1411       ac_cache_corrupted=: ;;
1412     ,);;
1413     *)
1414       if test "x$ac_old_val" != "x$ac_new_val"; then
1415         { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5
1416 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
1417         { echo "$as_me:$LINENO:   former value:  $ac_old_val" >&5
1418 echo "$as_me:   former value:  $ac_old_val" >&2;}
1419         { echo "$as_me:$LINENO:   current value: $ac_new_val" >&5
1420 echo "$as_me:   current value: $ac_new_val" >&2;}
1421         ac_cache_corrupted=:
1422       fi;;
1423   esac
1424   # Pass precious variables to config.status.
1425   if test "$ac_new_set" = set; then
1426     case $ac_new_val in
1427     *" "*|*"    "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\"\']*)
1428       ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
1429     *) ac_arg=$ac_var=$ac_new_val ;;
1430     esac
1431     case " $ac_configure_args " in
1432       *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
1433       *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;
1434     esac
1435   fi
1436 done
1437 if $ac_cache_corrupted; then
1438   { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5
1439 echo "$as_me: error: changes in the environment can compromise the build" >&2;}
1440   { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5
1441 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}
1442    { (exit 1); exit 1; }; }
1443 fi
1444
1445 ac_ext=c
1446 ac_cpp='$CPP $CPPFLAGS'
1447 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
1448 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
1449 ac_compiler_gnu=$ac_cv_c_compiler_gnu
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471 # Find the build, host, and target systems.
1472 ac_aux_dir=
1473 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do
1474   if test -f $ac_dir/install-sh; then
1475     ac_aux_dir=$ac_dir
1476     ac_install_sh="$ac_aux_dir/install-sh -c"
1477     break
1478   elif test -f $ac_dir/install.sh; then
1479     ac_aux_dir=$ac_dir
1480     ac_install_sh="$ac_aux_dir/install.sh -c"
1481     break
1482   elif test -f $ac_dir/shtool; then
1483     ac_aux_dir=$ac_dir
1484     ac_install_sh="$ac_aux_dir/shtool install -c"
1485     break
1486   fi
1487 done
1488 if test -z "$ac_aux_dir"; then
1489   { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5
1490 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}
1491    { (exit 1); exit 1; }; }
1492 fi
1493 ac_config_guess="$SHELL $ac_aux_dir/config.guess"
1494 ac_config_sub="$SHELL $ac_aux_dir/config.sub"
1495 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.
1496
1497 # Make sure we can run config.sub.
1498 $ac_config_sub sun4 >/dev/null 2>&1 ||
1499   { { echo "$as_me:$LINENO: error: cannot run $ac_config_sub" >&5
1500 echo "$as_me: error: cannot run $ac_config_sub" >&2;}
1501    { (exit 1); exit 1; }; }
1502
1503 echo "$as_me:$LINENO: checking build system type" >&5
1504 echo $ECHO_N "checking build system type... $ECHO_C" >&6
1505 if test "${ac_cv_build+set}" = set; then
1506   echo $ECHO_N "(cached) $ECHO_C" >&6
1507 else
1508   ac_cv_build_alias=$build_alias
1509 test -z "$ac_cv_build_alias" &&
1510   ac_cv_build_alias=`$ac_config_guess`
1511 test -z "$ac_cv_build_alias" &&
1512   { { echo "$as_me:$LINENO: error: cannot guess build type; you must specify one" >&5
1513 echo "$as_me: error: cannot guess build type; you must specify one" >&2;}
1514    { (exit 1); exit 1; }; }
1515 ac_cv_build=`$ac_config_sub $ac_cv_build_alias` ||
1516   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_build_alias failed" >&5
1517 echo "$as_me: error: $ac_config_sub $ac_cv_build_alias failed" >&2;}
1518    { (exit 1); exit 1; }; }
1519
1520 fi
1521 echo "$as_me:$LINENO: result: $ac_cv_build" >&5
1522 echo "${ECHO_T}$ac_cv_build" >&6
1523 build=$ac_cv_build
1524 build_cpu=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1525 build_vendor=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1526 build_os=`echo $ac_cv_build | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1527
1528
1529  case ${build_alias} in
1530   "") build_noncanonical=${build} ;;
1531   *) build_noncanonical=${build_alias} ;;
1532 esac
1533
1534
1535
1536  case ${host_alias} in
1537   "") host_noncanonical=${build_noncanonical} ;;
1538   *) host_noncanonical=${host_alias} ;;
1539 esac
1540
1541
1542
1543  case ${target_alias} in
1544   "") target_noncanonical=${host_noncanonical} ;;
1545   *) target_noncanonical=${target_alias} ;;
1546 esac
1547
1548
1549
1550
1551 test "$host_noncanonical" = "$target_noncanonical" &&
1552   test "$program_prefix$program_suffix$program_transform_name" = \
1553     NONENONEs,x,x, &&
1554   program_transform_name=s,y,y,
1555
1556 echo "$as_me:$LINENO: checking host system type" >&5
1557 echo $ECHO_N "checking host system type... $ECHO_C" >&6
1558 if test "${ac_cv_host+set}" = set; then
1559   echo $ECHO_N "(cached) $ECHO_C" >&6
1560 else
1561   ac_cv_host_alias=$host_alias
1562 test -z "$ac_cv_host_alias" &&
1563   ac_cv_host_alias=$ac_cv_build_alias
1564 ac_cv_host=`$ac_config_sub $ac_cv_host_alias` ||
1565   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_host_alias failed" >&5
1566 echo "$as_me: error: $ac_config_sub $ac_cv_host_alias failed" >&2;}
1567    { (exit 1); exit 1; }; }
1568
1569 fi
1570 echo "$as_me:$LINENO: result: $ac_cv_host" >&5
1571 echo "${ECHO_T}$ac_cv_host" >&6
1572 host=$ac_cv_host
1573 host_cpu=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1574 host_vendor=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1575 host_os=`echo $ac_cv_host | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1576
1577
1578 echo "$as_me:$LINENO: checking target system type" >&5
1579 echo $ECHO_N "checking target system type... $ECHO_C" >&6
1580 if test "${ac_cv_target+set}" = set; then
1581   echo $ECHO_N "(cached) $ECHO_C" >&6
1582 else
1583   ac_cv_target_alias=$target_alias
1584 test "x$ac_cv_target_alias" = "x" &&
1585   ac_cv_target_alias=$ac_cv_host_alias
1586 ac_cv_target=`$ac_config_sub $ac_cv_target_alias` ||
1587   { { echo "$as_me:$LINENO: error: $ac_config_sub $ac_cv_target_alias failed" >&5
1588 echo "$as_me: error: $ac_config_sub $ac_cv_target_alias failed" >&2;}
1589    { (exit 1); exit 1; }; }
1590
1591 fi
1592 echo "$as_me:$LINENO: result: $ac_cv_target" >&5
1593 echo "${ECHO_T}$ac_cv_target" >&6
1594 target=$ac_cv_target
1595 target_cpu=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'`
1596 target_vendor=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'`
1597 target_os=`echo $ac_cv_target | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'`
1598
1599
1600 # The aliases save the names the user supplied, while $host etc.
1601 # will get canonicalized.
1602 test -n "$target_alias" &&
1603   test "$program_prefix$program_suffix$program_transform_name" = \
1604     NONENONEs,x,x, &&
1605   program_prefix=${target_alias}-
1606 test "$program_prefix" != NONE &&
1607   program_transform_name="s,^,$program_prefix,;$program_transform_name"
1608 # Use a double $ so make ignores it.
1609 test "$program_suffix" != NONE &&
1610   program_transform_name="s,\$,$program_suffix,;$program_transform_name"
1611 # Double any \ or $.  echo might interpret backslashes.
1612 # By default was `s,x,x', remove it if useless.
1613 cat <<\_ACEOF >conftest.sed
1614 s/[\\$]/&&/g;s/;s,x,x,$//
1615 _ACEOF
1616 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`
1617 rm conftest.sed
1618
1619
1620
1621 # Get 'install' or 'install-sh' and its variants.
1622 # Find a good install program.  We prefer a C program (faster),
1623 # so one script is as good as another.  But avoid the broken or
1624 # incompatible versions:
1625 # SysV /etc/install, /usr/sbin/install
1626 # SunOS /usr/etc/install
1627 # IRIX /sbin/install
1628 # AIX /bin/install
1629 # AmigaOS /C/install, which installs bootblocks on floppy discs
1630 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
1631 # AFS /usr/afsws/bin/install, which mishandles nonexistent args
1632 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
1633 # OS/2's system install, which has a completely different semantic
1634 # ./install, which can be erroneously created by make from ./install.sh.
1635 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5
1636 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6
1637 if test -z "$INSTALL"; then
1638 if test "${ac_cv_path_install+set}" = set; then
1639   echo $ECHO_N "(cached) $ECHO_C" >&6
1640 else
1641   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
1642 for as_dir in $PATH
1643 do
1644   IFS=$as_save_IFS
1645   test -z "$as_dir" && as_dir=.
1646   # Account for people who put trailing slashes in PATH elements.
1647 case $as_dir/ in
1648   ./ | .// | /cC/* | \
1649   /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
1650   ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
1651   /usr/ucb/* ) ;;
1652   *)
1653     # OSF1 and SCO ODT 3.0 have their own names for install.
1654     # Don't use installbsd from OSF since it installs stuff as root
1655     # by default.
1656     for ac_prog in ginstall scoinst install; do
1657       for ac_exec_ext in '' $ac_executable_extensions; do
1658         if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
1659           if test $ac_prog = install &&
1660             grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1661             # AIX install.  It has an incompatible calling convention.
1662             :
1663           elif test $ac_prog = install &&
1664             grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
1665             # program-specific install script used by HP pwplus--don't use.
1666             :
1667           else
1668             ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
1669             break 3
1670           fi
1671         fi
1672       done
1673     done
1674     ;;
1675 esac
1676 done
1677
1678
1679 fi
1680   if test "${ac_cv_path_install+set}" = set; then
1681     INSTALL=$ac_cv_path_install
1682   else
1683     # As a last resort, use the slow shell script.  We don't cache a
1684     # path for INSTALL within a source directory, because that will
1685     # break other packages using the cache if that directory is
1686     # removed, or if the path is relative.
1687     INSTALL=$ac_install_sh
1688   fi
1689 fi
1690 echo "$as_me:$LINENO: result: $INSTALL" >&5
1691 echo "${ECHO_T}$INSTALL" >&6
1692
1693 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.
1694 # It thinks the first close brace ends the variable substitution.
1695 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
1696
1697 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
1698
1699 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
1700
1701 echo "$as_me:$LINENO: checking whether ln works" >&5
1702 echo $ECHO_N "checking whether ln works... $ECHO_C" >&6
1703 if test "${acx_cv_prog_LN+set}" = set; then
1704   echo $ECHO_N "(cached) $ECHO_C" >&6
1705 else
1706   rm -f conftestdata_t
1707 echo >conftestdata_f
1708 if ln conftestdata_f conftestdata_t 2>/dev/null
1709 then
1710   acx_cv_prog_LN=ln
1711 else
1712   acx_cv_prog_LN=no
1713 fi
1714 rm -f conftestdata_f conftestdata_t
1715
1716 fi
1717 if test $acx_cv_prog_LN = no; then
1718   LN="cp"
1719   echo "$as_me:$LINENO: result: no, using $LN" >&5
1720 echo "${ECHO_T}no, using $LN" >&6
1721 else
1722   LN="$acx_cv_prog_LN"
1723   echo "$as_me:$LINENO: result: yes" >&5
1724 echo "${ECHO_T}yes" >&6
1725 fi
1726
1727 echo "$as_me:$LINENO: checking whether ln -s works" >&5
1728 echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
1729 LN_S=$as_ln_s
1730 if test "$LN_S" = "ln -s"; then
1731   echo "$as_me:$LINENO: result: yes" >&5
1732 echo "${ECHO_T}yes" >&6
1733 else
1734   echo "$as_me:$LINENO: result: no, using $LN_S" >&5
1735 echo "${ECHO_T}no, using $LN_S" >&6
1736 fi
1737
1738
1739 ### we might need to use some other shell than /bin/sh for running subshells
1740 ### If we are on Windows, search for the shell.  This will permit people
1741 ### to not have /bin/sh, but to be able to see /SOME/PATH/sh configure
1742 ### without also having to set CONFIG_SHELL.  This code will work when
1743 ### using bash, which sets OSTYPE.
1744 case "${OSTYPE}" in
1745 *win32*)
1746   if test x${CONFIG_SHELL} = x ; then
1747     if test ! -f /bin/sh ; then
1748       if test x${SHELL} != x && test -f ${SHELL} ; then
1749         CONFIG_SHELL=${SHELL}
1750         export CONFIG_SHELL
1751       else
1752         for prog in sh sh.exe bash bash.exe; do
1753           IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
1754           for dir in $PATH; do
1755             test -z "$dir" && dir=.
1756             if test -f $dir/$prog; then
1757               CONFIG_SHELL=$dir/$prog
1758               export CONFIG_SHELL
1759               break
1760             fi
1761           done
1762           IFS="$save_ifs"
1763           test -n "${CONFIG_SHELL}" && break
1764         done
1765       fi
1766     fi
1767   fi
1768   ;;
1769 esac
1770
1771 config_shell=${CONFIG_SHELL-/bin/sh}
1772
1773 progname=$0
1774 # if PWD already has a value, it is probably wrong.
1775 if test -n "$PWD" ; then PWD=`${PWDCMD-pwd}`; fi
1776
1777 # Export original configure arguments for use by sub-configures.
1778 # Quote arguments with shell meta charatcers.
1779 TOPLEVEL_CONFIGURE_ARGUMENTS=
1780 set -- "$progname" "$@"
1781 for ac_arg
1782 do
1783   case "$ac_arg" in
1784   *" "*|*"      "*|*[\[\]\~\#\$\^\&\*\(\)\{\}\\\|\;\<\>\?\']*)
1785     ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"`
1786     # if the argument is of the form -foo=baz, quote the baz part only
1787     ac_arg=`echo "'$ac_arg'" | sed "s/^'\([-a-zA-Z0-9]*=\)/\\1'/"` ;;
1788   *) ;;
1789   esac
1790   # Add the quoted argument to the list.
1791   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS $ac_arg"
1792 done
1793 if test "$silent" = yes; then
1794   TOPLEVEL_CONFIGURE_ARGUMENTS="$TOPLEVEL_CONFIGURE_ARGUMENTS --silent"
1795 fi
1796 # Remove the initial space we just introduced and, as these will be
1797 # expanded by make, quote '$'.
1798 TOPLEVEL_CONFIGURE_ARGUMENTS=`echo "x$TOPLEVEL_CONFIGURE_ARGUMENTS" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
1799
1800
1801 moveifchange=${srcdir}/move-if-change
1802
1803 srcpwd=`cd ${srcdir} ; ${PWDCMD-pwd}`
1804
1805 # We pass INSTALL explicitly to sub-makes.  Make sure that it is not
1806 # a relative path.
1807 if test "$INSTALL" = "${srcdir}/install-sh -c"; then
1808   INSTALL="${srcpwd}/install-sh -c"
1809 fi
1810
1811 # Set srcdir to "." if that's what it is.
1812 # This is important for multilib support.
1813 pwd=`${PWDCMD-pwd}`
1814 if test "${pwd}" = "${srcpwd}" ; then
1815   srcdir=.
1816 fi
1817
1818 topsrcdir=$srcpwd
1819
1820 extra_host_args=
1821
1822 ### To add a new directory to the tree, first choose whether it is a target
1823 ### or a host dependent tool.  Then put it into the appropriate list
1824 ### (library or tools, host or target), doing a dependency sort.
1825
1826 # Subdirs will be configured in the order listed in build_configdirs,
1827 # configdirs, or target_configdirs; see the serialization section below.
1828
1829 # Dependency sorting is only needed when *configuration* must be done in
1830 # a particular order.  In all cases a dependency should be specified in
1831 # the Makefile, whether or not it's implicitly specified here.
1832
1833 # Double entries in build_configdirs, configdirs, or target_configdirs may
1834 # cause circular dependencies and break everything horribly.
1835
1836 # these library is used by various programs built for the build
1837 # environment
1838 #
1839 build_libs="build-libiberty"
1840
1841 # these tools are built for the build environment
1842 build_tools="build-texinfo build-byacc build-flex build-bison build-m4 build-fixincludes"
1843
1844 # these libraries are used by various programs built for the host environment
1845 #
1846 host_libs="intl mmalloc libiberty opcodes bfd readline tcl tk itcl libgui zlib libcpp libdecnumber gmp mpfr"
1847
1848 # these tools are built for the host environment
1849 # Note, the powerpc-eabi build depends on sim occurring before gdb in order to
1850 # know that we are building the simulator.
1851 # binutils, gas and ld appear in that order because it makes sense to run
1852 # "make check" in that particular order.
1853 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"
1854
1855 # libgcj represents the runtime libraries only used by gcj.
1856 libgcj="target-libffi \
1857         target-zlib \
1858         target-qthreads \
1859         target-libjava"
1860
1861 # these libraries are built for the target environment, and are built after
1862 # the host libraries and the host tools (which may be a cross compiler)
1863 #
1864 target_libraries="target-libgcc \
1865                 target-libiberty \
1866                 target-libgloss \
1867                 target-newlib \
1868                 target-libstdc++-v3 \
1869                 target-libmudflap \
1870                 target-libssp \
1871                 target-libgfortran \
1872                 target-boehm-gc \
1873                 ${libgcj} \
1874                 target-libobjc \
1875                 target-libada \
1876                 target-libgomp"
1877
1878 # these tools are built using the target libraries, and are intended to
1879 # run only in the target environment
1880 #
1881 # note: any program that *uses* libraries that are in the "target_libraries"
1882 # list belongs in this list.  those programs are also very likely
1883 # candidates for the "native_only" list which follows
1884 #
1885 target_tools="target-examples target-groff target-gperf target-rda"
1886
1887 ################################################################################
1888
1889 ## All tools belong in one of the four categories, and are assigned above
1890 ## We assign ${configdirs} this way to remove all embedded newlines.  This
1891 ## is important because configure will choke if they ever get through.
1892 ## ${configdirs} is directories we build using the host tools.
1893 ## ${target_configdirs} is directories we build using the target tools.
1894 configdirs=`echo ${host_libs} ${host_tools}`
1895 target_configdirs=`echo ${target_libraries} ${target_tools}`
1896 build_configdirs=`echo ${build_libs} ${build_tools}`
1897
1898 ################################################################################
1899
1900 srcname="gnu development package"
1901
1902 # This gets set non-empty for some net releases of packages.
1903 appdirs=""
1904
1905 # Define is_cross_compiler to save on calls to 'test'.
1906 is_cross_compiler=
1907 if test x"${host}" = x"${target}" ; then
1908   is_cross_compiler=no
1909 else
1910   is_cross_compiler=yes
1911 fi
1912
1913 # Find the build and target subdir names.
1914
1915 # post-stage1 host modules use a different CC_FOR_BUILD so, in order to
1916 # have matching libraries, they should use host libraries: Makefile.tpl
1917 # arranges to pass --with-build-libsubdir=$(HOST_SUBDIR).
1918 # However, they still use the build modules, because the corresponding
1919 # host modules (e.g. bison) are only built for the host when bootstrap
1920 # finishes. So:
1921 # - build_subdir is where we find build modules, and never changes.
1922 # - build_libsubdir is where we find build libraries, and can be overridden.
1923
1924 # Prefix 'build-' so this never conflicts with target_subdir.
1925 build_subdir="build-${build_noncanonical}"
1926
1927 # Check whether --with-build-libsubdir or --without-build-libsubdir was given.
1928 if test "${with_build_libsubdir+set}" = set; then
1929   withval="$with_build_libsubdir"
1930   build_libsubdir="$withval"
1931 else
1932   build_libsubdir="$build_subdir"
1933 fi;
1934 # --srcdir=. covers the toplevel, while "test -d" covers the subdirectories
1935 if ( test $srcdir = . && test -d gcc ) \
1936    || test -d $srcdir/../host-${host_noncanonical}; then
1937   host_subdir="host-${host_noncanonical}"
1938 else
1939   host_subdir=.
1940 fi
1941 # No prefix.
1942 target_subdir=${target_noncanonical}
1943
1944
1945 # Skipdirs are removed silently.
1946 skipdirs=
1947 # Noconfigdirs are removed loudly.
1948 noconfigdirs=""
1949
1950 use_gnu_ld=
1951 # Make sure we don't let GNU ld be added if we didn't want it.
1952 if test x$with_gnu_ld = xno ; then
1953   use_gnu_ld=no
1954   noconfigdirs="$noconfigdirs ld"
1955 fi
1956
1957 use_gnu_as=
1958 # Make sure we don't let GNU as be added if we didn't want it.
1959 if test x$with_gnu_as = xno ; then
1960   use_gnu_as=no
1961   noconfigdirs="$noconfigdirs gas"
1962 fi
1963
1964 # some tools are so dependent upon X11 that if we're not building with X,
1965 # it's not even worth trying to configure, much less build, that tool.
1966
1967 case ${with_x} in
1968   yes | "") ;; # the default value for this tree is that X11 is available
1969   no)
1970     skipdirs="${skipdirs} tk itcl libgui"
1971     # We won't be able to build gdbtk without X.
1972     enable_gdbtk=no
1973     ;;
1974   *)  echo "*** bad value \"${with_x}\" for -with-x flag; ignored" 1>&2 ;;
1975 esac
1976
1977 # Some tools are only suitable for building in a "native" situation.
1978 # Remove these if host!=target.
1979 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"
1980
1981 # Similarly, some are only suitable for cross toolchains.
1982 # Remove these if host=target.
1983 cross_only="target-libgloss target-newlib target-opcodes"
1984
1985 case $is_cross_compiler in
1986   no) skipdirs="${skipdirs} ${cross_only}" ;;
1987   yes) skipdirs="${skipdirs} ${native_only}" ;;
1988 esac
1989
1990 # If both --with-headers and --with-libs are specified, default to
1991 # --without-newlib.
1992 if test x"${with_headers}" != x && test x"${with_headers}" != xno \
1993    && test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
1994   if test x"${with_newlib}" = x ; then
1995     with_newlib=no
1996   fi
1997 fi
1998
1999 # Recognize --with-newlib/--without-newlib.
2000 case ${with_newlib} in
2001   no) skipdirs="${skipdirs} target-newlib" ;;
2002   yes) skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'` ;;
2003 esac
2004
2005 # Configure extra directories which are host specific
2006
2007 case "${host}" in
2008   *-cygwin*)
2009     configdirs="$configdirs libtermcap" ;;
2010 esac
2011
2012 # A target can indicate whether a language isn't supported for some reason.
2013 # Only spaces may be used in this macro; not newlines or tabs.
2014 unsupported_languages=
2015
2016 # Remove more programs from consideration, based on the host or
2017 # target this usually means that a port of the program doesn't
2018 # exist yet.
2019
2020 case "${host}" in
2021   hppa*64*-*-*)
2022     noconfigdirs="$noconfigdirs byacc"
2023     ;;
2024   i[3456789]86-*-vsta)
2025     noconfigdirs="$noconfigdirs tcl expect dejagnu make texinfo bison patch flex byacc send-pr gprof uudecode dejagnu diff guile perl itcl gnuserv gettext"
2026     ;;
2027   i[3456789]86-*-go32* | i[3456789]86-*-msdosdjgpp*)
2028     noconfigdirs="$noconfigdirs tcl tk expect dejagnu send-pr uudecode guile itcl gnuserv libffi"
2029     ;;
2030   x86_64-*-mingw*)
2031     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2032     ;;
2033   i[3456789]86-*-mingw32*)
2034     # noconfigdirs="tcl tk expect dejagnu make texinfo bison patch flex byacc send-pr uudecode dejagnu diff guile perl itcl gnuserv"
2035     noconfigdirs="$noconfigdirs expect dejagnu autoconf automake send-pr rcs guile perl texinfo libtool newlib"
2036     ;;
2037   i[3456789]86-*-beos*)
2038     noconfigdirs="$noconfigdirs tk itcl libgui gdb"
2039     ;;
2040   *-*-cygwin*)
2041     noconfigdirs="$noconfigdirs autoconf automake send-pr rcs guile perl"
2042     ;;
2043   *-*-netbsd*)
2044     noconfigdirs="$noconfigdirs rcs"
2045     ;;
2046   ppc*-*-pe)
2047     noconfigdirs="$noconfigdirs patch diff make tk tcl expect dejagnu autoconf automake texinfo bison send-pr gprof rcs guile perl itcl gnuserv"
2048     ;;
2049   powerpc-*-beos*)
2050     noconfigdirs="$noconfigdirs tk itcl libgui gdb dejagnu readline"
2051     ;;
2052 esac
2053
2054
2055 # Check whether --enable-libada or --disable-libada was given.
2056 if test "${enable_libada+set}" = set; then
2057   enableval="$enable_libada"
2058   ENABLE_LIBADA=$enableval
2059 else
2060   ENABLE_LIBADA=yes
2061 fi;
2062 if test "${ENABLE_LIBADA}" != "yes" ; then
2063   noconfigdirs="$noconfigdirs gnattools"
2064 fi
2065
2066 # Check whether --enable-libssp or --disable-libssp was given.
2067 if test "${enable_libssp+set}" = set; then
2068   enableval="$enable_libssp"
2069   ENABLE_LIBSSP=$enableval
2070 else
2071   ENABLE_LIBSSP=yes
2072 fi;
2073
2074 # Save it here so that, even in case of --enable-libgcj, if the Java
2075 # front-end isn't enabled, we still get libgcj disabled.
2076 libgcj_saved=$libgcj
2077 case $enable_libgcj in
2078 yes)
2079   # If we reset it here, it won't get added to noconfigdirs in the
2080   # target-specific build rules, so it will be forcibly enabled
2081   # (unless the Java language itself isn't enabled).
2082   libgcj=
2083   ;;
2084 no)
2085   # Make sure we get it printed in the list of not supported target libs.
2086   noconfigdirs="$noconfigdirs ${libgcj}"
2087   ;;
2088 esac
2089
2090
2091 # Disable libmudflap on some systems.
2092 if test x$enable_libmudflap = x ; then
2093     case "${target}" in
2094     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu | bfin*-*-uclinux*)
2095         # Enable libmudflap by default in GNU and friends.
2096         ;;
2097     *-*-freebsd*)
2098         # Enable libmudflap by default in FreeBSD.
2099         ;;
2100     *)
2101         # Disable it by default everywhere else.
2102         noconfigdirs="$noconfigdirs target-libmudflap"
2103         ;;
2104     esac
2105 fi
2106
2107 # Disable libgomp on non POSIX hosted systems.
2108 if test x$enable_libgomp = x ; then
2109     # Enable libgomp by default on hosted POSIX systems.
2110     case "${target}" in
2111     *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2112         ;;
2113     *-*-netbsd* | *-*-freebsd* | *-*-openbsd*)
2114         ;;
2115     *-*-solaris2* | *-*-sysv4* | *-*-irix6* | *-*-osf* | *-*-hpux11*)
2116         ;;
2117     *-*-darwin* | *-*-aix*)
2118         ;;
2119     *)
2120         noconfigdirs="$noconfigdirs target-libgomp"
2121         ;;
2122     esac
2123 fi
2124
2125 # Default libgloss CPU subdirectory.
2126 libgloss_dir="$target_cpu"
2127
2128 case "${target}" in
2129   *-*-chorusos)
2130     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2131     ;;
2132   powerpc-*-darwin* | i[3456789]86-*-darwin*)
2133     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2134     noconfigdirs="$noconfigdirs sim target-rda"
2135     ;;
2136   *-*-darwin*)
2137     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2138     noconfigdirs="$noconfigdirs sim target-rda"
2139     noconfigdirs="$noconfigdirs ${libgcj}"
2140     ;;
2141   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2142     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2143     ;;
2144   *-*-freebsd*)
2145     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2146     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2147         && test -f /usr/local/include/gmp.h; then
2148       with_gmp=/usr/local
2149     fi
2150
2151     # Skip some stuff that's unsupported on some FreeBSD configurations.
2152     case "${target}" in
2153       i*86-*-*) ;;
2154       alpha*-*-*) ;;
2155       *)
2156         noconfigdirs="$noconfigdirs ${libgcj}"
2157         ;;
2158     esac
2159     ;;
2160   *-*-kaos*)
2161     # Remove unsupported stuff on all kaOS configurations.
2162     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2163     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2164     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2165     noconfigdirs="$noconfigdirs target-libgloss"
2166     ;;
2167   *-*-netbsd*)
2168     # Skip some stuff on all NetBSD configurations.
2169     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2170
2171     # Skip some stuff that's unsupported on some NetBSD configurations.
2172     case "${target}" in
2173       i*86-*-netbsdelf*) ;;
2174       arm*-*-netbsdelf*) ;;
2175       *)
2176         noconfigdirs="$noconfigdirs ${libgcj}"
2177         ;;
2178     esac
2179     ;;
2180   *-*-netware*)
2181     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2182     ;;
2183   *-*-rtems*)
2184     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2185     ;;
2186     # The tpf target doesn't support gdb yet.
2187   *-*-tpf*)
2188     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2189     ;;
2190   *-*-uclinux*)
2191     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2192     ;;
2193   *-*-vxworks*)
2194     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2195     ;;
2196   alpha*-dec-osf*)
2197     # ld works, but does not support shared libraries.
2198     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2199     # gas doesn't generate exception information.
2200     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2201     ;;
2202   alpha*-*-*vms*)
2203     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2204     ;;
2205   alpha*-*-linux*)
2206     # newlib is not 64 bit ready
2207     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2208     ;;
2209   alpha*-*-*)
2210     # newlib is not 64 bit ready
2211     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2212     ;;
2213   am33_2.0-*-linux*)
2214     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2215     ;;
2216   sh-*-linux*)
2217     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2218     ;;
2219   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2220     noconfigdirs="$noconfigdirs ${libgcj}"
2221     noconfigdirs="$noconfigdirs target-examples"
2222     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2223     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2224     noconfigdirs="$noconfigdirs expect dejagnu"
2225     # the C++ libraries don't build on top of CE's C libraries
2226     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2227     noconfigdirs="$noconfigdirs target-newlib"
2228     case "${host}" in
2229       *-*-cygwin*) ;; # keep gdb and readline
2230       *) noconfigdirs="$noconfigdirs gdb readline"
2231          ;;
2232     esac
2233     libgloss_dir=wince
2234     ;;
2235   arc-*-*)
2236     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2237     ;;
2238   arm-semi-aof )
2239     ;;
2240   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2241     noconfigdirs="$noconfigdirs ${libgcj}"
2242     libgloss_dir=arm
2243     ;;
2244   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2245     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2246     libgloss_dir=arm
2247     ;;
2248   arm*-*-linux-gnueabi)
2249     noconfigdirs="$noconfigdirs target-qthreads"
2250     noconfigdirs="$noconfigdirs target-libobjc"
2251     case ${with_newlib} in
2252       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2253     esac
2254     libgloss_dir=arm
2255     ;;
2256   arm*-*-symbianelf*)
2257     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2258     libgloss_dir=arm
2259     ;;
2260   arm-*-pe*)
2261     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2262     ;;
2263   thumb-*-coff)
2264     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2265     ;;
2266   thumb-*-elf)
2267     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2268     ;;
2269   thumb-*-pe)
2270     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2271     ;;
2272   arm-*-riscix*)
2273     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2274     ;;
2275   avr-*-*)
2276     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2277     ;;
2278   bfin-*-*)
2279     noconfigdirs="$noconfigdirs gdb"
2280     if test x${is_cross_compiler} != xno ; then
2281       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2282     fi
2283     ;;
2284   c4x-*-* | tic4x-*-*)
2285     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2286     ;;
2287   c54x*-*-* | tic54x-*-*)
2288     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2289     ;;
2290   cris-*-* | crisv32-*-*)
2291     unsupported_languages="$unsupported_languages java"
2292     case "${target}" in
2293       *-*-aout)
2294         unsupported_languages="$unsupported_languages fortran"
2295         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2296       *-*-elf)
2297         unsupported_languages="$unsupported_languages fortran"
2298         noconfigdirs="$noconfigdirs target-boehm-gc";;
2299       *-*-linux*)
2300         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2301       *)
2302         unsupported_languages="$unsupported_languages fortran"
2303         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2304     esac
2305     libgloss_dir=cris
2306     ;;
2307   crx-*-*)
2308     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2309     ;;
2310   d10v-*-*)
2311     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2312     ;;
2313   d30v-*-*)
2314     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2315     ;;
2316   ep9312-*-elf | ep9312-*-coff)
2317     libgloss_dir=arm
2318     ;;
2319   fr30-*-elf*)
2320     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2321     ;;
2322   frv-*-*)
2323     noconfigdirs="$noconfigdirs ${libgcj}"
2324     ;;
2325   h8300*-*-*)
2326     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2327     ;;
2328   h8500-*-*)
2329     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2330     ;;
2331   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2332     ;;
2333   hppa*64*-*-linux* | parisc*64*-*-linux*)
2334     # In this case, it's because the hppa64-linux target is for
2335     # the kernel only at this point and has no libc, and thus no
2336     # headers, crt*.o, etc., all of which are needed by these.
2337     noconfigdirs="$noconfigdirs target-zlib"
2338     ;;
2339   parisc*-*-linux* | hppa*-*-linux*)
2340     ;;
2341   hppa*-*-*elf* | \
2342   hppa*-*-lites* | \
2343   hppa*-*-openbsd* | \
2344   hppa*64*-*-*)
2345     noconfigdirs="$noconfigdirs ${libgcj}"
2346     ;;
2347   hppa*-hp-hpux11*)
2348     noconfigdirs="$noconfigdirs ld shellutils"
2349     ;;
2350   hppa*-*-pro*)
2351     libgloss_dir=pa
2352     ;;
2353   hppa*-*-*)
2354     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2355     # build on HP-UX 10.20.
2356     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2357     ;;
2358   i960-*-*)
2359     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2360     ;;
2361   ia64*-*-elf*)
2362     # No gdb support yet.
2363     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2364     ;;
2365   ia64*-**-hpux*)
2366     # No gdb or ld support yet.
2367     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2368     ;;
2369   i370-*-opened*)
2370     ;;
2371   i[3456789]86-*-coff | i[3456789]86-*-elf)
2372     noconfigdirs="$noconfigdirs ${libgcj}"
2373     libgloss_dir=i386
2374     ;;
2375   i[3456789]86-*-linux*)
2376     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2377     # not build java stuff by default.
2378     case "${target}" in
2379       *-*-*libc1*)
2380         noconfigdirs="$noconfigdirs ${libgcj}";;
2381     esac
2382
2383     # This section makes it possible to build newlib natively on linux.
2384     # If we are using a cross compiler then don't configure newlib.
2385     if test x${is_cross_compiler} != xno ; then
2386       noconfigdirs="$noconfigdirs target-newlib"
2387     fi
2388     noconfigdirs="$noconfigdirs target-libgloss"
2389     # If we are not using a cross compiler, do configure newlib.
2390     # Note however, that newlib will only be configured in this situation
2391     # if the --with-newlib option has been given, because otherwise
2392     # 'target-newlib' will appear in skipdirs.
2393     ;;
2394   i[3456789]86-*-mingw32*)
2395     target_configdirs="$target_configdirs target-winsup"
2396     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2397     ;;
2398   x86_64-*-mingw*)
2399     target_configdirs="$target_configdirs target-winsup"
2400     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2401     ;;
2402   *-*-cygwin*)
2403     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2404     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2405     # always build newlib if winsup directory is present.
2406     if test -d "$srcdir/winsup/cygwin"; then
2407       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2408     elif test -d "$srcdir/newlib"; then
2409       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2410     fi
2411     ;;
2412   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2413   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2414     ;;
2415   i[3456789]86-*-pe)
2416     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2417     ;;
2418   i[3456789]86-*-sco3.2v5*)
2419     # The linker does not yet know about weak symbols in COFF,
2420     # and is not configured to handle mixed ELF and COFF.
2421     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2422     ;;
2423   i[3456789]86-*-sco*)
2424     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2425     ;;
2426   i[3456789]86-*-solaris2*)
2427     noconfigdirs="$noconfigdirs target-libgloss"
2428     ;;
2429   i[3456789]86-*-sysv4*)
2430     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2431     ;;
2432   i[3456789]86-*-beos*)
2433     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2434     ;;
2435   i[3456789]86-*-rdos*)
2436     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2437     ;;
2438   m32r-*-*)
2439     noconfigdirs="$noconfigdirs ${libgcj}"
2440     ;;
2441   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2442     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2443     libgloss_dir=m68hc11
2444     ;;
2445   m68k-*-elf*)
2446     noconfigdirs="$noconfigdirs ${libgcj}"
2447     ;;
2448   m68k-*-coff*)
2449     noconfigdirs="$noconfigdirs ${libgcj}"
2450     ;;
2451   m68*-*-* | fido-*-*)
2452     libgloss_dir=m68k
2453     ;;
2454   mcore-*-pe*)
2455   # The EPOC C++ environment does not support exceptions or rtti,
2456   # and so building libstdc++-v3 tends not to always work.
2457     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2458     ;;
2459   mmix-*-*)
2460     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2461     unsupported_languages="$unsupported_languages fortran java"
2462     ;;
2463   mn10200-*-*)
2464     noconfigdirs="$noconfigdirs ${libgcj}"
2465     ;;
2466   mn10300-*-*)
2467     noconfigdirs="$noconfigdirs ${libgcj}"
2468     ;;
2469   mt-*-*)
2470     noconfigdirs="$noconfigdirs sim"
2471     ;;
2472   powerpc-*-aix*)
2473     # copied from rs6000-*-* entry
2474     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2475     ;;
2476   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2477     target_configdirs="$target_configdirs target-winsup"
2478     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2479     # always build newlib.
2480     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2481     ;;
2482     # This is temporary until we can link against shared libraries
2483   powerpcle-*-solaris*)
2484     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2485     libgloss_dir=rs6000
2486     ;;
2487   powerpc-*-beos*)
2488     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2489     ;;
2490   powerpc-*-eabi)
2491     noconfigdirs="$noconfigdirs ${libgcj}"
2492     libgloss_dir=rs6000
2493     ;;
2494   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2495     libgloss_dir=rs6000
2496     ;;
2497   rs6000-*-lynxos*)
2498     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2499     ;;
2500   rs6000-*-aix*)
2501     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2502     ;;
2503   rs6000-*-*)
2504     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2505     ;;
2506   m68k-apollo-*)
2507     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2508     ;;
2509   mips*-*-irix5*)
2510     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2511     ;;
2512   mips*-*-irix6*)
2513     # Linking libjava exceeds command-line length limits on at least
2514     # IRIX 6.2, but not on IRIX 6.5.
2515     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2516     # <oldham@codesourcery.com>
2517     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2518     ;;
2519   mips*-*-bsd*)
2520     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2521     ;;
2522   mips64*-*-linux*)
2523     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2524     ;;
2525   mips*-*-linux*)
2526     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2527     ;;
2528   mips*-*-*)
2529     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2530     libgloss_dir=mips
2531     ;;
2532   romp-*-*)
2533     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2534     ;;
2535   sh-*-* | sh64-*-*)
2536     case "${host}" in
2537       i[3456789]86-*-vsta) ;; # don't add gprof back in
2538       i[3456789]86-*-go32*) ;; # don't add gprof back in
2539       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2540       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2541     esac
2542     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2543     ;;
2544   sparclet-*-aout* | sparc86x-*-*)
2545     libgloss_dir=sparc
2546     ;;
2547   sparc-*-elf*)
2548     noconfigdirs="$noconfigdirs ${libgcj}"
2549     ;;
2550   sparc64-*-elf*)
2551     noconfigdirs="$noconfigdirs ${libgcj}"
2552     libgloss_dir=sparc
2553     ;;
2554   sparclite-*-*)
2555     noconfigdirs="$noconfigdirs ${libgcj}"
2556     libgloss_dir=sparc
2557     ;;
2558   sparc-*-sunos4*)
2559     noconfigdirs="$noconfigdirs ${libgcj}"
2560     if test x${is_cross_compiler} != xno ; then
2561            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2562     else
2563            use_gnu_ld=no
2564     fi
2565     ;;
2566   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2567     noconfigdirs="$noconfigdirs ${libgcj}"
2568     ;;
2569   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2570     ;;
2571   spu-*-*)
2572     skipdirs="target-libssp"
2573     ;;
2574   v810-*-*)
2575     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2576     ;;
2577   v850-*-*)
2578     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2579     ;;
2580   v850e-*-*)
2581     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2582     ;;
2583   v850ea-*-*)
2584     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2585     ;;
2586   vax-*-vms)
2587     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2588     ;;
2589   vax-*-*)
2590     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2591     ;;
2592   xtensa-*-*)
2593     noconfigdirs="$noconfigdirs ${libgcj}"
2594     ;;
2595   ip2k-*-*)
2596     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2597     ;;
2598   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2599     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2600     ;;
2601   *-*-lynxos*)
2602     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2603     ;;
2604   *-*-*)
2605     noconfigdirs="$noconfigdirs ${libgcj}"
2606     ;;
2607 esac
2608
2609 # If we aren't building newlib, then don't build libgloss, since libgloss
2610 # depends upon some newlib header files.
2611 case "${noconfigdirs}" in
2612   *target-libgloss*) ;;
2613   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2614 esac
2615
2616 # Work in distributions that contain no compiler tools, like Autoconf.
2617 tentative_cc=""
2618 host_makefile_frag=/dev/null
2619 if test -d ${srcdir}/config ; then
2620 case "${host}" in
2621   m68k-hp-hpux*)
2622     # Avoid "too much defining" errors from HPUX compiler.
2623     tentative_cc="cc -Wp,-H256000"
2624     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2625     # If it's HP/UX ar, this should be harmless.
2626     RANLIB="ar ts"
2627     ;;
2628   m68k-apollo-sysv*)
2629     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2630     ;;
2631   m68k-apollo-bsd*)
2632     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2633     # chokes on bfd, the compiler won't let you assign integers to enums, and
2634     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2635     # the apollo compiler" (the preferred version of GCC could be called cc,
2636     # or whatever), but I'm not sure leaving CC as cc is any better...
2637     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2638     # Used to have BISON=yacc.
2639     tentative_cc=gcc
2640     ;;
2641   m88k-dg-dgux*)
2642     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2643     ;;
2644   m88k-harris-cxux*)
2645     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2646     tentative_cc="cc -Xa"
2647     host_makefile_frag="config/mh-cxux"
2648     ;;
2649   m88k-motorola-sysv*)
2650     ;;
2651   mips*-dec-ultrix*)
2652     tentative_cc="cc -Wf,-XNg1000"
2653     host_makefile_frag="config/mh-decstation"
2654     ;;
2655   mips*-nec-sysv4*)
2656     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2657     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2658     host_makefile_frag="config/mh-necv4"
2659     ;;
2660   mips*-sgi-irix4*)
2661     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2662     # environment.  Also bump switch table size so that cp-parse will
2663     # compile.  Bump string length limit so linker builds.
2664     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2665     ;;
2666   mips*-*-sysv4*)
2667     host_makefile_frag="config/mh-sysv4"
2668     ;;
2669   mips*-*-sysv*)
2670     # This is for a MIPS running RISC/os 4.52C.
2671
2672     # This is needed for GDB, but needs to be in the top-level make because
2673     # if a library is compiled with the bsd headers and gets linked with the
2674     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2675     # a different size).
2676     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2677     # known except to select the sysv environment.  Could we use /proc instead?
2678     # These "sysv environments" and "bsd environments" often end up being a pain.
2679     #
2680     # This is not part of CFLAGS because perhaps not all C compilers have this
2681     # option.
2682     tentative_cc="cc -systype sysv"
2683     ;;
2684   i370-ibm-opened*)
2685     tentative_cc="c89"
2686     ;;
2687   i[3456789]86-*-sysv5*)
2688     host_makefile_frag="config/mh-sysv5"
2689     ;;
2690   i[3456789]86-*-dgux*)
2691     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2692     host_makefile_frag="config/mh-dgux386"
2693     ;;
2694   i[3456789]86-ncr-sysv4.3*)
2695     # The MetaWare compiler will generate a copyright message unless you
2696     # turn it off by adding the -Hnocopyr flag.
2697     tentative_cc="cc -Hnocopyr"
2698     ;;
2699   i[3456789]86-ncr-sysv4*)
2700     # for an NCR 3000 (i486/SVR4) system.
2701     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2702     # This compiler not only emits obnoxious copyright messages every time
2703     # you run it, but it chokes and dies on a whole bunch of GNU source
2704     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2705     tentative_cc="/usr/ccs/ATT/cc"
2706     host_makefile_frag="config/mh-ncr3000"
2707     ;;
2708   i[3456789]86-*-sco3.2v5*)
2709     ;;
2710   i[3456789]86-*-sco*)
2711     # The native C compiler botches some simple uses of const.  Unfortunately,
2712     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2713     tentative_cc="cc -Dconst="
2714     host_makefile_frag="config/mh-sco"
2715     ;;
2716   i[3456789]86-*-udk*)
2717     host_makefile_frag="config/mh-sysv5"
2718     ;;
2719   i[3456789]86-*-solaris2*)
2720     host_makefile_frag="config/mh-sysv4"
2721     ;;
2722   i[3456789]86-*-msdosdjgpp*)
2723     host_makefile_frag="config/mh-djgpp"
2724     ;;
2725   *-cygwin*)
2726     host_makefile_frag="config/mh-cygwin"
2727     ;;
2728   *-mingw32*)
2729     ;;
2730   *-mingw64*)
2731     ;;
2732   *-interix*)
2733     host_makefile_frag="config/mh-interix"
2734     ;;
2735   vax-*-ultrix2*)
2736     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2737     tentative_cc=gcc
2738     ;;
2739   *-*-solaris2*)
2740     host_makefile_frag="config/mh-solaris"
2741     ;;
2742   m68k-sun-sunos*)
2743     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2744     # without overflowing the jump tables (-J says to use a 32 bit table)
2745     tentative_cc="cc -J"
2746     ;;
2747   *-hp-hpux*)
2748     tentative_cc="cc -Wp,-H256000"
2749     ;;
2750   *-*-hiux*)
2751     tentative_cc="cc -Wp,-H256000"
2752     ;;
2753   rs6000-*-lynxos*)
2754     # /bin/cc is less than useful for our purposes.  Always use GCC
2755     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2756     host_makefile_frag="config/mh-lynxrs6k"
2757     ;;
2758   powerpc-*-darwin*)
2759     host_makefile_frag="config/mh-ppc-darwin"
2760     ;;
2761   powerpc-*-aix*)
2762     host_makefile_frag="config/mh-ppc-aix"
2763     ;;
2764   rs6000-*-aix*)
2765     host_makefile_frag="config/mh-ppc-aix"
2766     ;;
2767   *-*-lynxos*)
2768     # /bin/cc is less than useful for our purposes.  Always use GCC
2769     tentative_cc="/bin/gcc"
2770     ;;
2771   *-*-sysv4*)
2772     host_makefile_frag="config/mh-sysv4"
2773     ;;
2774   # This is placed last to prevent interfering with the cases above.
2775   i[3456789]86-*-*)
2776     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2777     host_makefile_frag="config/mh-x86omitfp"
2778     ;;
2779 esac
2780 fi
2781
2782 # If we aren't going to be using gcc, see if we can extract a definition
2783 # of CC from the fragment.
2784 # Actually, use the 'pre-extracted' version above.
2785 if test -z "${CC}" && test "${build}" = "${host}" ; then
2786   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2787   found=
2788   for dir in $PATH; do
2789     test -z "$dir" && dir=.
2790     if test -f $dir/gcc; then
2791       found=yes
2792       break
2793     fi
2794   done
2795   IFS="$save_ifs"
2796   if test -z "${found}" && test -n "${tentative_cc}" ; then
2797     CC=$tentative_cc
2798   fi
2799 fi
2800
2801 if test "${build}" != "${host}" ; then
2802   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2803 else
2804   CC_FOR_BUILD="\$(CC)"
2805 fi
2806
2807 ac_ext=c
2808 ac_cpp='$CPP $CPPFLAGS'
2809 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2810 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2811 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2812 if test -n "$ac_tool_prefix"; then
2813   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2814 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2815 echo "$as_me:$LINENO: checking for $ac_word" >&5
2816 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2817 if test "${ac_cv_prog_CC+set}" = set; then
2818   echo $ECHO_N "(cached) $ECHO_C" >&6
2819 else
2820   if test -n "$CC"; then
2821   ac_cv_prog_CC="$CC" # Let the user override the test.
2822 else
2823 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2824 for as_dir in $PATH
2825 do
2826   IFS=$as_save_IFS
2827   test -z "$as_dir" && as_dir=.
2828   for ac_exec_ext in '' $ac_executable_extensions; do
2829   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2830     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2831     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2832     break 2
2833   fi
2834 done
2835 done
2836
2837 fi
2838 fi
2839 CC=$ac_cv_prog_CC
2840 if test -n "$CC"; then
2841   echo "$as_me:$LINENO: result: $CC" >&5
2842 echo "${ECHO_T}$CC" >&6
2843 else
2844   echo "$as_me:$LINENO: result: no" >&5
2845 echo "${ECHO_T}no" >&6
2846 fi
2847
2848 fi
2849 if test -z "$ac_cv_prog_CC"; then
2850   ac_ct_CC=$CC
2851   # Extract the first word of "gcc", so it can be a program name with args.
2852 set dummy gcc; ac_word=$2
2853 echo "$as_me:$LINENO: checking for $ac_word" >&5
2854 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2855 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2856   echo $ECHO_N "(cached) $ECHO_C" >&6
2857 else
2858   if test -n "$ac_ct_CC"; then
2859   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2860 else
2861 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2862 for as_dir in $PATH
2863 do
2864   IFS=$as_save_IFS
2865   test -z "$as_dir" && as_dir=.
2866   for ac_exec_ext in '' $ac_executable_extensions; do
2867   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2868     ac_cv_prog_ac_ct_CC="gcc"
2869     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2870     break 2
2871   fi
2872 done
2873 done
2874
2875 fi
2876 fi
2877 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2878 if test -n "$ac_ct_CC"; then
2879   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2880 echo "${ECHO_T}$ac_ct_CC" >&6
2881 else
2882   echo "$as_me:$LINENO: result: no" >&5
2883 echo "${ECHO_T}no" >&6
2884 fi
2885
2886   CC=$ac_ct_CC
2887 else
2888   CC="$ac_cv_prog_CC"
2889 fi
2890
2891 if test -z "$CC"; then
2892   if test -n "$ac_tool_prefix"; then
2893   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2894 set dummy ${ac_tool_prefix}cc; ac_word=$2
2895 echo "$as_me:$LINENO: checking for $ac_word" >&5
2896 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2897 if test "${ac_cv_prog_CC+set}" = set; then
2898   echo $ECHO_N "(cached) $ECHO_C" >&6
2899 else
2900   if test -n "$CC"; then
2901   ac_cv_prog_CC="$CC" # Let the user override the test.
2902 else
2903 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2904 for as_dir in $PATH
2905 do
2906   IFS=$as_save_IFS
2907   test -z "$as_dir" && as_dir=.
2908   for ac_exec_ext in '' $ac_executable_extensions; do
2909   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2910     ac_cv_prog_CC="${ac_tool_prefix}cc"
2911     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2912     break 2
2913   fi
2914 done
2915 done
2916
2917 fi
2918 fi
2919 CC=$ac_cv_prog_CC
2920 if test -n "$CC"; then
2921   echo "$as_me:$LINENO: result: $CC" >&5
2922 echo "${ECHO_T}$CC" >&6
2923 else
2924   echo "$as_me:$LINENO: result: no" >&5
2925 echo "${ECHO_T}no" >&6
2926 fi
2927
2928 fi
2929 if test -z "$ac_cv_prog_CC"; then
2930   ac_ct_CC=$CC
2931   # Extract the first word of "cc", so it can be a program name with args.
2932 set dummy cc; ac_word=$2
2933 echo "$as_me:$LINENO: checking for $ac_word" >&5
2934 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2935 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2936   echo $ECHO_N "(cached) $ECHO_C" >&6
2937 else
2938   if test -n "$ac_ct_CC"; then
2939   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2940 else
2941 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2942 for as_dir in $PATH
2943 do
2944   IFS=$as_save_IFS
2945   test -z "$as_dir" && as_dir=.
2946   for ac_exec_ext in '' $ac_executable_extensions; do
2947   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2948     ac_cv_prog_ac_ct_CC="cc"
2949     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2950     break 2
2951   fi
2952 done
2953 done
2954
2955 fi
2956 fi
2957 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2958 if test -n "$ac_ct_CC"; then
2959   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2960 echo "${ECHO_T}$ac_ct_CC" >&6
2961 else
2962   echo "$as_me:$LINENO: result: no" >&5
2963 echo "${ECHO_T}no" >&6
2964 fi
2965
2966   CC=$ac_ct_CC
2967 else
2968   CC="$ac_cv_prog_CC"
2969 fi
2970
2971 fi
2972 if test -z "$CC"; then
2973   # Extract the first word of "cc", so it can be a program name with args.
2974 set dummy cc; ac_word=$2
2975 echo "$as_me:$LINENO: checking for $ac_word" >&5
2976 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2977 if test "${ac_cv_prog_CC+set}" = set; then
2978   echo $ECHO_N "(cached) $ECHO_C" >&6
2979 else
2980   if test -n "$CC"; then
2981   ac_cv_prog_CC="$CC" # Let the user override the test.
2982 else
2983   ac_prog_rejected=no
2984 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2985 for as_dir in $PATH
2986 do
2987   IFS=$as_save_IFS
2988   test -z "$as_dir" && as_dir=.
2989   for ac_exec_ext in '' $ac_executable_extensions; do
2990   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2991     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2992        ac_prog_rejected=yes
2993        continue
2994      fi
2995     ac_cv_prog_CC="cc"
2996     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2997     break 2
2998   fi
2999 done
3000 done
3001
3002 if test $ac_prog_rejected = yes; then
3003   # We found a bogon in the path, so make sure we never use it.
3004   set dummy $ac_cv_prog_CC
3005   shift
3006   if test $# != 0; then
3007     # We chose a different compiler from the bogus one.
3008     # However, it has the same basename, so the bogon will be chosen
3009     # first if we set CC to just the basename; use the full file name.
3010     shift
3011     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3012   fi
3013 fi
3014 fi
3015 fi
3016 CC=$ac_cv_prog_CC
3017 if test -n "$CC"; then
3018   echo "$as_me:$LINENO: result: $CC" >&5
3019 echo "${ECHO_T}$CC" >&6
3020 else
3021   echo "$as_me:$LINENO: result: no" >&5
3022 echo "${ECHO_T}no" >&6
3023 fi
3024
3025 fi
3026 if test -z "$CC"; then
3027   if test -n "$ac_tool_prefix"; then
3028   for ac_prog in cl
3029   do
3030     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3031 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3032 echo "$as_me:$LINENO: checking for $ac_word" >&5
3033 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3034 if test "${ac_cv_prog_CC+set}" = set; then
3035   echo $ECHO_N "(cached) $ECHO_C" >&6
3036 else
3037   if test -n "$CC"; then
3038   ac_cv_prog_CC="$CC" # Let the user override the test.
3039 else
3040 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3041 for as_dir in $PATH
3042 do
3043   IFS=$as_save_IFS
3044   test -z "$as_dir" && as_dir=.
3045   for ac_exec_ext in '' $ac_executable_extensions; do
3046   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3047     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3048     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3049     break 2
3050   fi
3051 done
3052 done
3053
3054 fi
3055 fi
3056 CC=$ac_cv_prog_CC
3057 if test -n "$CC"; then
3058   echo "$as_me:$LINENO: result: $CC" >&5
3059 echo "${ECHO_T}$CC" >&6
3060 else
3061   echo "$as_me:$LINENO: result: no" >&5
3062 echo "${ECHO_T}no" >&6
3063 fi
3064
3065     test -n "$CC" && break
3066   done
3067 fi
3068 if test -z "$CC"; then
3069   ac_ct_CC=$CC
3070   for ac_prog in cl
3071 do
3072   # Extract the first word of "$ac_prog", so it can be a program name with args.
3073 set dummy $ac_prog; ac_word=$2
3074 echo "$as_me:$LINENO: checking for $ac_word" >&5
3075 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3076 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3077   echo $ECHO_N "(cached) $ECHO_C" >&6
3078 else
3079   if test -n "$ac_ct_CC"; then
3080   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3081 else
3082 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3083 for as_dir in $PATH
3084 do
3085   IFS=$as_save_IFS
3086   test -z "$as_dir" && as_dir=.
3087   for ac_exec_ext in '' $ac_executable_extensions; do
3088   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3089     ac_cv_prog_ac_ct_CC="$ac_prog"
3090     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3091     break 2
3092   fi
3093 done
3094 done
3095
3096 fi
3097 fi
3098 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3099 if test -n "$ac_ct_CC"; then
3100   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3101 echo "${ECHO_T}$ac_ct_CC" >&6
3102 else
3103   echo "$as_me:$LINENO: result: no" >&5
3104 echo "${ECHO_T}no" >&6
3105 fi
3106
3107   test -n "$ac_ct_CC" && break
3108 done
3109
3110   CC=$ac_ct_CC
3111 fi
3112
3113 fi
3114
3115
3116 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3117 See \`config.log' for more details." >&5
3118 echo "$as_me: error: no acceptable C compiler found in \$PATH
3119 See \`config.log' for more details." >&2;}
3120    { (exit 1); exit 1; }; }
3121
3122 # Provide some information about the compiler.
3123 echo "$as_me:$LINENO:" \
3124      "checking for C compiler version" >&5
3125 ac_compiler=`set X $ac_compile; echo $2`
3126 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3127   (eval $ac_compiler --version </dev/null >&5) 2>&5
3128   ac_status=$?
3129   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3130   (exit $ac_status); }
3131 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3132   (eval $ac_compiler -v </dev/null >&5) 2>&5
3133   ac_status=$?
3134   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3135   (exit $ac_status); }
3136 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3137   (eval $ac_compiler -V </dev/null >&5) 2>&5
3138   ac_status=$?
3139   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3140   (exit $ac_status); }
3141
3142 cat >conftest.$ac_ext <<_ACEOF
3143 /* confdefs.h.  */
3144 _ACEOF
3145 cat confdefs.h >>conftest.$ac_ext
3146 cat >>conftest.$ac_ext <<_ACEOF
3147 /* end confdefs.h.  */
3148
3149 int
3150 main ()
3151 {
3152
3153   ;
3154   return 0;
3155 }
3156 _ACEOF
3157 ac_clean_files_save=$ac_clean_files
3158 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3159 # Try to create an executable without -o first, disregard a.out.
3160 # It will help us diagnose broken compilers, and finding out an intuition
3161 # of exeext.
3162 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3163 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3164 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3165 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3166   (eval $ac_link_default) 2>&5
3167   ac_status=$?
3168   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3169   (exit $ac_status); }; then
3170   # Find the output, starting from the most likely.  This scheme is
3171 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3172 # resort.
3173
3174 # Be careful to initialize this variable, since it used to be cached.
3175 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3176 ac_cv_exeext=
3177 # b.out is created by i960 compilers.
3178 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3179 do
3180   test -f "$ac_file" || continue
3181   case $ac_file in
3182     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3183         ;;
3184     conftest.$ac_ext )
3185         # This is the source file.
3186         ;;
3187     [ab].out )
3188         # We found the default executable, but exeext='' is most
3189         # certainly right.
3190         break;;
3191     *.* )
3192         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3193         # FIXME: I believe we export ac_cv_exeext for Libtool,
3194         # but it would be cool to find out if it's true.  Does anybody
3195         # maintain Libtool? --akim.
3196         export ac_cv_exeext
3197         break;;
3198     * )
3199         break;;
3200   esac
3201 done
3202 else
3203   echo "$as_me: failed program was:" >&5
3204 sed 's/^/| /' conftest.$ac_ext >&5
3205
3206 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3207 See \`config.log' for more details." >&5
3208 echo "$as_me: error: C compiler cannot create executables
3209 See \`config.log' for more details." >&2;}
3210    { (exit 77); exit 77; }; }
3211 fi
3212
3213 ac_exeext=$ac_cv_exeext
3214 echo "$as_me:$LINENO: result: $ac_file" >&5
3215 echo "${ECHO_T}$ac_file" >&6
3216
3217 # Check the compiler produces executables we can run.  If not, either
3218 # the compiler is broken, or we cross compile.
3219 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3220 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3221 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3222 # If not cross compiling, check that we can run a simple program.
3223 if test "$cross_compiling" != yes; then
3224   if { ac_try='./$ac_file'
3225   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3226   (eval $ac_try) 2>&5
3227   ac_status=$?
3228   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3229   (exit $ac_status); }; }; then
3230     cross_compiling=no
3231   else
3232     if test "$cross_compiling" = maybe; then
3233         cross_compiling=yes
3234     else
3235         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3236 If you meant to cross compile, use \`--host'.
3237 See \`config.log' for more details." >&5
3238 echo "$as_me: error: cannot run C compiled programs.
3239 If you meant to cross compile, use \`--host'.
3240 See \`config.log' for more details." >&2;}
3241    { (exit 1); exit 1; }; }
3242     fi
3243   fi
3244 fi
3245 echo "$as_me:$LINENO: result: yes" >&5
3246 echo "${ECHO_T}yes" >&6
3247
3248 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3249 ac_clean_files=$ac_clean_files_save
3250 # Check the compiler produces executables we can run.  If not, either
3251 # the compiler is broken, or we cross compile.
3252 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3253 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3254 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3255 echo "${ECHO_T}$cross_compiling" >&6
3256
3257 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3258 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3259 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3260   (eval $ac_link) 2>&5
3261   ac_status=$?
3262   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3263   (exit $ac_status); }; then
3264   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3265 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3266 # work properly (i.e., refer to `conftest.exe'), while it won't with
3267 # `rm'.
3268 for ac_file in conftest.exe conftest conftest.*; do
3269   test -f "$ac_file" || continue
3270   case $ac_file in
3271     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3272     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3273           export ac_cv_exeext
3274           break;;
3275     * ) break;;
3276   esac
3277 done
3278 else
3279   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3280 See \`config.log' for more details." >&5
3281 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3282 See \`config.log' for more details." >&2;}
3283    { (exit 1); exit 1; }; }
3284 fi
3285
3286 rm -f conftest$ac_cv_exeext
3287 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3288 echo "${ECHO_T}$ac_cv_exeext" >&6
3289
3290 rm -f conftest.$ac_ext
3291 EXEEXT=$ac_cv_exeext
3292 ac_exeext=$EXEEXT
3293 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3294 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3295 if test "${ac_cv_objext+set}" = set; then
3296   echo $ECHO_N "(cached) $ECHO_C" >&6
3297 else
3298   cat >conftest.$ac_ext <<_ACEOF
3299 /* confdefs.h.  */
3300 _ACEOF
3301 cat confdefs.h >>conftest.$ac_ext
3302 cat >>conftest.$ac_ext <<_ACEOF
3303 /* end confdefs.h.  */
3304
3305 int
3306 main ()
3307 {
3308
3309   ;
3310   return 0;
3311 }
3312 _ACEOF
3313 rm -f conftest.o conftest.obj
3314 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3315   (eval $ac_compile) 2>&5
3316   ac_status=$?
3317   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3318   (exit $ac_status); }; then
3319   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3320   case $ac_file in
3321     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3322     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3323        break;;
3324   esac
3325 done
3326 else
3327   echo "$as_me: failed program was:" >&5
3328 sed 's/^/| /' conftest.$ac_ext >&5
3329
3330 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3331 See \`config.log' for more details." >&5
3332 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3333 See \`config.log' for more details." >&2;}
3334    { (exit 1); exit 1; }; }
3335 fi
3336
3337 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3338 fi
3339 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3340 echo "${ECHO_T}$ac_cv_objext" >&6
3341 OBJEXT=$ac_cv_objext
3342 ac_objext=$OBJEXT
3343 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3344 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3345 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3346   echo $ECHO_N "(cached) $ECHO_C" >&6
3347 else
3348   cat >conftest.$ac_ext <<_ACEOF
3349 /* confdefs.h.  */
3350 _ACEOF
3351 cat confdefs.h >>conftest.$ac_ext
3352 cat >>conftest.$ac_ext <<_ACEOF
3353 /* end confdefs.h.  */
3354
3355 int
3356 main ()
3357 {
3358 #ifndef __GNUC__
3359        choke me
3360 #endif
3361
3362   ;
3363   return 0;
3364 }
3365 _ACEOF
3366 rm -f conftest.$ac_objext
3367 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3368   (eval $ac_compile) 2>conftest.er1
3369   ac_status=$?
3370   grep -v '^ *+' conftest.er1 >conftest.err
3371   rm -f conftest.er1
3372   cat conftest.err >&5
3373   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3374   (exit $ac_status); } &&
3375          { ac_try='test -z "$ac_c_werror_flag"
3376                          || test ! -s conftest.err'
3377   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3378   (eval $ac_try) 2>&5
3379   ac_status=$?
3380   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3381   (exit $ac_status); }; } &&
3382          { ac_try='test -s conftest.$ac_objext'
3383   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3384   (eval $ac_try) 2>&5
3385   ac_status=$?
3386   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3387   (exit $ac_status); }; }; then
3388   ac_compiler_gnu=yes
3389 else
3390   echo "$as_me: failed program was:" >&5
3391 sed 's/^/| /' conftest.$ac_ext >&5
3392
3393 ac_compiler_gnu=no
3394 fi
3395 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3396 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3397
3398 fi
3399 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3400 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3401 GCC=`test $ac_compiler_gnu = yes && echo yes`
3402 ac_test_CFLAGS=${CFLAGS+set}
3403 ac_save_CFLAGS=$CFLAGS
3404 CFLAGS="-g"
3405 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3406 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3407 if test "${ac_cv_prog_cc_g+set}" = set; then
3408   echo $ECHO_N "(cached) $ECHO_C" >&6
3409 else
3410   cat >conftest.$ac_ext <<_ACEOF
3411 /* confdefs.h.  */
3412 _ACEOF
3413 cat confdefs.h >>conftest.$ac_ext
3414 cat >>conftest.$ac_ext <<_ACEOF
3415 /* end confdefs.h.  */
3416
3417 int
3418 main ()
3419 {
3420
3421   ;
3422   return 0;
3423 }
3424 _ACEOF
3425 rm -f conftest.$ac_objext
3426 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3427   (eval $ac_compile) 2>conftest.er1
3428   ac_status=$?
3429   grep -v '^ *+' conftest.er1 >conftest.err
3430   rm -f conftest.er1
3431   cat conftest.err >&5
3432   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3433   (exit $ac_status); } &&
3434          { ac_try='test -z "$ac_c_werror_flag"
3435                          || test ! -s conftest.err'
3436   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3437   (eval $ac_try) 2>&5
3438   ac_status=$?
3439   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3440   (exit $ac_status); }; } &&
3441          { ac_try='test -s conftest.$ac_objext'
3442   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3443   (eval $ac_try) 2>&5
3444   ac_status=$?
3445   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3446   (exit $ac_status); }; }; then
3447   ac_cv_prog_cc_g=yes
3448 else
3449   echo "$as_me: failed program was:" >&5
3450 sed 's/^/| /' conftest.$ac_ext >&5
3451
3452 ac_cv_prog_cc_g=no
3453 fi
3454 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3455 fi
3456 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3457 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3458 if test "$ac_test_CFLAGS" = set; then
3459   CFLAGS=$ac_save_CFLAGS
3460 elif test $ac_cv_prog_cc_g = yes; then
3461   if test "$GCC" = yes; then
3462     CFLAGS="-g -O2"
3463   else
3464     CFLAGS="-g"
3465   fi
3466 else
3467   if test "$GCC" = yes; then
3468     CFLAGS="-O2"
3469   else
3470     CFLAGS=
3471   fi
3472 fi
3473 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3474 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3475 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3476   echo $ECHO_N "(cached) $ECHO_C" >&6
3477 else
3478   ac_cv_prog_cc_stdc=no
3479 ac_save_CC=$CC
3480 cat >conftest.$ac_ext <<_ACEOF
3481 /* confdefs.h.  */
3482 _ACEOF
3483 cat confdefs.h >>conftest.$ac_ext
3484 cat >>conftest.$ac_ext <<_ACEOF
3485 /* end confdefs.h.  */
3486 #include <stdarg.h>
3487 #include <stdio.h>
3488 #include <sys/types.h>
3489 #include <sys/stat.h>
3490 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3491 struct buf { int x; };
3492 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3493 static char *e (p, i)
3494      char **p;
3495      int i;
3496 {
3497   return p[i];
3498 }
3499 static char *f (char * (*g) (char **, int), char **p, ...)
3500 {
3501   char *s;
3502   va_list v;
3503   va_start (v,p);
3504   s = g (p, va_arg (v,int));
3505   va_end (v);
3506   return s;
3507 }
3508
3509 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3510    function prototypes and stuff, but not '\xHH' hex character constants.
3511    These don't provoke an error unfortunately, instead are silently treated
3512    as 'x'.  The following induces an error, until -std1 is added to get
3513    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3514    array size at least.  It's necessary to write '\x00'==0 to get something
3515    that's true only with -std1.  */
3516 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3517
3518 int test (int i, double x);
3519 struct s1 {int (*f) (int a);};
3520 struct s2 {int (*f) (double a);};
3521 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3522 int argc;
3523 char **argv;
3524 int
3525 main ()
3526 {
3527 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3528   ;
3529   return 0;
3530 }
3531 _ACEOF
3532 # Don't try gcc -ansi; that turns off useful extensions and
3533 # breaks some systems' header files.
3534 # AIX                   -qlanglvl=ansi
3535 # Ultrix and OSF/1      -std1
3536 # HP-UX 10.20 and later -Ae
3537 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3538 # SVR4                  -Xc -D__EXTENSIONS__
3539 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3540 do
3541   CC="$ac_save_CC $ac_arg"
3542   rm -f conftest.$ac_objext
3543 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3544   (eval $ac_compile) 2>conftest.er1
3545   ac_status=$?
3546   grep -v '^ *+' conftest.er1 >conftest.err
3547   rm -f conftest.er1
3548   cat conftest.err >&5
3549   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3550   (exit $ac_status); } &&
3551          { ac_try='test -z "$ac_c_werror_flag"
3552                          || test ! -s conftest.err'
3553   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3554   (eval $ac_try) 2>&5
3555   ac_status=$?
3556   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3557   (exit $ac_status); }; } &&
3558          { ac_try='test -s conftest.$ac_objext'
3559   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3560   (eval $ac_try) 2>&5
3561   ac_status=$?
3562   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3563   (exit $ac_status); }; }; then
3564   ac_cv_prog_cc_stdc=$ac_arg
3565 break
3566 else
3567   echo "$as_me: failed program was:" >&5
3568 sed 's/^/| /' conftest.$ac_ext >&5
3569
3570 fi
3571 rm -f conftest.err conftest.$ac_objext
3572 done
3573 rm -f conftest.$ac_ext conftest.$ac_objext
3574 CC=$ac_save_CC
3575
3576 fi
3577
3578 case "x$ac_cv_prog_cc_stdc" in
3579   x|xno)
3580     echo "$as_me:$LINENO: result: none needed" >&5
3581 echo "${ECHO_T}none needed" >&6 ;;
3582   *)
3583     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3584 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3585     CC="$CC $ac_cv_prog_cc_stdc" ;;
3586 esac
3587
3588 # Some people use a C++ compiler to compile C.  Since we use `exit',
3589 # in C++ we need to declare it.  In case someone uses the same compiler
3590 # for both compiling C and C++ we need to have the C++ compiler decide
3591 # the declaration of exit, since it's the most demanding environment.
3592 cat >conftest.$ac_ext <<_ACEOF
3593 #ifndef __cplusplus
3594   choke me
3595 #endif
3596 _ACEOF
3597 rm -f conftest.$ac_objext
3598 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3599   (eval $ac_compile) 2>conftest.er1
3600   ac_status=$?
3601   grep -v '^ *+' conftest.er1 >conftest.err
3602   rm -f conftest.er1
3603   cat conftest.err >&5
3604   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3605   (exit $ac_status); } &&
3606          { ac_try='test -z "$ac_c_werror_flag"
3607                          || test ! -s conftest.err'
3608   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3609   (eval $ac_try) 2>&5
3610   ac_status=$?
3611   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3612   (exit $ac_status); }; } &&
3613          { ac_try='test -s conftest.$ac_objext'
3614   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3615   (eval $ac_try) 2>&5
3616   ac_status=$?
3617   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3618   (exit $ac_status); }; }; then
3619   for ac_declaration in \
3620    '' \
3621    'extern "C" void std::exit (int) throw (); using std::exit;' \
3622    'extern "C" void std::exit (int); using std::exit;' \
3623    'extern "C" void exit (int) throw ();' \
3624    'extern "C" void exit (int);' \
3625    'void exit (int);'
3626 do
3627   cat >conftest.$ac_ext <<_ACEOF
3628 /* confdefs.h.  */
3629 _ACEOF
3630 cat confdefs.h >>conftest.$ac_ext
3631 cat >>conftest.$ac_ext <<_ACEOF
3632 /* end confdefs.h.  */
3633 $ac_declaration
3634 #include <stdlib.h>
3635 int
3636 main ()
3637 {
3638 exit (42);
3639   ;
3640   return 0;
3641 }
3642 _ACEOF
3643 rm -f conftest.$ac_objext
3644 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3645   (eval $ac_compile) 2>conftest.er1
3646   ac_status=$?
3647   grep -v '^ *+' conftest.er1 >conftest.err
3648   rm -f conftest.er1
3649   cat conftest.err >&5
3650   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3651   (exit $ac_status); } &&
3652          { ac_try='test -z "$ac_c_werror_flag"
3653                          || test ! -s conftest.err'
3654   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3655   (eval $ac_try) 2>&5
3656   ac_status=$?
3657   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3658   (exit $ac_status); }; } &&
3659          { ac_try='test -s conftest.$ac_objext'
3660   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3661   (eval $ac_try) 2>&5
3662   ac_status=$?
3663   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3664   (exit $ac_status); }; }; then
3665   :
3666 else
3667   echo "$as_me: failed program was:" >&5
3668 sed 's/^/| /' conftest.$ac_ext >&5
3669
3670 continue
3671 fi
3672 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3673   cat >conftest.$ac_ext <<_ACEOF
3674 /* confdefs.h.  */
3675 _ACEOF
3676 cat confdefs.h >>conftest.$ac_ext
3677 cat >>conftest.$ac_ext <<_ACEOF
3678 /* end confdefs.h.  */
3679 $ac_declaration
3680 int
3681 main ()
3682 {
3683 exit (42);
3684   ;
3685   return 0;
3686 }
3687 _ACEOF
3688 rm -f conftest.$ac_objext
3689 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3690   (eval $ac_compile) 2>conftest.er1
3691   ac_status=$?
3692   grep -v '^ *+' conftest.er1 >conftest.err
3693   rm -f conftest.er1
3694   cat conftest.err >&5
3695   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3696   (exit $ac_status); } &&
3697          { ac_try='test -z "$ac_c_werror_flag"
3698                          || test ! -s conftest.err'
3699   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3700   (eval $ac_try) 2>&5
3701   ac_status=$?
3702   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3703   (exit $ac_status); }; } &&
3704          { ac_try='test -s conftest.$ac_objext'
3705   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3706   (eval $ac_try) 2>&5
3707   ac_status=$?
3708   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3709   (exit $ac_status); }; }; then
3710   break
3711 else
3712   echo "$as_me: failed program was:" >&5
3713 sed 's/^/| /' conftest.$ac_ext >&5
3714
3715 fi
3716 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3717 done
3718 rm -f conftest*
3719 if test -n "$ac_declaration"; then
3720   echo '#ifdef __cplusplus' >>confdefs.h
3721   echo $ac_declaration      >>confdefs.h
3722   echo '#endif'             >>confdefs.h
3723 fi
3724
3725 else
3726   echo "$as_me: failed program was:" >&5
3727 sed 's/^/| /' conftest.$ac_ext >&5
3728
3729 fi
3730 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3731 ac_ext=c
3732 ac_cpp='$CPP $CPPFLAGS'
3733 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3734 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3735 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3736
3737 ac_ext=cc
3738 ac_cpp='$CXXCPP $CPPFLAGS'
3739 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3740 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3741 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3742 if test -n "$ac_tool_prefix"; then
3743   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3744   do
3745     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3746 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3747 echo "$as_me:$LINENO: checking for $ac_word" >&5
3748 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3749 if test "${ac_cv_prog_CXX+set}" = set; then
3750   echo $ECHO_N "(cached) $ECHO_C" >&6
3751 else
3752   if test -n "$CXX"; then
3753   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3754 else
3755 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3756 for as_dir in $PATH
3757 do
3758   IFS=$as_save_IFS
3759   test -z "$as_dir" && as_dir=.
3760   for ac_exec_ext in '' $ac_executable_extensions; do
3761   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3762     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3763     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3764     break 2
3765   fi
3766 done
3767 done
3768
3769 fi
3770 fi
3771 CXX=$ac_cv_prog_CXX
3772 if test -n "$CXX"; then
3773   echo "$as_me:$LINENO: result: $CXX" >&5
3774 echo "${ECHO_T}$CXX" >&6
3775 else
3776   echo "$as_me:$LINENO: result: no" >&5
3777 echo "${ECHO_T}no" >&6
3778 fi
3779
3780     test -n "$CXX" && break
3781   done
3782 fi
3783 if test -z "$CXX"; then
3784   ac_ct_CXX=$CXX
3785   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3786 do
3787   # Extract the first word of "$ac_prog", so it can be a program name with args.
3788 set dummy $ac_prog; ac_word=$2
3789 echo "$as_me:$LINENO: checking for $ac_word" >&5
3790 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3791 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3792   echo $ECHO_N "(cached) $ECHO_C" >&6
3793 else
3794   if test -n "$ac_ct_CXX"; then
3795   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3796 else
3797 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3798 for as_dir in $PATH
3799 do
3800   IFS=$as_save_IFS
3801   test -z "$as_dir" && as_dir=.
3802   for ac_exec_ext in '' $ac_executable_extensions; do
3803   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3804     ac_cv_prog_ac_ct_CXX="$ac_prog"
3805     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3806     break 2
3807   fi
3808 done
3809 done
3810
3811 fi
3812 fi
3813 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3814 if test -n "$ac_ct_CXX"; then
3815   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3816 echo "${ECHO_T}$ac_ct_CXX" >&6
3817 else
3818   echo "$as_me:$LINENO: result: no" >&5
3819 echo "${ECHO_T}no" >&6
3820 fi
3821
3822   test -n "$ac_ct_CXX" && break
3823 done
3824 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3825
3826   CXX=$ac_ct_CXX
3827 fi
3828
3829
3830 # Provide some information about the compiler.
3831 echo "$as_me:$LINENO:" \
3832      "checking for C++ compiler version" >&5
3833 ac_compiler=`set X $ac_compile; echo $2`
3834 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3835   (eval $ac_compiler --version </dev/null >&5) 2>&5
3836   ac_status=$?
3837   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3838   (exit $ac_status); }
3839 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3840   (eval $ac_compiler -v </dev/null >&5) 2>&5
3841   ac_status=$?
3842   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3843   (exit $ac_status); }
3844 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3845   (eval $ac_compiler -V </dev/null >&5) 2>&5
3846   ac_status=$?
3847   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3848   (exit $ac_status); }
3849
3850 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3851 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3852 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3853   echo $ECHO_N "(cached) $ECHO_C" >&6
3854 else
3855   cat >conftest.$ac_ext <<_ACEOF
3856 /* confdefs.h.  */
3857 _ACEOF
3858 cat confdefs.h >>conftest.$ac_ext
3859 cat >>conftest.$ac_ext <<_ACEOF
3860 /* end confdefs.h.  */
3861
3862 int
3863 main ()
3864 {
3865 #ifndef __GNUC__
3866        choke me
3867 #endif
3868
3869   ;
3870   return 0;
3871 }
3872 _ACEOF
3873 rm -f conftest.$ac_objext
3874 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3875   (eval $ac_compile) 2>conftest.er1
3876   ac_status=$?
3877   grep -v '^ *+' conftest.er1 >conftest.err
3878   rm -f conftest.er1
3879   cat conftest.err >&5
3880   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3881   (exit $ac_status); } &&
3882          { ac_try='test -z "$ac_cxx_werror_flag"
3883                          || test ! -s conftest.err'
3884   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3885   (eval $ac_try) 2>&5
3886   ac_status=$?
3887   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3888   (exit $ac_status); }; } &&
3889          { ac_try='test -s conftest.$ac_objext'
3890   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3891   (eval $ac_try) 2>&5
3892   ac_status=$?
3893   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3894   (exit $ac_status); }; }; then
3895   ac_compiler_gnu=yes
3896 else
3897   echo "$as_me: failed program was:" >&5
3898 sed 's/^/| /' conftest.$ac_ext >&5
3899
3900 ac_compiler_gnu=no
3901 fi
3902 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3903 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3904
3905 fi
3906 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3907 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3908 GXX=`test $ac_compiler_gnu = yes && echo yes`
3909 ac_test_CXXFLAGS=${CXXFLAGS+set}
3910 ac_save_CXXFLAGS=$CXXFLAGS
3911 CXXFLAGS="-g"
3912 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3913 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3914 if test "${ac_cv_prog_cxx_g+set}" = set; then
3915   echo $ECHO_N "(cached) $ECHO_C" >&6
3916 else
3917   cat >conftest.$ac_ext <<_ACEOF
3918 /* confdefs.h.  */
3919 _ACEOF
3920 cat confdefs.h >>conftest.$ac_ext
3921 cat >>conftest.$ac_ext <<_ACEOF
3922 /* end confdefs.h.  */
3923
3924 int
3925 main ()
3926 {
3927
3928   ;
3929   return 0;
3930 }
3931 _ACEOF
3932 rm -f conftest.$ac_objext
3933 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3934   (eval $ac_compile) 2>conftest.er1
3935   ac_status=$?
3936   grep -v '^ *+' conftest.er1 >conftest.err
3937   rm -f conftest.er1
3938   cat conftest.err >&5
3939   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3940   (exit $ac_status); } &&
3941          { ac_try='test -z "$ac_cxx_werror_flag"
3942                          || test ! -s conftest.err'
3943   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3944   (eval $ac_try) 2>&5
3945   ac_status=$?
3946   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3947   (exit $ac_status); }; } &&
3948          { ac_try='test -s conftest.$ac_objext'
3949   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3950   (eval $ac_try) 2>&5
3951   ac_status=$?
3952   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3953   (exit $ac_status); }; }; then
3954   ac_cv_prog_cxx_g=yes
3955 else
3956   echo "$as_me: failed program was:" >&5
3957 sed 's/^/| /' conftest.$ac_ext >&5
3958
3959 ac_cv_prog_cxx_g=no
3960 fi
3961 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3962 fi
3963 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3964 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
3965 if test "$ac_test_CXXFLAGS" = set; then
3966   CXXFLAGS=$ac_save_CXXFLAGS
3967 elif test $ac_cv_prog_cxx_g = yes; then
3968   if test "$GXX" = yes; then
3969     CXXFLAGS="-g -O2"
3970   else
3971     CXXFLAGS="-g"
3972   fi
3973 else
3974   if test "$GXX" = yes; then
3975     CXXFLAGS="-O2"
3976   else
3977     CXXFLAGS=
3978   fi
3979 fi
3980 for ac_declaration in \
3981    '' \
3982    'extern "C" void std::exit (int) throw (); using std::exit;' \
3983    'extern "C" void std::exit (int); using std::exit;' \
3984    'extern "C" void exit (int) throw ();' \
3985    'extern "C" void exit (int);' \
3986    'void exit (int);'
3987 do
3988   cat >conftest.$ac_ext <<_ACEOF
3989 /* confdefs.h.  */
3990 _ACEOF
3991 cat confdefs.h >>conftest.$ac_ext
3992 cat >>conftest.$ac_ext <<_ACEOF
3993 /* end confdefs.h.  */
3994 $ac_declaration
3995 #include <stdlib.h>
3996 int
3997 main ()
3998 {
3999 exit (42);
4000   ;
4001   return 0;
4002 }
4003 _ACEOF
4004 rm -f conftest.$ac_objext
4005 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4006   (eval $ac_compile) 2>conftest.er1
4007   ac_status=$?
4008   grep -v '^ *+' conftest.er1 >conftest.err
4009   rm -f conftest.er1
4010   cat conftest.err >&5
4011   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4012   (exit $ac_status); } &&
4013          { ac_try='test -z "$ac_cxx_werror_flag"
4014                          || test ! -s conftest.err'
4015   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4016   (eval $ac_try) 2>&5
4017   ac_status=$?
4018   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4019   (exit $ac_status); }; } &&
4020          { ac_try='test -s conftest.$ac_objext'
4021   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4022   (eval $ac_try) 2>&5
4023   ac_status=$?
4024   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4025   (exit $ac_status); }; }; then
4026   :
4027 else
4028   echo "$as_me: failed program was:" >&5
4029 sed 's/^/| /' conftest.$ac_ext >&5
4030
4031 continue
4032 fi
4033 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4034   cat >conftest.$ac_ext <<_ACEOF
4035 /* confdefs.h.  */
4036 _ACEOF
4037 cat confdefs.h >>conftest.$ac_ext
4038 cat >>conftest.$ac_ext <<_ACEOF
4039 /* end confdefs.h.  */
4040 $ac_declaration
4041 int
4042 main ()
4043 {
4044 exit (42);
4045   ;
4046   return 0;
4047 }
4048 _ACEOF
4049 rm -f conftest.$ac_objext
4050 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4051   (eval $ac_compile) 2>conftest.er1
4052   ac_status=$?
4053   grep -v '^ *+' conftest.er1 >conftest.err
4054   rm -f conftest.er1
4055   cat conftest.err >&5
4056   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4057   (exit $ac_status); } &&
4058          { ac_try='test -z "$ac_cxx_werror_flag"
4059                          || test ! -s conftest.err'
4060   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4061   (eval $ac_try) 2>&5
4062   ac_status=$?
4063   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4064   (exit $ac_status); }; } &&
4065          { ac_try='test -s conftest.$ac_objext'
4066   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4067   (eval $ac_try) 2>&5
4068   ac_status=$?
4069   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4070   (exit $ac_status); }; }; then
4071   break
4072 else
4073   echo "$as_me: failed program was:" >&5
4074 sed 's/^/| /' conftest.$ac_ext >&5
4075
4076 fi
4077 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4078 done
4079 rm -f conftest*
4080 if test -n "$ac_declaration"; then
4081   echo '#ifdef __cplusplus' >>confdefs.h
4082   echo $ac_declaration      >>confdefs.h
4083   echo '#endif'             >>confdefs.h
4084 fi
4085
4086 ac_ext=c
4087 ac_cpp='$CPP $CPPFLAGS'
4088 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4089 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4090 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4091
4092
4093 # We must set the default linker to the linker used by gcc for the correct
4094 # operation of libtool.  If LD is not defined and we are using gcc, try to
4095 # set the LD default to the ld used by gcc.
4096 if test -z "$LD"; then
4097   if test "$GCC" = yes; then
4098     case $build in
4099     *-*-mingw*)
4100       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4101     *)
4102       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4103     esac
4104     case $gcc_prog_ld in
4105     # Accept absolute paths.
4106     [\\/]* | [A-Za-z]:[\\/]*)
4107       LD="$gcc_prog_ld" ;;
4108     esac
4109   fi
4110 fi
4111
4112
4113
4114
4115 if test -n "$ac_tool_prefix"; then
4116   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4117 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4118 echo "$as_me:$LINENO: checking for $ac_word" >&5
4119 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4120 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4121   echo $ECHO_N "(cached) $ECHO_C" >&6
4122 else
4123   if test -n "$GNATBIND"; then
4124   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4125 else
4126 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4127 for as_dir in $PATH
4128 do
4129   IFS=$as_save_IFS
4130   test -z "$as_dir" && as_dir=.
4131   for ac_exec_ext in '' $ac_executable_extensions; do
4132   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4133     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4134     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4135     break 2
4136   fi
4137 done
4138 done
4139
4140 fi
4141 fi
4142 GNATBIND=$ac_cv_prog_GNATBIND
4143 if test -n "$GNATBIND"; then
4144   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4145 echo "${ECHO_T}$GNATBIND" >&6
4146 else
4147   echo "$as_me:$LINENO: result: no" >&5
4148 echo "${ECHO_T}no" >&6
4149 fi
4150
4151 fi
4152 if test -z "$ac_cv_prog_GNATBIND"; then
4153   ac_ct_GNATBIND=$GNATBIND
4154   # Extract the first word of "gnatbind", so it can be a program name with args.
4155 set dummy gnatbind; ac_word=$2
4156 echo "$as_me:$LINENO: checking for $ac_word" >&5
4157 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4158 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4159   echo $ECHO_N "(cached) $ECHO_C" >&6
4160 else
4161   if test -n "$ac_ct_GNATBIND"; then
4162   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4163 else
4164 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4165 for as_dir in $PATH
4166 do
4167   IFS=$as_save_IFS
4168   test -z "$as_dir" && as_dir=.
4169   for ac_exec_ext in '' $ac_executable_extensions; do
4170   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4171     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4172     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4173     break 2
4174   fi
4175 done
4176 done
4177
4178   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4179 fi
4180 fi
4181 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4182 if test -n "$ac_ct_GNATBIND"; then
4183   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4184 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4185 else
4186   echo "$as_me:$LINENO: result: no" >&5
4187 echo "${ECHO_T}no" >&6
4188 fi
4189
4190   GNATBIND=$ac_ct_GNATBIND
4191 else
4192   GNATBIND="$ac_cv_prog_GNATBIND"
4193 fi
4194
4195 if test -n "$ac_tool_prefix"; then
4196   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4197 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4198 echo "$as_me:$LINENO: checking for $ac_word" >&5
4199 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4200 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4201   echo $ECHO_N "(cached) $ECHO_C" >&6
4202 else
4203   if test -n "$GNATMAKE"; then
4204   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4205 else
4206 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4207 for as_dir in $PATH
4208 do
4209   IFS=$as_save_IFS
4210   test -z "$as_dir" && as_dir=.
4211   for ac_exec_ext in '' $ac_executable_extensions; do
4212   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4213     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4214     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4215     break 2
4216   fi
4217 done
4218 done
4219
4220 fi
4221 fi
4222 GNATMAKE=$ac_cv_prog_GNATMAKE
4223 if test -n "$GNATMAKE"; then
4224   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4225 echo "${ECHO_T}$GNATMAKE" >&6
4226 else
4227   echo "$as_me:$LINENO: result: no" >&5
4228 echo "${ECHO_T}no" >&6
4229 fi
4230
4231 fi
4232 if test -z "$ac_cv_prog_GNATMAKE"; then
4233   ac_ct_GNATMAKE=$GNATMAKE
4234   # Extract the first word of "gnatmake", so it can be a program name with args.
4235 set dummy gnatmake; ac_word=$2
4236 echo "$as_me:$LINENO: checking for $ac_word" >&5
4237 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4238 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4239   echo $ECHO_N "(cached) $ECHO_C" >&6
4240 else
4241   if test -n "$ac_ct_GNATMAKE"; then
4242   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4243 else
4244 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4245 for as_dir in $PATH
4246 do
4247   IFS=$as_save_IFS
4248   test -z "$as_dir" && as_dir=.
4249   for ac_exec_ext in '' $ac_executable_extensions; do
4250   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4251     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4252     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4253     break 2
4254   fi
4255 done
4256 done
4257
4258   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4259 fi
4260 fi
4261 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4262 if test -n "$ac_ct_GNATMAKE"; then
4263   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4264 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4265 else
4266   echo "$as_me:$LINENO: result: no" >&5
4267 echo "${ECHO_T}no" >&6
4268 fi
4269
4270   GNATMAKE=$ac_ct_GNATMAKE
4271 else
4272   GNATMAKE="$ac_cv_prog_GNATMAKE"
4273 fi
4274
4275 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4276 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4277 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4278   echo $ECHO_N "(cached) $ECHO_C" >&6
4279 else
4280   cat >conftest.adb <<EOF
4281 procedure conftest is begin null; end conftest;
4282 EOF
4283 acx_cv_cc_gcc_supports_ada=no
4284 # There is a bug in old released versions of GCC which causes the
4285 # driver to exit successfully when the appropriate language module
4286 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4287 # Therefore we must check for the error message as well as an
4288 # unsuccessful exit.
4289 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4290 # given a .adb file, but produce no object file.  So we must check
4291 # if an object file was really produced to guard against this.
4292 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4293 if test x"$errors" = x && test -f conftest.$ac_objext; then
4294   acx_cv_cc_gcc_supports_ada=yes
4295 fi
4296 rm -f conftest.*
4297 fi
4298 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4299 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4300
4301 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4302   have_gnat=yes
4303 else
4304   have_gnat=no
4305 fi
4306
4307 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4308 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4309 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4310   echo $ECHO_N "(cached) $ECHO_C" >&6
4311 else
4312    echo abfoo >t1
4313   echo cdfoo >t2
4314   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4315   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4316     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4317       :
4318     else
4319       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4320     fi
4321   fi
4322   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4323     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4324       :
4325     else
4326       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4327     fi
4328   fi
4329   rm t1 t2
4330
4331 fi
4332 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4333 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4334 do_compare="$gcc_cv_prog_cmp_skip"
4335
4336
4337
4338 # Check for GMP and MPFR
4339 gmplibs="-lmpfr -lgmp"
4340 gmpinc=
4341 have_gmp=no
4342
4343 # Specify a location for mpfr
4344 # check for this first so it ends up on the link line before gmp.
4345
4346 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4347 if test "${with_mpfr_dir+set}" = set; then
4348   withval="$with_mpfr_dir"
4349   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4350 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4351 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4352 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4353    { (exit 1); exit 1; }; }
4354 fi;
4355
4356
4357 # Check whether --with-mpfr or --without-mpfr was given.
4358 if test "${with_mpfr+set}" = set; then
4359   withval="$with_mpfr"
4360
4361 fi;
4362
4363 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4364 if test "${with_mpfr_include+set}" = set; then
4365   withval="$with_mpfr_include"
4366
4367 fi;
4368
4369 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4370 if test "${with_mpfr_lib+set}" = set; then
4371   withval="$with_mpfr_lib"
4372
4373 fi;
4374
4375 if test "x$with_mpfr" != x; then
4376   gmplibs="-L$with_mpfr/lib $gmplibs"
4377   gmpinc="-I$with_mpfr/include"
4378 fi
4379 if test "x$with_mpfr_include" != x; then
4380   gmpinc="-I$with_mpfr_include"
4381 fi
4382 if test "x$with_mpfr_lib" != x; then
4383   gmplibs="-L$with_mpfr_lib $gmplibs"
4384 fi
4385 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4386   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4387   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4388   # Do not test the mpfr version.  Assume that it is sufficient, since
4389   # it is in the source tree, and the library has not been built yet
4390   # but it would be included on the link line in the version check below
4391   # hence making the test fail.
4392   have_gmp=yes
4393 fi
4394
4395 # Specify a location for gmp
4396
4397 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4398 if test "${with_gmp_dir+set}" = set; then
4399   withval="$with_gmp_dir"
4400   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4401 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4402 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4403 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4404    { (exit 1); exit 1; }; }
4405 fi;
4406
4407
4408 # Check whether --with-gmp or --without-gmp was given.
4409 if test "${with_gmp+set}" = set; then
4410   withval="$with_gmp"
4411
4412 fi;
4413
4414 # Check whether --with-gmp_include or --without-gmp_include was given.
4415 if test "${with_gmp_include+set}" = set; then
4416   withval="$with_gmp_include"
4417
4418 fi;
4419
4420 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4421 if test "${with_gmp_lib+set}" = set; then
4422   withval="$with_gmp_lib"
4423
4424 fi;
4425
4426
4427 if test "x$with_gmp" != x; then
4428   gmplibs="-L$with_gmp/lib $gmplibs"
4429   gmpinc="-I$with_gmp/include $gmpinc"
4430 fi
4431 if test "x$with_gmp_include" != x; then
4432   gmpinc="-I$with_gmp_include $gmpinc"
4433 fi
4434 if test "x$with_gmp_lib" != x; then
4435   gmplibs="-L$with_gmp_lib $gmplibs"
4436 fi
4437 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4438   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4439   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4440   # Do not test the gmp version.  Assume that it is sufficient, since
4441   # it is in the source tree, and the library has not been built yet
4442   # but it would be included on the link line in the version check below
4443   # hence making the test fail.
4444   have_gmp=yes
4445 fi
4446
4447 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4448   have_gmp=yes
4449   saved_CFLAGS="$CFLAGS"
4450   CFLAGS="$CFLAGS $gmpinc"
4451   # Check GMP actually works
4452   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4453 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4454
4455 cat >conftest.$ac_ext <<_ACEOF
4456 /* confdefs.h.  */
4457 _ACEOF
4458 cat confdefs.h >>conftest.$ac_ext
4459 cat >>conftest.$ac_ext <<_ACEOF
4460 /* end confdefs.h.  */
4461 #include "gmp.h"
4462 int
4463 main ()
4464 {
4465
4466   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4467   choke me
4468   #endif
4469
4470   ;
4471   return 0;
4472 }
4473 _ACEOF
4474 rm -f conftest.$ac_objext
4475 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4476   (eval $ac_compile) 2>conftest.er1
4477   ac_status=$?
4478   grep -v '^ *+' conftest.er1 >conftest.err
4479   rm -f conftest.er1
4480   cat conftest.err >&5
4481   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4482   (exit $ac_status); } &&
4483          { ac_try='test -z "$ac_c_werror_flag"
4484                          || test ! -s conftest.err'
4485   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4486   (eval $ac_try) 2>&5
4487   ac_status=$?
4488   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4489   (exit $ac_status); }; } &&
4490          { ac_try='test -s conftest.$ac_objext'
4491   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4492   (eval $ac_try) 2>&5
4493   ac_status=$?
4494   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4495   (exit $ac_status); }; }; then
4496   echo "$as_me:$LINENO: result: yes" >&5
4497 echo "${ECHO_T}yes" >&6
4498 else
4499   echo "$as_me: failed program was:" >&5
4500 sed 's/^/| /' conftest.$ac_ext >&5
4501
4502 echo "$as_me:$LINENO: result: no" >&5
4503 echo "${ECHO_T}no" >&6; have_gmp=no
4504 fi
4505 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4506
4507   if test x"$have_gmp" = xyes; then
4508     saved_LIBS="$LIBS"
4509     LIBS="$LIBS $gmplibs"
4510         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4511 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4512     cat >conftest.$ac_ext <<_ACEOF
4513 /* confdefs.h.  */
4514 _ACEOF
4515 cat confdefs.h >>conftest.$ac_ext
4516 cat >>conftest.$ac_ext <<_ACEOF
4517 /* end confdefs.h.  */
4518 #include <gmp.h>
4519     #include <mpfr.h>
4520 int
4521 main ()
4522 {
4523
4524     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,0)
4525     choke me
4526     #endif
4527     mpfr_t n;
4528     mpfr_t x;
4529     int t;
4530     mpfr_init (n);
4531     mpfr_init (x);
4532     mpfr_atan2 (n, n, x, GMP_RNDN);
4533     mpfr_erfc (n, x, GMP_RNDN);
4534     mpfr_subnormalize (x, t, GMP_RNDN);
4535
4536   ;
4537   return 0;
4538 }
4539 _ACEOF
4540 rm -f conftest.$ac_objext conftest$ac_exeext
4541 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4542   (eval $ac_link) 2>conftest.er1
4543   ac_status=$?
4544   grep -v '^ *+' conftest.er1 >conftest.err
4545   rm -f conftest.er1
4546   cat conftest.err >&5
4547   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4548   (exit $ac_status); } &&
4549          { ac_try='test -z "$ac_c_werror_flag"
4550                          || test ! -s conftest.err'
4551   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4552   (eval $ac_try) 2>&5
4553   ac_status=$?
4554   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4555   (exit $ac_status); }; } &&
4556          { ac_try='test -s conftest$ac_exeext'
4557   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4558   (eval $ac_try) 2>&5
4559   ac_status=$?
4560   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4561   (exit $ac_status); }; }; then
4562   cat >conftest.$ac_ext <<_ACEOF
4563 /* confdefs.h.  */
4564 _ACEOF
4565 cat confdefs.h >>conftest.$ac_ext
4566 cat >>conftest.$ac_ext <<_ACEOF
4567 /* end confdefs.h.  */
4568 #include <gmp.h>
4569     #include <mpfr.h>
4570 int
4571 main ()
4572 {
4573
4574     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4575     choke me
4576     #endif
4577     mpfr_t n; mpfr_init(n);
4578
4579   ;
4580   return 0;
4581 }
4582 _ACEOF
4583 rm -f conftest.$ac_objext conftest$ac_exeext
4584 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4585   (eval $ac_link) 2>conftest.er1
4586   ac_status=$?
4587   grep -v '^ *+' conftest.er1 >conftest.err
4588   rm -f conftest.er1
4589   cat conftest.err >&5
4590   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4591   (exit $ac_status); } &&
4592          { ac_try='test -z "$ac_c_werror_flag"
4593                          || test ! -s conftest.err'
4594   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4595   (eval $ac_try) 2>&5
4596   ac_status=$?
4597   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4598   (exit $ac_status); }; } &&
4599          { ac_try='test -s conftest$ac_exeext'
4600   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4601   (eval $ac_try) 2>&5
4602   ac_status=$?
4603   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4604   (exit $ac_status); }; }; then
4605   echo "$as_me:$LINENO: result: yes" >&5
4606 echo "${ECHO_T}yes" >&6
4607 else
4608   echo "$as_me: failed program was:" >&5
4609 sed 's/^/| /' conftest.$ac_ext >&5
4610
4611 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4612 echo "${ECHO_T}buggy but acceptable" >&6
4613 fi
4614 rm -f conftest.err conftest.$ac_objext \
4615       conftest$ac_exeext conftest.$ac_ext
4616 else
4617   echo "$as_me: failed program was:" >&5
4618 sed 's/^/| /' conftest.$ac_ext >&5
4619
4620 echo "$as_me:$LINENO: result: no" >&5
4621 echo "${ECHO_T}no" >&6; have_gmp=no
4622 fi
4623 rm -f conftest.err conftest.$ac_objext \
4624       conftest$ac_exeext conftest.$ac_ext
4625       LIBS="$saved_LIBS"
4626   fi
4627   CFLAGS="$saved_CFLAGS"
4628
4629   if test x$have_gmp != xyes; then
4630     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4631 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4632 Copies of these libraries' source code can be found at their respective
4633 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4634 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4635 If you obtained GMP and/or MPFR from a vendor distribution package, make
4636 sure that you have installed both the libraries and the header files.
4637 They may be located in separate packages." >&5
4638 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4639 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4640 Copies of these libraries' source code can be found at their respective
4641 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4642 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4643 If you obtained GMP and/or MPFR from a vendor distribution package, make
4644 sure that you have installed both the libraries and the header files.
4645 They may be located in separate packages." >&2;}
4646    { (exit 1); exit 1; }; }
4647   fi
4648 fi
4649
4650 # Flags needed for both GMP and/or MPFR
4651
4652
4653
4654 # By default, C is the only stage 1 language.
4655 stage1_languages=,c,
4656
4657 # Figure out what language subdirectories are present.
4658 # Look if the user specified --enable-languages="..."; if not, use
4659 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4660 # go away some day.
4661 # NB:  embedded tabs in this IF block -- do not untabify
4662 if test -d ${srcdir}/gcc; then
4663   if test x"${enable_languages+set}" != xset; then
4664     if test x"${LANGUAGES+set}" = xset; then
4665       enable_languages="${LANGUAGES}"
4666         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4667     else
4668       enable_languages=all
4669     fi
4670   else
4671     if test x"${enable_languages}" = x ||
4672        test x"${enable_languages}" = xyes;
4673        then
4674       echo configure.in: --enable-languages needs at least one language argument 1>&2
4675       exit 1
4676     fi
4677   fi
4678   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4679
4680   # 'f95' is the old name for the 'fortran' language. We issue a warning
4681   # and make the substitution.
4682   case ,${enable_languages}, in
4683     *,f95,*)
4684       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4685       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4686       ;;
4687   esac
4688
4689   # First scan to see if an enabled language requires some other language.
4690   # We assume that a given config-lang.in will list all the language
4691   # front ends it requires, even if some are required indirectly.
4692   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4693     case ${lang_frag} in
4694       ..) ;;
4695       # The odd quoting in the next line works around
4696       # an apparent bug in bash 1.12 on linux.
4697       ${srcdir}/gcc/[*]/config-lang.in) ;;
4698       *)
4699         # From the config-lang.in, get $language, $lang_requires
4700         language=
4701         lang_requires=
4702         . ${lang_frag}
4703         for other in ${lang_requires} ; do
4704           case ,${enable_languages}, in
4705             *,$other,*) ;;
4706             *,all,*) ;;
4707             *,$language,*)
4708               echo " \`$other' language required by \`$language'; enabling" 1>&2
4709               enable_languages="${enable_languages},${other}"
4710               ;;
4711           esac
4712         done
4713         ;;
4714     esac
4715   done
4716
4717   new_enable_languages=,c,
4718   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4719   potential_languages=,c,
4720
4721   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4722     case ${lang_frag} in
4723       ..) ;;
4724       # The odd quoting in the next line works around
4725       # an apparent bug in bash 1.12 on linux.
4726       ${srcdir}/gcc/[*]/config-lang.in) ;;
4727       *)
4728         # From the config-lang.in, get $language, $target_libs,
4729         # $lang_dirs, $boot_language, and $build_by_default
4730         language=
4731         target_libs=
4732         lang_dirs=
4733         subdir_requires=
4734         boot_language=no
4735         build_by_default=yes
4736         . ${lang_frag}
4737         if test x${language} = x; then
4738           echo "${lang_frag} doesn't set \$language." 1>&2
4739           exit 1
4740         fi
4741
4742         case ,${enable_languages}, in
4743           *,${language},*)
4744             # Language was explicitly selected; include it.
4745             add_this_lang=yes
4746             ;;
4747           *,all,*)
4748             # 'all' was selected, select it if it is a default language
4749             add_this_lang=${build_by_default}
4750             ;;
4751           *)
4752             add_this_lang=no
4753             ;;
4754         esac
4755
4756         # Disable languages that need other directories if these aren't available.
4757         for i in $subdir_requires; do
4758           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4759           case ,${enable_languages}, in
4760             *,${language},*)
4761               # Specifically requested language; tell them.
4762               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4763 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4764    { (exit 1); exit 1; }; }
4765               ;;
4766             *)
4767               # Silently disable.
4768               add_this_lang=unsupported
4769               ;;
4770           esac
4771         done
4772
4773         # Disable Ada if no preexisting GNAT is available.
4774         case ,${enable_languages},:${language}:${have_gnat} in
4775           *,${language},*:ada:no)
4776             # Specifically requested language; tell them.
4777             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4778 echo "$as_me: error: GNAT is required to build $language" >&2;}
4779    { (exit 1); exit 1; }; }
4780             ;;
4781           *:ada:no)
4782             # Silently disable.
4783             add_this_lang=unsupported
4784             ;;
4785         esac
4786
4787         # Disable a language that is unsupported by the target.
4788         case " $unsupported_languages " in
4789           *" $language "*)
4790             add_this_lang=unsupported
4791             ;;
4792         esac
4793
4794         case $add_this_lang in
4795           unsupported)
4796             # Remove language-dependent dirs.
4797             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4798             ;;
4799           no)
4800             # Remove language-dependent dirs; still show language as supported.
4801             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4802             potential_languages="${potential_languages}${language},"
4803             ;;
4804           yes)
4805             new_enable_languages="${new_enable_languages}${language},"
4806             potential_languages="${potential_languages}${language},"
4807             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4808             case ${boot_language} in
4809               yes)
4810                 # Add to (comma-separated) list of stage 1 languages.
4811                 stage1_languages="${stage1_languages}${language},"
4812                 ;;
4813             esac
4814             ;;
4815         esac
4816         ;;
4817     esac
4818   done
4819
4820   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4821 if test "${enable_stage1_languages+set}" = set; then
4822   enableval="$enable_stage1_languages"
4823   case ,${enable_stage1_languages}, in
4824     ,no,|,,)
4825       # Set it to something that will have no effect in the loop below
4826       enable_stage1_languages=c ;;
4827     ,yes,)
4828       enable_stage1_languages=`echo $new_enable_languages | \
4829         sed -e "s/^,//" -e "s/,$//" ` ;;
4830     *,all,*)
4831       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4832         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4833   esac
4834
4835   # Add "good" languages from enable_stage1_languages to stage1_languages,
4836   # while "bad" languages go in missing_languages.  Leave no duplicates.
4837   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4838     case $potential_languages in
4839       *,$i,*)
4840         case $stage1_languages in
4841           *,$i,*) ;;
4842           *) stage1_languages="$stage1_languages$i," ;;
4843         esac ;;
4844       *)
4845         case $missing_languages in
4846           *,$i,*) ;;
4847           *) missing_languages="$missing_languages$i," ;;
4848         esac ;;
4849      esac
4850   done
4851 fi;
4852
4853   # Remove leading/trailing commas that were added for simplicity
4854   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4855   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4856   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4857   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4858
4859   if test "x$missing_languages" != x; then
4860     { { echo "$as_me:$LINENO: error:
4861 The following requested languages could not be built: ${missing_languages}
4862 Supported languages are: ${potential_languages}" >&5
4863 echo "$as_me: error:
4864 The following requested languages could not be built: ${missing_languages}
4865 Supported languages are: ${potential_languages}" >&2;}
4866    { (exit 1); exit 1; }; }
4867   fi
4868   if test "x$new_enable_languages" != "x$enable_languages"; then
4869     echo The following languages will be built: ${new_enable_languages}
4870     enable_languages="$new_enable_languages"
4871   fi
4872
4873
4874   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4875 fi
4876
4877 # Handle --disable-<component> generically.
4878 for dir in $configdirs $build_configdirs $target_configdirs ; do
4879   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4880   if eval test x\${enable_${dirname}} "=" xno ; then
4881     noconfigdirs="$noconfigdirs $dir"
4882   fi
4883 done
4884
4885 # Check for Boehm's garbage collector
4886 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4887 if test "${enable_objc_gc+set}" = set; then
4888   enableval="$enable_objc_gc"
4889   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4890   *,objc,*:*:yes:*target-boehm-gc*)
4891     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4892 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4893    { (exit 1); exit 1; }; }
4894     ;;
4895 esac
4896 fi;
4897
4898 # Make sure we only build Boehm's garbage collector if required.
4899 case ,${enable_languages},:${enable_objc_gc} in
4900   *,objc,*:yes)
4901     # Keep target-boehm-gc if requested for Objective-C.
4902     ;;
4903   *)
4904     # Otherwise remove target-boehm-gc depending on target-libjava.
4905     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4906       noconfigdirs="$noconfigdirs target-boehm-gc"
4907     fi
4908     ;;
4909 esac
4910
4911 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4912 # $build_configdirs and $target_configdirs.
4913 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4914
4915 notsupp=""
4916 for dir in . $skipdirs $noconfigdirs ; do
4917   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4918   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4919     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4920     if test -r $srcdir/$dirname/configure ; then
4921       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4922         true
4923       else
4924         notsupp="$notsupp $dir"
4925       fi
4926     fi
4927   fi
4928   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4929     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4930     if test -r $srcdir/$dirname/configure ; then
4931       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4932         true
4933       else
4934         notsupp="$notsupp $dir"
4935       fi
4936     fi
4937   fi
4938   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4939     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4940     if test -r $srcdir/$dirname/configure ; then
4941       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4942         true
4943       else
4944         notsupp="$notsupp $dir"
4945       fi
4946     fi
4947   fi
4948 done
4949
4950 # Sometimes the tools are distributed with libiberty but with no other
4951 # libraries.  In that case, we don't want to build target-libiberty.
4952 # Don't let libgcc imply libiberty either.
4953 if test -n "${target_configdirs}" ; then
4954   libgcc=
4955   others=
4956   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
4957     if test "$i" = "libgcc"; then
4958       libgcc=target-libgcc
4959     elif test "$i" != "libiberty" ; then
4960       if test -r $srcdir/$i/configure ; then
4961         others=yes;
4962         break;
4963       fi
4964     fi
4965   done
4966   if test -z "${others}" ; then
4967     target_configdirs=$libgcc
4968   fi
4969 fi
4970
4971 # Quietly strip out all directories which aren't configurable in this tree.
4972 # This relies on all configurable subdirectories being autoconfiscated, which
4973 # is now the case.
4974 build_configdirs_all="$build_configdirs"
4975 build_configdirs=
4976 for i in ${build_configdirs_all} ; do
4977   j=`echo $i | sed -e s/build-//g`
4978   if test -f ${srcdir}/$j/configure ; then
4979     build_configdirs="${build_configdirs} $i"
4980   fi
4981 done
4982
4983 configdirs_all="$configdirs"
4984 configdirs=
4985 for i in ${configdirs_all} ; do
4986   if test -f ${srcdir}/$i/configure ; then
4987     configdirs="${configdirs} $i"
4988   fi
4989 done
4990
4991 target_configdirs_all="$target_configdirs"
4992 target_configdirs=
4993 for i in ${target_configdirs_all} ; do
4994   j=`echo $i | sed -e s/target-//g`
4995   if test -f ${srcdir}/$j/configure ; then
4996     target_configdirs="${target_configdirs} $i"
4997   fi
4998 done
4999
5000 # Produce a warning message for the subdirs we can't configure.
5001 # This isn't especially interesting in the Cygnus tree, but in the individual
5002 # FSF releases, it's important to let people know when their machine isn't
5003 # supported by the one or two programs in a package.
5004
5005 if test -n "${notsupp}" && test -z "${norecursion}" ; then
5006   # If $appdirs is non-empty, at least one of those directories must still
5007   # be configured, or we error out.  (E.g., if the gas release supports a
5008   # specified target in some subdirs but not the gas subdir, we shouldn't
5009   # pretend that all is well.)
5010   if test -n "$appdirs" ; then
5011     for dir in $appdirs ; do
5012       if test -r $dir/Makefile.in ; then
5013         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
5014           appdirs=""
5015           break
5016         fi
5017         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
5018           appdirs=""
5019           break
5020         fi
5021       fi
5022     done
5023     if test -n "$appdirs" ; then
5024       echo "*** This configuration is not supported by this package." 1>&2
5025       exit 1
5026     fi
5027   fi
5028   # Okay, some application will build, or we don't care to check.  Still
5029   # notify of subdirs not getting built.
5030   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5031   echo "    ${notsupp}" 1>&2
5032   echo "    (Any other directories should still work fine.)" 1>&2
5033 fi
5034
5035 case "$host" in
5036   *msdosdjgpp*)
5037     enable_gdbtk=no ;;
5038 esac
5039
5040 # To find our prefix, in gcc_cv_tool_prefix.
5041
5042 # The user is always right.
5043 if test "${PATH_SEPARATOR+set}" != set; then
5044   echo "#! /bin/sh" >conf$$.sh
5045   echo  "exit 0"   >>conf$$.sh
5046   chmod +x conf$$.sh
5047   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5048     PATH_SEPARATOR=';'
5049   else
5050     PATH_SEPARATOR=:
5051   fi
5052   rm -f conf$$.sh
5053 fi
5054
5055
5056
5057 if test "x$exec_prefix" = xNONE; then
5058         if test "x$prefix" = xNONE; then
5059                 gcc_cv_tool_prefix=$ac_default_prefix
5060         else
5061                 gcc_cv_tool_prefix=$prefix
5062         fi
5063 else
5064         gcc_cv_tool_prefix=$exec_prefix
5065 fi
5066
5067 # If there is no compiler in the tree, use the PATH only.  In any
5068 # case, if there is no compiler in the tree nobody should use
5069 # AS_FOR_TARGET and LD_FOR_TARGET.
5070 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5071     gcc_version=`cat $srcdir/gcc/BASE-VER`
5072     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5073     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5074     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5075     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5076     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5077     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5078 else
5079     gcc_cv_tool_dirs=
5080 fi
5081
5082 if test x$build = x$target && test -n "$md_exec_prefix"; then
5083         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5084 fi
5085
5086
5087
5088 copy_dirs=
5089
5090
5091 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5092 if test "${with_build_sysroot+set}" = set; then
5093   withval="$with_build_sysroot"
5094   if test x"$withval" != x ; then
5095      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5096    fi
5097 else
5098   SYSROOT_CFLAGS_FOR_TARGET=
5099 fi;
5100
5101
5102
5103 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5104 if test "${with_debug_prefix_map+set}" = set; then
5105   withval="$with_debug_prefix_map"
5106   if test x"$withval" != x; then
5107      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5108      for debug_map in $withval; do
5109        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5110      done
5111    fi
5112 else
5113   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5114 fi;
5115
5116
5117 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5118 # the named directory are copied to $(tooldir)/sys-include.
5119 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5120   if test x${is_cross_compiler} = xno ; then
5121     echo 1>&2 '***' --with-headers is only supported when cross compiling
5122     exit 1
5123   fi
5124   if test x"${with_headers}" != xyes ; then
5125     x=${gcc_cv_tool_prefix}
5126     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5127   fi
5128 fi
5129
5130 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5131 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5132 # are permitted.
5133 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5134   if test x${is_cross_compiler} = xno ; then
5135     echo 1>&2 '***' --with-libs is only supported when cross compiling
5136     exit 1
5137   fi
5138   if test x"${with_libs}" != xyes ; then
5139     # Copy the libraries in reverse order, so that files in the first named
5140     # library override files in subsequent libraries.
5141     x=${gcc_cv_tool_prefix}
5142     for l in ${with_libs}; do
5143       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5144     done
5145   fi
5146 fi
5147
5148 # Set with_gnu_as and with_gnu_ld as appropriate.
5149 #
5150 # This is done by determining whether or not the appropriate directory
5151 # is available, and by checking whether or not specific configurations
5152 # have requested that this magic not happen.
5153 #
5154 # The command line options always override the explicit settings in
5155 # configure.in, and the settings in configure.in override this magic.
5156 #
5157 # If the default for a toolchain is to use GNU as and ld, and you don't
5158 # want to do that, then you should use the --without-gnu-as and
5159 # --without-gnu-ld options for the configure script.
5160
5161 if test x${use_gnu_as} = x &&
5162    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5163   with_gnu_as=yes
5164   extra_host_args="$extra_host_args --with-gnu-as"
5165 fi
5166
5167 if test x${use_gnu_ld} = x &&
5168    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5169   with_gnu_ld=yes
5170   extra_host_args="$extra_host_args --with-gnu-ld"
5171 fi
5172
5173 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5174 # can detect this case.
5175
5176 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5177   with_newlib=yes
5178   extra_host_args="$extra_host_args --with-newlib"
5179 fi
5180
5181 # Handle ${copy_dirs}
5182 set fnord ${copy_dirs}
5183 shift
5184 while test $# != 0 ; do
5185   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5186     :
5187   else
5188     echo Copying $1 to $2
5189
5190     # Use the install script to create the directory and all required
5191     # parent directories.
5192     if test -d $2 ; then
5193       :
5194     else
5195       echo >config.temp
5196       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5197     fi
5198
5199     # Copy the directory, assuming we have tar.
5200     # FIXME: Should we use B in the second tar?  Not all systems support it.
5201     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5202
5203     # It is the responsibility of the user to correctly adjust all
5204     # symlinks.  If somebody can figure out how to handle them correctly
5205     # here, feel free to add the code.
5206
5207     echo $1 > $2/COPIED
5208   fi
5209   shift; shift
5210 done
5211
5212 # Determine a target-dependent exec_prefix that the installed
5213 # gcc will search in.  Keep this list sorted by triplet, with
5214 # the *-*-osname triplets last.
5215 md_exec_prefix=
5216 case "${target}" in
5217   alpha*-*-*vms*)
5218     md_exec_prefix=/gnu/lib/gcc-lib
5219     ;;
5220   i[34567]86-pc-msdosdjgpp*)
5221     md_exec_prefix=/dev/env/DJDIR/bin
5222     ;;
5223   i[34567]86-*-sco3.2v5*)
5224     if test $with_gnu_as = yes; then
5225       md_exec_prefix=/usr/gnu/bin
5226     else
5227       md_exec_prefix=/usr/ccs/bin/elf
5228     fi
5229     ;;
5230
5231   mn10300-*-* | \
5232   powerpc-*-chorusos* | \
5233   powerpc*-*-eabi* | \
5234   powerpc*-*-sysv* | \
5235   powerpc*-*-kaos* | \
5236   s390x-ibm-tpf*)
5237     md_exec_prefix=/usr/ccs/bin
5238     ;;
5239   sparc64-*-elf*)
5240     ;;
5241   v850*-*-*)
5242     md_exec_prefix=/usr/ccs/bin
5243     ;;
5244   xtensa-*-elf*)
5245     ;;
5246
5247   *-*-beos* | \
5248   *-*-elf* | \
5249   *-*-hpux* | \
5250   *-*-netware* | \
5251   *-*-nto-qnx* | \
5252   *-*-rtems* | \
5253   *-*-solaris2* | \
5254   *-*-sysv[45]* | \
5255   *-*-vxworks* | \
5256   *-wrs-windiss)
5257     md_exec_prefix=/usr/ccs/bin
5258     ;;
5259 esac
5260
5261 extra_arflags_for_target=
5262 extra_nmflags_for_target=
5263 extra_ranlibflags_for_target=
5264 target_makefile_frag=/dev/null
5265 case "${target}" in
5266   mep*-*-*)
5267     target_makefile_frag="config/mt-mep"
5268     ;;
5269   spu-*-*)
5270     target_makefile_frag="config/mt-spu"
5271     ;;
5272   mips*-sde-elf*)
5273     target_makefile_frag="config/mt-sde"
5274     ;;
5275   *-*-netware*)
5276     target_makefile_frag="config/mt-netware"
5277     ;;
5278   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5279     target_makefile_frag="config/mt-gnu"
5280     ;;
5281   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5282     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5283     # commands to handle both 32-bit and 64-bit objects.  These flags are
5284     # harmless if we're using GNU nm or ar.
5285     extra_arflags_for_target=" -X32_64"
5286     extra_nmflags_for_target=" -B -X32_64"
5287     ;;
5288   *-*-darwin*)
5289     # ranlib from Darwin requires the -c flag to look at common symbols.
5290     extra_ranlibflags_for_target=" -c"
5291     ;;
5292   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5293     target_makefile_frag="config/mt-wince"
5294     ;;
5295 esac
5296
5297 alphaieee_frag=/dev/null
5298 case $target in
5299   alpha*-*-*)
5300     # This just makes sure to use the -mieee option to build target libs.
5301     # This should probably be set individually by each library.
5302     alphaieee_frag="config/mt-alphaieee"
5303     ;;
5304 esac
5305
5306 # If --enable-target-optspace always use -Os instead of -O2 to build
5307 # the target libraries, similarly if it is not specified, use -Os
5308 # on selected platforms.
5309 ospace_frag=/dev/null
5310 case "${enable_target_optspace}:${target}" in
5311   yes:*)
5312     ospace_frag="config/mt-ospace"
5313     ;;
5314   :d30v-*)
5315     ospace_frag="config/mt-d30v"
5316     ;;
5317   :m32r-* | :d10v-* | :fr30-*)
5318     ospace_frag="config/mt-ospace"
5319     ;;
5320   no:* | :*)
5321     ;;
5322   *)
5323     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5324     ;;
5325 esac
5326
5327 # Default to using --with-stabs for certain targets.
5328 if test x${with_stabs} = x ; then
5329   case "${target}" in
5330   mips*-*-irix[56]*)
5331     ;;
5332   mips*-*-* | alpha*-*-osf*)
5333     with_stabs=yes;
5334     extra_host_args="${extra_host_args} --with-stabs"
5335     ;;
5336   esac
5337 fi
5338
5339 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5340 # them automatically.
5341 case "${host}" in
5342   hppa*64*-*-hpux11*)
5343     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5344     ;;
5345 esac
5346
5347 # Some systems (e.g., one of the i386-aix systems the gas testers are
5348 # using) don't handle "\$" correctly, so don't use it here.
5349 tooldir='${exec_prefix}'/${target_noncanonical}
5350 build_tooldir=${tooldir}
5351
5352 # Create a .gdbinit file which runs the one in srcdir
5353 # and tells GDB to look there for source files.
5354
5355 if test -r ${srcdir}/.gdbinit ; then
5356   case ${srcdir} in
5357     .) ;;
5358     *) cat > ./.gdbinit <<EOF
5359 # ${NO_EDIT}
5360 dir ${srcdir}
5361 dir .
5362 source ${srcdir}/.gdbinit
5363 EOF
5364     ;;
5365   esac
5366 fi
5367
5368 # Make sure that the compiler is able to generate an executable.  If it
5369 # can't, we are probably in trouble.  We don't care whether we can run the
5370 # executable--we might be using a cross compiler--we only care whether it
5371 # can be created.  At this point the main configure script has set CC.
5372 we_are_ok=no
5373 echo "int main () { return 0; }" > conftest.c
5374 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5375 if test $? = 0 ; then
5376   if test -s conftest || test -s conftest.exe ; then
5377     we_are_ok=yes
5378   fi
5379 fi
5380 case $we_are_ok in
5381   no)
5382     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5383     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5384     rm -f conftest*
5385     exit 1
5386     ;;
5387 esac
5388 rm -f conftest*
5389
5390 # The Solaris /usr/ucb/cc compiler does not appear to work.
5391 case "${host}" in
5392   sparc-sun-solaris2*)
5393       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5394       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5395           could_use=
5396           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5397           if test -d /opt/cygnus/bin ; then
5398               if test "$could_use" = "" ; then
5399                   could_use="/opt/cygnus/bin"
5400               else
5401                   could_use="$could_use or /opt/cygnus/bin"
5402               fi
5403           fi
5404         if test "$could_use" = "" ; then
5405             echo "Warning: compilation may fail because you're using"
5406             echo "/usr/ucb/cc.  You should change your PATH or CC "
5407             echo "variable and rerun configure."
5408         else
5409             echo "Warning: compilation may fail because you're using"
5410             echo "/usr/ucb/cc, when you should use the C compiler from"
5411             echo "$could_use.  You should change your"
5412             echo "PATH or CC variable and rerun configure."
5413         fi
5414       fi
5415   ;;
5416 esac
5417
5418 case "${host}" in
5419   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5420   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5421   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5422 esac
5423
5424 # Record target_configdirs and the configure arguments for target and
5425 # build configuration in Makefile.
5426 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5427 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5428
5429 # Determine whether gdb needs tk/tcl or not.
5430 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5431 # and in that case we want gdb to be built without tk.  Ugh!
5432 # In fact I believe gdb is the *only* package directly dependent on tk,
5433 # so we should be able to put the 'maybe's in unconditionally and
5434 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5435 # 100% sure that that's safe though.
5436
5437 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5438 case "$enable_gdbtk" in
5439   no)
5440     GDB_TK="" ;;
5441   yes)
5442     GDB_TK="${gdb_tk}" ;;
5443   *)
5444     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5445     # distro.  Eventually someone will fix this and move Insight, nee
5446     # gdbtk to a separate directory.
5447     if test -d ${srcdir}/gdb/gdbtk ; then
5448       GDB_TK="${gdb_tk}"
5449     else
5450       GDB_TK=""
5451     fi
5452     ;;
5453 esac
5454 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5455 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5456
5457 # Strip out unwanted targets.
5458
5459 # While at that, we remove Makefiles if we were started for recursive
5460 # configuration, so that the top-level Makefile reconfigures them,
5461 # like we used to do when configure itself was recursive.
5462
5463 # Loop over modules.  $extrasub must be used with care, limiting as
5464 # much as possible the usage of range addresses.  That's because autoconf
5465 # splits the sed script to overcome limits in the number of commands,
5466 # and relying on carefully-timed sed passes may turn out to be very hard
5467 # to maintain later.  In this particular case, you just have to be careful
5468 # not to nest @if/@endif pairs, because configure will not warn you at all.
5469
5470 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5471 if test "${enable_bootstrap+set}" = set; then
5472   enableval="$enable_bootstrap"
5473
5474 else
5475   enable_bootstrap=default
5476 fi;
5477
5478 # Issue errors and warnings for invalid/strange bootstrap combinations.
5479 case "$configdirs" in
5480   *gcc*) have_compiler=yes ;;
5481   *) have_compiler=no ;;
5482 esac
5483
5484 case "$have_compiler:$host:$target:$enable_bootstrap" in
5485   *:*:*:no) ;;
5486
5487   # Default behavior.  Enable bootstrap if we have a compiler
5488   # and we are in a native configuration.
5489   yes:$build:$build:default)
5490     enable_bootstrap=yes ;;
5491
5492   *:*:*:default)
5493     enable_bootstrap=no ;;
5494
5495   # We have a compiler and we are in a native configuration, bootstrap is ok
5496   yes:$build:$build:yes)
5497     ;;
5498
5499   # Other configurations, but we have a compiler.  Assume the user knows
5500   # what he's doing.
5501   yes:*:*:yes)
5502     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5503 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5504     ;;
5505
5506   # No compiler: if they passed --enable-bootstrap explicitly, fail
5507   no:*:*:yes)
5508     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5509 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5510    { (exit 1); exit 1; }; } ;;
5511
5512   # Fail if wrong command line
5513   *)
5514     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5515 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5516    { (exit 1); exit 1; }; }
5517     ;;
5518 esac
5519
5520 # Adjust the toplevel makefile according to whether bootstrap was selected.
5521 case "$enable_bootstrap" in
5522   yes)
5523     bootstrap_suffix=bootstrap ;;
5524   no)
5525     bootstrap_suffix=no-bootstrap ;;
5526 esac
5527
5528 for module in ${build_configdirs} ; do
5529   if test -z "${no_recursion}" \
5530      && test -f ${build_subdir}/${module}/Makefile; then
5531     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5532     rm -f ${build_subdir}/${module}/Makefile
5533   fi
5534   extrasub="$extrasub
5535 /^@if build-$module\$/d
5536 /^@endif build-$module\$/d
5537 /^@if build-$module-$bootstrap_suffix\$/d
5538 /^@endif build-$module-$bootstrap_suffix\$/d"
5539 done
5540 for module in ${configdirs} ; do
5541   if test -z "${no_recursion}"; then
5542     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5543       if test -f ${file}; then
5544         echo 1>&2 "*** removing ${file} to force reconfigure"
5545         rm -f ${file}
5546       fi
5547     done
5548   fi
5549   extrasub="$extrasub
5550 /^@if $module\$/d
5551 /^@endif $module\$/d
5552 /^@if $module-$bootstrap_suffix\$/d
5553 /^@endif $module-$bootstrap_suffix\$/d"
5554 done
5555 for module in ${target_configdirs} ; do
5556   if test -z "${no_recursion}" \
5557      && test -f ${target_subdir}/${module}/Makefile; then
5558     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5559     rm -f ${target_subdir}/${module}/Makefile
5560   fi
5561   extrasub="$extrasub
5562 /^@if target-$module\$/d
5563 /^@endif target-$module\$/d
5564 /^@if target-$module-$bootstrap_suffix\$/d
5565 /^@endif target-$module-$bootstrap_suffix\$/d"
5566 done
5567
5568 extrasub="$extrasub
5569 /^@if /,/^@endif /d"
5570
5571 # Create the serialization dependencies.  This uses a temporary file.
5572
5573 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5574 if test "${enable_serial_configure+set}" = set; then
5575   enableval="$enable_serial_configure"
5576
5577 fi;
5578
5579 case ${enable_serial_configure} in
5580   yes)
5581     enable_serial_build_configure=yes
5582     enable_serial_host_configure=yes
5583     enable_serial_target_configure=yes
5584     ;;
5585 esac
5586
5587 # These force 'configure's to be done one at a time, to avoid problems
5588 # with contention over a shared config.cache.
5589 rm -f serdep.tmp
5590 echo '# serdep.tmp' > serdep.tmp
5591 olditem=
5592 test "x${enable_serial_build_configure}" = xyes &&
5593 for item in ${build_configdirs} ; do
5594   case ${olditem} in
5595     "") ;;
5596     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5597   esac
5598   olditem=${item}
5599 done
5600 olditem=
5601 test "x${enable_serial_host_configure}" = xyes &&
5602 for item in ${configdirs} ; do
5603   case ${olditem} in
5604     "") ;;
5605     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5606   esac
5607   olditem=${item}
5608 done
5609 olditem=
5610 test "x${enable_serial_target_configure}" = xyes &&
5611 for item in ${target_configdirs} ; do
5612   case ${olditem} in
5613     "") ;;
5614     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5615   esac
5616   olditem=${item}
5617 done
5618 serialization_dependencies=serdep.tmp
5619
5620
5621 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5622 # target, nonopt, and variable assignments.  These are the ones we
5623 # might not want to pass down to subconfigures.  Also strip
5624 # program-prefix, program-suffix, and program-transform-name, so that
5625 # we can pass down a consistent program-transform-name.
5626 baseargs=
5627 keep_next=no
5628 skip_next=no
5629 eval "set -- $ac_configure_args"
5630 for ac_arg
5631 do
5632   if test X"$skip_next" = X"yes"; then
5633     skip_next=no
5634     continue
5635   fi
5636   if test X"$keep_next" = X"yes"; then
5637     case $ac_arg in
5638       *\'*)
5639         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5640     esac
5641     baseargs="$baseargs '$ac_arg'"
5642     keep_next=no
5643     continue
5644   fi
5645
5646   # Handle separated arguments.  Based on the logic generated by
5647   # autoconf 2.59.
5648   case $ac_arg in
5649     *=* | --config-cache | -C | -disable-* | --disable-* \
5650       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5651       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5652       | -with-* | --with-* | -without-* | --without-* | --x)
5653       separate_arg=no
5654       ;;
5655     -*)
5656       separate_arg=yes
5657       ;;
5658     *)
5659       separate_arg=no
5660       ;;
5661   esac
5662
5663   case "$ac_arg" in
5664     --no*)
5665       continue
5666       ;;
5667     --c* | \
5668     --sr* | \
5669     --ho* | \
5670     --bu* | \
5671     --t* | \
5672     --program-* | \
5673     -cache_file* | \
5674     -srcdir* | \
5675     -host* | \
5676     -build* | \
5677     -target* | \
5678     -program-prefix* | \
5679     -program-suffix* | \
5680     -program-transform-name* )
5681       skip_next=$separate_arg
5682       continue
5683       ;;
5684     -*)
5685       # An option.  Add it.
5686       case $ac_arg in
5687         *\'*)
5688           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5689       esac
5690       baseargs="$baseargs '$ac_arg'"
5691       keep_next=$separate_arg
5692       ;;
5693     *)
5694       # Either a variable assignment, or a nonopt (triplet).  Don't
5695       # pass it down; let the Makefile handle this.
5696       continue
5697       ;;
5698   esac
5699 done
5700 # Remove the initial space we just introduced and, as these will be
5701 # expanded by make, quote '$'.
5702 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5703
5704 # Add in --program-transform-name, after --program-prefix and
5705 # --program-suffix have been applied to it.  Autoconf has already
5706 # doubled dollar signs and backslashes in program_transform_name; we want
5707 # the backslashes un-doubled, and then the entire thing wrapped in single
5708 # quotes, because this will be expanded first by make and then by the shell.
5709 # Also, because we want to override the logic in subdir configure scripts to
5710 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5711 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5712 ${program_transform_name}
5713 EOF_SED
5714 gcc_transform_name=`cat conftestsed.out`
5715 rm -f conftestsed.out
5716 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5717 if test "$silent" = yes; then
5718   baseargs="$baseargs --silent"
5719 fi
5720
5721 # For the build-side libraries, we just need to pretend we're native,
5722 # and not use the same cache file.  Multilibs are neither needed nor
5723 # desired.
5724 build_configargs="--cache-file=../config.cache ${baseargs}"
5725
5726 # For host modules, accept cache file option, or specification as blank.
5727 case "${cache_file}" in
5728 "") # empty
5729   cache_file_option="" ;;
5730 /* | [A-Za-z]:[\\/]* ) # absolute path
5731   cache_file_option="--cache-file=${cache_file}" ;;
5732 *) # relative path
5733   cache_file_option="--cache-file=../${cache_file}" ;;
5734 esac
5735
5736 # Host dirs don't like to share a cache file either, horribly enough.
5737 # This seems to be due to autoconf 2.5x stupidity.
5738 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5739
5740 target_configargs=${baseargs}
5741
5742 # Passing a --with-cross-host argument lets the target libraries know
5743 # whether they are being built with a cross-compiler or being built
5744 # native.  However, it would be better to use other mechanisms to make the
5745 # sorts of decisions they want to make on this basis.  Please consider
5746 # this option to be deprecated.  FIXME.
5747 if test x${is_cross_compiler} = xyes ; then
5748   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5749 fi
5750
5751 # Default to --enable-multilib.
5752 if test x${enable_multilib} = x ; then
5753   target_configargs="--enable-multilib ${target_configargs}"
5754 fi
5755
5756 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5757 # changed from the earlier setting of with_newlib.
5758 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5759   target_configargs="--with-newlib ${target_configargs}"
5760 fi
5761
5762 # Different target subdirs use different values of certain variables
5763 # (notably CXX).  Worse, multilibs use *lots* of different values.
5764 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5765 # it doesn't automatically accept command-line overrides of them.
5766 # This means it's not safe for target subdirs to share a cache file,
5767 # which is disgusting, but there you have it.  Hopefully this can be
5768 # fixed in future.  It's still worthwhile to use a cache file for each
5769 # directory.  I think.
5770
5771 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5772 # We need to pass --target, as newer autoconf's requires consistency
5773 # for target_alias and gcc doesn't manage it consistently.
5774 target_configargs="--cache-file=./config.cache ${target_configargs}"
5775
5776 FLAGS_FOR_TARGET=
5777 case " $target_configdirs " in
5778  *" newlib "*)
5779   case " $target_configargs " in
5780   *" --with-newlib "*)
5781    case "$target" in
5782    *-cygwin*)
5783      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' ;;
5784    esac
5785
5786    # If we're not building GCC, don't discard standard headers.
5787    if test -d ${srcdir}/gcc; then
5788      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5789
5790      if test "${build}" != "${host}"; then
5791        # On Canadian crosses, CC_FOR_TARGET will have already been set
5792        # by `configure', so we won't have an opportunity to add -Bgcc/
5793        # to it.  This is right: we don't want to search that directory
5794        # for binaries, but we want the header files in there, so add
5795        # them explicitly.
5796        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5797
5798        # Someone might think of using the pre-installed headers on
5799        # Canadian crosses, in case the installed compiler is not fully
5800        # compatible with the compiler being built.  In this case, it
5801        # would be better to flag an error than risking having
5802        # incompatible object files being constructed.  We can't
5803        # guarantee that an error will be flagged, but let's hope the
5804        # compiler will do it, when presented with incompatible header
5805        # files.
5806      fi
5807    fi
5808
5809    case "${target}-${is_cross_compiler}" in
5810    i[3456789]86-*-linux*-no)
5811       # Here host == target, so we don't need to build gcc,
5812       # so we don't want to discard standard headers.
5813       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5814       ;;
5815    *)
5816       # If we're building newlib, use its generic headers last, but search
5817       # for any libc-related directories first (so make it the last -B
5818       # switch).
5819       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5820
5821       # If we're building libgloss, find the startup file, simulator library
5822       # and linker script.
5823       case " $target_configdirs " in
5824         *" libgloss "*)
5825         # Look for startup file, simulator library and maybe linker script.
5826         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/'"$libgloss_dir"
5827         # Look for libnosys.a in case the target needs it.
5828         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5829         # Most targets have the linker script in the source directory.
5830         FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$s/libgloss/'"$libgloss_dir"
5831         ;;
5832       esac
5833       ;;
5834    esac
5835    ;;
5836   esac
5837   ;;
5838 esac
5839 case "$target" in
5840 *-mingw*)
5841   # Can't be handled as Cygwin above since Mingw does not use newlib.
5842   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' ;;
5843 esac
5844
5845 # Allow the user to override the flags for
5846 # our build compiler if desired.
5847 CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5848
5849 # On Canadian crosses, we'll be searching the right directories for
5850 # the previously-installed cross compiler, so don't bother to add
5851 # flags for directories within the install tree of the compiler
5852 # being built; programs in there won't even run.
5853 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5854   # Search for pre-installed headers if nothing else fits.
5855   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5856 fi
5857
5858 if test "x${use_gnu_ld}" = x &&
5859    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5860   # Arrange for us to find uninstalled linker scripts.
5861   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5862 fi
5863
5864 # Search for other target-specific linker scripts and such.
5865 case "${target}" in
5866   mep*)
5867     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5868     ;;
5869 esac
5870
5871 # Makefile fragments.
5872 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5873 do
5874   eval fragval=\$$frag
5875   if test $fragval != /dev/null; then
5876     eval $frag=${srcdir}/$fragval
5877   fi
5878 done
5879
5880
5881
5882
5883
5884 # Miscellanea: directories, flags, etc.
5885
5886
5887
5888
5889
5890
5891
5892 # Build module lists & subconfigure args.
5893
5894
5895
5896 # Host module lists & subconfigure args.
5897
5898
5899
5900 # Target module lists & subconfigure args.
5901
5902
5903
5904 # Build tools.
5905
5906
5907
5908 # Generate default definitions for YACC, M4, LEX and other programs that run
5909 # on the build machine.  These are used if the Makefile can't locate these
5910 # programs in objdir.
5911 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5912
5913 for ac_prog in 'bison -y' byacc yacc
5914 do
5915   # Extract the first word of "$ac_prog", so it can be a program name with args.
5916 set dummy $ac_prog; ac_word=$2
5917 echo "$as_me:$LINENO: checking for $ac_word" >&5
5918 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5919 if test "${ac_cv_prog_YACC+set}" = set; then
5920   echo $ECHO_N "(cached) $ECHO_C" >&6
5921 else
5922   if test -n "$YACC"; then
5923   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5924 else
5925 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5926 for as_dir in $PATH
5927 do
5928   IFS=$as_save_IFS
5929   test -z "$as_dir" && as_dir=.
5930   for ac_exec_ext in '' $ac_executable_extensions; do
5931   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5932     ac_cv_prog_YACC="$ac_prog"
5933     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5934     break 2
5935   fi
5936 done
5937 done
5938
5939 fi
5940 fi
5941 YACC=$ac_cv_prog_YACC
5942 if test -n "$YACC"; then
5943   echo "$as_me:$LINENO: result: $YACC" >&5
5944 echo "${ECHO_T}$YACC" >&6
5945 else
5946   echo "$as_me:$LINENO: result: no" >&5
5947 echo "${ECHO_T}no" >&6
5948 fi
5949
5950   test -n "$YACC" && break
5951 done
5952 test -n "$YACC" || YACC="$MISSING bison -y"
5953
5954 case " $build_configdirs " in
5955   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
5956   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
5957 esac
5958
5959 for ac_prog in bison
5960 do
5961   # Extract the first word of "$ac_prog", so it can be a program name with args.
5962 set dummy $ac_prog; ac_word=$2
5963 echo "$as_me:$LINENO: checking for $ac_word" >&5
5964 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5965 if test "${ac_cv_prog_BISON+set}" = set; then
5966   echo $ECHO_N "(cached) $ECHO_C" >&6
5967 else
5968   if test -n "$BISON"; then
5969   ac_cv_prog_BISON="$BISON" # Let the user override the test.
5970 else
5971 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5972 for as_dir in $PATH
5973 do
5974   IFS=$as_save_IFS
5975   test -z "$as_dir" && as_dir=.
5976   for ac_exec_ext in '' $ac_executable_extensions; do
5977   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5978     ac_cv_prog_BISON="$ac_prog"
5979     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5980     break 2
5981   fi
5982 done
5983 done
5984
5985 fi
5986 fi
5987 BISON=$ac_cv_prog_BISON
5988 if test -n "$BISON"; then
5989   echo "$as_me:$LINENO: result: $BISON" >&5
5990 echo "${ECHO_T}$BISON" >&6
5991 else
5992   echo "$as_me:$LINENO: result: no" >&5
5993 echo "${ECHO_T}no" >&6
5994 fi
5995
5996   test -n "$BISON" && break
5997 done
5998 test -n "$BISON" || BISON="$MISSING bison"
5999
6000 case " $build_configdirs " in
6001   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
6002 esac
6003
6004 for ac_prog in gm4 gnum4 m4
6005 do
6006   # Extract the first word of "$ac_prog", so it can be a program name with args.
6007 set dummy $ac_prog; ac_word=$2
6008 echo "$as_me:$LINENO: checking for $ac_word" >&5
6009 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6010 if test "${ac_cv_prog_M4+set}" = set; then
6011   echo $ECHO_N "(cached) $ECHO_C" >&6
6012 else
6013   if test -n "$M4"; then
6014   ac_cv_prog_M4="$M4" # Let the user override the test.
6015 else
6016 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6017 for as_dir in $PATH
6018 do
6019   IFS=$as_save_IFS
6020   test -z "$as_dir" && as_dir=.
6021   for ac_exec_ext in '' $ac_executable_extensions; do
6022   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6023     ac_cv_prog_M4="$ac_prog"
6024     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6025     break 2
6026   fi
6027 done
6028 done
6029
6030 fi
6031 fi
6032 M4=$ac_cv_prog_M4
6033 if test -n "$M4"; then
6034   echo "$as_me:$LINENO: result: $M4" >&5
6035 echo "${ECHO_T}$M4" >&6
6036 else
6037   echo "$as_me:$LINENO: result: no" >&5
6038 echo "${ECHO_T}no" >&6
6039 fi
6040
6041   test -n "$M4" && break
6042 done
6043 test -n "$M4" || M4="$MISSING m4"
6044
6045 case " $build_configdirs " in
6046   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6047 esac
6048
6049 for ac_prog in flex lex
6050 do
6051   # Extract the first word of "$ac_prog", so it can be a program name with args.
6052 set dummy $ac_prog; ac_word=$2
6053 echo "$as_me:$LINENO: checking for $ac_word" >&5
6054 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6055 if test "${ac_cv_prog_LEX+set}" = set; then
6056   echo $ECHO_N "(cached) $ECHO_C" >&6
6057 else
6058   if test -n "$LEX"; then
6059   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6060 else
6061 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6062 for as_dir in $PATH
6063 do
6064   IFS=$as_save_IFS
6065   test -z "$as_dir" && as_dir=.
6066   for ac_exec_ext in '' $ac_executable_extensions; do
6067   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6068     ac_cv_prog_LEX="$ac_prog"
6069     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6070     break 2
6071   fi
6072 done
6073 done
6074
6075 fi
6076 fi
6077 LEX=$ac_cv_prog_LEX
6078 if test -n "$LEX"; then
6079   echo "$as_me:$LINENO: result: $LEX" >&5
6080 echo "${ECHO_T}$LEX" >&6
6081 else
6082   echo "$as_me:$LINENO: result: no" >&5
6083 echo "${ECHO_T}no" >&6
6084 fi
6085
6086   test -n "$LEX" && break
6087 done
6088 test -n "$LEX" || LEX="$MISSING flex"
6089
6090 case " $build_configdirs " in
6091   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6092   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6093 esac
6094
6095 for ac_prog in flex
6096 do
6097   # Extract the first word of "$ac_prog", so it can be a program name with args.
6098 set dummy $ac_prog; ac_word=$2
6099 echo "$as_me:$LINENO: checking for $ac_word" >&5
6100 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6101 if test "${ac_cv_prog_FLEX+set}" = set; then
6102   echo $ECHO_N "(cached) $ECHO_C" >&6
6103 else
6104   if test -n "$FLEX"; then
6105   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6106 else
6107 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6108 for as_dir in $PATH
6109 do
6110   IFS=$as_save_IFS
6111   test -z "$as_dir" && as_dir=.
6112   for ac_exec_ext in '' $ac_executable_extensions; do
6113   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6114     ac_cv_prog_FLEX="$ac_prog"
6115     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6116     break 2
6117   fi
6118 done
6119 done
6120
6121 fi
6122 fi
6123 FLEX=$ac_cv_prog_FLEX
6124 if test -n "$FLEX"; then
6125   echo "$as_me:$LINENO: result: $FLEX" >&5
6126 echo "${ECHO_T}$FLEX" >&6
6127 else
6128   echo "$as_me:$LINENO: result: no" >&5
6129 echo "${ECHO_T}no" >&6
6130 fi
6131
6132   test -n "$FLEX" && break
6133 done
6134 test -n "$FLEX" || FLEX="$MISSING flex"
6135
6136 case " $build_configdirs " in
6137   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6138 esac
6139
6140 for ac_prog in makeinfo
6141 do
6142   # Extract the first word of "$ac_prog", so it can be a program name with args.
6143 set dummy $ac_prog; ac_word=$2
6144 echo "$as_me:$LINENO: checking for $ac_word" >&5
6145 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6146 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6147   echo $ECHO_N "(cached) $ECHO_C" >&6
6148 else
6149   if test -n "$MAKEINFO"; then
6150   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6151 else
6152 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6153 for as_dir in $PATH
6154 do
6155   IFS=$as_save_IFS
6156   test -z "$as_dir" && as_dir=.
6157   for ac_exec_ext in '' $ac_executable_extensions; do
6158   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6159     ac_cv_prog_MAKEINFO="$ac_prog"
6160     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6161     break 2
6162   fi
6163 done
6164 done
6165
6166 fi
6167 fi
6168 MAKEINFO=$ac_cv_prog_MAKEINFO
6169 if test -n "$MAKEINFO"; then
6170   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6171 echo "${ECHO_T}$MAKEINFO" >&6
6172 else
6173   echo "$as_me:$LINENO: result: no" >&5
6174 echo "${ECHO_T}no" >&6
6175 fi
6176
6177   test -n "$MAKEINFO" && break
6178 done
6179 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6180
6181 case " $build_configdirs " in
6182   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6183   *)
6184
6185     # For an installed makeinfo, we require it to be from texinfo 4.4 or
6186     # higher, else we use the "missing" dummy.
6187     if ${MAKEINFO} --version \
6188        | egrep 'texinfo[^0-9]*([1-3][0-9]|4\.[4-9]|[5-9])' >/dev/null 2>&1; then
6189       :
6190     else
6191       MAKEINFO="$MISSING makeinfo"
6192     fi
6193     ;;
6194
6195 esac
6196
6197 # FIXME: expect and dejagnu may become build tools?
6198
6199 for ac_prog in expect
6200 do
6201   # Extract the first word of "$ac_prog", so it can be a program name with args.
6202 set dummy $ac_prog; ac_word=$2
6203 echo "$as_me:$LINENO: checking for $ac_word" >&5
6204 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6205 if test "${ac_cv_prog_EXPECT+set}" = set; then
6206   echo $ECHO_N "(cached) $ECHO_C" >&6
6207 else
6208   if test -n "$EXPECT"; then
6209   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6210 else
6211 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6212 for as_dir in $PATH
6213 do
6214   IFS=$as_save_IFS
6215   test -z "$as_dir" && as_dir=.
6216   for ac_exec_ext in '' $ac_executable_extensions; do
6217   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6218     ac_cv_prog_EXPECT="$ac_prog"
6219     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6220     break 2
6221   fi
6222 done
6223 done
6224
6225 fi
6226 fi
6227 EXPECT=$ac_cv_prog_EXPECT
6228 if test -n "$EXPECT"; then
6229   echo "$as_me:$LINENO: result: $EXPECT" >&5
6230 echo "${ECHO_T}$EXPECT" >&6
6231 else
6232   echo "$as_me:$LINENO: result: no" >&5
6233 echo "${ECHO_T}no" >&6
6234 fi
6235
6236   test -n "$EXPECT" && break
6237 done
6238 test -n "$EXPECT" || EXPECT="expect"
6239
6240 case " $configdirs " in
6241   *" expect "*)
6242     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6243     ;;
6244 esac
6245
6246 for ac_prog in runtest
6247 do
6248   # Extract the first word of "$ac_prog", so it can be a program name with args.
6249 set dummy $ac_prog; ac_word=$2
6250 echo "$as_me:$LINENO: checking for $ac_word" >&5
6251 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6252 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6253   echo $ECHO_N "(cached) $ECHO_C" >&6
6254 else
6255   if test -n "$RUNTEST"; then
6256   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6257 else
6258 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6259 for as_dir in $PATH
6260 do
6261   IFS=$as_save_IFS
6262   test -z "$as_dir" && as_dir=.
6263   for ac_exec_ext in '' $ac_executable_extensions; do
6264   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6265     ac_cv_prog_RUNTEST="$ac_prog"
6266     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6267     break 2
6268   fi
6269 done
6270 done
6271
6272 fi
6273 fi
6274 RUNTEST=$ac_cv_prog_RUNTEST
6275 if test -n "$RUNTEST"; then
6276   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6277 echo "${ECHO_T}$RUNTEST" >&6
6278 else
6279   echo "$as_me:$LINENO: result: no" >&5
6280 echo "${ECHO_T}no" >&6
6281 fi
6282
6283   test -n "$RUNTEST" && break
6284 done
6285 test -n "$RUNTEST" || RUNTEST="runtest"
6286
6287 case " $configdirs " in
6288   *" dejagnu "*)
6289     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6290     ;;
6291 esac
6292
6293
6294 # Host tools.
6295 ncn_tool_prefix=
6296 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6297 ncn_target_tool_prefix=
6298 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6299
6300
6301
6302 if test -n "$AR"; then
6303   ac_cv_prog_AR=$AR
6304 elif test -n "$ac_cv_prog_AR"; then
6305   AR=$ac_cv_prog_AR
6306 fi
6307
6308 if test -n "$ac_cv_prog_AR"; then
6309   for ncn_progname in ar; do
6310     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6311 set dummy ${ncn_progname}; ac_word=$2
6312 echo "$as_me:$LINENO: checking for $ac_word" >&5
6313 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6314 if test "${ac_cv_prog_AR+set}" = set; then
6315   echo $ECHO_N "(cached) $ECHO_C" >&6
6316 else
6317   if test -n "$AR"; then
6318   ac_cv_prog_AR="$AR" # Let the user override the test.
6319 else
6320 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6321 for as_dir in $PATH
6322 do
6323   IFS=$as_save_IFS
6324   test -z "$as_dir" && as_dir=.
6325   for ac_exec_ext in '' $ac_executable_extensions; do
6326   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6327     ac_cv_prog_AR="${ncn_progname}"
6328     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6329     break 2
6330   fi
6331 done
6332 done
6333
6334 fi
6335 fi
6336 AR=$ac_cv_prog_AR
6337 if test -n "$AR"; then
6338   echo "$as_me:$LINENO: result: $AR" >&5
6339 echo "${ECHO_T}$AR" >&6
6340 else
6341   echo "$as_me:$LINENO: result: no" >&5
6342 echo "${ECHO_T}no" >&6
6343 fi
6344
6345   done
6346 fi
6347
6348 for ncn_progname in ar; do
6349   if test -n "$ncn_tool_prefix"; then
6350     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6351 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6352 echo "$as_me:$LINENO: checking for $ac_word" >&5
6353 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6354 if test "${ac_cv_prog_AR+set}" = set; then
6355   echo $ECHO_N "(cached) $ECHO_C" >&6
6356 else
6357   if test -n "$AR"; then
6358   ac_cv_prog_AR="$AR" # Let the user override the test.
6359 else
6360 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6361 for as_dir in $PATH
6362 do
6363   IFS=$as_save_IFS
6364   test -z "$as_dir" && as_dir=.
6365   for ac_exec_ext in '' $ac_executable_extensions; do
6366   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6367     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6368     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6369     break 2
6370   fi
6371 done
6372 done
6373
6374 fi
6375 fi
6376 AR=$ac_cv_prog_AR
6377 if test -n "$AR"; then
6378   echo "$as_me:$LINENO: result: $AR" >&5
6379 echo "${ECHO_T}$AR" >&6
6380 else
6381   echo "$as_me:$LINENO: result: no" >&5
6382 echo "${ECHO_T}no" >&6
6383 fi
6384
6385   fi
6386   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6387     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6388 set dummy ${ncn_progname}; ac_word=$2
6389 echo "$as_me:$LINENO: checking for $ac_word" >&5
6390 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6391 if test "${ac_cv_prog_AR+set}" = set; then
6392   echo $ECHO_N "(cached) $ECHO_C" >&6
6393 else
6394   if test -n "$AR"; then
6395   ac_cv_prog_AR="$AR" # Let the user override the test.
6396 else
6397 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6398 for as_dir in $PATH
6399 do
6400   IFS=$as_save_IFS
6401   test -z "$as_dir" && as_dir=.
6402   for ac_exec_ext in '' $ac_executable_extensions; do
6403   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6404     ac_cv_prog_AR="${ncn_progname}"
6405     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6406     break 2
6407   fi
6408 done
6409 done
6410
6411 fi
6412 fi
6413 AR=$ac_cv_prog_AR
6414 if test -n "$AR"; then
6415   echo "$as_me:$LINENO: result: $AR" >&5
6416 echo "${ECHO_T}$AR" >&6
6417 else
6418   echo "$as_me:$LINENO: result: no" >&5
6419 echo "${ECHO_T}no" >&6
6420 fi
6421
6422   fi
6423   test -n "$ac_cv_prog_AR" && break
6424 done
6425
6426 if test -z "$ac_cv_prog_AR" ; then
6427   set dummy ar
6428   if test $build = $host ; then
6429     AR="$2"
6430   else
6431     AR="${ncn_tool_prefix}$2"
6432   fi
6433 fi
6434
6435
6436
6437 if test -n "$AS"; then
6438   ac_cv_prog_AS=$AS
6439 elif test -n "$ac_cv_prog_AS"; then
6440   AS=$ac_cv_prog_AS
6441 fi
6442
6443 if test -n "$ac_cv_prog_AS"; then
6444   for ncn_progname in as; do
6445     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6446 set dummy ${ncn_progname}; ac_word=$2
6447 echo "$as_me:$LINENO: checking for $ac_word" >&5
6448 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6449 if test "${ac_cv_prog_AS+set}" = set; then
6450   echo $ECHO_N "(cached) $ECHO_C" >&6
6451 else
6452   if test -n "$AS"; then
6453   ac_cv_prog_AS="$AS" # Let the user override the test.
6454 else
6455 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6456 for as_dir in $PATH
6457 do
6458   IFS=$as_save_IFS
6459   test -z "$as_dir" && as_dir=.
6460   for ac_exec_ext in '' $ac_executable_extensions; do
6461   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6462     ac_cv_prog_AS="${ncn_progname}"
6463     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6464     break 2
6465   fi
6466 done
6467 done
6468
6469 fi
6470 fi
6471 AS=$ac_cv_prog_AS
6472 if test -n "$AS"; then
6473   echo "$as_me:$LINENO: result: $AS" >&5
6474 echo "${ECHO_T}$AS" >&6
6475 else
6476   echo "$as_me:$LINENO: result: no" >&5
6477 echo "${ECHO_T}no" >&6
6478 fi
6479
6480   done
6481 fi
6482
6483 for ncn_progname in as; do
6484   if test -n "$ncn_tool_prefix"; then
6485     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6486 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6487 echo "$as_me:$LINENO: checking for $ac_word" >&5
6488 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6489 if test "${ac_cv_prog_AS+set}" = set; then
6490   echo $ECHO_N "(cached) $ECHO_C" >&6
6491 else
6492   if test -n "$AS"; then
6493   ac_cv_prog_AS="$AS" # Let the user override the test.
6494 else
6495 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6496 for as_dir in $PATH
6497 do
6498   IFS=$as_save_IFS
6499   test -z "$as_dir" && as_dir=.
6500   for ac_exec_ext in '' $ac_executable_extensions; do
6501   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6502     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6503     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6504     break 2
6505   fi
6506 done
6507 done
6508
6509 fi
6510 fi
6511 AS=$ac_cv_prog_AS
6512 if test -n "$AS"; then
6513   echo "$as_me:$LINENO: result: $AS" >&5
6514 echo "${ECHO_T}$AS" >&6
6515 else
6516   echo "$as_me:$LINENO: result: no" >&5
6517 echo "${ECHO_T}no" >&6
6518 fi
6519
6520   fi
6521   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6522     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6523 set dummy ${ncn_progname}; ac_word=$2
6524 echo "$as_me:$LINENO: checking for $ac_word" >&5
6525 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6526 if test "${ac_cv_prog_AS+set}" = set; then
6527   echo $ECHO_N "(cached) $ECHO_C" >&6
6528 else
6529   if test -n "$AS"; then
6530   ac_cv_prog_AS="$AS" # Let the user override the test.
6531 else
6532 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6533 for as_dir in $PATH
6534 do
6535   IFS=$as_save_IFS
6536   test -z "$as_dir" && as_dir=.
6537   for ac_exec_ext in '' $ac_executable_extensions; do
6538   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6539     ac_cv_prog_AS="${ncn_progname}"
6540     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6541     break 2
6542   fi
6543 done
6544 done
6545
6546 fi
6547 fi
6548 AS=$ac_cv_prog_AS
6549 if test -n "$AS"; then
6550   echo "$as_me:$LINENO: result: $AS" >&5
6551 echo "${ECHO_T}$AS" >&6
6552 else
6553   echo "$as_me:$LINENO: result: no" >&5
6554 echo "${ECHO_T}no" >&6
6555 fi
6556
6557   fi
6558   test -n "$ac_cv_prog_AS" && break
6559 done
6560
6561 if test -z "$ac_cv_prog_AS" ; then
6562   set dummy as
6563   if test $build = $host ; then
6564     AS="$2"
6565   else
6566     AS="${ncn_tool_prefix}$2"
6567   fi
6568 fi
6569
6570
6571
6572 if test -n "$DLLTOOL"; then
6573   ac_cv_prog_DLLTOOL=$DLLTOOL
6574 elif test -n "$ac_cv_prog_DLLTOOL"; then
6575   DLLTOOL=$ac_cv_prog_DLLTOOL
6576 fi
6577
6578 if test -n "$ac_cv_prog_DLLTOOL"; then
6579   for ncn_progname in dlltool; do
6580     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6581 set dummy ${ncn_progname}; ac_word=$2
6582 echo "$as_me:$LINENO: checking for $ac_word" >&5
6583 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6584 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6585   echo $ECHO_N "(cached) $ECHO_C" >&6
6586 else
6587   if test -n "$DLLTOOL"; then
6588   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6589 else
6590 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6591 for as_dir in $PATH
6592 do
6593   IFS=$as_save_IFS
6594   test -z "$as_dir" && as_dir=.
6595   for ac_exec_ext in '' $ac_executable_extensions; do
6596   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6597     ac_cv_prog_DLLTOOL="${ncn_progname}"
6598     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6599     break 2
6600   fi
6601 done
6602 done
6603
6604 fi
6605 fi
6606 DLLTOOL=$ac_cv_prog_DLLTOOL
6607 if test -n "$DLLTOOL"; then
6608   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6609 echo "${ECHO_T}$DLLTOOL" >&6
6610 else
6611   echo "$as_me:$LINENO: result: no" >&5
6612 echo "${ECHO_T}no" >&6
6613 fi
6614
6615   done
6616 fi
6617
6618 for ncn_progname in dlltool; do
6619   if test -n "$ncn_tool_prefix"; then
6620     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6621 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6622 echo "$as_me:$LINENO: checking for $ac_word" >&5
6623 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6624 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6625   echo $ECHO_N "(cached) $ECHO_C" >&6
6626 else
6627   if test -n "$DLLTOOL"; then
6628   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6629 else
6630 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6631 for as_dir in $PATH
6632 do
6633   IFS=$as_save_IFS
6634   test -z "$as_dir" && as_dir=.
6635   for ac_exec_ext in '' $ac_executable_extensions; do
6636   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6637     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6638     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6639     break 2
6640   fi
6641 done
6642 done
6643
6644 fi
6645 fi
6646 DLLTOOL=$ac_cv_prog_DLLTOOL
6647 if test -n "$DLLTOOL"; then
6648   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6649 echo "${ECHO_T}$DLLTOOL" >&6
6650 else
6651   echo "$as_me:$LINENO: result: no" >&5
6652 echo "${ECHO_T}no" >&6
6653 fi
6654
6655   fi
6656   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6657     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6658 set dummy ${ncn_progname}; ac_word=$2
6659 echo "$as_me:$LINENO: checking for $ac_word" >&5
6660 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6661 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6662   echo $ECHO_N "(cached) $ECHO_C" >&6
6663 else
6664   if test -n "$DLLTOOL"; then
6665   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6666 else
6667 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6668 for as_dir in $PATH
6669 do
6670   IFS=$as_save_IFS
6671   test -z "$as_dir" && as_dir=.
6672   for ac_exec_ext in '' $ac_executable_extensions; do
6673   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6674     ac_cv_prog_DLLTOOL="${ncn_progname}"
6675     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6676     break 2
6677   fi
6678 done
6679 done
6680
6681 fi
6682 fi
6683 DLLTOOL=$ac_cv_prog_DLLTOOL
6684 if test -n "$DLLTOOL"; then
6685   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6686 echo "${ECHO_T}$DLLTOOL" >&6
6687 else
6688   echo "$as_me:$LINENO: result: no" >&5
6689 echo "${ECHO_T}no" >&6
6690 fi
6691
6692   fi
6693   test -n "$ac_cv_prog_DLLTOOL" && break
6694 done
6695
6696 if test -z "$ac_cv_prog_DLLTOOL" ; then
6697   set dummy dlltool
6698   if test $build = $host ; then
6699     DLLTOOL="$2"
6700   else
6701     DLLTOOL="${ncn_tool_prefix}$2"
6702   fi
6703 fi
6704
6705
6706
6707 if test -n "$LD"; then
6708   ac_cv_prog_LD=$LD
6709 elif test -n "$ac_cv_prog_LD"; then
6710   LD=$ac_cv_prog_LD
6711 fi
6712
6713 if test -n "$ac_cv_prog_LD"; then
6714   for ncn_progname in ld; do
6715     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6716 set dummy ${ncn_progname}; ac_word=$2
6717 echo "$as_me:$LINENO: checking for $ac_word" >&5
6718 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6719 if test "${ac_cv_prog_LD+set}" = set; then
6720   echo $ECHO_N "(cached) $ECHO_C" >&6
6721 else
6722   if test -n "$LD"; then
6723   ac_cv_prog_LD="$LD" # Let the user override the test.
6724 else
6725 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6726 for as_dir in $PATH
6727 do
6728   IFS=$as_save_IFS
6729   test -z "$as_dir" && as_dir=.
6730   for ac_exec_ext in '' $ac_executable_extensions; do
6731   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6732     ac_cv_prog_LD="${ncn_progname}"
6733     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6734     break 2
6735   fi
6736 done
6737 done
6738
6739 fi
6740 fi
6741 LD=$ac_cv_prog_LD
6742 if test -n "$LD"; then
6743   echo "$as_me:$LINENO: result: $LD" >&5
6744 echo "${ECHO_T}$LD" >&6
6745 else
6746   echo "$as_me:$LINENO: result: no" >&5
6747 echo "${ECHO_T}no" >&6
6748 fi
6749
6750   done
6751 fi
6752
6753 for ncn_progname in ld; do
6754   if test -n "$ncn_tool_prefix"; then
6755     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6756 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6757 echo "$as_me:$LINENO: checking for $ac_word" >&5
6758 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6759 if test "${ac_cv_prog_LD+set}" = set; then
6760   echo $ECHO_N "(cached) $ECHO_C" >&6
6761 else
6762   if test -n "$LD"; then
6763   ac_cv_prog_LD="$LD" # Let the user override the test.
6764 else
6765 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6766 for as_dir in $PATH
6767 do
6768   IFS=$as_save_IFS
6769   test -z "$as_dir" && as_dir=.
6770   for ac_exec_ext in '' $ac_executable_extensions; do
6771   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6772     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6773     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6774     break 2
6775   fi
6776 done
6777 done
6778
6779 fi
6780 fi
6781 LD=$ac_cv_prog_LD
6782 if test -n "$LD"; then
6783   echo "$as_me:$LINENO: result: $LD" >&5
6784 echo "${ECHO_T}$LD" >&6
6785 else
6786   echo "$as_me:$LINENO: result: no" >&5
6787 echo "${ECHO_T}no" >&6
6788 fi
6789
6790   fi
6791   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6792     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6793 set dummy ${ncn_progname}; ac_word=$2
6794 echo "$as_me:$LINENO: checking for $ac_word" >&5
6795 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6796 if test "${ac_cv_prog_LD+set}" = set; then
6797   echo $ECHO_N "(cached) $ECHO_C" >&6
6798 else
6799   if test -n "$LD"; then
6800   ac_cv_prog_LD="$LD" # Let the user override the test.
6801 else
6802 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6803 for as_dir in $PATH
6804 do
6805   IFS=$as_save_IFS
6806   test -z "$as_dir" && as_dir=.
6807   for ac_exec_ext in '' $ac_executable_extensions; do
6808   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6809     ac_cv_prog_LD="${ncn_progname}"
6810     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6811     break 2
6812   fi
6813 done
6814 done
6815
6816 fi
6817 fi
6818 LD=$ac_cv_prog_LD
6819 if test -n "$LD"; then
6820   echo "$as_me:$LINENO: result: $LD" >&5
6821 echo "${ECHO_T}$LD" >&6
6822 else
6823   echo "$as_me:$LINENO: result: no" >&5
6824 echo "${ECHO_T}no" >&6
6825 fi
6826
6827   fi
6828   test -n "$ac_cv_prog_LD" && break
6829 done
6830
6831 if test -z "$ac_cv_prog_LD" ; then
6832   set dummy ld
6833   if test $build = $host ; then
6834     LD="$2"
6835   else
6836     LD="${ncn_tool_prefix}$2"
6837   fi
6838 fi
6839
6840
6841
6842 if test -n "$LIPO"; then
6843   ac_cv_prog_LIPO=$LIPO
6844 elif test -n "$ac_cv_prog_LIPO"; then
6845   LIPO=$ac_cv_prog_LIPO
6846 fi
6847
6848 if test -n "$ac_cv_prog_LIPO"; then
6849   for ncn_progname in lipo; do
6850     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6851 set dummy ${ncn_progname}; ac_word=$2
6852 echo "$as_me:$LINENO: checking for $ac_word" >&5
6853 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6854 if test "${ac_cv_prog_LIPO+set}" = set; then
6855   echo $ECHO_N "(cached) $ECHO_C" >&6
6856 else
6857   if test -n "$LIPO"; then
6858   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6859 else
6860 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6861 for as_dir in $PATH
6862 do
6863   IFS=$as_save_IFS
6864   test -z "$as_dir" && as_dir=.
6865   for ac_exec_ext in '' $ac_executable_extensions; do
6866   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6867     ac_cv_prog_LIPO="${ncn_progname}"
6868     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6869     break 2
6870   fi
6871 done
6872 done
6873
6874 fi
6875 fi
6876 LIPO=$ac_cv_prog_LIPO
6877 if test -n "$LIPO"; then
6878   echo "$as_me:$LINENO: result: $LIPO" >&5
6879 echo "${ECHO_T}$LIPO" >&6
6880 else
6881   echo "$as_me:$LINENO: result: no" >&5
6882 echo "${ECHO_T}no" >&6
6883 fi
6884
6885   done
6886 fi
6887
6888 for ncn_progname in lipo; do
6889   if test -n "$ncn_tool_prefix"; then
6890     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6891 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6892 echo "$as_me:$LINENO: checking for $ac_word" >&5
6893 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6894 if test "${ac_cv_prog_LIPO+set}" = set; then
6895   echo $ECHO_N "(cached) $ECHO_C" >&6
6896 else
6897   if test -n "$LIPO"; then
6898   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6899 else
6900 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6901 for as_dir in $PATH
6902 do
6903   IFS=$as_save_IFS
6904   test -z "$as_dir" && as_dir=.
6905   for ac_exec_ext in '' $ac_executable_extensions; do
6906   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6907     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6908     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6909     break 2
6910   fi
6911 done
6912 done
6913
6914 fi
6915 fi
6916 LIPO=$ac_cv_prog_LIPO
6917 if test -n "$LIPO"; then
6918   echo "$as_me:$LINENO: result: $LIPO" >&5
6919 echo "${ECHO_T}$LIPO" >&6
6920 else
6921   echo "$as_me:$LINENO: result: no" >&5
6922 echo "${ECHO_T}no" >&6
6923 fi
6924
6925   fi
6926   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6927     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6928 set dummy ${ncn_progname}; ac_word=$2
6929 echo "$as_me:$LINENO: checking for $ac_word" >&5
6930 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6931 if test "${ac_cv_prog_LIPO+set}" = set; then
6932   echo $ECHO_N "(cached) $ECHO_C" >&6
6933 else
6934   if test -n "$LIPO"; then
6935   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6936 else
6937 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6938 for as_dir in $PATH
6939 do
6940   IFS=$as_save_IFS
6941   test -z "$as_dir" && as_dir=.
6942   for ac_exec_ext in '' $ac_executable_extensions; do
6943   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6944     ac_cv_prog_LIPO="${ncn_progname}"
6945     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6946     break 2
6947   fi
6948 done
6949 done
6950
6951 fi
6952 fi
6953 LIPO=$ac_cv_prog_LIPO
6954 if test -n "$LIPO"; then
6955   echo "$as_me:$LINENO: result: $LIPO" >&5
6956 echo "${ECHO_T}$LIPO" >&6
6957 else
6958   echo "$as_me:$LINENO: result: no" >&5
6959 echo "${ECHO_T}no" >&6
6960 fi
6961
6962   fi
6963   test -n "$ac_cv_prog_LIPO" && break
6964 done
6965
6966 if test -z "$ac_cv_prog_LIPO" ; then
6967   set dummy lipo
6968   if test $build = $host ; then
6969     LIPO="$2"
6970   else
6971     LIPO="${ncn_tool_prefix}$2"
6972   fi
6973 fi
6974
6975
6976
6977 if test -n "$NM"; then
6978   ac_cv_prog_NM=$NM
6979 elif test -n "$ac_cv_prog_NM"; then
6980   NM=$ac_cv_prog_NM
6981 fi
6982
6983 if test -n "$ac_cv_prog_NM"; then
6984   for ncn_progname in nm; do
6985     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6986 set dummy ${ncn_progname}; ac_word=$2
6987 echo "$as_me:$LINENO: checking for $ac_word" >&5
6988 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6989 if test "${ac_cv_prog_NM+set}" = set; then
6990   echo $ECHO_N "(cached) $ECHO_C" >&6
6991 else
6992   if test -n "$NM"; then
6993   ac_cv_prog_NM="$NM" # Let the user override the test.
6994 else
6995 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6996 for as_dir in $PATH
6997 do
6998   IFS=$as_save_IFS
6999   test -z "$as_dir" && as_dir=.
7000   for ac_exec_ext in '' $ac_executable_extensions; do
7001   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7002     ac_cv_prog_NM="${ncn_progname}"
7003     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7004     break 2
7005   fi
7006 done
7007 done
7008
7009 fi
7010 fi
7011 NM=$ac_cv_prog_NM
7012 if test -n "$NM"; then
7013   echo "$as_me:$LINENO: result: $NM" >&5
7014 echo "${ECHO_T}$NM" >&6
7015 else
7016   echo "$as_me:$LINENO: result: no" >&5
7017 echo "${ECHO_T}no" >&6
7018 fi
7019
7020   done
7021 fi
7022
7023 for ncn_progname in nm; do
7024   if test -n "$ncn_tool_prefix"; then
7025     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7026 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7027 echo "$as_me:$LINENO: checking for $ac_word" >&5
7028 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7029 if test "${ac_cv_prog_NM+set}" = set; then
7030   echo $ECHO_N "(cached) $ECHO_C" >&6
7031 else
7032   if test -n "$NM"; then
7033   ac_cv_prog_NM="$NM" # Let the user override the test.
7034 else
7035 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7036 for as_dir in $PATH
7037 do
7038   IFS=$as_save_IFS
7039   test -z "$as_dir" && as_dir=.
7040   for ac_exec_ext in '' $ac_executable_extensions; do
7041   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7042     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7043     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7044     break 2
7045   fi
7046 done
7047 done
7048
7049 fi
7050 fi
7051 NM=$ac_cv_prog_NM
7052 if test -n "$NM"; then
7053   echo "$as_me:$LINENO: result: $NM" >&5
7054 echo "${ECHO_T}$NM" >&6
7055 else
7056   echo "$as_me:$LINENO: result: no" >&5
7057 echo "${ECHO_T}no" >&6
7058 fi
7059
7060   fi
7061   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7062     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7063 set dummy ${ncn_progname}; ac_word=$2
7064 echo "$as_me:$LINENO: checking for $ac_word" >&5
7065 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7066 if test "${ac_cv_prog_NM+set}" = set; then
7067   echo $ECHO_N "(cached) $ECHO_C" >&6
7068 else
7069   if test -n "$NM"; then
7070   ac_cv_prog_NM="$NM" # Let the user override the test.
7071 else
7072 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7073 for as_dir in $PATH
7074 do
7075   IFS=$as_save_IFS
7076   test -z "$as_dir" && as_dir=.
7077   for ac_exec_ext in '' $ac_executable_extensions; do
7078   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7079     ac_cv_prog_NM="${ncn_progname}"
7080     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7081     break 2
7082   fi
7083 done
7084 done
7085
7086 fi
7087 fi
7088 NM=$ac_cv_prog_NM
7089 if test -n "$NM"; then
7090   echo "$as_me:$LINENO: result: $NM" >&5
7091 echo "${ECHO_T}$NM" >&6
7092 else
7093   echo "$as_me:$LINENO: result: no" >&5
7094 echo "${ECHO_T}no" >&6
7095 fi
7096
7097   fi
7098   test -n "$ac_cv_prog_NM" && break
7099 done
7100
7101 if test -z "$ac_cv_prog_NM" ; then
7102   set dummy nm
7103   if test $build = $host ; then
7104     NM="$2"
7105   else
7106     NM="${ncn_tool_prefix}$2"
7107   fi
7108 fi
7109
7110
7111
7112 if test -n "$RANLIB"; then
7113   ac_cv_prog_RANLIB=$RANLIB
7114 elif test -n "$ac_cv_prog_RANLIB"; then
7115   RANLIB=$ac_cv_prog_RANLIB
7116 fi
7117
7118 if test -n "$ac_cv_prog_RANLIB"; then
7119   for ncn_progname in ranlib; do
7120     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7121 set dummy ${ncn_progname}; ac_word=$2
7122 echo "$as_me:$LINENO: checking for $ac_word" >&5
7123 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7124 if test "${ac_cv_prog_RANLIB+set}" = set; then
7125   echo $ECHO_N "(cached) $ECHO_C" >&6
7126 else
7127   if test -n "$RANLIB"; then
7128   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7129 else
7130 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7131 for as_dir in $PATH
7132 do
7133   IFS=$as_save_IFS
7134   test -z "$as_dir" && as_dir=.
7135   for ac_exec_ext in '' $ac_executable_extensions; do
7136   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7137     ac_cv_prog_RANLIB="${ncn_progname}"
7138     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7139     break 2
7140   fi
7141 done
7142 done
7143
7144 fi
7145 fi
7146 RANLIB=$ac_cv_prog_RANLIB
7147 if test -n "$RANLIB"; then
7148   echo "$as_me:$LINENO: result: $RANLIB" >&5
7149 echo "${ECHO_T}$RANLIB" >&6
7150 else
7151   echo "$as_me:$LINENO: result: no" >&5
7152 echo "${ECHO_T}no" >&6
7153 fi
7154
7155   done
7156 fi
7157
7158 for ncn_progname in ranlib; do
7159   if test -n "$ncn_tool_prefix"; then
7160     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7161 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7162 echo "$as_me:$LINENO: checking for $ac_word" >&5
7163 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7164 if test "${ac_cv_prog_RANLIB+set}" = set; then
7165   echo $ECHO_N "(cached) $ECHO_C" >&6
7166 else
7167   if test -n "$RANLIB"; then
7168   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7169 else
7170 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7171 for as_dir in $PATH
7172 do
7173   IFS=$as_save_IFS
7174   test -z "$as_dir" && as_dir=.
7175   for ac_exec_ext in '' $ac_executable_extensions; do
7176   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7177     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7178     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7179     break 2
7180   fi
7181 done
7182 done
7183
7184 fi
7185 fi
7186 RANLIB=$ac_cv_prog_RANLIB
7187 if test -n "$RANLIB"; then
7188   echo "$as_me:$LINENO: result: $RANLIB" >&5
7189 echo "${ECHO_T}$RANLIB" >&6
7190 else
7191   echo "$as_me:$LINENO: result: no" >&5
7192 echo "${ECHO_T}no" >&6
7193 fi
7194
7195   fi
7196   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7197     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7198 set dummy ${ncn_progname}; ac_word=$2
7199 echo "$as_me:$LINENO: checking for $ac_word" >&5
7200 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7201 if test "${ac_cv_prog_RANLIB+set}" = set; then
7202   echo $ECHO_N "(cached) $ECHO_C" >&6
7203 else
7204   if test -n "$RANLIB"; then
7205   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7206 else
7207 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7208 for as_dir in $PATH
7209 do
7210   IFS=$as_save_IFS
7211   test -z "$as_dir" && as_dir=.
7212   for ac_exec_ext in '' $ac_executable_extensions; do
7213   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7214     ac_cv_prog_RANLIB="${ncn_progname}"
7215     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7216     break 2
7217   fi
7218 done
7219 done
7220
7221 fi
7222 fi
7223 RANLIB=$ac_cv_prog_RANLIB
7224 if test -n "$RANLIB"; then
7225   echo "$as_me:$LINENO: result: $RANLIB" >&5
7226 echo "${ECHO_T}$RANLIB" >&6
7227 else
7228   echo "$as_me:$LINENO: result: no" >&5
7229 echo "${ECHO_T}no" >&6
7230 fi
7231
7232   fi
7233   test -n "$ac_cv_prog_RANLIB" && break
7234 done
7235
7236 if test -z "$ac_cv_prog_RANLIB" ; then
7237   RANLIB=":"
7238 fi
7239
7240
7241
7242 if test -n "$STRIP"; then
7243   ac_cv_prog_STRIP=$STRIP
7244 elif test -n "$ac_cv_prog_STRIP"; then
7245   STRIP=$ac_cv_prog_STRIP
7246 fi
7247
7248 if test -n "$ac_cv_prog_STRIP"; then
7249   for ncn_progname in strip; do
7250     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7251 set dummy ${ncn_progname}; ac_word=$2
7252 echo "$as_me:$LINENO: checking for $ac_word" >&5
7253 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7254 if test "${ac_cv_prog_STRIP+set}" = set; then
7255   echo $ECHO_N "(cached) $ECHO_C" >&6
7256 else
7257   if test -n "$STRIP"; then
7258   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7259 else
7260 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7261 for as_dir in $PATH
7262 do
7263   IFS=$as_save_IFS
7264   test -z "$as_dir" && as_dir=.
7265   for ac_exec_ext in '' $ac_executable_extensions; do
7266   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7267     ac_cv_prog_STRIP="${ncn_progname}"
7268     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7269     break 2
7270   fi
7271 done
7272 done
7273
7274 fi
7275 fi
7276 STRIP=$ac_cv_prog_STRIP
7277 if test -n "$STRIP"; then
7278   echo "$as_me:$LINENO: result: $STRIP" >&5
7279 echo "${ECHO_T}$STRIP" >&6
7280 else
7281   echo "$as_me:$LINENO: result: no" >&5
7282 echo "${ECHO_T}no" >&6
7283 fi
7284
7285   done
7286 fi
7287
7288 for ncn_progname in strip; do
7289   if test -n "$ncn_tool_prefix"; then
7290     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7291 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7292 echo "$as_me:$LINENO: checking for $ac_word" >&5
7293 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7294 if test "${ac_cv_prog_STRIP+set}" = set; then
7295   echo $ECHO_N "(cached) $ECHO_C" >&6
7296 else
7297   if test -n "$STRIP"; then
7298   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7299 else
7300 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7301 for as_dir in $PATH
7302 do
7303   IFS=$as_save_IFS
7304   test -z "$as_dir" && as_dir=.
7305   for ac_exec_ext in '' $ac_executable_extensions; do
7306   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7307     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7308     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7309     break 2
7310   fi
7311 done
7312 done
7313
7314 fi
7315 fi
7316 STRIP=$ac_cv_prog_STRIP
7317 if test -n "$STRIP"; then
7318   echo "$as_me:$LINENO: result: $STRIP" >&5
7319 echo "${ECHO_T}$STRIP" >&6
7320 else
7321   echo "$as_me:$LINENO: result: no" >&5
7322 echo "${ECHO_T}no" >&6
7323 fi
7324
7325   fi
7326   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7327     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7328 set dummy ${ncn_progname}; ac_word=$2
7329 echo "$as_me:$LINENO: checking for $ac_word" >&5
7330 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7331 if test "${ac_cv_prog_STRIP+set}" = set; then
7332   echo $ECHO_N "(cached) $ECHO_C" >&6
7333 else
7334   if test -n "$STRIP"; then
7335   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7336 else
7337 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7338 for as_dir in $PATH
7339 do
7340   IFS=$as_save_IFS
7341   test -z "$as_dir" && as_dir=.
7342   for ac_exec_ext in '' $ac_executable_extensions; do
7343   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7344     ac_cv_prog_STRIP="${ncn_progname}"
7345     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7346     break 2
7347   fi
7348 done
7349 done
7350
7351 fi
7352 fi
7353 STRIP=$ac_cv_prog_STRIP
7354 if test -n "$STRIP"; then
7355   echo "$as_me:$LINENO: result: $STRIP" >&5
7356 echo "${ECHO_T}$STRIP" >&6
7357 else
7358   echo "$as_me:$LINENO: result: no" >&5
7359 echo "${ECHO_T}no" >&6
7360 fi
7361
7362   fi
7363   test -n "$ac_cv_prog_STRIP" && break
7364 done
7365
7366 if test -z "$ac_cv_prog_STRIP" ; then
7367   STRIP=":"
7368 fi
7369
7370
7371
7372 if test -n "$WINDRES"; then
7373   ac_cv_prog_WINDRES=$WINDRES
7374 elif test -n "$ac_cv_prog_WINDRES"; then
7375   WINDRES=$ac_cv_prog_WINDRES
7376 fi
7377
7378 if test -n "$ac_cv_prog_WINDRES"; then
7379   for ncn_progname in windres; do
7380     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7381 set dummy ${ncn_progname}; ac_word=$2
7382 echo "$as_me:$LINENO: checking for $ac_word" >&5
7383 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7384 if test "${ac_cv_prog_WINDRES+set}" = set; then
7385   echo $ECHO_N "(cached) $ECHO_C" >&6
7386 else
7387   if test -n "$WINDRES"; then
7388   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7389 else
7390 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7391 for as_dir in $PATH
7392 do
7393   IFS=$as_save_IFS
7394   test -z "$as_dir" && as_dir=.
7395   for ac_exec_ext in '' $ac_executable_extensions; do
7396   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7397     ac_cv_prog_WINDRES="${ncn_progname}"
7398     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7399     break 2
7400   fi
7401 done
7402 done
7403
7404 fi
7405 fi
7406 WINDRES=$ac_cv_prog_WINDRES
7407 if test -n "$WINDRES"; then
7408   echo "$as_me:$LINENO: result: $WINDRES" >&5
7409 echo "${ECHO_T}$WINDRES" >&6
7410 else
7411   echo "$as_me:$LINENO: result: no" >&5
7412 echo "${ECHO_T}no" >&6
7413 fi
7414
7415   done
7416 fi
7417
7418 for ncn_progname in windres; do
7419   if test -n "$ncn_tool_prefix"; then
7420     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7421 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7422 echo "$as_me:$LINENO: checking for $ac_word" >&5
7423 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7424 if test "${ac_cv_prog_WINDRES+set}" = set; then
7425   echo $ECHO_N "(cached) $ECHO_C" >&6
7426 else
7427   if test -n "$WINDRES"; then
7428   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7429 else
7430 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7431 for as_dir in $PATH
7432 do
7433   IFS=$as_save_IFS
7434   test -z "$as_dir" && as_dir=.
7435   for ac_exec_ext in '' $ac_executable_extensions; do
7436   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7437     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7438     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7439     break 2
7440   fi
7441 done
7442 done
7443
7444 fi
7445 fi
7446 WINDRES=$ac_cv_prog_WINDRES
7447 if test -n "$WINDRES"; then
7448   echo "$as_me:$LINENO: result: $WINDRES" >&5
7449 echo "${ECHO_T}$WINDRES" >&6
7450 else
7451   echo "$as_me:$LINENO: result: no" >&5
7452 echo "${ECHO_T}no" >&6
7453 fi
7454
7455   fi
7456   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7457     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7458 set dummy ${ncn_progname}; ac_word=$2
7459 echo "$as_me:$LINENO: checking for $ac_word" >&5
7460 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7461 if test "${ac_cv_prog_WINDRES+set}" = set; then
7462   echo $ECHO_N "(cached) $ECHO_C" >&6
7463 else
7464   if test -n "$WINDRES"; then
7465   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7466 else
7467 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7468 for as_dir in $PATH
7469 do
7470   IFS=$as_save_IFS
7471   test -z "$as_dir" && as_dir=.
7472   for ac_exec_ext in '' $ac_executable_extensions; do
7473   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7474     ac_cv_prog_WINDRES="${ncn_progname}"
7475     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7476     break 2
7477   fi
7478 done
7479 done
7480
7481 fi
7482 fi
7483 WINDRES=$ac_cv_prog_WINDRES
7484 if test -n "$WINDRES"; then
7485   echo "$as_me:$LINENO: result: $WINDRES" >&5
7486 echo "${ECHO_T}$WINDRES" >&6
7487 else
7488   echo "$as_me:$LINENO: result: no" >&5
7489 echo "${ECHO_T}no" >&6
7490 fi
7491
7492   fi
7493   test -n "$ac_cv_prog_WINDRES" && break
7494 done
7495
7496 if test -z "$ac_cv_prog_WINDRES" ; then
7497   set dummy windres
7498   if test $build = $host ; then
7499     WINDRES="$2"
7500   else
7501     WINDRES="${ncn_tool_prefix}$2"
7502   fi
7503 fi
7504
7505
7506
7507 if test -n "$WINDMC"; then
7508   ac_cv_prog_WINDMC=$WINDMC
7509 elif test -n "$ac_cv_prog_WINDMC"; then
7510   WINDMC=$ac_cv_prog_WINDMC
7511 fi
7512
7513 if test -n "$ac_cv_prog_WINDMC"; then
7514   for ncn_progname in windmc; do
7515     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7516 set dummy ${ncn_progname}; ac_word=$2
7517 echo "$as_me:$LINENO: checking for $ac_word" >&5
7518 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7519 if test "${ac_cv_prog_WINDMC+set}" = set; then
7520   echo $ECHO_N "(cached) $ECHO_C" >&6
7521 else
7522   if test -n "$WINDMC"; then
7523   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7524 else
7525 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7526 for as_dir in $PATH
7527 do
7528   IFS=$as_save_IFS
7529   test -z "$as_dir" && as_dir=.
7530   for ac_exec_ext in '' $ac_executable_extensions; do
7531   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7532     ac_cv_prog_WINDMC="${ncn_progname}"
7533     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7534     break 2
7535   fi
7536 done
7537 done
7538
7539 fi
7540 fi
7541 WINDMC=$ac_cv_prog_WINDMC
7542 if test -n "$WINDMC"; then
7543   echo "$as_me:$LINENO: result: $WINDMC" >&5
7544 echo "${ECHO_T}$WINDMC" >&6
7545 else
7546   echo "$as_me:$LINENO: result: no" >&5
7547 echo "${ECHO_T}no" >&6
7548 fi
7549
7550   done
7551 fi
7552
7553 for ncn_progname in windmc; do
7554   if test -n "$ncn_tool_prefix"; then
7555     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7556 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7557 echo "$as_me:$LINENO: checking for $ac_word" >&5
7558 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7559 if test "${ac_cv_prog_WINDMC+set}" = set; then
7560   echo $ECHO_N "(cached) $ECHO_C" >&6
7561 else
7562   if test -n "$WINDMC"; then
7563   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7564 else
7565 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7566 for as_dir in $PATH
7567 do
7568   IFS=$as_save_IFS
7569   test -z "$as_dir" && as_dir=.
7570   for ac_exec_ext in '' $ac_executable_extensions; do
7571   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7572     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7573     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7574     break 2
7575   fi
7576 done
7577 done
7578
7579 fi
7580 fi
7581 WINDMC=$ac_cv_prog_WINDMC
7582 if test -n "$WINDMC"; then
7583   echo "$as_me:$LINENO: result: $WINDMC" >&5
7584 echo "${ECHO_T}$WINDMC" >&6
7585 else
7586   echo "$as_me:$LINENO: result: no" >&5
7587 echo "${ECHO_T}no" >&6
7588 fi
7589
7590   fi
7591   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7592     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7593 set dummy ${ncn_progname}; ac_word=$2
7594 echo "$as_me:$LINENO: checking for $ac_word" >&5
7595 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7596 if test "${ac_cv_prog_WINDMC+set}" = set; then
7597   echo $ECHO_N "(cached) $ECHO_C" >&6
7598 else
7599   if test -n "$WINDMC"; then
7600   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7601 else
7602 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7603 for as_dir in $PATH
7604 do
7605   IFS=$as_save_IFS
7606   test -z "$as_dir" && as_dir=.
7607   for ac_exec_ext in '' $ac_executable_extensions; do
7608   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7609     ac_cv_prog_WINDMC="${ncn_progname}"
7610     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7611     break 2
7612   fi
7613 done
7614 done
7615
7616 fi
7617 fi
7618 WINDMC=$ac_cv_prog_WINDMC
7619 if test -n "$WINDMC"; then
7620   echo "$as_me:$LINENO: result: $WINDMC" >&5
7621 echo "${ECHO_T}$WINDMC" >&6
7622 else
7623   echo "$as_me:$LINENO: result: no" >&5
7624 echo "${ECHO_T}no" >&6
7625 fi
7626
7627   fi
7628   test -n "$ac_cv_prog_WINDMC" && break
7629 done
7630
7631 if test -z "$ac_cv_prog_WINDMC" ; then
7632   set dummy windmc
7633   if test $build = $host ; then
7634     WINDMC="$2"
7635   else
7636     WINDMC="${ncn_tool_prefix}$2"
7637   fi
7638 fi
7639
7640
7641
7642 if test -n "$OBJCOPY"; then
7643   ac_cv_prog_OBJCOPY=$OBJCOPY
7644 elif test -n "$ac_cv_prog_OBJCOPY"; then
7645   OBJCOPY=$ac_cv_prog_OBJCOPY
7646 fi
7647
7648 if test -n "$ac_cv_prog_OBJCOPY"; then
7649   for ncn_progname in objcopy; do
7650     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7651 set dummy ${ncn_progname}; ac_word=$2
7652 echo "$as_me:$LINENO: checking for $ac_word" >&5
7653 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7654 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7655   echo $ECHO_N "(cached) $ECHO_C" >&6
7656 else
7657   if test -n "$OBJCOPY"; then
7658   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7659 else
7660 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7661 for as_dir in $PATH
7662 do
7663   IFS=$as_save_IFS
7664   test -z "$as_dir" && as_dir=.
7665   for ac_exec_ext in '' $ac_executable_extensions; do
7666   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7667     ac_cv_prog_OBJCOPY="${ncn_progname}"
7668     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7669     break 2
7670   fi
7671 done
7672 done
7673
7674 fi
7675 fi
7676 OBJCOPY=$ac_cv_prog_OBJCOPY
7677 if test -n "$OBJCOPY"; then
7678   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7679 echo "${ECHO_T}$OBJCOPY" >&6
7680 else
7681   echo "$as_me:$LINENO: result: no" >&5
7682 echo "${ECHO_T}no" >&6
7683 fi
7684
7685   done
7686 fi
7687
7688 for ncn_progname in objcopy; do
7689   if test -n "$ncn_tool_prefix"; then
7690     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7691 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7692 echo "$as_me:$LINENO: checking for $ac_word" >&5
7693 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7694 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7695   echo $ECHO_N "(cached) $ECHO_C" >&6
7696 else
7697   if test -n "$OBJCOPY"; then
7698   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7699 else
7700 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7701 for as_dir in $PATH
7702 do
7703   IFS=$as_save_IFS
7704   test -z "$as_dir" && as_dir=.
7705   for ac_exec_ext in '' $ac_executable_extensions; do
7706   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7707     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7708     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7709     break 2
7710   fi
7711 done
7712 done
7713
7714 fi
7715 fi
7716 OBJCOPY=$ac_cv_prog_OBJCOPY
7717 if test -n "$OBJCOPY"; then
7718   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7719 echo "${ECHO_T}$OBJCOPY" >&6
7720 else
7721   echo "$as_me:$LINENO: result: no" >&5
7722 echo "${ECHO_T}no" >&6
7723 fi
7724
7725   fi
7726   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7727     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7728 set dummy ${ncn_progname}; ac_word=$2
7729 echo "$as_me:$LINENO: checking for $ac_word" >&5
7730 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7731 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7732   echo $ECHO_N "(cached) $ECHO_C" >&6
7733 else
7734   if test -n "$OBJCOPY"; then
7735   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7736 else
7737 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7738 for as_dir in $PATH
7739 do
7740   IFS=$as_save_IFS
7741   test -z "$as_dir" && as_dir=.
7742   for ac_exec_ext in '' $ac_executable_extensions; do
7743   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7744     ac_cv_prog_OBJCOPY="${ncn_progname}"
7745     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7746     break 2
7747   fi
7748 done
7749 done
7750
7751 fi
7752 fi
7753 OBJCOPY=$ac_cv_prog_OBJCOPY
7754 if test -n "$OBJCOPY"; then
7755   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7756 echo "${ECHO_T}$OBJCOPY" >&6
7757 else
7758   echo "$as_me:$LINENO: result: no" >&5
7759 echo "${ECHO_T}no" >&6
7760 fi
7761
7762   fi
7763   test -n "$ac_cv_prog_OBJCOPY" && break
7764 done
7765
7766 if test -z "$ac_cv_prog_OBJCOPY" ; then
7767   set dummy objcopy
7768   if test $build = $host ; then
7769     OBJCOPY="$2"
7770   else
7771     OBJCOPY="${ncn_tool_prefix}$2"
7772   fi
7773 fi
7774
7775
7776
7777 if test -n "$OBJDUMP"; then
7778   ac_cv_prog_OBJDUMP=$OBJDUMP
7779 elif test -n "$ac_cv_prog_OBJDUMP"; then
7780   OBJDUMP=$ac_cv_prog_OBJDUMP
7781 fi
7782
7783 if test -n "$ac_cv_prog_OBJDUMP"; then
7784   for ncn_progname in objdump; do
7785     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7786 set dummy ${ncn_progname}; ac_word=$2
7787 echo "$as_me:$LINENO: checking for $ac_word" >&5
7788 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7789 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7790   echo $ECHO_N "(cached) $ECHO_C" >&6
7791 else
7792   if test -n "$OBJDUMP"; then
7793   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7794 else
7795 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7796 for as_dir in $PATH
7797 do
7798   IFS=$as_save_IFS
7799   test -z "$as_dir" && as_dir=.
7800   for ac_exec_ext in '' $ac_executable_extensions; do
7801   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7802     ac_cv_prog_OBJDUMP="${ncn_progname}"
7803     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7804     break 2
7805   fi
7806 done
7807 done
7808
7809 fi
7810 fi
7811 OBJDUMP=$ac_cv_prog_OBJDUMP
7812 if test -n "$OBJDUMP"; then
7813   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7814 echo "${ECHO_T}$OBJDUMP" >&6
7815 else
7816   echo "$as_me:$LINENO: result: no" >&5
7817 echo "${ECHO_T}no" >&6
7818 fi
7819
7820   done
7821 fi
7822
7823 for ncn_progname in objdump; do
7824   if test -n "$ncn_tool_prefix"; then
7825     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7826 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7827 echo "$as_me:$LINENO: checking for $ac_word" >&5
7828 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7829 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7830   echo $ECHO_N "(cached) $ECHO_C" >&6
7831 else
7832   if test -n "$OBJDUMP"; then
7833   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7834 else
7835 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7836 for as_dir in $PATH
7837 do
7838   IFS=$as_save_IFS
7839   test -z "$as_dir" && as_dir=.
7840   for ac_exec_ext in '' $ac_executable_extensions; do
7841   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7842     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7843     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7844     break 2
7845   fi
7846 done
7847 done
7848
7849 fi
7850 fi
7851 OBJDUMP=$ac_cv_prog_OBJDUMP
7852 if test -n "$OBJDUMP"; then
7853   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7854 echo "${ECHO_T}$OBJDUMP" >&6
7855 else
7856   echo "$as_me:$LINENO: result: no" >&5
7857 echo "${ECHO_T}no" >&6
7858 fi
7859
7860   fi
7861   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7862     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7863 set dummy ${ncn_progname}; ac_word=$2
7864 echo "$as_me:$LINENO: checking for $ac_word" >&5
7865 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7866 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7867   echo $ECHO_N "(cached) $ECHO_C" >&6
7868 else
7869   if test -n "$OBJDUMP"; then
7870   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7871 else
7872 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7873 for as_dir in $PATH
7874 do
7875   IFS=$as_save_IFS
7876   test -z "$as_dir" && as_dir=.
7877   for ac_exec_ext in '' $ac_executable_extensions; do
7878   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7879     ac_cv_prog_OBJDUMP="${ncn_progname}"
7880     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7881     break 2
7882   fi
7883 done
7884 done
7885
7886 fi
7887 fi
7888 OBJDUMP=$ac_cv_prog_OBJDUMP
7889 if test -n "$OBJDUMP"; then
7890   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7891 echo "${ECHO_T}$OBJDUMP" >&6
7892 else
7893   echo "$as_me:$LINENO: result: no" >&5
7894 echo "${ECHO_T}no" >&6
7895 fi
7896
7897   fi
7898   test -n "$ac_cv_prog_OBJDUMP" && break
7899 done
7900
7901 if test -z "$ac_cv_prog_OBJDUMP" ; then
7902   set dummy objdump
7903   if test $build = $host ; then
7904     OBJDUMP="$2"
7905   else
7906     OBJDUMP="${ncn_tool_prefix}$2"
7907   fi
7908 fi
7909
7910
7911
7912
7913
7914
7915
7916 # Target tools.
7917
7918 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7919 if test "${with_build_time_tools+set}" = set; then
7920   withval="$with_build_time_tools"
7921   case x"$withval" in
7922      x/*) ;;
7923      *)
7924        with_build_time_tools=
7925        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7926 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7927        ;;
7928    esac
7929 else
7930   with_build_time_tools=
7931 fi;
7932
7933
7934
7935 if test -n "$CC_FOR_TARGET"; then
7936   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7937 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7938   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7939 fi
7940
7941 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7942   for ncn_progname in cc gcc; 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_CC_FOR_TARGET+set}" = set; then
7948   echo $ECHO_N "(cached) $ECHO_C" >&6
7949 else
7950   if test -n "$CC_FOR_TARGET"; then
7951   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7952 else
7953 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7954 for as_dir in $PATH
7955 do
7956   IFS=$as_save_IFS
7957   test -z "$as_dir" && as_dir=.
7958   for ac_exec_ext in '' $ac_executable_extensions; do
7959   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7960     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7961     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7962     break 2
7963   fi
7964 done
7965 done
7966
7967 fi
7968 fi
7969 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7970 if test -n "$CC_FOR_TARGET"; then
7971   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7972 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7973 else
7974   echo "$as_me:$LINENO: result: no" >&5
7975 echo "${ECHO_T}no" >&6
7976 fi
7977
7978   done
7979 fi
7980
7981 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
7982   for ncn_progname in cc gcc; do
7983     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7984 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7985     if test -x $with_build_time_tools/${ncn_progname}; then
7986       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7987       echo "$as_me:$LINENO: result: yes" >&5
7988 echo "${ECHO_T}yes" >&6
7989       break
7990     else
7991       echo "$as_me:$LINENO: result: no" >&5
7992 echo "${ECHO_T}no" >&6
7993     fi
7994   done
7995 fi
7996
7997 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
7998   for ncn_progname in cc gcc; do
7999     if test -n "$ncn_target_tool_prefix"; then
8000       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8001 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8002 echo "$as_me:$LINENO: checking for $ac_word" >&5
8003 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8004 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8005   echo $ECHO_N "(cached) $ECHO_C" >&6
8006 else
8007   if test -n "$CC_FOR_TARGET"; then
8008   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8009 else
8010 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8011 for as_dir in $PATH
8012 do
8013   IFS=$as_save_IFS
8014   test -z "$as_dir" && as_dir=.
8015   for ac_exec_ext in '' $ac_executable_extensions; do
8016   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8017     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8018     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8019     break 2
8020   fi
8021 done
8022 done
8023
8024 fi
8025 fi
8026 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8027 if test -n "$CC_FOR_TARGET"; then
8028   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8029 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8030 else
8031   echo "$as_me:$LINENO: result: no" >&5
8032 echo "${ECHO_T}no" >&6
8033 fi
8034
8035     fi
8036     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8037       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8038 set dummy ${ncn_progname}; ac_word=$2
8039 echo "$as_me:$LINENO: checking for $ac_word" >&5
8040 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8041 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8042   echo $ECHO_N "(cached) $ECHO_C" >&6
8043 else
8044   if test -n "$CC_FOR_TARGET"; then
8045   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8046 else
8047 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8048 for as_dir in $PATH
8049 do
8050   IFS=$as_save_IFS
8051   test -z "$as_dir" && as_dir=.
8052   for ac_exec_ext in '' $ac_executable_extensions; do
8053   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8054     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8055     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8056     break 2
8057   fi
8058 done
8059 done
8060
8061 fi
8062 fi
8063 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8064 if test -n "$CC_FOR_TARGET"; then
8065   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8066 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8067 else
8068   echo "$as_me:$LINENO: result: no" >&5
8069 echo "${ECHO_T}no" >&6
8070 fi
8071
8072     fi
8073     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8074   done
8075 fi
8076
8077 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8078   set dummy cc gcc
8079   if test $build = $target ; then
8080     CC_FOR_TARGET="$2"
8081   else
8082     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8083   fi
8084 else
8085   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8086 fi
8087
8088
8089
8090 if test -n "$CXX_FOR_TARGET"; then
8091   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8092 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8093   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8094 fi
8095
8096 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8097   for ncn_progname in c++ g++ cxx gxx; do
8098     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8099 set dummy ${ncn_progname}; ac_word=$2
8100 echo "$as_me:$LINENO: checking for $ac_word" >&5
8101 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8102 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8103   echo $ECHO_N "(cached) $ECHO_C" >&6
8104 else
8105   if test -n "$CXX_FOR_TARGET"; then
8106   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8107 else
8108 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8109 for as_dir in $PATH
8110 do
8111   IFS=$as_save_IFS
8112   test -z "$as_dir" && as_dir=.
8113   for ac_exec_ext in '' $ac_executable_extensions; do
8114   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8115     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8116     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8117     break 2
8118   fi
8119 done
8120 done
8121
8122 fi
8123 fi
8124 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8125 if test -n "$CXX_FOR_TARGET"; then
8126   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8127 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8128 else
8129   echo "$as_me:$LINENO: result: no" >&5
8130 echo "${ECHO_T}no" >&6
8131 fi
8132
8133   done
8134 fi
8135
8136 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8137   for ncn_progname in c++ g++ cxx gxx; do
8138     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8139 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8140     if test -x $with_build_time_tools/${ncn_progname}; then
8141       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8142       echo "$as_me:$LINENO: result: yes" >&5
8143 echo "${ECHO_T}yes" >&6
8144       break
8145     else
8146       echo "$as_me:$LINENO: result: no" >&5
8147 echo "${ECHO_T}no" >&6
8148     fi
8149   done
8150 fi
8151
8152 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8153   for ncn_progname in c++ g++ cxx gxx; do
8154     if test -n "$ncn_target_tool_prefix"; then
8155       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8156 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8157 echo "$as_me:$LINENO: checking for $ac_word" >&5
8158 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8159 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8160   echo $ECHO_N "(cached) $ECHO_C" >&6
8161 else
8162   if test -n "$CXX_FOR_TARGET"; then
8163   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8164 else
8165 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8166 for as_dir in $PATH
8167 do
8168   IFS=$as_save_IFS
8169   test -z "$as_dir" && as_dir=.
8170   for ac_exec_ext in '' $ac_executable_extensions; do
8171   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8172     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8173     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8174     break 2
8175   fi
8176 done
8177 done
8178
8179 fi
8180 fi
8181 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8182 if test -n "$CXX_FOR_TARGET"; then
8183   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8184 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8185 else
8186   echo "$as_me:$LINENO: result: no" >&5
8187 echo "${ECHO_T}no" >&6
8188 fi
8189
8190     fi
8191     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8192       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8193 set dummy ${ncn_progname}; ac_word=$2
8194 echo "$as_me:$LINENO: checking for $ac_word" >&5
8195 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8196 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8197   echo $ECHO_N "(cached) $ECHO_C" >&6
8198 else
8199   if test -n "$CXX_FOR_TARGET"; then
8200   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8201 else
8202 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8203 for as_dir in $PATH
8204 do
8205   IFS=$as_save_IFS
8206   test -z "$as_dir" && as_dir=.
8207   for ac_exec_ext in '' $ac_executable_extensions; do
8208   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8209     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8210     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8211     break 2
8212   fi
8213 done
8214 done
8215
8216 fi
8217 fi
8218 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8219 if test -n "$CXX_FOR_TARGET"; then
8220   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8221 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8222 else
8223   echo "$as_me:$LINENO: result: no" >&5
8224 echo "${ECHO_T}no" >&6
8225 fi
8226
8227     fi
8228     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8229   done
8230 fi
8231
8232 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8233   set dummy c++ g++ cxx gxx
8234   if test $build = $target ; then
8235     CXX_FOR_TARGET="$2"
8236   else
8237     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8238   fi
8239 else
8240   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8241 fi
8242
8243
8244
8245 if test -n "$GCC_FOR_TARGET"; then
8246   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8247 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8248   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8249 fi
8250
8251 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8252   for ncn_progname in gcc; do
8253     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8254 set dummy ${ncn_progname}; ac_word=$2
8255 echo "$as_me:$LINENO: checking for $ac_word" >&5
8256 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8257 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8258   echo $ECHO_N "(cached) $ECHO_C" >&6
8259 else
8260   if test -n "$GCC_FOR_TARGET"; then
8261   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8262 else
8263 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8264 for as_dir in $PATH
8265 do
8266   IFS=$as_save_IFS
8267   test -z "$as_dir" && as_dir=.
8268   for ac_exec_ext in '' $ac_executable_extensions; do
8269   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8270     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8271     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8272     break 2
8273   fi
8274 done
8275 done
8276
8277 fi
8278 fi
8279 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8280 if test -n "$GCC_FOR_TARGET"; then
8281   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8282 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8283 else
8284   echo "$as_me:$LINENO: result: no" >&5
8285 echo "${ECHO_T}no" >&6
8286 fi
8287
8288   done
8289 fi
8290
8291 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8292   for ncn_progname in gcc; do
8293     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8294 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8295     if test -x $with_build_time_tools/${ncn_progname}; then
8296       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8297       echo "$as_me:$LINENO: result: yes" >&5
8298 echo "${ECHO_T}yes" >&6
8299       break
8300     else
8301       echo "$as_me:$LINENO: result: no" >&5
8302 echo "${ECHO_T}no" >&6
8303     fi
8304   done
8305 fi
8306
8307 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8308   for ncn_progname in gcc; do
8309     if test -n "$ncn_target_tool_prefix"; then
8310       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8311 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8312 echo "$as_me:$LINENO: checking for $ac_word" >&5
8313 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8314 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8315   echo $ECHO_N "(cached) $ECHO_C" >&6
8316 else
8317   if test -n "$GCC_FOR_TARGET"; then
8318   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8319 else
8320 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8321 for as_dir in $PATH
8322 do
8323   IFS=$as_save_IFS
8324   test -z "$as_dir" && as_dir=.
8325   for ac_exec_ext in '' $ac_executable_extensions; do
8326   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8327     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8328     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8329     break 2
8330   fi
8331 done
8332 done
8333
8334 fi
8335 fi
8336 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8337 if test -n "$GCC_FOR_TARGET"; then
8338   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8339 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8340 else
8341   echo "$as_me:$LINENO: result: no" >&5
8342 echo "${ECHO_T}no" >&6
8343 fi
8344
8345     fi
8346     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8347       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8348 set dummy ${ncn_progname}; ac_word=$2
8349 echo "$as_me:$LINENO: checking for $ac_word" >&5
8350 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8351 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8352   echo $ECHO_N "(cached) $ECHO_C" >&6
8353 else
8354   if test -n "$GCC_FOR_TARGET"; then
8355   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8356 else
8357 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8358 for as_dir in $PATH
8359 do
8360   IFS=$as_save_IFS
8361   test -z "$as_dir" && as_dir=.
8362   for ac_exec_ext in '' $ac_executable_extensions; do
8363   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8364     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8365     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8366     break 2
8367   fi
8368 done
8369 done
8370
8371 fi
8372 fi
8373 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8374 if test -n "$GCC_FOR_TARGET"; then
8375   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8376 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8377 else
8378   echo "$as_me:$LINENO: result: no" >&5
8379 echo "${ECHO_T}no" >&6
8380 fi
8381
8382     fi
8383     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8384   done
8385 fi
8386
8387 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8388   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8389 else
8390   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8391 fi
8392
8393
8394
8395 if test -n "$GCJ_FOR_TARGET"; then
8396   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8397 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8398   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8399 fi
8400
8401 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8402   for ncn_progname in gcj; do
8403     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8404 set dummy ${ncn_progname}; ac_word=$2
8405 echo "$as_me:$LINENO: checking for $ac_word" >&5
8406 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8407 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8408   echo $ECHO_N "(cached) $ECHO_C" >&6
8409 else
8410   if test -n "$GCJ_FOR_TARGET"; then
8411   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8412 else
8413 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8414 for as_dir in $PATH
8415 do
8416   IFS=$as_save_IFS
8417   test -z "$as_dir" && as_dir=.
8418   for ac_exec_ext in '' $ac_executable_extensions; do
8419   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8420     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8421     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8422     break 2
8423   fi
8424 done
8425 done
8426
8427 fi
8428 fi
8429 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8430 if test -n "$GCJ_FOR_TARGET"; then
8431   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8432 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8433 else
8434   echo "$as_me:$LINENO: result: no" >&5
8435 echo "${ECHO_T}no" >&6
8436 fi
8437
8438   done
8439 fi
8440
8441 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8442   for ncn_progname in gcj; do
8443     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8444 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8445     if test -x $with_build_time_tools/${ncn_progname}; then
8446       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8447       echo "$as_me:$LINENO: result: yes" >&5
8448 echo "${ECHO_T}yes" >&6
8449       break
8450     else
8451       echo "$as_me:$LINENO: result: no" >&5
8452 echo "${ECHO_T}no" >&6
8453     fi
8454   done
8455 fi
8456
8457 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8458   for ncn_progname in gcj; do
8459     if test -n "$ncn_target_tool_prefix"; then
8460       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8461 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8462 echo "$as_me:$LINENO: checking for $ac_word" >&5
8463 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8464 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8465   echo $ECHO_N "(cached) $ECHO_C" >&6
8466 else
8467   if test -n "$GCJ_FOR_TARGET"; then
8468   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8469 else
8470 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8471 for as_dir in $PATH
8472 do
8473   IFS=$as_save_IFS
8474   test -z "$as_dir" && as_dir=.
8475   for ac_exec_ext in '' $ac_executable_extensions; do
8476   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8477     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8478     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8479     break 2
8480   fi
8481 done
8482 done
8483
8484 fi
8485 fi
8486 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8487 if test -n "$GCJ_FOR_TARGET"; then
8488   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8489 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8490 else
8491   echo "$as_me:$LINENO: result: no" >&5
8492 echo "${ECHO_T}no" >&6
8493 fi
8494
8495     fi
8496     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8497       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8498 set dummy ${ncn_progname}; ac_word=$2
8499 echo "$as_me:$LINENO: checking for $ac_word" >&5
8500 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8501 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8502   echo $ECHO_N "(cached) $ECHO_C" >&6
8503 else
8504   if test -n "$GCJ_FOR_TARGET"; then
8505   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8506 else
8507 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8508 for as_dir in $PATH
8509 do
8510   IFS=$as_save_IFS
8511   test -z "$as_dir" && as_dir=.
8512   for ac_exec_ext in '' $ac_executable_extensions; do
8513   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8514     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8515     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8516     break 2
8517   fi
8518 done
8519 done
8520
8521 fi
8522 fi
8523 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8524 if test -n "$GCJ_FOR_TARGET"; then
8525   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8526 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8527 else
8528   echo "$as_me:$LINENO: result: no" >&5
8529 echo "${ECHO_T}no" >&6
8530 fi
8531
8532     fi
8533     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8534   done
8535 fi
8536
8537 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8538   set dummy gcj
8539   if test $build = $target ; then
8540     GCJ_FOR_TARGET="$2"
8541   else
8542     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8543   fi
8544 else
8545   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8546 fi
8547
8548
8549
8550 if test -n "$GFORTRAN_FOR_TARGET"; then
8551   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8552 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8553   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8554 fi
8555
8556 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8557   for ncn_progname in gfortran; do
8558     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8559 set dummy ${ncn_progname}; ac_word=$2
8560 echo "$as_me:$LINENO: checking for $ac_word" >&5
8561 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8562 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8563   echo $ECHO_N "(cached) $ECHO_C" >&6
8564 else
8565   if test -n "$GFORTRAN_FOR_TARGET"; then
8566   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8567 else
8568 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8569 for as_dir in $PATH
8570 do
8571   IFS=$as_save_IFS
8572   test -z "$as_dir" && as_dir=.
8573   for ac_exec_ext in '' $ac_executable_extensions; do
8574   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8575     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8576     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8577     break 2
8578   fi
8579 done
8580 done
8581
8582 fi
8583 fi
8584 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8585 if test -n "$GFORTRAN_FOR_TARGET"; then
8586   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8587 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8588 else
8589   echo "$as_me:$LINENO: result: no" >&5
8590 echo "${ECHO_T}no" >&6
8591 fi
8592
8593   done
8594 fi
8595
8596 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8597   for ncn_progname in gfortran; do
8598     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8599 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8600     if test -x $with_build_time_tools/${ncn_progname}; then
8601       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8602       echo "$as_me:$LINENO: result: yes" >&5
8603 echo "${ECHO_T}yes" >&6
8604       break
8605     else
8606       echo "$as_me:$LINENO: result: no" >&5
8607 echo "${ECHO_T}no" >&6
8608     fi
8609   done
8610 fi
8611
8612 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8613   for ncn_progname in gfortran; do
8614     if test -n "$ncn_target_tool_prefix"; then
8615       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8616 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8617 echo "$as_me:$LINENO: checking for $ac_word" >&5
8618 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8619 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8620   echo $ECHO_N "(cached) $ECHO_C" >&6
8621 else
8622   if test -n "$GFORTRAN_FOR_TARGET"; then
8623   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8624 else
8625 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8626 for as_dir in $PATH
8627 do
8628   IFS=$as_save_IFS
8629   test -z "$as_dir" && as_dir=.
8630   for ac_exec_ext in '' $ac_executable_extensions; do
8631   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8632     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8633     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8634     break 2
8635   fi
8636 done
8637 done
8638
8639 fi
8640 fi
8641 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8642 if test -n "$GFORTRAN_FOR_TARGET"; then
8643   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8644 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8645 else
8646   echo "$as_me:$LINENO: result: no" >&5
8647 echo "${ECHO_T}no" >&6
8648 fi
8649
8650     fi
8651     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8652       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8653 set dummy ${ncn_progname}; ac_word=$2
8654 echo "$as_me:$LINENO: checking for $ac_word" >&5
8655 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8656 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8657   echo $ECHO_N "(cached) $ECHO_C" >&6
8658 else
8659   if test -n "$GFORTRAN_FOR_TARGET"; then
8660   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8661 else
8662 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8663 for as_dir in $PATH
8664 do
8665   IFS=$as_save_IFS
8666   test -z "$as_dir" && as_dir=.
8667   for ac_exec_ext in '' $ac_executable_extensions; do
8668   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8669     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8670     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8671     break 2
8672   fi
8673 done
8674 done
8675
8676 fi
8677 fi
8678 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8679 if test -n "$GFORTRAN_FOR_TARGET"; then
8680   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8681 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8682 else
8683   echo "$as_me:$LINENO: result: no" >&5
8684 echo "${ECHO_T}no" >&6
8685 fi
8686
8687     fi
8688     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8689   done
8690 fi
8691
8692 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8693   set dummy gfortran
8694   if test $build = $target ; then
8695     GFORTRAN_FOR_TARGET="$2"
8696   else
8697     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8698   fi
8699 else
8700   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8701 fi
8702
8703
8704
8705 cat > conftest.c << \EOF
8706 #ifdef __GNUC__
8707   gcc_yay;
8708 #endif
8709 EOF
8710 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8711   have_gcc_for_target=yes
8712 else
8713   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8714   have_gcc_for_target=no
8715 fi
8716 rm conftest.c
8717
8718
8719
8720
8721 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8722   if test -n "$with_build_time_tools"; then
8723     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8724 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8725     if test -x $with_build_time_tools/ar; then
8726       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8727       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8728       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8729 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8730     else
8731       echo "$as_me:$LINENO: result: no" >&5
8732 echo "${ECHO_T}no" >&6
8733     fi
8734   elif test $build != $host && test $have_gcc_for_target = yes; then
8735     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8736     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8737     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8738   fi
8739 fi
8740 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8741   # Extract the first word of "ar", so it can be a program name with args.
8742 set dummy ar; ac_word=$2
8743 echo "$as_me:$LINENO: checking for $ac_word" >&5
8744 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8745 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8746   echo $ECHO_N "(cached) $ECHO_C" >&6
8747 else
8748   case $AR_FOR_TARGET in
8749   [\\/]* | ?:[\\/]*)
8750   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8751   ;;
8752   *)
8753   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8754 for as_dir in $gcc_cv_tool_dirs
8755 do
8756   IFS=$as_save_IFS
8757   test -z "$as_dir" && as_dir=.
8758   for ac_exec_ext in '' $ac_executable_extensions; do
8759   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8760     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8761     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8762     break 2
8763   fi
8764 done
8765 done
8766
8767   ;;
8768 esac
8769 fi
8770 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8771
8772 if test -n "$AR_FOR_TARGET"; then
8773   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8774 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8775 else
8776   echo "$as_me:$LINENO: result: no" >&5
8777 echo "${ECHO_T}no" >&6
8778 fi
8779
8780 fi
8781 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8782
8783
8784 if test -n "$AR_FOR_TARGET"; then
8785   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8786 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8787   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8788 fi
8789
8790 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8791   for ncn_progname in ar; do
8792     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8793 set dummy ${ncn_progname}; ac_word=$2
8794 echo "$as_me:$LINENO: checking for $ac_word" >&5
8795 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8796 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8797   echo $ECHO_N "(cached) $ECHO_C" >&6
8798 else
8799   if test -n "$AR_FOR_TARGET"; then
8800   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8801 else
8802 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8803 for as_dir in $PATH
8804 do
8805   IFS=$as_save_IFS
8806   test -z "$as_dir" && as_dir=.
8807   for ac_exec_ext in '' $ac_executable_extensions; do
8808   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8809     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8810     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8811     break 2
8812   fi
8813 done
8814 done
8815
8816 fi
8817 fi
8818 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8819 if test -n "$AR_FOR_TARGET"; then
8820   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8821 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8822 else
8823   echo "$as_me:$LINENO: result: no" >&5
8824 echo "${ECHO_T}no" >&6
8825 fi
8826
8827   done
8828 fi
8829
8830 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8831   for ncn_progname in ar; do
8832     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8833 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8834     if test -x $with_build_time_tools/${ncn_progname}; then
8835       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8836       echo "$as_me:$LINENO: result: yes" >&5
8837 echo "${ECHO_T}yes" >&6
8838       break
8839     else
8840       echo "$as_me:$LINENO: result: no" >&5
8841 echo "${ECHO_T}no" >&6
8842     fi
8843   done
8844 fi
8845
8846 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8847   for ncn_progname in ar; do
8848     if test -n "$ncn_target_tool_prefix"; then
8849       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8850 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8851 echo "$as_me:$LINENO: checking for $ac_word" >&5
8852 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8853 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8854   echo $ECHO_N "(cached) $ECHO_C" >&6
8855 else
8856   if test -n "$AR_FOR_TARGET"; then
8857   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8858 else
8859 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8860 for as_dir in $PATH
8861 do
8862   IFS=$as_save_IFS
8863   test -z "$as_dir" && as_dir=.
8864   for ac_exec_ext in '' $ac_executable_extensions; do
8865   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8866     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8867     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8868     break 2
8869   fi
8870 done
8871 done
8872
8873 fi
8874 fi
8875 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8876 if test -n "$AR_FOR_TARGET"; then
8877   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8878 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8879 else
8880   echo "$as_me:$LINENO: result: no" >&5
8881 echo "${ECHO_T}no" >&6
8882 fi
8883
8884     fi
8885     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8886       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8887 set dummy ${ncn_progname}; ac_word=$2
8888 echo "$as_me:$LINENO: checking for $ac_word" >&5
8889 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8890 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8891   echo $ECHO_N "(cached) $ECHO_C" >&6
8892 else
8893   if test -n "$AR_FOR_TARGET"; then
8894   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8895 else
8896 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8897 for as_dir in $PATH
8898 do
8899   IFS=$as_save_IFS
8900   test -z "$as_dir" && as_dir=.
8901   for ac_exec_ext in '' $ac_executable_extensions; do
8902   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8903     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8904     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8905     break 2
8906   fi
8907 done
8908 done
8909
8910 fi
8911 fi
8912 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8913 if test -n "$AR_FOR_TARGET"; then
8914   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8915 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8916 else
8917   echo "$as_me:$LINENO: result: no" >&5
8918 echo "${ECHO_T}no" >&6
8919 fi
8920
8921     fi
8922     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8923   done
8924 fi
8925
8926 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8927   set dummy ar
8928   if test $build = $target ; then
8929     AR_FOR_TARGET="$2"
8930   else
8931     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8932   fi
8933 else
8934   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
8935 fi
8936
8937 else
8938   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8939 fi
8940
8941
8942
8943
8944 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8945   if test -n "$with_build_time_tools"; then
8946     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
8947 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
8948     if test -x $with_build_time_tools/as; then
8949       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
8950       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8951       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
8952 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
8953     else
8954       echo "$as_me:$LINENO: result: no" >&5
8955 echo "${ECHO_T}no" >&6
8956     fi
8957   elif test $build != $host && test $have_gcc_for_target = yes; then
8958     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
8959     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
8960     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8961   fi
8962 fi
8963 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8964   # Extract the first word of "as", so it can be a program name with args.
8965 set dummy as; ac_word=$2
8966 echo "$as_me:$LINENO: checking for $ac_word" >&5
8967 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8968 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
8969   echo $ECHO_N "(cached) $ECHO_C" >&6
8970 else
8971   case $AS_FOR_TARGET in
8972   [\\/]* | ?:[\\/]*)
8973   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
8974   ;;
8975   *)
8976   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8977 for as_dir in $gcc_cv_tool_dirs
8978 do
8979   IFS=$as_save_IFS
8980   test -z "$as_dir" && as_dir=.
8981   for ac_exec_ext in '' $ac_executable_extensions; do
8982   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8983     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8984     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8985     break 2
8986   fi
8987 done
8988 done
8989
8990   ;;
8991 esac
8992 fi
8993 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8994
8995 if test -n "$AS_FOR_TARGET"; then
8996   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8997 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8998 else
8999   echo "$as_me:$LINENO: result: no" >&5
9000 echo "${ECHO_T}no" >&6
9001 fi
9002
9003 fi
9004 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
9005
9006
9007 if test -n "$AS_FOR_TARGET"; then
9008   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
9009 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9010   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9011 fi
9012
9013 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
9014   for ncn_progname in as; do
9015     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9016 set dummy ${ncn_progname}; ac_word=$2
9017 echo "$as_me:$LINENO: checking for $ac_word" >&5
9018 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9019 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9020   echo $ECHO_N "(cached) $ECHO_C" >&6
9021 else
9022   if test -n "$AS_FOR_TARGET"; then
9023   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9024 else
9025 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9026 for as_dir in $PATH
9027 do
9028   IFS=$as_save_IFS
9029   test -z "$as_dir" && as_dir=.
9030   for ac_exec_ext in '' $ac_executable_extensions; do
9031   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9032     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9033     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9034     break 2
9035   fi
9036 done
9037 done
9038
9039 fi
9040 fi
9041 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9042 if test -n "$AS_FOR_TARGET"; then
9043   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9044 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9045 else
9046   echo "$as_me:$LINENO: result: no" >&5
9047 echo "${ECHO_T}no" >&6
9048 fi
9049
9050   done
9051 fi
9052
9053 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9054   for ncn_progname in as; do
9055     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9056 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9057     if test -x $with_build_time_tools/${ncn_progname}; then
9058       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9059       echo "$as_me:$LINENO: result: yes" >&5
9060 echo "${ECHO_T}yes" >&6
9061       break
9062     else
9063       echo "$as_me:$LINENO: result: no" >&5
9064 echo "${ECHO_T}no" >&6
9065     fi
9066   done
9067 fi
9068
9069 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9070   for ncn_progname in as; do
9071     if test -n "$ncn_target_tool_prefix"; then
9072       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9073 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9074 echo "$as_me:$LINENO: checking for $ac_word" >&5
9075 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9076 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9077   echo $ECHO_N "(cached) $ECHO_C" >&6
9078 else
9079   if test -n "$AS_FOR_TARGET"; then
9080   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9081 else
9082 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9083 for as_dir in $PATH
9084 do
9085   IFS=$as_save_IFS
9086   test -z "$as_dir" && as_dir=.
9087   for ac_exec_ext in '' $ac_executable_extensions; do
9088   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9089     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9090     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9091     break 2
9092   fi
9093 done
9094 done
9095
9096 fi
9097 fi
9098 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9099 if test -n "$AS_FOR_TARGET"; then
9100   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9101 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9102 else
9103   echo "$as_me:$LINENO: result: no" >&5
9104 echo "${ECHO_T}no" >&6
9105 fi
9106
9107     fi
9108     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9109       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9110 set dummy ${ncn_progname}; ac_word=$2
9111 echo "$as_me:$LINENO: checking for $ac_word" >&5
9112 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9113 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9114   echo $ECHO_N "(cached) $ECHO_C" >&6
9115 else
9116   if test -n "$AS_FOR_TARGET"; then
9117   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9118 else
9119 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9120 for as_dir in $PATH
9121 do
9122   IFS=$as_save_IFS
9123   test -z "$as_dir" && as_dir=.
9124   for ac_exec_ext in '' $ac_executable_extensions; do
9125   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9126     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9127     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9128     break 2
9129   fi
9130 done
9131 done
9132
9133 fi
9134 fi
9135 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9136 if test -n "$AS_FOR_TARGET"; then
9137   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9138 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9139 else
9140   echo "$as_me:$LINENO: result: no" >&5
9141 echo "${ECHO_T}no" >&6
9142 fi
9143
9144     fi
9145     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9146   done
9147 fi
9148
9149 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9150   set dummy as
9151   if test $build = $target ; then
9152     AS_FOR_TARGET="$2"
9153   else
9154     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9155   fi
9156 else
9157   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9158 fi
9159
9160 else
9161   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9162 fi
9163
9164
9165
9166
9167 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9168   if test -n "$with_build_time_tools"; then
9169     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9170 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9171     if test -x $with_build_time_tools/dlltool; then
9172       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9173       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9174       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9175 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9176     else
9177       echo "$as_me:$LINENO: result: no" >&5
9178 echo "${ECHO_T}no" >&6
9179     fi
9180   elif test $build != $host && test $have_gcc_for_target = yes; then
9181     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9182     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9183     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9184   fi
9185 fi
9186 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9187   # Extract the first word of "dlltool", so it can be a program name with args.
9188 set dummy dlltool; ac_word=$2
9189 echo "$as_me:$LINENO: checking for $ac_word" >&5
9190 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9191 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9192   echo $ECHO_N "(cached) $ECHO_C" >&6
9193 else
9194   case $DLLTOOL_FOR_TARGET in
9195   [\\/]* | ?:[\\/]*)
9196   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9197   ;;
9198   *)
9199   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9200 for as_dir in $gcc_cv_tool_dirs
9201 do
9202   IFS=$as_save_IFS
9203   test -z "$as_dir" && as_dir=.
9204   for ac_exec_ext in '' $ac_executable_extensions; do
9205   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9206     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9207     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9208     break 2
9209   fi
9210 done
9211 done
9212
9213   ;;
9214 esac
9215 fi
9216 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9217
9218 if test -n "$DLLTOOL_FOR_TARGET"; then
9219   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9220 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9221 else
9222   echo "$as_me:$LINENO: result: no" >&5
9223 echo "${ECHO_T}no" >&6
9224 fi
9225
9226 fi
9227 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9228
9229
9230 if test -n "$DLLTOOL_FOR_TARGET"; then
9231   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9232 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9233   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9234 fi
9235
9236 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9237   for ncn_progname in dlltool; do
9238     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9239 set dummy ${ncn_progname}; ac_word=$2
9240 echo "$as_me:$LINENO: checking for $ac_word" >&5
9241 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9242 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9243   echo $ECHO_N "(cached) $ECHO_C" >&6
9244 else
9245   if test -n "$DLLTOOL_FOR_TARGET"; then
9246   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9247 else
9248 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9249 for as_dir in $PATH
9250 do
9251   IFS=$as_save_IFS
9252   test -z "$as_dir" && as_dir=.
9253   for ac_exec_ext in '' $ac_executable_extensions; do
9254   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9255     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9256     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9257     break 2
9258   fi
9259 done
9260 done
9261
9262 fi
9263 fi
9264 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9265 if test -n "$DLLTOOL_FOR_TARGET"; then
9266   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9267 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9268 else
9269   echo "$as_me:$LINENO: result: no" >&5
9270 echo "${ECHO_T}no" >&6
9271 fi
9272
9273   done
9274 fi
9275
9276 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9277   for ncn_progname in dlltool; do
9278     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9279 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9280     if test -x $with_build_time_tools/${ncn_progname}; then
9281       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9282       echo "$as_me:$LINENO: result: yes" >&5
9283 echo "${ECHO_T}yes" >&6
9284       break
9285     else
9286       echo "$as_me:$LINENO: result: no" >&5
9287 echo "${ECHO_T}no" >&6
9288     fi
9289   done
9290 fi
9291
9292 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9293   for ncn_progname in dlltool; do
9294     if test -n "$ncn_target_tool_prefix"; then
9295       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9296 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9297 echo "$as_me:$LINENO: checking for $ac_word" >&5
9298 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9299 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9300   echo $ECHO_N "(cached) $ECHO_C" >&6
9301 else
9302   if test -n "$DLLTOOL_FOR_TARGET"; then
9303   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9304 else
9305 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9306 for as_dir in $PATH
9307 do
9308   IFS=$as_save_IFS
9309   test -z "$as_dir" && as_dir=.
9310   for ac_exec_ext in '' $ac_executable_extensions; do
9311   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9312     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9313     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9314     break 2
9315   fi
9316 done
9317 done
9318
9319 fi
9320 fi
9321 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9322 if test -n "$DLLTOOL_FOR_TARGET"; then
9323   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9324 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9325 else
9326   echo "$as_me:$LINENO: result: no" >&5
9327 echo "${ECHO_T}no" >&6
9328 fi
9329
9330     fi
9331     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9332       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9333 set dummy ${ncn_progname}; ac_word=$2
9334 echo "$as_me:$LINENO: checking for $ac_word" >&5
9335 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9336 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9337   echo $ECHO_N "(cached) $ECHO_C" >&6
9338 else
9339   if test -n "$DLLTOOL_FOR_TARGET"; then
9340   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9341 else
9342 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9343 for as_dir in $PATH
9344 do
9345   IFS=$as_save_IFS
9346   test -z "$as_dir" && as_dir=.
9347   for ac_exec_ext in '' $ac_executable_extensions; do
9348   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9349     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9350     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9351     break 2
9352   fi
9353 done
9354 done
9355
9356 fi
9357 fi
9358 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9359 if test -n "$DLLTOOL_FOR_TARGET"; then
9360   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9361 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9362 else
9363   echo "$as_me:$LINENO: result: no" >&5
9364 echo "${ECHO_T}no" >&6
9365 fi
9366
9367     fi
9368     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9369   done
9370 fi
9371
9372 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9373   set dummy dlltool
9374   if test $build = $target ; then
9375     DLLTOOL_FOR_TARGET="$2"
9376   else
9377     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9378   fi
9379 else
9380   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9381 fi
9382
9383 else
9384   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9385 fi
9386
9387
9388
9389
9390 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9391   if test -n "$with_build_time_tools"; then
9392     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9393 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9394     if test -x $with_build_time_tools/ld; then
9395       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9396       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9397       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9398 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9399     else
9400       echo "$as_me:$LINENO: result: no" >&5
9401 echo "${ECHO_T}no" >&6
9402     fi
9403   elif test $build != $host && test $have_gcc_for_target = yes; then
9404     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9405     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9406     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9407   fi
9408 fi
9409 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9410   # Extract the first word of "ld", so it can be a program name with args.
9411 set dummy ld; ac_word=$2
9412 echo "$as_me:$LINENO: checking for $ac_word" >&5
9413 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9414 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9415   echo $ECHO_N "(cached) $ECHO_C" >&6
9416 else
9417   case $LD_FOR_TARGET in
9418   [\\/]* | ?:[\\/]*)
9419   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9420   ;;
9421   *)
9422   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9423 for as_dir in $gcc_cv_tool_dirs
9424 do
9425   IFS=$as_save_IFS
9426   test -z "$as_dir" && as_dir=.
9427   for ac_exec_ext in '' $ac_executable_extensions; do
9428   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9429     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9430     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9431     break 2
9432   fi
9433 done
9434 done
9435
9436   ;;
9437 esac
9438 fi
9439 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9440
9441 if test -n "$LD_FOR_TARGET"; then
9442   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9443 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9444 else
9445   echo "$as_me:$LINENO: result: no" >&5
9446 echo "${ECHO_T}no" >&6
9447 fi
9448
9449 fi
9450 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9451
9452
9453 if test -n "$LD_FOR_TARGET"; then
9454   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9455 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9456   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9457 fi
9458
9459 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9460   for ncn_progname in ld; do
9461     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9462 set dummy ${ncn_progname}; ac_word=$2
9463 echo "$as_me:$LINENO: checking for $ac_word" >&5
9464 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9465 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9466   echo $ECHO_N "(cached) $ECHO_C" >&6
9467 else
9468   if test -n "$LD_FOR_TARGET"; then
9469   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9470 else
9471 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9472 for as_dir in $PATH
9473 do
9474   IFS=$as_save_IFS
9475   test -z "$as_dir" && as_dir=.
9476   for ac_exec_ext in '' $ac_executable_extensions; do
9477   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9478     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9479     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9480     break 2
9481   fi
9482 done
9483 done
9484
9485 fi
9486 fi
9487 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9488 if test -n "$LD_FOR_TARGET"; then
9489   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9490 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9491 else
9492   echo "$as_me:$LINENO: result: no" >&5
9493 echo "${ECHO_T}no" >&6
9494 fi
9495
9496   done
9497 fi
9498
9499 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9500   for ncn_progname in ld; do
9501     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9502 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9503     if test -x $with_build_time_tools/${ncn_progname}; then
9504       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9505       echo "$as_me:$LINENO: result: yes" >&5
9506 echo "${ECHO_T}yes" >&6
9507       break
9508     else
9509       echo "$as_me:$LINENO: result: no" >&5
9510 echo "${ECHO_T}no" >&6
9511     fi
9512   done
9513 fi
9514
9515 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9516   for ncn_progname in ld; do
9517     if test -n "$ncn_target_tool_prefix"; then
9518       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9519 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9520 echo "$as_me:$LINENO: checking for $ac_word" >&5
9521 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9522 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9523   echo $ECHO_N "(cached) $ECHO_C" >&6
9524 else
9525   if test -n "$LD_FOR_TARGET"; then
9526   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9527 else
9528 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9529 for as_dir in $PATH
9530 do
9531   IFS=$as_save_IFS
9532   test -z "$as_dir" && as_dir=.
9533   for ac_exec_ext in '' $ac_executable_extensions; do
9534   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9535     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9536     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9537     break 2
9538   fi
9539 done
9540 done
9541
9542 fi
9543 fi
9544 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9545 if test -n "$LD_FOR_TARGET"; then
9546   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9547 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9548 else
9549   echo "$as_me:$LINENO: result: no" >&5
9550 echo "${ECHO_T}no" >&6
9551 fi
9552
9553     fi
9554     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9555       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9556 set dummy ${ncn_progname}; ac_word=$2
9557 echo "$as_me:$LINENO: checking for $ac_word" >&5
9558 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9559 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9560   echo $ECHO_N "(cached) $ECHO_C" >&6
9561 else
9562   if test -n "$LD_FOR_TARGET"; then
9563   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9564 else
9565 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9566 for as_dir in $PATH
9567 do
9568   IFS=$as_save_IFS
9569   test -z "$as_dir" && as_dir=.
9570   for ac_exec_ext in '' $ac_executable_extensions; do
9571   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9572     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9573     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9574     break 2
9575   fi
9576 done
9577 done
9578
9579 fi
9580 fi
9581 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9582 if test -n "$LD_FOR_TARGET"; then
9583   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9584 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9585 else
9586   echo "$as_me:$LINENO: result: no" >&5
9587 echo "${ECHO_T}no" >&6
9588 fi
9589
9590     fi
9591     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9592   done
9593 fi
9594
9595 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9596   set dummy ld
9597   if test $build = $target ; then
9598     LD_FOR_TARGET="$2"
9599   else
9600     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9601   fi
9602 else
9603   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9604 fi
9605
9606 else
9607   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9608 fi
9609
9610
9611
9612
9613 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9614   if test -n "$with_build_time_tools"; then
9615     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9616 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9617     if test -x $with_build_time_tools/lipo; then
9618       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9619       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9620       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9621 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9622     else
9623       echo "$as_me:$LINENO: result: no" >&5
9624 echo "${ECHO_T}no" >&6
9625     fi
9626   elif test $build != $host && test $have_gcc_for_target = yes; then
9627     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9628     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9629     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9630   fi
9631 fi
9632 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9633   # Extract the first word of "lipo", so it can be a program name with args.
9634 set dummy lipo; ac_word=$2
9635 echo "$as_me:$LINENO: checking for $ac_word" >&5
9636 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9637 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9638   echo $ECHO_N "(cached) $ECHO_C" >&6
9639 else
9640   case $LIPO_FOR_TARGET in
9641   [\\/]* | ?:[\\/]*)
9642   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9643   ;;
9644   *)
9645   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9646 for as_dir in $gcc_cv_tool_dirs
9647 do
9648   IFS=$as_save_IFS
9649   test -z "$as_dir" && as_dir=.
9650   for ac_exec_ext in '' $ac_executable_extensions; do
9651   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9652     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9653     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9654     break 2
9655   fi
9656 done
9657 done
9658
9659   ;;
9660 esac
9661 fi
9662 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9663
9664 if test -n "$LIPO_FOR_TARGET"; then
9665   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9666 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9667 else
9668   echo "$as_me:$LINENO: result: no" >&5
9669 echo "${ECHO_T}no" >&6
9670 fi
9671
9672 fi
9673 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9674
9675
9676 if test -n "$LIPO_FOR_TARGET"; then
9677   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9678 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9679   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9680 fi
9681
9682 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9683   for ncn_progname in lipo; do
9684     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9685 set dummy ${ncn_progname}; ac_word=$2
9686 echo "$as_me:$LINENO: checking for $ac_word" >&5
9687 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9688 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9689   echo $ECHO_N "(cached) $ECHO_C" >&6
9690 else
9691   if test -n "$LIPO_FOR_TARGET"; then
9692   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9693 else
9694 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9695 for as_dir in $PATH
9696 do
9697   IFS=$as_save_IFS
9698   test -z "$as_dir" && as_dir=.
9699   for ac_exec_ext in '' $ac_executable_extensions; do
9700   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9701     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9702     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9703     break 2
9704   fi
9705 done
9706 done
9707
9708 fi
9709 fi
9710 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9711 if test -n "$LIPO_FOR_TARGET"; then
9712   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9713 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9714 else
9715   echo "$as_me:$LINENO: result: no" >&5
9716 echo "${ECHO_T}no" >&6
9717 fi
9718
9719   done
9720 fi
9721
9722 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9723   for ncn_progname in lipo; do
9724     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9725 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9726     if test -x $with_build_time_tools/${ncn_progname}; then
9727       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9728       echo "$as_me:$LINENO: result: yes" >&5
9729 echo "${ECHO_T}yes" >&6
9730       break
9731     else
9732       echo "$as_me:$LINENO: result: no" >&5
9733 echo "${ECHO_T}no" >&6
9734     fi
9735   done
9736 fi
9737
9738 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9739   for ncn_progname in lipo; do
9740     if test -n "$ncn_target_tool_prefix"; then
9741       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9742 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9743 echo "$as_me:$LINENO: checking for $ac_word" >&5
9744 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9745 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9746   echo $ECHO_N "(cached) $ECHO_C" >&6
9747 else
9748   if test -n "$LIPO_FOR_TARGET"; then
9749   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9750 else
9751 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9752 for as_dir in $PATH
9753 do
9754   IFS=$as_save_IFS
9755   test -z "$as_dir" && as_dir=.
9756   for ac_exec_ext in '' $ac_executable_extensions; do
9757   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9758     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9759     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9760     break 2
9761   fi
9762 done
9763 done
9764
9765 fi
9766 fi
9767 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9768 if test -n "$LIPO_FOR_TARGET"; then
9769   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9770 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9771 else
9772   echo "$as_me:$LINENO: result: no" >&5
9773 echo "${ECHO_T}no" >&6
9774 fi
9775
9776     fi
9777     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9778       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9779 set dummy ${ncn_progname}; ac_word=$2
9780 echo "$as_me:$LINENO: checking for $ac_word" >&5
9781 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9782 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9783   echo $ECHO_N "(cached) $ECHO_C" >&6
9784 else
9785   if test -n "$LIPO_FOR_TARGET"; then
9786   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9787 else
9788 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9789 for as_dir in $PATH
9790 do
9791   IFS=$as_save_IFS
9792   test -z "$as_dir" && as_dir=.
9793   for ac_exec_ext in '' $ac_executable_extensions; do
9794   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9795     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9796     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9797     break 2
9798   fi
9799 done
9800 done
9801
9802 fi
9803 fi
9804 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9805 if test -n "$LIPO_FOR_TARGET"; then
9806   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9807 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9808 else
9809   echo "$as_me:$LINENO: result: no" >&5
9810 echo "${ECHO_T}no" >&6
9811 fi
9812
9813     fi
9814     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9815   done
9816 fi
9817
9818 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9819   set dummy lipo
9820   if test $build = $target ; then
9821     LIPO_FOR_TARGET="$2"
9822   else
9823     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9824   fi
9825 else
9826   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9827 fi
9828
9829 else
9830   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9831 fi
9832
9833
9834
9835
9836 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9837   if test -n "$with_build_time_tools"; then
9838     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9839 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9840     if test -x $with_build_time_tools/nm; then
9841       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9842       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9843       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9844 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9845     else
9846       echo "$as_me:$LINENO: result: no" >&5
9847 echo "${ECHO_T}no" >&6
9848     fi
9849   elif test $build != $host && test $have_gcc_for_target = yes; then
9850     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9851     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9852     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9853   fi
9854 fi
9855 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9856   # Extract the first word of "nm", so it can be a program name with args.
9857 set dummy nm; ac_word=$2
9858 echo "$as_me:$LINENO: checking for $ac_word" >&5
9859 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9860 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9861   echo $ECHO_N "(cached) $ECHO_C" >&6
9862 else
9863   case $NM_FOR_TARGET in
9864   [\\/]* | ?:[\\/]*)
9865   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9866   ;;
9867   *)
9868   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9869 for as_dir in $gcc_cv_tool_dirs
9870 do
9871   IFS=$as_save_IFS
9872   test -z "$as_dir" && as_dir=.
9873   for ac_exec_ext in '' $ac_executable_extensions; do
9874   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9875     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9876     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9877     break 2
9878   fi
9879 done
9880 done
9881
9882   ;;
9883 esac
9884 fi
9885 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9886
9887 if test -n "$NM_FOR_TARGET"; then
9888   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9889 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9890 else
9891   echo "$as_me:$LINENO: result: no" >&5
9892 echo "${ECHO_T}no" >&6
9893 fi
9894
9895 fi
9896 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9897
9898
9899 if test -n "$NM_FOR_TARGET"; then
9900   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9901 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9902   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9903 fi
9904
9905 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9906   for ncn_progname in nm; do
9907     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9908 set dummy ${ncn_progname}; ac_word=$2
9909 echo "$as_me:$LINENO: checking for $ac_word" >&5
9910 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9911 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9912   echo $ECHO_N "(cached) $ECHO_C" >&6
9913 else
9914   if test -n "$NM_FOR_TARGET"; then
9915   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9916 else
9917 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9918 for as_dir in $PATH
9919 do
9920   IFS=$as_save_IFS
9921   test -z "$as_dir" && as_dir=.
9922   for ac_exec_ext in '' $ac_executable_extensions; do
9923   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9924     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9925     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9926     break 2
9927   fi
9928 done
9929 done
9930
9931 fi
9932 fi
9933 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9934 if test -n "$NM_FOR_TARGET"; then
9935   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9936 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9937 else
9938   echo "$as_me:$LINENO: result: no" >&5
9939 echo "${ECHO_T}no" >&6
9940 fi
9941
9942   done
9943 fi
9944
9945 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
9946   for ncn_progname in nm; do
9947     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9948 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9949     if test -x $with_build_time_tools/${ncn_progname}; then
9950       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9951       echo "$as_me:$LINENO: result: yes" >&5
9952 echo "${ECHO_T}yes" >&6
9953       break
9954     else
9955       echo "$as_me:$LINENO: result: no" >&5
9956 echo "${ECHO_T}no" >&6
9957     fi
9958   done
9959 fi
9960
9961 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
9962   for ncn_progname in nm; do
9963     if test -n "$ncn_target_tool_prefix"; then
9964       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9965 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9966 echo "$as_me:$LINENO: checking for $ac_word" >&5
9967 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9968 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9969   echo $ECHO_N "(cached) $ECHO_C" >&6
9970 else
9971   if test -n "$NM_FOR_TARGET"; then
9972   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9973 else
9974 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9975 for as_dir in $PATH
9976 do
9977   IFS=$as_save_IFS
9978   test -z "$as_dir" && as_dir=.
9979   for ac_exec_ext in '' $ac_executable_extensions; do
9980   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9981     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9982     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9983     break 2
9984   fi
9985 done
9986 done
9987
9988 fi
9989 fi
9990 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9991 if test -n "$NM_FOR_TARGET"; then
9992   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9993 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9994 else
9995   echo "$as_me:$LINENO: result: no" >&5
9996 echo "${ECHO_T}no" >&6
9997 fi
9998
9999     fi
10000     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
10001       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10002 set dummy ${ncn_progname}; ac_word=$2
10003 echo "$as_me:$LINENO: checking for $ac_word" >&5
10004 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10005 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
10006   echo $ECHO_N "(cached) $ECHO_C" >&6
10007 else
10008   if test -n "$NM_FOR_TARGET"; then
10009   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
10010 else
10011 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10012 for as_dir in $PATH
10013 do
10014   IFS=$as_save_IFS
10015   test -z "$as_dir" && as_dir=.
10016   for ac_exec_ext in '' $ac_executable_extensions; do
10017   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10018     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
10019     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10020     break 2
10021   fi
10022 done
10023 done
10024
10025 fi
10026 fi
10027 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
10028 if test -n "$NM_FOR_TARGET"; then
10029   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
10030 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10031 else
10032   echo "$as_me:$LINENO: result: no" >&5
10033 echo "${ECHO_T}no" >&6
10034 fi
10035
10036     fi
10037     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10038   done
10039 fi
10040
10041 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10042   set dummy nm
10043   if test $build = $target ; then
10044     NM_FOR_TARGET="$2"
10045   else
10046     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10047   fi
10048 else
10049   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10050 fi
10051
10052 else
10053   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10054 fi
10055
10056
10057
10058
10059 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10060   if test -n "$with_build_time_tools"; then
10061     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10062 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10063     if test -x $with_build_time_tools/objdump; then
10064       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10065       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10066       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10067 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10068     else
10069       echo "$as_me:$LINENO: result: no" >&5
10070 echo "${ECHO_T}no" >&6
10071     fi
10072   elif test $build != $host && test $have_gcc_for_target = yes; then
10073     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10074     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10075     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10076   fi
10077 fi
10078 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10079   # Extract the first word of "objdump", so it can be a program name with args.
10080 set dummy objdump; ac_word=$2
10081 echo "$as_me:$LINENO: checking for $ac_word" >&5
10082 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10083 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10084   echo $ECHO_N "(cached) $ECHO_C" >&6
10085 else
10086   case $OBJDUMP_FOR_TARGET in
10087   [\\/]* | ?:[\\/]*)
10088   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10089   ;;
10090   *)
10091   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10092 for as_dir in $gcc_cv_tool_dirs
10093 do
10094   IFS=$as_save_IFS
10095   test -z "$as_dir" && as_dir=.
10096   for ac_exec_ext in '' $ac_executable_extensions; do
10097   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10098     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10099     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10100     break 2
10101   fi
10102 done
10103 done
10104
10105   ;;
10106 esac
10107 fi
10108 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10109
10110 if test -n "$OBJDUMP_FOR_TARGET"; then
10111   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10112 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10113 else
10114   echo "$as_me:$LINENO: result: no" >&5
10115 echo "${ECHO_T}no" >&6
10116 fi
10117
10118 fi
10119 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10120
10121
10122 if test -n "$OBJDUMP_FOR_TARGET"; then
10123   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10124 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10125   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10126 fi
10127
10128 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10129   for ncn_progname in objdump; do
10130     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10131 set dummy ${ncn_progname}; ac_word=$2
10132 echo "$as_me:$LINENO: checking for $ac_word" >&5
10133 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10134 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10135   echo $ECHO_N "(cached) $ECHO_C" >&6
10136 else
10137   if test -n "$OBJDUMP_FOR_TARGET"; then
10138   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10139 else
10140 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10141 for as_dir in $PATH
10142 do
10143   IFS=$as_save_IFS
10144   test -z "$as_dir" && as_dir=.
10145   for ac_exec_ext in '' $ac_executable_extensions; do
10146   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10147     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10148     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10149     break 2
10150   fi
10151 done
10152 done
10153
10154 fi
10155 fi
10156 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10157 if test -n "$OBJDUMP_FOR_TARGET"; then
10158   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10159 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10160 else
10161   echo "$as_me:$LINENO: result: no" >&5
10162 echo "${ECHO_T}no" >&6
10163 fi
10164
10165   done
10166 fi
10167
10168 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10169   for ncn_progname in objdump; do
10170     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10171 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10172     if test -x $with_build_time_tools/${ncn_progname}; then
10173       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10174       echo "$as_me:$LINENO: result: yes" >&5
10175 echo "${ECHO_T}yes" >&6
10176       break
10177     else
10178       echo "$as_me:$LINENO: result: no" >&5
10179 echo "${ECHO_T}no" >&6
10180     fi
10181   done
10182 fi
10183
10184 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10185   for ncn_progname in objdump; do
10186     if test -n "$ncn_target_tool_prefix"; then
10187       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10188 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10189 echo "$as_me:$LINENO: checking for $ac_word" >&5
10190 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10191 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10192   echo $ECHO_N "(cached) $ECHO_C" >&6
10193 else
10194   if test -n "$OBJDUMP_FOR_TARGET"; then
10195   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10196 else
10197 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10198 for as_dir in $PATH
10199 do
10200   IFS=$as_save_IFS
10201   test -z "$as_dir" && as_dir=.
10202   for ac_exec_ext in '' $ac_executable_extensions; do
10203   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10204     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10205     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10206     break 2
10207   fi
10208 done
10209 done
10210
10211 fi
10212 fi
10213 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10214 if test -n "$OBJDUMP_FOR_TARGET"; then
10215   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10216 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10217 else
10218   echo "$as_me:$LINENO: result: no" >&5
10219 echo "${ECHO_T}no" >&6
10220 fi
10221
10222     fi
10223     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10224       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10225 set dummy ${ncn_progname}; ac_word=$2
10226 echo "$as_me:$LINENO: checking for $ac_word" >&5
10227 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10228 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10229   echo $ECHO_N "(cached) $ECHO_C" >&6
10230 else
10231   if test -n "$OBJDUMP_FOR_TARGET"; then
10232   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10233 else
10234 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10235 for as_dir in $PATH
10236 do
10237   IFS=$as_save_IFS
10238   test -z "$as_dir" && as_dir=.
10239   for ac_exec_ext in '' $ac_executable_extensions; do
10240   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10241     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10242     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10243     break 2
10244   fi
10245 done
10246 done
10247
10248 fi
10249 fi
10250 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10251 if test -n "$OBJDUMP_FOR_TARGET"; then
10252   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10253 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10254 else
10255   echo "$as_me:$LINENO: result: no" >&5
10256 echo "${ECHO_T}no" >&6
10257 fi
10258
10259     fi
10260     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10261   done
10262 fi
10263
10264 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10265   set dummy objdump
10266   if test $build = $target ; then
10267     OBJDUMP_FOR_TARGET="$2"
10268   else
10269     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10270   fi
10271 else
10272   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10273 fi
10274
10275 else
10276   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10277 fi
10278
10279
10280
10281
10282 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10283   if test -n "$with_build_time_tools"; then
10284     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10285 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10286     if test -x $with_build_time_tools/ranlib; then
10287       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10288       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10289       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10290 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10291     else
10292       echo "$as_me:$LINENO: result: no" >&5
10293 echo "${ECHO_T}no" >&6
10294     fi
10295   elif test $build != $host && test $have_gcc_for_target = yes; then
10296     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10297     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10298     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10299   fi
10300 fi
10301 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10302   # Extract the first word of "ranlib", so it can be a program name with args.
10303 set dummy ranlib; ac_word=$2
10304 echo "$as_me:$LINENO: checking for $ac_word" >&5
10305 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10306 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10307   echo $ECHO_N "(cached) $ECHO_C" >&6
10308 else
10309   case $RANLIB_FOR_TARGET in
10310   [\\/]* | ?:[\\/]*)
10311   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10312   ;;
10313   *)
10314   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10315 for as_dir in $gcc_cv_tool_dirs
10316 do
10317   IFS=$as_save_IFS
10318   test -z "$as_dir" && as_dir=.
10319   for ac_exec_ext in '' $ac_executable_extensions; do
10320   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10321     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10322     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10323     break 2
10324   fi
10325 done
10326 done
10327
10328   ;;
10329 esac
10330 fi
10331 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10332
10333 if test -n "$RANLIB_FOR_TARGET"; then
10334   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10335 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10336 else
10337   echo "$as_me:$LINENO: result: no" >&5
10338 echo "${ECHO_T}no" >&6
10339 fi
10340
10341 fi
10342 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10343
10344
10345 if test -n "$RANLIB_FOR_TARGET"; then
10346   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10347 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10348   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10349 fi
10350
10351 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10352   for ncn_progname in ranlib; do
10353     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10354 set dummy ${ncn_progname}; ac_word=$2
10355 echo "$as_me:$LINENO: checking for $ac_word" >&5
10356 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10357 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10358   echo $ECHO_N "(cached) $ECHO_C" >&6
10359 else
10360   if test -n "$RANLIB_FOR_TARGET"; then
10361   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10362 else
10363 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10364 for as_dir in $PATH
10365 do
10366   IFS=$as_save_IFS
10367   test -z "$as_dir" && as_dir=.
10368   for ac_exec_ext in '' $ac_executable_extensions; do
10369   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10370     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10371     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10372     break 2
10373   fi
10374 done
10375 done
10376
10377 fi
10378 fi
10379 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10380 if test -n "$RANLIB_FOR_TARGET"; then
10381   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10382 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10383 else
10384   echo "$as_me:$LINENO: result: no" >&5
10385 echo "${ECHO_T}no" >&6
10386 fi
10387
10388   done
10389 fi
10390
10391 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10392   for ncn_progname in ranlib; do
10393     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10394 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10395     if test -x $with_build_time_tools/${ncn_progname}; then
10396       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10397       echo "$as_me:$LINENO: result: yes" >&5
10398 echo "${ECHO_T}yes" >&6
10399       break
10400     else
10401       echo "$as_me:$LINENO: result: no" >&5
10402 echo "${ECHO_T}no" >&6
10403     fi
10404   done
10405 fi
10406
10407 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10408   for ncn_progname in ranlib; do
10409     if test -n "$ncn_target_tool_prefix"; then
10410       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10411 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10412 echo "$as_me:$LINENO: checking for $ac_word" >&5
10413 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10414 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10415   echo $ECHO_N "(cached) $ECHO_C" >&6
10416 else
10417   if test -n "$RANLIB_FOR_TARGET"; then
10418   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10419 else
10420 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10421 for as_dir in $PATH
10422 do
10423   IFS=$as_save_IFS
10424   test -z "$as_dir" && as_dir=.
10425   for ac_exec_ext in '' $ac_executable_extensions; do
10426   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10427     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10428     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10429     break 2
10430   fi
10431 done
10432 done
10433
10434 fi
10435 fi
10436 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10437 if test -n "$RANLIB_FOR_TARGET"; then
10438   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10439 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10440 else
10441   echo "$as_me:$LINENO: result: no" >&5
10442 echo "${ECHO_T}no" >&6
10443 fi
10444
10445     fi
10446     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10447       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10448 set dummy ${ncn_progname}; ac_word=$2
10449 echo "$as_me:$LINENO: checking for $ac_word" >&5
10450 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10451 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10452   echo $ECHO_N "(cached) $ECHO_C" >&6
10453 else
10454   if test -n "$RANLIB_FOR_TARGET"; then
10455   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10456 else
10457 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10458 for as_dir in $PATH
10459 do
10460   IFS=$as_save_IFS
10461   test -z "$as_dir" && as_dir=.
10462   for ac_exec_ext in '' $ac_executable_extensions; do
10463   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10464     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10465     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10466     break 2
10467   fi
10468 done
10469 done
10470
10471 fi
10472 fi
10473 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10474 if test -n "$RANLIB_FOR_TARGET"; then
10475   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10476 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10477 else
10478   echo "$as_me:$LINENO: result: no" >&5
10479 echo "${ECHO_T}no" >&6
10480 fi
10481
10482     fi
10483     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10484   done
10485 fi
10486
10487 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10488   set dummy ranlib
10489   if test $build = $target ; then
10490     RANLIB_FOR_TARGET="$2"
10491   else
10492     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10493   fi
10494 else
10495   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10496 fi
10497
10498 else
10499   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10500 fi
10501
10502
10503
10504
10505 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10506   if test -n "$with_build_time_tools"; then
10507     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10508 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10509     if test -x $with_build_time_tools/strip; then
10510       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10511       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10512       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10513 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10514     else
10515       echo "$as_me:$LINENO: result: no" >&5
10516 echo "${ECHO_T}no" >&6
10517     fi
10518   elif test $build != $host && test $have_gcc_for_target = yes; then
10519     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10520     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10521     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10522   fi
10523 fi
10524 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10525   # Extract the first word of "strip", so it can be a program name with args.
10526 set dummy strip; ac_word=$2
10527 echo "$as_me:$LINENO: checking for $ac_word" >&5
10528 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10529 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10530   echo $ECHO_N "(cached) $ECHO_C" >&6
10531 else
10532   case $STRIP_FOR_TARGET in
10533   [\\/]* | ?:[\\/]*)
10534   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10535   ;;
10536   *)
10537   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10538 for as_dir in $gcc_cv_tool_dirs
10539 do
10540   IFS=$as_save_IFS
10541   test -z "$as_dir" && as_dir=.
10542   for ac_exec_ext in '' $ac_executable_extensions; do
10543   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10544     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10545     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10546     break 2
10547   fi
10548 done
10549 done
10550
10551   ;;
10552 esac
10553 fi
10554 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10555
10556 if test -n "$STRIP_FOR_TARGET"; then
10557   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10558 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10559 else
10560   echo "$as_me:$LINENO: result: no" >&5
10561 echo "${ECHO_T}no" >&6
10562 fi
10563
10564 fi
10565 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10566
10567
10568 if test -n "$STRIP_FOR_TARGET"; then
10569   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10570 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10571   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10572 fi
10573
10574 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10575   for ncn_progname in strip; do
10576     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10577 set dummy ${ncn_progname}; ac_word=$2
10578 echo "$as_me:$LINENO: checking for $ac_word" >&5
10579 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10580 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10581   echo $ECHO_N "(cached) $ECHO_C" >&6
10582 else
10583   if test -n "$STRIP_FOR_TARGET"; then
10584   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10585 else
10586 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10587 for as_dir in $PATH
10588 do
10589   IFS=$as_save_IFS
10590   test -z "$as_dir" && as_dir=.
10591   for ac_exec_ext in '' $ac_executable_extensions; do
10592   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10593     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10594     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10595     break 2
10596   fi
10597 done
10598 done
10599
10600 fi
10601 fi
10602 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10603 if test -n "$STRIP_FOR_TARGET"; then
10604   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10605 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10606 else
10607   echo "$as_me:$LINENO: result: no" >&5
10608 echo "${ECHO_T}no" >&6
10609 fi
10610
10611   done
10612 fi
10613
10614 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10615   for ncn_progname in strip; do
10616     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10617 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10618     if test -x $with_build_time_tools/${ncn_progname}; then
10619       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10620       echo "$as_me:$LINENO: result: yes" >&5
10621 echo "${ECHO_T}yes" >&6
10622       break
10623     else
10624       echo "$as_me:$LINENO: result: no" >&5
10625 echo "${ECHO_T}no" >&6
10626     fi
10627   done
10628 fi
10629
10630 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10631   for ncn_progname in strip; do
10632     if test -n "$ncn_target_tool_prefix"; then
10633       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10634 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10635 echo "$as_me:$LINENO: checking for $ac_word" >&5
10636 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10637 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10638   echo $ECHO_N "(cached) $ECHO_C" >&6
10639 else
10640   if test -n "$STRIP_FOR_TARGET"; then
10641   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10642 else
10643 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10644 for as_dir in $PATH
10645 do
10646   IFS=$as_save_IFS
10647   test -z "$as_dir" && as_dir=.
10648   for ac_exec_ext in '' $ac_executable_extensions; do
10649   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10650     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10651     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10652     break 2
10653   fi
10654 done
10655 done
10656
10657 fi
10658 fi
10659 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10660 if test -n "$STRIP_FOR_TARGET"; then
10661   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10662 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10663 else
10664   echo "$as_me:$LINENO: result: no" >&5
10665 echo "${ECHO_T}no" >&6
10666 fi
10667
10668     fi
10669     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10670       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10671 set dummy ${ncn_progname}; ac_word=$2
10672 echo "$as_me:$LINENO: checking for $ac_word" >&5
10673 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10674 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10675   echo $ECHO_N "(cached) $ECHO_C" >&6
10676 else
10677   if test -n "$STRIP_FOR_TARGET"; then
10678   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10679 else
10680 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10681 for as_dir in $PATH
10682 do
10683   IFS=$as_save_IFS
10684   test -z "$as_dir" && as_dir=.
10685   for ac_exec_ext in '' $ac_executable_extensions; do
10686   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10687     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10688     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10689     break 2
10690   fi
10691 done
10692 done
10693
10694 fi
10695 fi
10696 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10697 if test -n "$STRIP_FOR_TARGET"; then
10698   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10699 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10700 else
10701   echo "$as_me:$LINENO: result: no" >&5
10702 echo "${ECHO_T}no" >&6
10703 fi
10704
10705     fi
10706     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10707   done
10708 fi
10709
10710 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10711   set dummy strip
10712   if test $build = $target ; then
10713     STRIP_FOR_TARGET="$2"
10714   else
10715     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10716   fi
10717 else
10718   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10719 fi
10720
10721 else
10722   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10723 fi
10724
10725
10726
10727
10728 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10729   if test -n "$with_build_time_tools"; then
10730     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10731 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10732     if test -x $with_build_time_tools/windres; then
10733       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10734       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10735       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10736 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10737     else
10738       echo "$as_me:$LINENO: result: no" >&5
10739 echo "${ECHO_T}no" >&6
10740     fi
10741   elif test $build != $host && test $have_gcc_for_target = yes; then
10742     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10743     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10744     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10745   fi
10746 fi
10747 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10748   # Extract the first word of "windres", so it can be a program name with args.
10749 set dummy windres; ac_word=$2
10750 echo "$as_me:$LINENO: checking for $ac_word" >&5
10751 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10752 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10753   echo $ECHO_N "(cached) $ECHO_C" >&6
10754 else
10755   case $WINDRES_FOR_TARGET in
10756   [\\/]* | ?:[\\/]*)
10757   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10758   ;;
10759   *)
10760   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10761 for as_dir in $gcc_cv_tool_dirs
10762 do
10763   IFS=$as_save_IFS
10764   test -z "$as_dir" && as_dir=.
10765   for ac_exec_ext in '' $ac_executable_extensions; do
10766   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10767     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10768     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10769     break 2
10770   fi
10771 done
10772 done
10773
10774   ;;
10775 esac
10776 fi
10777 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10778
10779 if test -n "$WINDRES_FOR_TARGET"; then
10780   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10781 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10782 else
10783   echo "$as_me:$LINENO: result: no" >&5
10784 echo "${ECHO_T}no" >&6
10785 fi
10786
10787 fi
10788 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10789
10790
10791 if test -n "$WINDRES_FOR_TARGET"; then
10792   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10793 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10794   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10795 fi
10796
10797 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10798   for ncn_progname in windres; do
10799     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10800 set dummy ${ncn_progname}; ac_word=$2
10801 echo "$as_me:$LINENO: checking for $ac_word" >&5
10802 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10803 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10804   echo $ECHO_N "(cached) $ECHO_C" >&6
10805 else
10806   if test -n "$WINDRES_FOR_TARGET"; then
10807   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10808 else
10809 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10810 for as_dir in $PATH
10811 do
10812   IFS=$as_save_IFS
10813   test -z "$as_dir" && as_dir=.
10814   for ac_exec_ext in '' $ac_executable_extensions; do
10815   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10816     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10817     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10818     break 2
10819   fi
10820 done
10821 done
10822
10823 fi
10824 fi
10825 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10826 if test -n "$WINDRES_FOR_TARGET"; then
10827   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10828 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10829 else
10830   echo "$as_me:$LINENO: result: no" >&5
10831 echo "${ECHO_T}no" >&6
10832 fi
10833
10834   done
10835 fi
10836
10837 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10838   for ncn_progname in windres; do
10839     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10840 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10841     if test -x $with_build_time_tools/${ncn_progname}; then
10842       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10843       echo "$as_me:$LINENO: result: yes" >&5
10844 echo "${ECHO_T}yes" >&6
10845       break
10846     else
10847       echo "$as_me:$LINENO: result: no" >&5
10848 echo "${ECHO_T}no" >&6
10849     fi
10850   done
10851 fi
10852
10853 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10854   for ncn_progname in windres; do
10855     if test -n "$ncn_target_tool_prefix"; then
10856       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10857 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10858 echo "$as_me:$LINENO: checking for $ac_word" >&5
10859 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10860 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10861   echo $ECHO_N "(cached) $ECHO_C" >&6
10862 else
10863   if test -n "$WINDRES_FOR_TARGET"; then
10864   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10865 else
10866 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10867 for as_dir in $PATH
10868 do
10869   IFS=$as_save_IFS
10870   test -z "$as_dir" && as_dir=.
10871   for ac_exec_ext in '' $ac_executable_extensions; do
10872   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10873     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10874     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10875     break 2
10876   fi
10877 done
10878 done
10879
10880 fi
10881 fi
10882 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10883 if test -n "$WINDRES_FOR_TARGET"; then
10884   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10885 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10886 else
10887   echo "$as_me:$LINENO: result: no" >&5
10888 echo "${ECHO_T}no" >&6
10889 fi
10890
10891     fi
10892     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10893       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10894 set dummy ${ncn_progname}; ac_word=$2
10895 echo "$as_me:$LINENO: checking for $ac_word" >&5
10896 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10897 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10898   echo $ECHO_N "(cached) $ECHO_C" >&6
10899 else
10900   if test -n "$WINDRES_FOR_TARGET"; then
10901   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10902 else
10903 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10904 for as_dir in $PATH
10905 do
10906   IFS=$as_save_IFS
10907   test -z "$as_dir" && as_dir=.
10908   for ac_exec_ext in '' $ac_executable_extensions; do
10909   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10910     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10911     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10912     break 2
10913   fi
10914 done
10915 done
10916
10917 fi
10918 fi
10919 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10920 if test -n "$WINDRES_FOR_TARGET"; then
10921   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10922 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10923 else
10924   echo "$as_me:$LINENO: result: no" >&5
10925 echo "${ECHO_T}no" >&6
10926 fi
10927
10928     fi
10929     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10930   done
10931 fi
10932
10933 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10934   set dummy windres
10935   if test $build = $target ; then
10936     WINDRES_FOR_TARGET="$2"
10937   else
10938     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10939   fi
10940 else
10941   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
10942 fi
10943
10944 else
10945   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10946 fi
10947
10948
10949
10950
10951 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
10952   if test -n "$with_build_time_tools"; then
10953     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
10954 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
10955     if test -x $with_build_time_tools/windmc; then
10956       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
10957       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10958       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
10959 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
10960     else
10961       echo "$as_me:$LINENO: result: no" >&5
10962 echo "${ECHO_T}no" >&6
10963     fi
10964   elif test $build != $host && test $have_gcc_for_target = yes; then
10965     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
10966     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
10967     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10968   fi
10969 fi
10970 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10971   # Extract the first word of "windmc", so it can be a program name with args.
10972 set dummy windmc; ac_word=$2
10973 echo "$as_me:$LINENO: checking for $ac_word" >&5
10974 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10975 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
10976   echo $ECHO_N "(cached) $ECHO_C" >&6
10977 else
10978   case $WINDMC_FOR_TARGET in
10979   [\\/]* | ?:[\\/]*)
10980   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
10981   ;;
10982   *)
10983   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10984 for as_dir in $gcc_cv_tool_dirs
10985 do
10986   IFS=$as_save_IFS
10987   test -z "$as_dir" && as_dir=.
10988   for ac_exec_ext in '' $ac_executable_extensions; do
10989   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10990     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10991     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10992     break 2
10993   fi
10994 done
10995 done
10996
10997   ;;
10998 esac
10999 fi
11000 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11001
11002 if test -n "$WINDMC_FOR_TARGET"; then
11003   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11004 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11005 else
11006   echo "$as_me:$LINENO: result: no" >&5
11007 echo "${ECHO_T}no" >&6
11008 fi
11009
11010 fi
11011 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
11012
11013
11014 if test -n "$WINDMC_FOR_TARGET"; then
11015   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
11016 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11017   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11018 fi
11019
11020 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11021   for ncn_progname in windmc; do
11022     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11023 set dummy ${ncn_progname}; ac_word=$2
11024 echo "$as_me:$LINENO: checking for $ac_word" >&5
11025 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11026 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11027   echo $ECHO_N "(cached) $ECHO_C" >&6
11028 else
11029   if test -n "$WINDMC_FOR_TARGET"; then
11030   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11031 else
11032 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11033 for as_dir in $PATH
11034 do
11035   IFS=$as_save_IFS
11036   test -z "$as_dir" && as_dir=.
11037   for ac_exec_ext in '' $ac_executable_extensions; do
11038   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11039     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11040     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11041     break 2
11042   fi
11043 done
11044 done
11045
11046 fi
11047 fi
11048 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11049 if test -n "$WINDMC_FOR_TARGET"; then
11050   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11051 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11052 else
11053   echo "$as_me:$LINENO: result: no" >&5
11054 echo "${ECHO_T}no" >&6
11055 fi
11056
11057   done
11058 fi
11059
11060 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11061   for ncn_progname in windmc; do
11062     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11063 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11064     if test -x $with_build_time_tools/${ncn_progname}; then
11065       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11066       echo "$as_me:$LINENO: result: yes" >&5
11067 echo "${ECHO_T}yes" >&6
11068       break
11069     else
11070       echo "$as_me:$LINENO: result: no" >&5
11071 echo "${ECHO_T}no" >&6
11072     fi
11073   done
11074 fi
11075
11076 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11077   for ncn_progname in windmc; do
11078     if test -n "$ncn_target_tool_prefix"; then
11079       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11080 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11081 echo "$as_me:$LINENO: checking for $ac_word" >&5
11082 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11083 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11084   echo $ECHO_N "(cached) $ECHO_C" >&6
11085 else
11086   if test -n "$WINDMC_FOR_TARGET"; then
11087   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11088 else
11089 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11090 for as_dir in $PATH
11091 do
11092   IFS=$as_save_IFS
11093   test -z "$as_dir" && as_dir=.
11094   for ac_exec_ext in '' $ac_executable_extensions; do
11095   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11096     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11097     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11098     break 2
11099   fi
11100 done
11101 done
11102
11103 fi
11104 fi
11105 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11106 if test -n "$WINDMC_FOR_TARGET"; then
11107   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11108 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11109 else
11110   echo "$as_me:$LINENO: result: no" >&5
11111 echo "${ECHO_T}no" >&6
11112 fi
11113
11114     fi
11115     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11116       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11117 set dummy ${ncn_progname}; ac_word=$2
11118 echo "$as_me:$LINENO: checking for $ac_word" >&5
11119 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11120 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11121   echo $ECHO_N "(cached) $ECHO_C" >&6
11122 else
11123   if test -n "$WINDMC_FOR_TARGET"; then
11124   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11125 else
11126 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11127 for as_dir in $PATH
11128 do
11129   IFS=$as_save_IFS
11130   test -z "$as_dir" && as_dir=.
11131   for ac_exec_ext in '' $ac_executable_extensions; do
11132   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11133     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11134     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11135     break 2
11136   fi
11137 done
11138 done
11139
11140 fi
11141 fi
11142 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11143 if test -n "$WINDMC_FOR_TARGET"; then
11144   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11145 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11146 else
11147   echo "$as_me:$LINENO: result: no" >&5
11148 echo "${ECHO_T}no" >&6
11149 fi
11150
11151     fi
11152     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11153   done
11154 fi
11155
11156 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11157   set dummy windmc
11158   if test $build = $target ; then
11159     WINDMC_FOR_TARGET="$2"
11160   else
11161     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11162   fi
11163 else
11164   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11165 fi
11166
11167 else
11168   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11169 fi
11170
11171
11172 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11173
11174 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11175 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11176 if test "x${build}" != "x${host}" ; then
11177   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11178     # We already found the complete path
11179     ac_dir=`dirname $AR_FOR_TARGET`
11180     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11181 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11182   else
11183     # Canadian cross, just use what we found
11184     echo "$as_me:$LINENO: result: pre-installed" >&5
11185 echo "${ECHO_T}pre-installed" >&6
11186   fi
11187 else
11188   ok=yes
11189   case " ${configdirs} " in
11190     *" binutils "*) ;;
11191     *) ok=no ;;
11192   esac
11193
11194   if test $ok = yes; then
11195     # An in-tree tool is available and we can use it
11196     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11197     echo "$as_me:$LINENO: result: just compiled" >&5
11198 echo "${ECHO_T}just compiled" >&6
11199   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11200     # We already found the complete path
11201     ac_dir=`dirname $AR_FOR_TARGET`
11202     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11203 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11204   elif test "x$target" = "x$host"; then
11205     # We can use an host tool
11206     AR_FOR_TARGET='$(AR)'
11207     echo "$as_me:$LINENO: result: host tool" >&5
11208 echo "${ECHO_T}host tool" >&6
11209   else
11210     # We need a cross tool
11211     echo "$as_me:$LINENO: result: pre-installed" >&5
11212 echo "${ECHO_T}pre-installed" >&6
11213   fi
11214 fi
11215
11216 echo "$as_me:$LINENO: checking where to find the target as" >&5
11217 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11218 if test "x${build}" != "x${host}" ; then
11219   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11220     # We already found the complete path
11221     ac_dir=`dirname $AS_FOR_TARGET`
11222     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11223 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11224   else
11225     # Canadian cross, just use what we found
11226     echo "$as_me:$LINENO: result: pre-installed" >&5
11227 echo "${ECHO_T}pre-installed" >&6
11228   fi
11229 else
11230   ok=yes
11231   case " ${configdirs} " in
11232     *" gas "*) ;;
11233     *) ok=no ;;
11234   esac
11235
11236   if test $ok = yes; then
11237     # An in-tree tool is available and we can use it
11238     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11239     echo "$as_me:$LINENO: result: just compiled" >&5
11240 echo "${ECHO_T}just compiled" >&6
11241   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11242     # We already found the complete path
11243     ac_dir=`dirname $AS_FOR_TARGET`
11244     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11245 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11246   elif test "x$target" = "x$host"; then
11247     # We can use an host tool
11248     AS_FOR_TARGET='$(AS)'
11249     echo "$as_me:$LINENO: result: host tool" >&5
11250 echo "${ECHO_T}host tool" >&6
11251   else
11252     # We need a cross tool
11253     echo "$as_me:$LINENO: result: pre-installed" >&5
11254 echo "${ECHO_T}pre-installed" >&6
11255   fi
11256 fi
11257
11258 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11259 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11260 if test "x${build}" != "x${host}" ; then
11261   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11262     # We already found the complete path
11263     ac_dir=`dirname $CC_FOR_TARGET`
11264     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11265 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11266   else
11267     # Canadian cross, just use what we found
11268     echo "$as_me:$LINENO: result: pre-installed" >&5
11269 echo "${ECHO_T}pre-installed" >&6
11270   fi
11271 else
11272   ok=yes
11273   case " ${configdirs} " in
11274     *" gcc "*) ;;
11275     *) ok=no ;;
11276   esac
11277
11278   if test $ok = yes; then
11279     # An in-tree tool is available and we can use it
11280     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11281     echo "$as_me:$LINENO: result: just compiled" >&5
11282 echo "${ECHO_T}just compiled" >&6
11283   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11284     # We already found the complete path
11285     ac_dir=`dirname $CC_FOR_TARGET`
11286     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11287 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11288   elif test "x$target" = "x$host"; then
11289     # We can use an host tool
11290     CC_FOR_TARGET='$(CC)'
11291     echo "$as_me:$LINENO: result: host tool" >&5
11292 echo "${ECHO_T}host tool" >&6
11293   else
11294     # We need a cross tool
11295     echo "$as_me:$LINENO: result: pre-installed" >&5
11296 echo "${ECHO_T}pre-installed" >&6
11297   fi
11298 fi
11299
11300 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11301 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11302 if test "x${build}" != "x${host}" ; then
11303   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11304     # We already found the complete path
11305     ac_dir=`dirname $CXX_FOR_TARGET`
11306     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11307 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11308   else
11309     # Canadian cross, just use what we found
11310     echo "$as_me:$LINENO: result: pre-installed" >&5
11311 echo "${ECHO_T}pre-installed" >&6
11312   fi
11313 else
11314   ok=yes
11315   case " ${configdirs} " in
11316     *" gcc "*) ;;
11317     *) ok=no ;;
11318   esac
11319   case ,${enable_languages}, in
11320     *,c++,*) ;;
11321     *) ok=no ;;
11322   esac
11323   if test $ok = yes; then
11324     # An in-tree tool is available and we can use it
11325     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'
11326     echo "$as_me:$LINENO: result: just compiled" >&5
11327 echo "${ECHO_T}just compiled" >&6
11328   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11329     # We already found the complete path
11330     ac_dir=`dirname $CXX_FOR_TARGET`
11331     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11332 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11333   elif test "x$target" = "x$host"; then
11334     # We can use an host tool
11335     CXX_FOR_TARGET='$(CXX)'
11336     echo "$as_me:$LINENO: result: host tool" >&5
11337 echo "${ECHO_T}host tool" >&6
11338   else
11339     # We need a cross tool
11340     echo "$as_me:$LINENO: result: pre-installed" >&5
11341 echo "${ECHO_T}pre-installed" >&6
11342   fi
11343 fi
11344
11345 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11346 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11347 if test "x${build}" != "x${host}" ; then
11348   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11349     # We already found the complete path
11350     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11351     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11352 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11353   else
11354     # Canadian cross, just use what we found
11355     echo "$as_me:$LINENO: result: pre-installed" >&5
11356 echo "${ECHO_T}pre-installed" >&6
11357   fi
11358 else
11359   ok=yes
11360   case " ${configdirs} " in
11361     *" gcc "*) ;;
11362     *) ok=no ;;
11363   esac
11364   case ,${enable_languages}, in
11365     *,c++,*) ;;
11366     *) ok=no ;;
11367   esac
11368   if test $ok = yes; then
11369     # An in-tree tool is available and we can use it
11370     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'
11371     echo "$as_me:$LINENO: result: just compiled" >&5
11372 echo "${ECHO_T}just compiled" >&6
11373   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11374     # We already found the complete path
11375     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11376     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11377 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11378   elif test "x$target" = "x$host"; then
11379     # We can use an host tool
11380     RAW_CXX_FOR_TARGET='$(CXX)'
11381     echo "$as_me:$LINENO: result: host tool" >&5
11382 echo "${ECHO_T}host tool" >&6
11383   else
11384     # We need a cross tool
11385     echo "$as_me:$LINENO: result: pre-installed" >&5
11386 echo "${ECHO_T}pre-installed" >&6
11387   fi
11388 fi
11389
11390 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11391 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11392 if test "x${build}" != "x${host}" ; then
11393   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11394     # We already found the complete path
11395     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11396     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11397 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11398   else
11399     # Canadian cross, just use what we found
11400     echo "$as_me:$LINENO: result: pre-installed" >&5
11401 echo "${ECHO_T}pre-installed" >&6
11402   fi
11403 else
11404   ok=yes
11405   case " ${configdirs} " in
11406     *" binutils "*) ;;
11407     *) ok=no ;;
11408   esac
11409
11410   if test $ok = yes; then
11411     # An in-tree tool is available and we can use it
11412     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11413     echo "$as_me:$LINENO: result: just compiled" >&5
11414 echo "${ECHO_T}just compiled" >&6
11415   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11416     # We already found the complete path
11417     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11418     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11419 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11420   elif test "x$target" = "x$host"; then
11421     # We can use an host tool
11422     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11423     echo "$as_me:$LINENO: result: host tool" >&5
11424 echo "${ECHO_T}host tool" >&6
11425   else
11426     # We need a cross tool
11427     echo "$as_me:$LINENO: result: pre-installed" >&5
11428 echo "${ECHO_T}pre-installed" >&6
11429   fi
11430 fi
11431
11432 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11433 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11434 if test "x${build}" != "x${host}" ; then
11435   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11436     # We already found the complete path
11437     ac_dir=`dirname $GCC_FOR_TARGET`
11438     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11439 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11440   else
11441     # Canadian cross, just use what we found
11442     echo "$as_me:$LINENO: result: pre-installed" >&5
11443 echo "${ECHO_T}pre-installed" >&6
11444   fi
11445 else
11446   ok=yes
11447   case " ${configdirs} " in
11448     *" gcc "*) ;;
11449     *) ok=no ;;
11450   esac
11451
11452   if test $ok = yes; then
11453     # An in-tree tool is available and we can use it
11454     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11455     echo "$as_me:$LINENO: result: just compiled" >&5
11456 echo "${ECHO_T}just compiled" >&6
11457   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11458     # We already found the complete path
11459     ac_dir=`dirname $GCC_FOR_TARGET`
11460     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11461 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11462   elif test "x$target" = "x$host"; then
11463     # We can use an host tool
11464     GCC_FOR_TARGET='$()'
11465     echo "$as_me:$LINENO: result: host tool" >&5
11466 echo "${ECHO_T}host tool" >&6
11467   else
11468     # We need a cross tool
11469     echo "$as_me:$LINENO: result: pre-installed" >&5
11470 echo "${ECHO_T}pre-installed" >&6
11471   fi
11472 fi
11473
11474 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11475 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11476 if test "x${build}" != "x${host}" ; then
11477   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11478     # We already found the complete path
11479     ac_dir=`dirname $GCJ_FOR_TARGET`
11480     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11481 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11482   else
11483     # Canadian cross, just use what we found
11484     echo "$as_me:$LINENO: result: pre-installed" >&5
11485 echo "${ECHO_T}pre-installed" >&6
11486   fi
11487 else
11488   ok=yes
11489   case " ${configdirs} " in
11490     *" gcc "*) ;;
11491     *) ok=no ;;
11492   esac
11493   case ,${enable_languages}, in
11494     *,java,*) ;;
11495     *) ok=no ;;
11496   esac
11497   if test $ok = yes; then
11498     # An in-tree tool is available and we can use it
11499     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11500     echo "$as_me:$LINENO: result: just compiled" >&5
11501 echo "${ECHO_T}just compiled" >&6
11502   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11503     # We already found the complete path
11504     ac_dir=`dirname $GCJ_FOR_TARGET`
11505     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11506 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11507   elif test "x$target" = "x$host"; then
11508     # We can use an host tool
11509     GCJ_FOR_TARGET='$(GCJ)'
11510     echo "$as_me:$LINENO: result: host tool" >&5
11511 echo "${ECHO_T}host tool" >&6
11512   else
11513     # We need a cross tool
11514     echo "$as_me:$LINENO: result: pre-installed" >&5
11515 echo "${ECHO_T}pre-installed" >&6
11516   fi
11517 fi
11518
11519 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11520 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11521 if test "x${build}" != "x${host}" ; then
11522   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11523     # We already found the complete path
11524     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11525     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11526 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11527   else
11528     # Canadian cross, just use what we found
11529     echo "$as_me:$LINENO: result: pre-installed" >&5
11530 echo "${ECHO_T}pre-installed" >&6
11531   fi
11532 else
11533   ok=yes
11534   case " ${configdirs} " in
11535     *" gcc "*) ;;
11536     *) ok=no ;;
11537   esac
11538   case ,${enable_languages}, in
11539     *,fortran,*) ;;
11540     *) ok=no ;;
11541   esac
11542   if test $ok = yes; then
11543     # An in-tree tool is available and we can use it
11544     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11545     echo "$as_me:$LINENO: result: just compiled" >&5
11546 echo "${ECHO_T}just compiled" >&6
11547   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11548     # We already found the complete path
11549     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11550     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11551 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11552   elif test "x$target" = "x$host"; then
11553     # We can use an host tool
11554     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11555     echo "$as_me:$LINENO: result: host tool" >&5
11556 echo "${ECHO_T}host tool" >&6
11557   else
11558     # We need a cross tool
11559     echo "$as_me:$LINENO: result: pre-installed" >&5
11560 echo "${ECHO_T}pre-installed" >&6
11561   fi
11562 fi
11563
11564 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11565 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11566 if test "x${build}" != "x${host}" ; then
11567   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11568     # We already found the complete path
11569     ac_dir=`dirname $LD_FOR_TARGET`
11570     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11571 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11572   else
11573     # Canadian cross, just use what we found
11574     echo "$as_me:$LINENO: result: pre-installed" >&5
11575 echo "${ECHO_T}pre-installed" >&6
11576   fi
11577 else
11578   ok=yes
11579   case " ${configdirs} " in
11580     *" ld "*) ;;
11581     *) ok=no ;;
11582   esac
11583
11584   if test $ok = yes; then
11585     # An in-tree tool is available and we can use it
11586     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11587     echo "$as_me:$LINENO: result: just compiled" >&5
11588 echo "${ECHO_T}just compiled" >&6
11589   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11590     # We already found the complete path
11591     ac_dir=`dirname $LD_FOR_TARGET`
11592     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11593 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11594   elif test "x$target" = "x$host"; then
11595     # We can use an host tool
11596     LD_FOR_TARGET='$(LD)'
11597     echo "$as_me:$LINENO: result: host tool" >&5
11598 echo "${ECHO_T}host tool" >&6
11599   else
11600     # We need a cross tool
11601     echo "$as_me:$LINENO: result: pre-installed" >&5
11602 echo "${ECHO_T}pre-installed" >&6
11603   fi
11604 fi
11605
11606 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11607 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11608 if test "x${build}" != "x${host}" ; then
11609   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11610     # We already found the complete path
11611     ac_dir=`dirname $LIPO_FOR_TARGET`
11612     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11613 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11614   else
11615     # Canadian cross, just use what we found
11616     echo "$as_me:$LINENO: result: pre-installed" >&5
11617 echo "${ECHO_T}pre-installed" >&6
11618   fi
11619 else
11620   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11621     # We already found the complete path
11622     ac_dir=`dirname $LIPO_FOR_TARGET`
11623     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11624 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11625   elif test "x$target" = "x$host"; then
11626     # We can use an host tool
11627     LIPO_FOR_TARGET='$(LIPO)'
11628     echo "$as_me:$LINENO: result: host tool" >&5
11629 echo "${ECHO_T}host tool" >&6
11630   else
11631     # We need a cross tool
11632     echo "$as_me:$LINENO: result: pre-installed" >&5
11633 echo "${ECHO_T}pre-installed" >&6
11634   fi
11635 fi
11636
11637 echo "$as_me:$LINENO: checking where to find the target nm" >&5
11638 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11639 if test "x${build}" != "x${host}" ; then
11640   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11641     # We already found the complete path
11642     ac_dir=`dirname $NM_FOR_TARGET`
11643     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11644 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11645   else
11646     # Canadian cross, just use what we found
11647     echo "$as_me:$LINENO: result: pre-installed" >&5
11648 echo "${ECHO_T}pre-installed" >&6
11649   fi
11650 else
11651   ok=yes
11652   case " ${configdirs} " in
11653     *" binutils "*) ;;
11654     *) ok=no ;;
11655   esac
11656
11657   if test $ok = yes; then
11658     # An in-tree tool is available and we can use it
11659     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11660     echo "$as_me:$LINENO: result: just compiled" >&5
11661 echo "${ECHO_T}just compiled" >&6
11662   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11663     # We already found the complete path
11664     ac_dir=`dirname $NM_FOR_TARGET`
11665     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11666 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11667   elif test "x$target" = "x$host"; then
11668     # We can use an host tool
11669     NM_FOR_TARGET='$(NM)'
11670     echo "$as_me:$LINENO: result: host tool" >&5
11671 echo "${ECHO_T}host tool" >&6
11672   else
11673     # We need a cross tool
11674     echo "$as_me:$LINENO: result: pre-installed" >&5
11675 echo "${ECHO_T}pre-installed" >&6
11676   fi
11677 fi
11678
11679 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11680 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11681 if test "x${build}" != "x${host}" ; then
11682   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11683     # We already found the complete path
11684     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11685     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11686 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11687   else
11688     # Canadian cross, just use what we found
11689     echo "$as_me:$LINENO: result: pre-installed" >&5
11690 echo "${ECHO_T}pre-installed" >&6
11691   fi
11692 else
11693   ok=yes
11694   case " ${configdirs} " in
11695     *" binutils "*) ;;
11696     *) ok=no ;;
11697   esac
11698
11699   if test $ok = yes; then
11700     # An in-tree tool is available and we can use it
11701     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11702     echo "$as_me:$LINENO: result: just compiled" >&5
11703 echo "${ECHO_T}just compiled" >&6
11704   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11705     # We already found the complete path
11706     ac_dir=`dirname $OBJDUMP_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     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
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 ranlib" >&5
11722 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11723 if test "x${build}" != "x${host}" ; then
11724   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11725     # We already found the complete path
11726     ac_dir=`dirname $RANLIB_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     *" binutils "*) ;;
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     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11744     echo "$as_me:$LINENO: result: just compiled" >&5
11745 echo "${ECHO_T}just compiled" >&6
11746   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11747     # We already found the complete path
11748     ac_dir=`dirname $RANLIB_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     RANLIB_FOR_TARGET='$(RANLIB)'
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 strip" >&5
11764 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11765 if test "x${build}" != "x${host}" ; then
11766   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11767     # We already found the complete path
11768     ac_dir=`dirname $STRIP_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   ok=yes
11778   case " ${configdirs} " in
11779     *" binutils "*) ;;
11780     *) ok=no ;;
11781   esac
11782
11783   if test $ok = yes; then
11784     # An in-tree tool is available and we can use it
11785     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11786     echo "$as_me:$LINENO: result: just compiled" >&5
11787 echo "${ECHO_T}just compiled" >&6
11788   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11789     # We already found the complete path
11790     ac_dir=`dirname $STRIP_FOR_TARGET`
11791     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11792 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11793   elif test "x$target" = "x$host"; then
11794     # We can use an host tool
11795     STRIP_FOR_TARGET='$(STRIP)'
11796     echo "$as_me:$LINENO: result: host tool" >&5
11797 echo "${ECHO_T}host tool" >&6
11798   else
11799     # We need a cross tool
11800     echo "$as_me:$LINENO: result: pre-installed" >&5
11801 echo "${ECHO_T}pre-installed" >&6
11802   fi
11803 fi
11804
11805 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11806 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11807 if test "x${build}" != "x${host}" ; then
11808   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11809     # We already found the complete path
11810     ac_dir=`dirname $WINDRES_FOR_TARGET`
11811     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11812 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11813   else
11814     # Canadian cross, just use what we found
11815     echo "$as_me:$LINENO: result: pre-installed" >&5
11816 echo "${ECHO_T}pre-installed" >&6
11817   fi
11818 else
11819   ok=yes
11820   case " ${configdirs} " in
11821     *" binutils "*) ;;
11822     *) ok=no ;;
11823   esac
11824
11825   if test $ok = yes; then
11826     # An in-tree tool is available and we can use it
11827     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11828     echo "$as_me:$LINENO: result: just compiled" >&5
11829 echo "${ECHO_T}just compiled" >&6
11830   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11831     # We already found the complete path
11832     ac_dir=`dirname $WINDRES_FOR_TARGET`
11833     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11834 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11835   elif test "x$target" = "x$host"; then
11836     # We can use an host tool
11837     WINDRES_FOR_TARGET='$(WINDRES)'
11838     echo "$as_me:$LINENO: result: host tool" >&5
11839 echo "${ECHO_T}host tool" >&6
11840   else
11841     # We need a cross tool
11842     echo "$as_me:$LINENO: result: pre-installed" >&5
11843 echo "${ECHO_T}pre-installed" >&6
11844   fi
11845 fi
11846
11847 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
11848 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
11849 if test "x${build}" != "x${host}" ; then
11850   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11851     # We already found the complete path
11852     ac_dir=`dirname $WINDMC_FOR_TARGET`
11853     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11854 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11855   else
11856     # Canadian cross, just use what we found
11857     echo "$as_me:$LINENO: result: pre-installed" >&5
11858 echo "${ECHO_T}pre-installed" >&6
11859   fi
11860 else
11861   ok=yes
11862   case " ${configdirs} " in
11863     *" binutils "*) ;;
11864     *) ok=no ;;
11865   esac
11866
11867   if test $ok = yes; then
11868     # An in-tree tool is available and we can use it
11869     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
11870     echo "$as_me:$LINENO: result: just compiled" >&5
11871 echo "${ECHO_T}just compiled" >&6
11872   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11873     # We already found the complete path
11874     ac_dir=`dirname $WINDMC_FOR_TARGET`
11875     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11876 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11877   elif test "x$target" = "x$host"; then
11878     # We can use an host tool
11879     WINDMC_FOR_TARGET='$(WINDMC)'
11880     echo "$as_me:$LINENO: result: host tool" >&5
11881 echo "${ECHO_T}host tool" >&6
11882   else
11883     # We need a cross tool
11884     echo "$as_me:$LINENO: result: pre-installed" >&5
11885 echo "${ECHO_T}pre-installed" >&6
11886   fi
11887 fi
11888
11889
11890
11891
11892
11893 # Certain tools may need extra flags.
11894 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11895 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11896 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11897
11898 # When building target libraries, except in a Canadian cross, we use
11899 # the same toolchain as the compiler we just built.
11900 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11901 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11902 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11903 if test $host = $build; then
11904   case " $configdirs " in
11905     *" gcc "*)
11906       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11907       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11908       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11909       ;;
11910   esac
11911 fi
11912
11913
11914
11915
11916
11917 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11918 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11919 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11920 if test "${enable_maintainer_mode+set}" = set; then
11921   enableval="$enable_maintainer_mode"
11922   USE_MAINTAINER_MODE=$enableval
11923 else
11924   USE_MAINTAINER_MODE=no
11925 fi;
11926 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11927 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11928
11929
11930 if test "$USE_MAINTAINER_MODE" = yes; then
11931   MAINTAINER_MODE_TRUE=
11932   MAINTAINER_MODE_FALSE='#'
11933 else
11934   MAINTAINER_MODE_TRUE='#'
11935   MAINTAINER_MODE_FALSE=
11936 fi
11937 MAINT=$MAINTAINER_MODE_TRUE
11938
11939 # ---------------------
11940 # GCC bootstrap support
11941 # ---------------------
11942
11943 # Stage specific cflags for build.
11944 stage1_cflags="-g"
11945 case $build in
11946   vax-*-*)
11947     case ${GCC} in
11948       yes) stage1_cflags="-g -Wa,-J" ;;
11949       *) stage1_cflags="-g -J" ;;
11950     esac ;;
11951 esac
11952
11953 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
11954 if test "$GCC" = yes; then
11955   saved_CFLAGS="$CFLAGS"
11956
11957   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
11958   CFLAGS="$CFLAGS -fkeep-inline-functions"
11959   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
11960 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
11961   cat >conftest.$ac_ext <<_ACEOF
11962 /* confdefs.h.  */
11963 _ACEOF
11964 cat confdefs.h >>conftest.$ac_ext
11965 cat >>conftest.$ac_ext <<_ACEOF
11966 /* end confdefs.h.  */
11967
11968 #if (__GNUC__ < 3) \
11969     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
11970                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
11971 #error http://gcc.gnu.org/PR29382
11972 #endif
11973
11974 int
11975 main ()
11976 {
11977
11978   ;
11979   return 0;
11980 }
11981 _ACEOF
11982 rm -f conftest.$ac_objext
11983 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11984   (eval $ac_compile) 2>conftest.er1
11985   ac_status=$?
11986   grep -v '^ *+' conftest.er1 >conftest.err
11987   rm -f conftest.er1
11988   cat conftest.err >&5
11989   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11990   (exit $ac_status); } &&
11991          { ac_try='test -z "$ac_c_werror_flag"
11992                          || test ! -s conftest.err'
11993   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11994   (eval $ac_try) 2>&5
11995   ac_status=$?
11996   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11997   (exit $ac_status); }; } &&
11998          { ac_try='test -s conftest.$ac_objext'
11999   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
12000   (eval $ac_try) 2>&5
12001   ac_status=$?
12002   echo "$as_me:$LINENO: \$? = $ac_status" >&5
12003   (exit $ac_status); }; }; then
12004   echo "$as_me:$LINENO: result: yes" >&5
12005 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
12006 else
12007   echo "$as_me: failed program was:" >&5
12008 sed 's/^/| /' conftest.$ac_ext >&5
12009
12010 echo "$as_me:$LINENO: result: no" >&5
12011 echo "${ECHO_T}no" >&6
12012 fi
12013 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
12014
12015   CFLAGS="$saved_CFLAGS"
12016 fi
12017
12018
12019
12020 # Enable --enable-checking in stage1 of the compiler.
12021 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
12022 if test "${enable_stage1_checking+set}" = set; then
12023   enableval="$enable_stage1_checking"
12024   stage1_checking=--enable-checking=${enable_stage1_checking}
12025 else
12026   if test "x$enable_checking" = xno; then
12027   stage1_checking=--enable-checking=yes,types
12028 else
12029   stage1_checking=--enable-checking=types${enable_checking+,}$enable_checking
12030 fi
12031 fi;
12032
12033
12034 # Enable -Werror in bootstrap stage2 and later.
12035 # Check whether --enable-werror or --disable-werror was given.
12036 if test "${enable_werror+set}" = set; then
12037   enableval="$enable_werror"
12038
12039 else
12040   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12041   enable_werror=yes
12042 else
12043   enable_werror=no
12044 fi
12045 fi;
12046 case ${enable_werror} in
12047   yes) stage2_werror_flag="--enable-werror-always" ;;
12048   *) stage2_werror_flag="" ;;
12049 esac
12050
12051
12052 # Flags needed to enable html installing and building
12053
12054 # Check whether --with-datarootdir or --without-datarootdir was given.
12055 if test "${with_datarootdir+set}" = set; then
12056   withval="$with_datarootdir"
12057   datarootdir="\${prefix}/${withval}"
12058 else
12059   datarootdir="\${prefix}/share"
12060 fi;
12061
12062
12063 # Check whether --with-docdir or --without-docdir was given.
12064 if test "${with_docdir+set}" = set; then
12065   withval="$with_docdir"
12066   docdir="\${prefix}/${withval}"
12067 else
12068   docdir="\${datarootdir}/doc"
12069 fi;
12070
12071
12072 # Check whether --with-pdfdir or --without-pdfdir was given.
12073 if test "${with_pdfdir+set}" = set; then
12074   withval="$with_pdfdir"
12075   pdfdir="\${prefix}/${withval}"
12076 else
12077   pdfdir="\${docdir}"
12078 fi;
12079
12080
12081 # Check whether --with-htmldir or --without-htmldir was given.
12082 if test "${with_htmldir+set}" = set; then
12083   withval="$with_htmldir"
12084   htmldir="\${prefix}/${withval}"
12085 else
12086   htmldir="\${docdir}"
12087 fi;
12088
12089
12090
12091
12092
12093
12094           ac_config_files="$ac_config_files Makefile"
12095 cat >confcache <<\_ACEOF
12096 # This file is a shell script that caches the results of configure
12097 # tests run on this system so they can be shared between configure
12098 # scripts and configure runs, see configure's option --config-cache.
12099 # It is not useful on other systems.  If it contains results you don't
12100 # want to keep, you may remove or edit it.
12101 #
12102 # config.status only pays attention to the cache file if you give it
12103 # the --recheck option to rerun configure.
12104 #
12105 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12106 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12107 # following values.
12108
12109 _ACEOF
12110
12111 # The following way of writing the cache mishandles newlines in values,
12112 # but we know of no workaround that is simple, portable, and efficient.
12113 # So, don't put newlines in cache variables' values.
12114 # Ultrix sh set writes to stderr and can't be redirected directly,
12115 # and sets the high bit in the cache file unless we assign to the vars.
12116 {
12117   (set) 2>&1 |
12118     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12119     *ac_space=\ *)
12120       # `set' does not quote correctly, so add quotes (double-quote
12121       # substitution turns \\\\ into \\, and sed turns \\ into \).
12122       sed -n \
12123         "s/'/'\\\\''/g;
12124           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12125       ;;
12126     *)
12127       # `set' quotes correctly as required by POSIX, so do not add quotes.
12128       sed -n \
12129         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12130       ;;
12131     esac;
12132 } |
12133   sed '
12134      t clear
12135      : clear
12136      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12137      t end
12138      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12139      : end' >>confcache
12140 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12141   if test -w $cache_file; then
12142     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12143     cat confcache >$cache_file
12144   else
12145     echo "not updating unwritable cache $cache_file"
12146   fi
12147 fi
12148 rm -f confcache
12149
12150 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12151 # Let make expand exec_prefix.
12152 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12153
12154 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12155 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12156 # trailing colons and then remove the whole line if VPATH becomes empty
12157 # (actually we leave an empty line to preserve line numbers).
12158 if test "x$srcdir" = x.; then
12159   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12160 s/:*\$(srcdir):*/:/;
12161 s/:*\${srcdir}:*/:/;
12162 s/:*@srcdir@:*/:/;
12163 s/^\([^=]*=[     ]*\):*/\1/;
12164 s/:*$//;
12165 s/^[^=]*=[       ]*$//;
12166 }'
12167 fi
12168
12169 # Transform confdefs.h into DEFS.
12170 # Protect against shell expansion while executing Makefile rules.
12171 # Protect against Makefile macro expansion.
12172 #
12173 # If the first sed substitution is executed (which looks for macros that
12174 # take arguments), then we branch to the quote section.  Otherwise,
12175 # look for a macro that doesn't take arguments.
12176 cat >confdef2opt.sed <<\_ACEOF
12177 t clear
12178 : clear
12179 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12180 t quote
12181 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12182 t quote
12183 d
12184 : quote
12185 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12186 s,\[,\\&,g
12187 s,\],\\&,g
12188 s,\$,$$,g
12189 p
12190 _ACEOF
12191 # We use echo to avoid assuming a particular line-breaking character.
12192 # The extra dot is to prevent the shell from consuming trailing
12193 # line-breaks from the sub-command output.  A line-break within
12194 # single-quotes doesn't work because, if this script is created in a
12195 # platform that uses two characters for line-breaks (e.g., DOS), tr
12196 # would break.
12197 ac_LF_and_DOT=`echo; echo .`
12198 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12199 rm -f confdef2opt.sed
12200
12201
12202 ac_libobjs=
12203 ac_ltlibobjs=
12204 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12205   # 1. Remove the extension, and $U if already installed.
12206   ac_i=`echo "$ac_i" |
12207          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12208   # 2. Add them.
12209   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12210   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12211 done
12212 LIBOBJS=$ac_libobjs
12213
12214 LTLIBOBJS=$ac_ltlibobjs
12215
12216
12217
12218 : ${CONFIG_STATUS=./config.status}
12219 ac_clean_files_save=$ac_clean_files
12220 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12221 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12222 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12223 cat >$CONFIG_STATUS <<_ACEOF
12224 #! $SHELL
12225 # Generated by $as_me.
12226 # Run this file to recreate the current configuration.
12227 # Compiler output produced by configure, useful for debugging
12228 # configure, is in config.log if it exists.
12229
12230 debug=false
12231 ac_cs_recheck=false
12232 ac_cs_silent=false
12233 SHELL=\${CONFIG_SHELL-$SHELL}
12234 _ACEOF
12235
12236 cat >>$CONFIG_STATUS <<\_ACEOF
12237 ## --------------------- ##
12238 ## M4sh Initialization.  ##
12239 ## --------------------- ##
12240
12241 # Be Bourne compatible
12242 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12243   emulate sh
12244   NULLCMD=:
12245   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12246   # is contrary to our usage.  Disable this feature.
12247   alias -g '${1+"$@"}'='"$@"'
12248 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12249   set -o posix
12250 fi
12251 DUALCASE=1; export DUALCASE # for MKS sh
12252
12253 # Support unset when possible.
12254 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12255   as_unset=unset
12256 else
12257   as_unset=false
12258 fi
12259
12260
12261 # Work around bugs in pre-3.0 UWIN ksh.
12262 $as_unset ENV MAIL MAILPATH
12263 PS1='$ '
12264 PS2='> '
12265 PS4='+ '
12266
12267 # NLS nuisances.
12268 for as_var in \
12269   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12270   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12271   LC_TELEPHONE LC_TIME
12272 do
12273   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12274     eval $as_var=C; export $as_var
12275   else
12276     $as_unset $as_var
12277   fi
12278 done
12279
12280 # Required to use basename.
12281 if expr a : '\(a\)' >/dev/null 2>&1; then
12282   as_expr=expr
12283 else
12284   as_expr=false
12285 fi
12286
12287 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12288   as_basename=basename
12289 else
12290   as_basename=false
12291 fi
12292
12293
12294 # Name of the executable.
12295 as_me=`$as_basename "$0" ||
12296 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12297          X"$0" : 'X\(//\)$' \| \
12298          X"$0" : 'X\(/\)$' \| \
12299          .     : '\(.\)' 2>/dev/null ||
12300 echo X/"$0" |
12301     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12302           /^X\/\(\/\/\)$/{ s//\1/; q; }
12303           /^X\/\(\/\).*/{ s//\1/; q; }
12304           s/.*/./; q'`
12305
12306
12307 # PATH needs CR, and LINENO needs CR and PATH.
12308 # Avoid depending upon Character Ranges.
12309 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12310 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12311 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12312 as_cr_digits='0123456789'
12313 as_cr_alnum=$as_cr_Letters$as_cr_digits
12314
12315 # The user is always right.
12316 if test "${PATH_SEPARATOR+set}" != set; then
12317   echo "#! /bin/sh" >conf$$.sh
12318   echo  "exit 0"   >>conf$$.sh
12319   chmod +x conf$$.sh
12320   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12321     PATH_SEPARATOR=';'
12322   else
12323     PATH_SEPARATOR=:
12324   fi
12325   rm -f conf$$.sh
12326 fi
12327
12328
12329   as_lineno_1=$LINENO
12330   as_lineno_2=$LINENO
12331   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12332   test "x$as_lineno_1" != "x$as_lineno_2" &&
12333   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12334   # Find who we are.  Look in the path if we contain no path at all
12335   # relative or not.
12336   case $0 in
12337     *[\\/]* ) as_myself=$0 ;;
12338     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12339 for as_dir in $PATH
12340 do
12341   IFS=$as_save_IFS
12342   test -z "$as_dir" && as_dir=.
12343   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12344 done
12345
12346        ;;
12347   esac
12348   # We did not find ourselves, most probably we were run as `sh COMMAND'
12349   # in which case we are not to be found in the path.
12350   if test "x$as_myself" = x; then
12351     as_myself=$0
12352   fi
12353   if test ! -f "$as_myself"; then
12354     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12355 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12356    { (exit 1); exit 1; }; }
12357   fi
12358   case $CONFIG_SHELL in
12359   '')
12360     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12361 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12362 do
12363   IFS=$as_save_IFS
12364   test -z "$as_dir" && as_dir=.
12365   for as_base in sh bash ksh sh5; do
12366          case $as_dir in
12367          /*)
12368            if ("$as_dir/$as_base" -c '
12369   as_lineno_1=$LINENO
12370   as_lineno_2=$LINENO
12371   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12372   test "x$as_lineno_1" != "x$as_lineno_2" &&
12373   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12374              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12375              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12376              CONFIG_SHELL=$as_dir/$as_base
12377              export CONFIG_SHELL
12378              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12379            fi;;
12380          esac
12381        done
12382 done
12383 ;;
12384   esac
12385
12386   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12387   # uniformly replaced by the line number.  The first 'sed' inserts a
12388   # line-number line before each line; the second 'sed' does the real
12389   # work.  The second script uses 'N' to pair each line-number line
12390   # with the numbered line, and appends trailing '-' during
12391   # substitution so that $LINENO is not a special case at line end.
12392   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12393   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12394   sed '=' <$as_myself |
12395     sed '
12396       N
12397       s,$,-,
12398       : loop
12399       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12400       t loop
12401       s,-$,,
12402       s,^['$as_cr_digits']*\n,,
12403     ' >$as_me.lineno &&
12404   chmod +x $as_me.lineno ||
12405     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12406 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12407    { (exit 1); exit 1; }; }
12408
12409   # Don't try to exec as it changes $[0], causing all sort of problems
12410   # (the dirname of $[0] is not the place where we might find the
12411   # original and so on.  Autoconf is especially sensible to this).
12412   . ./$as_me.lineno
12413   # Exit status is that of the last command.
12414   exit
12415 }
12416
12417
12418 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12419   *c*,-n*) ECHO_N= ECHO_C='
12420 ' ECHO_T='      ' ;;
12421   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12422   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12423 esac
12424
12425 if expr a : '\(a\)' >/dev/null 2>&1; then
12426   as_expr=expr
12427 else
12428   as_expr=false
12429 fi
12430
12431 rm -f conf$$ conf$$.exe conf$$.file
12432 echo >conf$$.file
12433 if ln -s conf$$.file conf$$ 2>/dev/null; then
12434   # We could just check for DJGPP; but this test a) works b) is more generic
12435   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12436   if test -f conf$$.exe; then
12437     # Don't use ln at all; we don't have any links
12438     as_ln_s='cp -p'
12439   else
12440     as_ln_s='ln -s'
12441   fi
12442 elif ln conf$$.file conf$$ 2>/dev/null; then
12443   as_ln_s=ln
12444 else
12445   as_ln_s='cp -p'
12446 fi
12447 rm -f conf$$ conf$$.exe conf$$.file
12448
12449 if mkdir -p . 2>/dev/null; then
12450   as_mkdir_p=:
12451 else
12452   test -d ./-p && rmdir ./-p
12453   as_mkdir_p=false
12454 fi
12455
12456 as_executable_p="test -f"
12457
12458 # Sed expression to map a string onto a valid CPP name.
12459 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12460
12461 # Sed expression to map a string onto a valid variable name.
12462 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12463
12464
12465 # IFS
12466 # We need space, tab and new line, in precisely that order.
12467 as_nl='
12468 '
12469 IFS="   $as_nl"
12470
12471 # CDPATH.
12472 $as_unset CDPATH
12473
12474 exec 6>&1
12475
12476 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12477 # report actual input values of CONFIG_FILES etc. instead of their
12478 # values after options handling.  Logging --version etc. is OK.
12479 exec 5>>config.log
12480 {
12481   echo
12482   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12483 ## Running $as_me. ##
12484 _ASBOX
12485 } >&5
12486 cat >&5 <<_CSEOF
12487
12488 This file was extended by $as_me, which was
12489 generated by GNU Autoconf 2.59.  Invocation command line was
12490
12491   CONFIG_FILES    = $CONFIG_FILES
12492   CONFIG_HEADERS  = $CONFIG_HEADERS
12493   CONFIG_LINKS    = $CONFIG_LINKS
12494   CONFIG_COMMANDS = $CONFIG_COMMANDS
12495   $ $0 $@
12496
12497 _CSEOF
12498 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12499 echo >&5
12500 _ACEOF
12501
12502 # Files that config.status was made for.
12503 if test -n "$ac_config_files"; then
12504   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12505 fi
12506
12507 if test -n "$ac_config_headers"; then
12508   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12509 fi
12510
12511 if test -n "$ac_config_links"; then
12512   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12513 fi
12514
12515 if test -n "$ac_config_commands"; then
12516   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12517 fi
12518
12519 cat >>$CONFIG_STATUS <<\_ACEOF
12520
12521 ac_cs_usage="\
12522 \`$as_me' instantiates files from templates according to the
12523 current configuration.
12524
12525 Usage: $0 [OPTIONS] [FILE]...
12526
12527   -h, --help       print this help, then exit
12528   -V, --version    print version number, then exit
12529   -q, --quiet      do not print progress messages
12530   -d, --debug      don't remove temporary files
12531       --recheck    update $as_me by reconfiguring in the same conditions
12532   --file=FILE[:TEMPLATE]
12533                    instantiate the configuration file FILE
12534
12535 Configuration files:
12536 $config_files
12537
12538 Report bugs to <bug-autoconf@gnu.org>."
12539 _ACEOF
12540
12541 cat >>$CONFIG_STATUS <<_ACEOF
12542 ac_cs_version="\\
12543 config.status
12544 configured by $0, generated by GNU Autoconf 2.59,
12545   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12546
12547 Copyright (C) 2003 Free Software Foundation, Inc.
12548 This config.status script is free software; the Free Software Foundation
12549 gives unlimited permission to copy, distribute and modify it."
12550 srcdir=$srcdir
12551 INSTALL="$INSTALL"
12552 _ACEOF
12553
12554 cat >>$CONFIG_STATUS <<\_ACEOF
12555 # If no file are specified by the user, then we need to provide default
12556 # value.  By we need to know if files were specified by the user.
12557 ac_need_defaults=:
12558 while test $# != 0
12559 do
12560   case $1 in
12561   --*=*)
12562     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12563     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12564     ac_shift=:
12565     ;;
12566   -*)
12567     ac_option=$1
12568     ac_optarg=$2
12569     ac_shift=shift
12570     ;;
12571   *) # This is not an option, so the user has probably given explicit
12572      # arguments.
12573      ac_option=$1
12574      ac_need_defaults=false;;
12575   esac
12576
12577   case $ac_option in
12578   # Handling of the options.
12579 _ACEOF
12580 cat >>$CONFIG_STATUS <<\_ACEOF
12581   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12582     ac_cs_recheck=: ;;
12583   --version | --vers* | -V )
12584     echo "$ac_cs_version"; exit 0 ;;
12585   --he | --h)
12586     # Conflict between --help and --header
12587     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12588 Try \`$0 --help' for more information." >&5
12589 echo "$as_me: error: ambiguous option: $1
12590 Try \`$0 --help' for more information." >&2;}
12591    { (exit 1); exit 1; }; };;
12592   --help | --hel | -h )
12593     echo "$ac_cs_usage"; exit 0 ;;
12594   --debug | --d* | -d )
12595     debug=: ;;
12596   --file | --fil | --fi | --f )
12597     $ac_shift
12598     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12599     ac_need_defaults=false;;
12600   --header | --heade | --head | --hea )
12601     $ac_shift
12602     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12603     ac_need_defaults=false;;
12604   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12605   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12606     ac_cs_silent=: ;;
12607
12608   # This is an error.
12609   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12610 Try \`$0 --help' for more information." >&5
12611 echo "$as_me: error: unrecognized option: $1
12612 Try \`$0 --help' for more information." >&2;}
12613    { (exit 1); exit 1; }; } ;;
12614
12615   *) ac_config_targets="$ac_config_targets $1" ;;
12616
12617   esac
12618   shift
12619 done
12620
12621 ac_configure_extra_args=
12622
12623 if $ac_cs_silent; then
12624   exec 6>/dev/null
12625   ac_configure_extra_args="$ac_configure_extra_args --silent"
12626 fi
12627
12628 _ACEOF
12629 cat >>$CONFIG_STATUS <<_ACEOF
12630 if \$ac_cs_recheck; then
12631   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12632   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12633 fi
12634
12635 _ACEOF
12636
12637
12638
12639
12640
12641 cat >>$CONFIG_STATUS <<\_ACEOF
12642 for ac_config_target in $ac_config_targets
12643 do
12644   case "$ac_config_target" in
12645   # Handling of arguments.
12646   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12647   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12648 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12649    { (exit 1); exit 1; }; };;
12650   esac
12651 done
12652
12653 # If the user did not use the arguments to specify the items to instantiate,
12654 # then the envvar interface is used.  Set only those that are not.
12655 # We use the long form for the default assignment because of an extremely
12656 # bizarre bug on SunOS 4.1.3.
12657 if $ac_need_defaults; then
12658   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12659 fi
12660
12661 # Have a temporary directory for convenience.  Make it in the build tree
12662 # simply because there is no reason to put it here, and in addition,
12663 # creating and moving files from /tmp can sometimes cause problems.
12664 # Create a temporary directory, and hook for its removal unless debugging.
12665 $debug ||
12666 {
12667   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12668   trap '{ (exit 1); exit 1; }' 1 2 13 15
12669 }
12670
12671 # Create a (secure) tmp directory for tmp files.
12672
12673 {
12674   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12675   test -n "$tmp" && test -d "$tmp"
12676 }  ||
12677 {
12678   tmp=./confstat$$-$RANDOM
12679   (umask 077 && mkdir $tmp)
12680 } ||
12681 {
12682    echo "$me: cannot create a temporary directory in ." >&2
12683    { (exit 1); exit 1; }
12684 }
12685
12686 _ACEOF
12687
12688 cat >>$CONFIG_STATUS <<_ACEOF
12689
12690 #
12691 # CONFIG_FILES section.
12692 #
12693
12694 # No need to generate the scripts if there are no CONFIG_FILES.
12695 # This happens for instance when ./config.status config.h
12696 if test -n "\$CONFIG_FILES"; then
12697   # Protect against being on the right side of a sed subst in config.status.
12698   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12699    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12700 s,@SHELL@,$SHELL,;t t
12701 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12702 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12703 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12704 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12705 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12706 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12707 s,@exec_prefix@,$exec_prefix,;t t
12708 s,@prefix@,$prefix,;t t
12709 s,@program_transform_name@,$program_transform_name,;t t
12710 s,@bindir@,$bindir,;t t
12711 s,@sbindir@,$sbindir,;t t
12712 s,@libexecdir@,$libexecdir,;t t
12713 s,@datadir@,$datadir,;t t
12714 s,@sysconfdir@,$sysconfdir,;t t
12715 s,@sharedstatedir@,$sharedstatedir,;t t
12716 s,@localstatedir@,$localstatedir,;t t
12717 s,@libdir@,$libdir,;t t
12718 s,@includedir@,$includedir,;t t
12719 s,@oldincludedir@,$oldincludedir,;t t
12720 s,@infodir@,$infodir,;t t
12721 s,@mandir@,$mandir,;t t
12722 s,@build_alias@,$build_alias,;t t
12723 s,@host_alias@,$host_alias,;t t
12724 s,@target_alias@,$target_alias,;t t
12725 s,@DEFS@,$DEFS,;t t
12726 s,@ECHO_C@,$ECHO_C,;t t
12727 s,@ECHO_N@,$ECHO_N,;t t
12728 s,@ECHO_T@,$ECHO_T,;t t
12729 s,@LIBS@,$LIBS,;t t
12730 s,@build@,$build,;t t
12731 s,@build_cpu@,$build_cpu,;t t
12732 s,@build_vendor@,$build_vendor,;t t
12733 s,@build_os@,$build_os,;t t
12734 s,@build_noncanonical@,$build_noncanonical,;t t
12735 s,@host_noncanonical@,$host_noncanonical,;t t
12736 s,@target_noncanonical@,$target_noncanonical,;t t
12737 s,@host@,$host,;t t
12738 s,@host_cpu@,$host_cpu,;t t
12739 s,@host_vendor@,$host_vendor,;t t
12740 s,@host_os@,$host_os,;t t
12741 s,@target@,$target,;t t
12742 s,@target_cpu@,$target_cpu,;t t
12743 s,@target_vendor@,$target_vendor,;t t
12744 s,@target_os@,$target_os,;t t
12745 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12746 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12747 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12748 s,@LN@,$LN,;t t
12749 s,@LN_S@,$LN_S,;t t
12750 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12751 s,@build_libsubdir@,$build_libsubdir,;t t
12752 s,@build_subdir@,$build_subdir,;t t
12753 s,@host_subdir@,$host_subdir,;t t
12754 s,@target_subdir@,$target_subdir,;t t
12755 s,@CC@,$CC,;t t
12756 s,@CFLAGS@,$CFLAGS,;t t
12757 s,@LDFLAGS@,$LDFLAGS,;t t
12758 s,@CPPFLAGS@,$CPPFLAGS,;t t
12759 s,@ac_ct_CC@,$ac_ct_CC,;t t
12760 s,@EXEEXT@,$EXEEXT,;t t
12761 s,@OBJEXT@,$OBJEXT,;t t
12762 s,@CXX@,$CXX,;t t
12763 s,@CXXFLAGS@,$CXXFLAGS,;t t
12764 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12765 s,@GNATBIND@,$GNATBIND,;t t
12766 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12767 s,@GNATMAKE@,$GNATMAKE,;t t
12768 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12769 s,@do_compare@,$do_compare,;t t
12770 s,@gmplibs@,$gmplibs,;t t
12771 s,@gmpinc@,$gmpinc,;t t
12772 s,@stage1_languages@,$stage1_languages,;t t
12773 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12774 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12775 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12776 s,@tooldir@,$tooldir,;t t
12777 s,@build_tooldir@,$build_tooldir,;t t
12778 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12779 s,@GDB_TK@,$GDB_TK,;t t
12780 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12781 s,@build_configargs@,$build_configargs,;t t
12782 s,@build_configdirs@,$build_configdirs,;t t
12783 s,@host_configargs@,$host_configargs,;t t
12784 s,@configdirs@,$configdirs,;t t
12785 s,@target_configargs@,$target_configargs,;t t
12786 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12787 s,@config_shell@,$config_shell,;t t
12788 s,@YACC@,$YACC,;t t
12789 s,@BISON@,$BISON,;t t
12790 s,@M4@,$M4,;t t
12791 s,@LEX@,$LEX,;t t
12792 s,@FLEX@,$FLEX,;t t
12793 s,@MAKEINFO@,$MAKEINFO,;t t
12794 s,@EXPECT@,$EXPECT,;t t
12795 s,@RUNTEST@,$RUNTEST,;t t
12796 s,@AR@,$AR,;t t
12797 s,@AS@,$AS,;t t
12798 s,@DLLTOOL@,$DLLTOOL,;t t
12799 s,@LD@,$LD,;t t
12800 s,@LIPO@,$LIPO,;t t
12801 s,@NM@,$NM,;t t
12802 s,@RANLIB@,$RANLIB,;t t
12803 s,@STRIP@,$STRIP,;t t
12804 s,@WINDRES@,$WINDRES,;t t
12805 s,@WINDMC@,$WINDMC,;t t
12806 s,@OBJCOPY@,$OBJCOPY,;t t
12807 s,@OBJDUMP@,$OBJDUMP,;t t
12808 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12809 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12810 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12811 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12812 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12813 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12814 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12815 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12816 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12817 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12818 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12819 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12820 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12821 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12822 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12823 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12824 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12825 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12826 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12827 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12828 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12829 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12830 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12831 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12832 s,@MAINT@,$MAINT,;t t
12833 s,@stage1_cflags@,$stage1_cflags,;t t
12834 s,@stage1_checking@,$stage1_checking,;t t
12835 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12836 s,@datarootdir@,$datarootdir,;t t
12837 s,@docdir@,$docdir,;t t
12838 s,@pdfdir@,$pdfdir,;t t
12839 s,@htmldir@,$htmldir,;t t
12840 s,@LIBOBJS@,$LIBOBJS,;t t
12841 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12842 /@serialization_dependencies@/r $serialization_dependencies
12843 s,@serialization_dependencies@,,;t t
12844 /@host_makefile_frag@/r $host_makefile_frag
12845 s,@host_makefile_frag@,,;t t
12846 /@target_makefile_frag@/r $target_makefile_frag
12847 s,@target_makefile_frag@,,;t t
12848 /@alphaieee_frag@/r $alphaieee_frag
12849 s,@alphaieee_frag@,,;t t
12850 /@ospace_frag@/r $ospace_frag
12851 s,@ospace_frag@,,;t t
12852 CEOF
12853
12854 _ACEOF
12855
12856   cat >>$CONFIG_STATUS <<\_ACEOF
12857   # Split the substitutions into bite-sized pieces for seds with
12858   # small command number limits, like on Digital OSF/1 and HP-UX.
12859   ac_max_sed_lines=48
12860   ac_sed_frag=1 # Number of current file.
12861   ac_beg=1 # First line for current file.
12862   ac_end=$ac_max_sed_lines # Line after last line for current file.
12863   ac_more_lines=:
12864   ac_sed_cmds=
12865   while $ac_more_lines; do
12866     if test $ac_beg -gt 1; then
12867       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12868     else
12869       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12870     fi
12871     if test ! -s $tmp/subs.frag; then
12872       ac_more_lines=false
12873     else
12874       # The purpose of the label and of the branching condition is to
12875       # speed up the sed processing (if there are no `@' at all, there
12876       # is no need to browse any of the substitutions).
12877       # These are the two extra sed commands mentioned above.
12878       (echo ':t
12879   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12880       if test -z "$ac_sed_cmds"; then
12881         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12882       else
12883         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12884       fi
12885       ac_sed_frag=`expr $ac_sed_frag + 1`
12886       ac_beg=$ac_end
12887       ac_end=`expr $ac_end + $ac_max_sed_lines`
12888     fi
12889   done
12890   if test -z "$ac_sed_cmds"; then
12891     ac_sed_cmds=cat
12892   fi
12893 fi # test -n "$CONFIG_FILES"
12894
12895 _ACEOF
12896 cat >>$CONFIG_STATUS <<\_ACEOF
12897 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12898   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12899   case $ac_file in
12900   - | *:- | *:-:* ) # input from stdin
12901         cat >$tmp/stdin
12902         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12903         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12904   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12905         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12906   * )   ac_file_in=$ac_file.in ;;
12907   esac
12908
12909   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12910   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12911 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12912          X"$ac_file" : 'X\(//\)[^/]' \| \
12913          X"$ac_file" : 'X\(//\)$' \| \
12914          X"$ac_file" : 'X\(/\)' \| \
12915          .     : '\(.\)' 2>/dev/null ||
12916 echo X"$ac_file" |
12917     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12918           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12919           /^X\(\/\/\)$/{ s//\1/; q; }
12920           /^X\(\/\).*/{ s//\1/; q; }
12921           s/.*/./; q'`
12922   { if $as_mkdir_p; then
12923     mkdir -p "$ac_dir"
12924   else
12925     as_dir="$ac_dir"
12926     as_dirs=
12927     while test ! -d "$as_dir"; do
12928       as_dirs="$as_dir $as_dirs"
12929       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12930 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12931          X"$as_dir" : 'X\(//\)[^/]' \| \
12932          X"$as_dir" : 'X\(//\)$' \| \
12933          X"$as_dir" : 'X\(/\)' \| \
12934          .     : '\(.\)' 2>/dev/null ||
12935 echo X"$as_dir" |
12936     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12937           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12938           /^X\(\/\/\)$/{ s//\1/; q; }
12939           /^X\(\/\).*/{ s//\1/; q; }
12940           s/.*/./; q'`
12941     done
12942     test ! -n "$as_dirs" || mkdir $as_dirs
12943   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
12944 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
12945    { (exit 1); exit 1; }; }; }
12946
12947   ac_builddir=.
12948
12949 if test "$ac_dir" != .; then
12950   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
12951   # A "../" for each directory in $ac_dir_suffix.
12952   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
12953 else
12954   ac_dir_suffix= ac_top_builddir=
12955 fi
12956
12957 case $srcdir in
12958   .)  # No --srcdir option.  We are building in place.
12959     ac_srcdir=.
12960     if test -z "$ac_top_builddir"; then
12961        ac_top_srcdir=.
12962     else
12963        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
12964     fi ;;
12965   [\\/]* | ?:[\\/]* )  # Absolute path.
12966     ac_srcdir=$srcdir$ac_dir_suffix;
12967     ac_top_srcdir=$srcdir ;;
12968   *) # Relative path.
12969     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
12970     ac_top_srcdir=$ac_top_builddir$srcdir ;;
12971 esac
12972
12973 # Do not use `cd foo && pwd` to compute absolute paths, because
12974 # the directories may not exist.
12975 case `pwd` in
12976 .) ac_abs_builddir="$ac_dir";;
12977 *)
12978   case "$ac_dir" in
12979   .) ac_abs_builddir=`pwd`;;
12980   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
12981   *) ac_abs_builddir=`pwd`/"$ac_dir";;
12982   esac;;
12983 esac
12984 case $ac_abs_builddir in
12985 .) ac_abs_top_builddir=${ac_top_builddir}.;;
12986 *)
12987   case ${ac_top_builddir}. in
12988   .) ac_abs_top_builddir=$ac_abs_builddir;;
12989   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
12990   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
12991   esac;;
12992 esac
12993 case $ac_abs_builddir in
12994 .) ac_abs_srcdir=$ac_srcdir;;
12995 *)
12996   case $ac_srcdir in
12997   .) ac_abs_srcdir=$ac_abs_builddir;;
12998   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
12999   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
13000   esac;;
13001 esac
13002 case $ac_abs_builddir in
13003 .) ac_abs_top_srcdir=$ac_top_srcdir;;
13004 *)
13005   case $ac_top_srcdir in
13006   .) ac_abs_top_srcdir=$ac_abs_builddir;;
13007   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
13008   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
13009   esac;;
13010 esac
13011
13012
13013   case $INSTALL in
13014   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
13015   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
13016   esac
13017
13018   if test x"$ac_file" != x-; then
13019     { echo "$as_me:$LINENO: creating $ac_file" >&5
13020 echo "$as_me: creating $ac_file" >&6;}
13021     rm -f "$ac_file"
13022   fi
13023   # Let's still pretend it is `configure' which instantiates (i.e., don't
13024   # use $as_me), people would be surprised to read:
13025   #    /* config.h.  Generated by config.status.  */
13026   if test x"$ac_file" = x-; then
13027     configure_input=
13028   else
13029     configure_input="$ac_file.  "
13030   fi
13031   configure_input=$configure_input"Generated from `echo $ac_file_in |
13032                                      sed 's,.*/,,'` by configure."
13033
13034   # First look for the input files in the build tree, otherwise in the
13035   # src tree.
13036   ac_file_inputs=`IFS=:
13037     for f in $ac_file_in; do
13038       case $f in
13039       -) echo $tmp/stdin ;;
13040       [\\/$]*)
13041          # Absolute (can't be DOS-style, as IFS=:)
13042          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13043 echo "$as_me: error: cannot find input file: $f" >&2;}
13044    { (exit 1); exit 1; }; }
13045          echo "$f";;
13046       *) # Relative
13047          if test -f "$f"; then
13048            # Build tree
13049            echo "$f"
13050          elif test -f "$srcdir/$f"; then
13051            # Source tree
13052            echo "$srcdir/$f"
13053          else
13054            # /dev/null tree
13055            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13056 echo "$as_me: error: cannot find input file: $f" >&2;}
13057    { (exit 1); exit 1; }; }
13058          fi;;
13059       esac
13060     done` || { (exit 1); exit 1; }
13061 _ACEOF
13062 cat >>$CONFIG_STATUS <<_ACEOF
13063   sed "$ac_vpsub
13064 $extrasub
13065 _ACEOF
13066 cat >>$CONFIG_STATUS <<\_ACEOF
13067 :t
13068 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13069 s,@configure_input@,$configure_input,;t t
13070 s,@srcdir@,$ac_srcdir,;t t
13071 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13072 s,@top_srcdir@,$ac_top_srcdir,;t t
13073 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13074 s,@builddir@,$ac_builddir,;t t
13075 s,@abs_builddir@,$ac_abs_builddir,;t t
13076 s,@top_builddir@,$ac_top_builddir,;t t
13077 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13078 s,@INSTALL@,$ac_INSTALL,;t t
13079 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13080   rm -f $tmp/stdin
13081   if test x"$ac_file" != x-; then
13082     mv $tmp/out $ac_file
13083   else
13084     cat $tmp/out
13085     rm -f $tmp/out
13086   fi
13087
13088 done
13089 _ACEOF
13090
13091 cat >>$CONFIG_STATUS <<\_ACEOF
13092
13093 { (exit 0); exit 0; }
13094 _ACEOF
13095 chmod +x $CONFIG_STATUS
13096 ac_clean_files=$ac_clean_files_save
13097
13098
13099 # configure is writing to config.log, and then calls config.status.
13100 # config.status does its own redirection, appending to config.log.
13101 # Unfortunately, on DOS this fails, as config.log is still kept open
13102 # by configure, so config.status won't be able to write to it; its
13103 # output is simply discarded.  So we exec the FD to /dev/null,
13104 # effectively closing config.log, so it can be properly (re)opened and
13105 # appended to by config.status.  When coming back to configure, we
13106 # need to make the FD available again.
13107 if test "$no_create" != yes; then
13108   ac_cs_success=:
13109   ac_config_status_args=
13110   test "$silent" = yes &&
13111     ac_config_status_args="$ac_config_status_args --quiet"
13112   exec 5>/dev/null
13113   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13114   exec 5>>config.log
13115   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13116   # would make configure fail if this is the last instruction.
13117   $ac_cs_success || { (exit 1); exit 1; }
13118 fi
13119