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
2126 case "${target}" in
2127   *-*-chorusos)
2128     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2129     ;;
2130   powerpc-*-darwin* | i[3456789]86-*-darwin*)
2131     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes gdb gprof"
2132     noconfigdirs="$noconfigdirs sim target-rda"
2133     ;;
2134   *-*-darwin*)
2135     noconfigdirs="$noconfigdirs ld gas gdb gprof"
2136     noconfigdirs="$noconfigdirs sim target-rda"
2137     noconfigdirs="$noconfigdirs ${libgcj}"
2138     ;;
2139   *-*-freebsd[12] | *-*-freebsd[12].* | *-*-freebsd*aout*)
2140     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2141     ;;
2142   *-*-freebsd*)
2143     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2144     if test "x$with_gmp" = x && test "x$with_gmp_dir" = x \
2145         && test -f /usr/local/include/gmp.h; then
2146       with_gmp=/usr/local
2147     fi
2148
2149     # Skip some stuff that's unsupported on some FreeBSD configurations.
2150     case "${target}" in
2151       i*86-*-*) ;;
2152       alpha*-*-*) ;;
2153       *)
2154         noconfigdirs="$noconfigdirs ${libgcj}"
2155         ;;
2156     esac
2157     ;;
2158   *-*-kaos*)
2159     # Remove unsupported stuff on all kaOS configurations.
2160     skipdirs="target-libiberty ${libgcj} target-libstdc++-v3 target-librx"
2161     skipdirs="$skipdirs target-libobjc target-examples target-groff target-gperf"
2162     skipdirs="$skipdirs zlib fastjar target-libjava target-boehm-gc target-zlib"
2163     noconfigdirs="$noconfigdirs target-libgloss"
2164     ;;
2165   *-*-netbsd*)
2166     # Skip some stuff on all NetBSD configurations.
2167     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss"
2168
2169     # Skip some stuff that's unsupported on some NetBSD configurations.
2170     case "${target}" in
2171       i*86-*-netbsdelf*) ;;
2172       arm*-*-netbsdelf*) ;;
2173       *)
2174         noconfigdirs="$noconfigdirs ${libgcj}"
2175         ;;
2176     esac
2177     ;;
2178   *-*-netware*)
2179     noconfigdirs="$noconfigdirs target-newlib target-libiberty target-libgloss ${libgcj} target-libmudflap"
2180     ;;
2181   *-*-rtems*)
2182     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2183     ;;
2184     # The tpf target doesn't support gdb yet.
2185   *-*-tpf*)
2186     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty ${libgcj} target-libmudflap gdb tcl tk libgui itcl"
2187     ;;
2188   *-*-uclinux*)
2189     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-rda ${libgcj}"
2190     ;;
2191   *-*-vxworks*)
2192     noconfigdirs="$noconfigdirs target-newlib target-libgloss target-libiberty target-libstdc++-v3 ${libgcj}"
2193     ;;
2194   alpha*-dec-osf*)
2195     # ld works, but does not support shared libraries.
2196     # newlib is not 64 bit ready.  I'm not sure about fileutils.
2197     # gas doesn't generate exception information.
2198     noconfigdirs="$noconfigdirs gas ld fileutils target-newlib target-libgloss"
2199     ;;
2200   alpha*-*-*vms*)
2201     noconfigdirs="$noconfigdirs gdb ld target-newlib target-libgloss ${libgcj}"
2202     ;;
2203   alpha*-*-linux*)
2204     # newlib is not 64 bit ready
2205     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2206     ;;
2207   alpha*-*-*)
2208     # newlib is not 64 bit ready
2209     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2210     ;;
2211   am33_2.0-*-linux*)
2212     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2213     ;;
2214   sh-*-linux*)
2215     noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss"
2216     ;;
2217   sh*-*-pe|mips*-*-pe|*arm-wince-pe)
2218     noconfigdirs="$noconfigdirs ${libgcj}"
2219     noconfigdirs="$noconfigdirs target-examples"
2220     noconfigdirs="$noconfigdirs target-libiberty texinfo send-pr"
2221     noconfigdirs="$noconfigdirs tcl tk itcl libgui sim"
2222     noconfigdirs="$noconfigdirs expect dejagnu"
2223     # the C++ libraries don't build on top of CE's C libraries
2224     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2225     noconfigdirs="$noconfigdirs target-newlib"
2226     case "${host}" in
2227       *-*-cygwin*) ;; # keep gdb and readline
2228       *) noconfigdirs="$noconfigdirs gdb readline"
2229          ;;
2230     esac
2231     ;;
2232   arc-*-*)
2233     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2234     ;;
2235   arm-semi-aof )
2236     ;;
2237   arm-*-coff | strongarm-*-coff | xscale-*-coff)
2238     noconfigdirs="$noconfigdirs ${libgcj}"
2239     ;;
2240   arm-*-elf* | strongarm-*-elf* | xscale-*-elf* | arm*-*-eabi* )
2241     noconfigdirs="$noconfigdirs target-libffi target-qthreads"
2242     ;;
2243   arm*-*-linux-gnueabi)
2244     noconfigdirs="$noconfigdirs target-qthreads"
2245     noconfigdirs="$noconfigdirs target-libobjc"
2246     case ${with_newlib} in
2247       no) noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2248     esac
2249     ;;
2250   arm*-*-symbianelf*)
2251     noconfigdirs="$noconfigdirs ${libgcj} target-libiberty"
2252     ;;
2253   arm-*-pe*)
2254     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2255     ;;
2256   thumb-*-coff)
2257     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2258     ;;
2259   thumb-*-elf)
2260     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2261     ;;
2262   thumb-*-pe)
2263     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2264     ;;
2265   arm-*-riscix*)
2266     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2267     ;;
2268   avr-*-*)
2269     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2270     ;;
2271   bfin-*-*)
2272     noconfigdirs="$noconfigdirs gdb"
2273     if test x${is_cross_compiler} != xno ; then
2274       target_configdirs="${target_configdirs} target-bsp target-cygmon"
2275     fi
2276     ;;
2277   c4x-*-* | tic4x-*-*)
2278     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2279     ;;
2280   c54x*-*-* | tic54x-*-*)
2281     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj} gcc gdb newlib"
2282     ;;
2283   cris-*-* | crisv32-*-*)
2284     unsupported_languages="$unsupported_languages java"
2285     case "${target}" in
2286       *-*-aout)
2287         unsupported_languages="$unsupported_languages fortran"
2288         noconfigdirs="$noconfigdirs target-libffi target-boehm-gc";;
2289       *-*-elf)
2290         unsupported_languages="$unsupported_languages fortran"
2291         noconfigdirs="$noconfigdirs target-boehm-gc";;
2292       *-*-linux*)
2293         noconfigdirs="$noconfigdirs target-newlib target-libgloss";;
2294       *)
2295         unsupported_languages="$unsupported_languages fortran"
2296         noconfigdirs="$noconfigdirs ${libgcj} target-newlib target-libgloss";;
2297     esac
2298     ;;
2299   crx-*-*)
2300     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-mudflap ${libgcj}"
2301     ;;
2302   d10v-*-*)
2303     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2304     ;;
2305   d30v-*-*)
2306     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2307     ;;
2308   fr30-*-elf*)
2309     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2310     ;;
2311   frv-*-*)
2312     noconfigdirs="$noconfigdirs ${libgcj}"
2313     ;;
2314   h8300*-*-*)
2315     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2316     ;;
2317   h8500-*-*)
2318     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2319     ;;
2320   hppa1.1-*-osf* | hppa1.1-*-bsd* )
2321     ;;
2322   hppa*64*-*-linux* | parisc*64*-*-linux*)
2323     # In this case, it's because the hppa64-linux target is for
2324     # the kernel only at this point and has no libc, and thus no
2325     # headers, crt*.o, etc., all of which are needed by these.
2326     noconfigdirs="$noconfigdirs target-zlib"
2327     ;;
2328   parisc*-*-linux* | hppa*-*-linux*)
2329     ;;
2330   hppa*-*-*elf* | \
2331   hppa*-*-lites* | \
2332   hppa*-*-openbsd* | \
2333   hppa*64*-*-*)
2334     noconfigdirs="$noconfigdirs ${libgcj}"
2335     ;;
2336   hppa*-hp-hpux11*)
2337     noconfigdirs="$noconfigdirs ld shellutils"
2338     ;;
2339   hppa*-*-*)
2340     # According to Alexandre Oliva <aoliva@redhat.com>, libjava won't
2341     # build on HP-UX 10.20.
2342     noconfigdirs="$noconfigdirs ld shellutils ${libgcj}"
2343     ;;
2344   i960-*-*)
2345     noconfigdirs="$noconfigdirs ${libgcj} gdb"
2346     ;;
2347   ia64*-*-elf*)
2348     # No gdb support yet.
2349     noconfigdirs="$noconfigdirs readline mmalloc libgui itcl gdb"
2350     ;;
2351   ia64*-**-hpux*)
2352     # No gdb or ld support yet.
2353     noconfigdirs="$noconfigdirs ${libgcj} readline mmalloc libgui itcl gdb ld"
2354     ;;
2355   i370-*-opened*)
2356     ;;
2357   i[3456789]86-*-coff | i[3456789]86-*-elf)
2358     noconfigdirs="$noconfigdirs ${libgcj}"
2359     ;;
2360   i[3456789]86-*-linux*)
2361     # The GCC port for glibc1 has no MD_FALLBACK_FRAME_STATE_FOR, so let's
2362     # not build java stuff by default.
2363     case "${target}" in
2364       *-*-*libc1*)
2365         noconfigdirs="$noconfigdirs ${libgcj}";;
2366     esac
2367
2368     # This section makes it possible to build newlib natively on linux.
2369     # If we are using a cross compiler then don't configure newlib.
2370     if test x${is_cross_compiler} != xno ; then
2371       noconfigdirs="$noconfigdirs target-newlib"
2372     fi
2373     noconfigdirs="$noconfigdirs target-libgloss"
2374     # If we are not using a cross compiler, do configure newlib.
2375     # Note however, that newlib will only be configured in this situation
2376     # if the --with-newlib option has been given, because otherwise
2377     # 'target-newlib' will appear in skipdirs.
2378     ;;
2379   i[3456789]86-*-mingw32*)
2380     target_configdirs="$target_configdirs target-winsup"
2381     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2382     ;;
2383   x86_64-*-mingw*)
2384     target_configdirs="$target_configdirs target-winsup"
2385     noconfigdirs="$noconfigdirs expect target-libgloss target-newlib ${libgcj}"
2386     ;;
2387   *-*-cygwin*)
2388     target_configdirs="$target_configdirs target-libtermcap target-winsup"
2389     noconfigdirs="$noconfigdirs target-gperf target-libgloss ${libgcj}"
2390     # always build newlib if winsup directory is present.
2391     if test -d "$srcdir/winsup/cygwin"; then
2392       skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2393     elif test -d "$srcdir/newlib"; then
2394       echo "Warning: winsup/cygwin is missing so newlib can't be built."
2395     fi
2396     ;;
2397   i[3456789]86-moss-msdos | i[3456789]86-*-moss* | \
2398   i[3456789]86-*-uwin* | i[3456789]86-*-interix* )
2399     ;;
2400   i[3456789]86-*-pe)
2401     noconfigdirs="$noconfigdirs target-libstdc++-v3 target-libgloss ${libgcj}"
2402     ;;
2403   i[3456789]86-*-sco3.2v5*)
2404     # The linker does not yet know about weak symbols in COFF,
2405     # and is not configured to handle mixed ELF and COFF.
2406     noconfigdirs="$noconfigdirs ld target-libgloss ${libgcj}"
2407     ;;
2408   i[3456789]86-*-sco*)
2409     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2410     ;;
2411   i[3456789]86-*-solaris2*)
2412     noconfigdirs="$noconfigdirs target-libgloss"
2413     ;;
2414   i[3456789]86-*-sysv4*)
2415     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2416     ;;
2417   i[3456789]86-*-beos*)
2418     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2419     ;;
2420   i[3456789]86-*-rdos*)
2421     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2422     ;;
2423   m32r-*-*)
2424     noconfigdirs="$noconfigdirs ${libgcj}"
2425     ;;
2426   m68hc11-*-*|m6811-*-*|m68hc12-*-*|m6812-*-*)
2427     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2428     ;;
2429   m68k-*-elf*)
2430     noconfigdirs="$noconfigdirs ${libgcj}"
2431     ;;
2432   m68k-*-coff*)
2433     noconfigdirs="$noconfigdirs ${libgcj}"
2434     ;;
2435   mcore-*-pe*)
2436   # The EPOC C++ environment does not support exceptions or rtti,
2437   # and so building libstdc++-v3 tends not to always work.
2438     noconfigdirs="$noconfigdirs target-libstdc++-v3"
2439     ;;
2440   mmix-*-*)
2441     noconfigdirs="$noconfigdirs target-libffi target-boehm-gc gdb libgloss"
2442     unsupported_languages="$unsupported_languages fortran java"
2443     ;;
2444   mn10200-*-*)
2445     noconfigdirs="$noconfigdirs ${libgcj}"
2446     ;;
2447   mn10300-*-*)
2448     noconfigdirs="$noconfigdirs ${libgcj}"
2449     ;;
2450   mt-*-*)
2451     noconfigdirs="$noconfigdirs sim"
2452     ;;
2453   powerpc-*-aix*)
2454     # copied from rs6000-*-* entry
2455     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2456     ;;
2457   powerpc*-*-winnt* | powerpc*-*-pe* | ppc*-*-pe)
2458     target_configdirs="$target_configdirs target-winsup"
2459     noconfigdirs="$noconfigdirs gdb tcl tk make expect target-libgloss itcl gnuserv ${libgcj}"
2460     # always build newlib.
2461     skipdirs=`echo " ${skipdirs} " | sed -e 's/ target-newlib / /'`
2462     ;;
2463     # This is temporary until we can link against shared libraries
2464   powerpcle-*-solaris*)
2465     noconfigdirs="$noconfigdirs gdb sim make tcl tk expect itcl gnuserv ${libgcj}"
2466     ;;
2467   powerpc-*-beos*)
2468     noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss ${libgcj}"
2469     ;;
2470   powerpc-*-eabi)
2471     noconfigdirs="$noconfigdirs ${libgcj}"
2472     ;;
2473   powerpc-*-eabi* | powerpcle-*-eabi* | powerpc-*-rtems* )
2474     ;;
2475   rs6000-*-lynxos*)
2476     noconfigdirs="$noconfigdirs target-newlib gprof ${libgcj}"
2477     ;;
2478   rs6000-*-aix*)
2479     noconfigdirs="$noconfigdirs gprof target-libgloss target-libssp ${libgcj}"
2480     ;;
2481   rs6000-*-*)
2482     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2483     ;;
2484   m68k-apollo-*)
2485     noconfigdirs="$noconfigdirs ld binutils gprof target-libgloss ${libgcj}"
2486     ;;
2487   mips*-*-irix5*)
2488     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2489     ;;
2490   mips*-*-irix6*)
2491     # Linking libjava exceeds command-line length limits on at least
2492     # IRIX 6.2, but not on IRIX 6.5.
2493     # Also, boehm-gc won't build on IRIX 6.5, according to Jeffrey Oldham
2494     # <oldham@codesourcery.com>
2495     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2496     ;;
2497   mips*-*-bsd*)
2498     noconfigdirs="$noconfigdirs gprof target-libgloss ${libgcj}"
2499     ;;
2500   mips64*-*-linux*)
2501     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2502     ;;
2503   mips*-*-linux*)
2504     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2505     ;;
2506   mips*-*-*)
2507     noconfigdirs="$noconfigdirs gprof ${libgcj}"
2508     ;;
2509   romp-*-*)
2510     noconfigdirs="$noconfigdirs bfd binutils ld gas opcodes target-libgloss ${libgcj}"
2511     ;;
2512   sh-*-* | sh64-*-*)
2513     case "${host}" in
2514       i[3456789]86-*-vsta) ;; # don't add gprof back in
2515       i[3456789]86-*-go32*) ;; # don't add gprof back in
2516       i[3456789]86-*-msdosdjgpp*) ;; # don't add gprof back in
2517       *) skipdirs=`echo " ${skipdirs} " | sed -e 's/ gprof / /'` ;;
2518     esac
2519     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2520     ;;
2521   sparc-*-elf*)
2522     noconfigdirs="$noconfigdirs ${libgcj}"
2523     ;;
2524   sparc64-*-elf*)
2525     noconfigdirs="$noconfigdirs ${libgcj}"
2526     ;;
2527   sparclite-*-*)
2528     noconfigdirs="$noconfigdirs ${libgcj}"
2529     ;;
2530   sparc-*-sunos4*)
2531     noconfigdirs="$noconfigdirs ${libgcj}"
2532     if test x${is_cross_compiler} != xno ; then
2533            noconfigdirs="$noconfigdirs gdb target-newlib target-libgloss"
2534     else
2535            use_gnu_ld=no
2536     fi
2537     ;;
2538   sparc-*-solaris2.[0-6] | sparc-*-solaris2.[0-6].*)
2539     noconfigdirs="$noconfigdirs ${libgcj}"
2540     ;;
2541   sparc-*-solaris* | sparc64-*-solaris* | sparcv9-*-solaris*)
2542     ;;
2543   spu-*-*)
2544     skipdirs="target-libssp"
2545     ;;
2546   v810-*-*)
2547     noconfigdirs="$noconfigdirs bfd binutils gas gcc gdb ld target-libstdc++-v3 opcodes target-libgloss ${libgcj}"
2548     ;;
2549   v850-*-*)
2550     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2551     ;;
2552   v850e-*-*)
2553     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2554     ;;
2555   v850ea-*-*)
2556     noconfigdirs="$noconfigdirs target-libgloss ${libgcj}"
2557     ;;
2558   vax-*-vms)
2559     noconfigdirs="$noconfigdirs bfd binutils gdb ld target-newlib opcodes target-libgloss ${libgcj}"
2560     ;;
2561   vax-*-*)
2562     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2563     ;;
2564   xtensa-*-*)
2565     noconfigdirs="$noconfigdirs ${libgcj}"
2566     ;;
2567   ip2k-*-*)
2568     noconfigdirs="$noconfigdirs target-libiberty target-libstdc++-v3 ${libgcj}"
2569     ;;
2570   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
2571     noconfigdirs="$noconfigdirs target-newlib target-libgloss"
2572     ;;
2573   *-*-lynxos*)
2574     noconfigdirs="$noconfigdirs target-newlib target-libgloss ${libgcj}"
2575     ;;
2576   *-*-*)
2577     noconfigdirs="$noconfigdirs ${libgcj}"
2578     ;;
2579 esac
2580
2581 # If we aren't building newlib, then don't build libgloss, since libgloss
2582 # depends upon some newlib header files.
2583 case "${noconfigdirs}" in
2584   *target-libgloss*) ;;
2585   *target-newlib*) noconfigdirs="$noconfigdirs target-libgloss" ;;
2586 esac
2587
2588 # Work in distributions that contain no compiler tools, like Autoconf.
2589 tentative_cc=""
2590 host_makefile_frag=/dev/null
2591 if test -d ${srcdir}/config ; then
2592 case "${host}" in
2593   m68k-hp-hpux*)
2594     # Avoid "too much defining" errors from HPUX compiler.
2595     tentative_cc="cc -Wp,-H256000"
2596     # If "ar" in $PATH is GNU ar, the symbol table may need rebuilding.
2597     # If it's HP/UX ar, this should be harmless.
2598     RANLIB="ar ts"
2599     ;;
2600   m68k-apollo-sysv*)
2601     tentative_cc="cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DUSG"
2602     ;;
2603   m68k-apollo-bsd*)
2604     #None of the Apollo compilers can compile gas or binutils.  The preprocessor
2605     # chokes on bfd, the compiler won't let you assign integers to enums, and
2606     # other problems.  Defining CC to gcc is a questionable way to say "don't use
2607     # the apollo compiler" (the preferred version of GCC could be called cc,
2608     # or whatever), but I'm not sure leaving CC as cc is any better...
2609     #CC=cc -A ansi -A runtype,any -A systype,any -U__STDC__ -DNO_STDARG
2610     # Used to have BISON=yacc.
2611     tentative_cc=gcc
2612     ;;
2613   m88k-dg-dgux*)
2614     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2615     ;;
2616   m88k-harris-cxux*)
2617     # Under CX/UX, we want to tell the compiler to use ANSI mode.
2618     tentative_cc="cc -Xa"
2619     host_makefile_frag="config/mh-cxux"
2620     ;;
2621   m88k-motorola-sysv*)
2622     ;;
2623   mips*-dec-ultrix*)
2624     tentative_cc="cc -Wf,-XNg1000"
2625     host_makefile_frag="config/mh-decstation"
2626     ;;
2627   mips*-nec-sysv4*)
2628     # The C compiler on NEC MIPS SVR4 needs bigger tables.
2629     tentative_cc="cc -ZXNd=5000 -ZXNg=1000"
2630     host_makefile_frag="config/mh-necv4"
2631     ;;
2632   mips*-sgi-irix4*)
2633     # Tell compiler to use K&R C.  We can't compile under the SGI Ansi
2634     # environment.  Also bump switch table size so that cp-parse will
2635     # compile.  Bump string length limit so linker builds.
2636     tentative_cc="cc -cckr -Wf,-XNg1500 -Wf,-XNk1000 -Wf,-XNh2000 -Wf,-XNl8192"
2637     ;;
2638   mips*-*-sysv4*)
2639     host_makefile_frag="config/mh-sysv4"
2640     ;;
2641   mips*-*-sysv*)
2642     # This is for a MIPS running RISC/os 4.52C.
2643
2644     # This is needed for GDB, but needs to be in the top-level make because
2645     # if a library is compiled with the bsd headers and gets linked with the
2646     # sysv system libraries all hell can break loose (e.g. a jmp_buf might be
2647     # a different size).
2648     # ptrace(2) apparently has problems in the BSD environment.  No workaround is
2649     # known except to select the sysv environment.  Could we use /proc instead?
2650     # These "sysv environments" and "bsd environments" often end up being a pain.
2651     #
2652     # This is not part of CFLAGS because perhaps not all C compilers have this
2653     # option.
2654     tentative_cc="cc -systype sysv"
2655     ;;
2656   i370-ibm-opened*)
2657     tentative_cc="c89"
2658     ;;
2659   i[3456789]86-*-sysv5*)
2660     host_makefile_frag="config/mh-sysv5"
2661     ;;
2662   i[3456789]86-*-dgux*)
2663     tentative_cc="gcc -Wall -ansi -D__using_DGUX"
2664     host_makefile_frag="config/mh-dgux386"
2665     ;;
2666   i[3456789]86-ncr-sysv4.3*)
2667     # The MetaWare compiler will generate a copyright message unless you
2668     # turn it off by adding the -Hnocopyr flag.
2669     tentative_cc="cc -Hnocopyr"
2670     ;;
2671   i[3456789]86-ncr-sysv4*)
2672     # for an NCR 3000 (i486/SVR4) system.
2673     # The NCR 3000 ships with a MetaWare compiler installed as /bin/cc.
2674     # This compiler not only emits obnoxious copyright messages every time
2675     # you run it, but it chokes and dies on a whole bunch of GNU source
2676     # files.  Default to using the AT&T compiler installed in /usr/ccs/ATT/cc.
2677     tentative_cc="/usr/ccs/ATT/cc"
2678     host_makefile_frag="config/mh-ncr3000"
2679     ;;
2680   i[3456789]86-*-sco3.2v5*)
2681     ;;
2682   i[3456789]86-*-sco*)
2683     # The native C compiler botches some simple uses of const.  Unfortunately,
2684     # it doesn't defined anything like "__sco__" for us to test for in ansidecl.h.
2685     tentative_cc="cc -Dconst="
2686     host_makefile_frag="config/mh-sco"
2687     ;;
2688   i[3456789]86-*-udk*)
2689     host_makefile_frag="config/mh-sysv5"
2690     ;;
2691   i[3456789]86-*-solaris2*)
2692     host_makefile_frag="config/mh-sysv4"
2693     ;;
2694   i[3456789]86-*-msdosdjgpp*)
2695     host_makefile_frag="config/mh-djgpp"
2696     ;;
2697   *-cygwin*)
2698     host_makefile_frag="config/mh-cygwin"
2699     ;;
2700   *-mingw32*)
2701     ;;
2702   *-mingw64*)
2703     ;;
2704   *-interix*)
2705     host_makefile_frag="config/mh-interix"
2706     ;;
2707   vax-*-ultrix2*)
2708     # The old BSD pcc isn't up to compiling parts of gdb so use gcc
2709     tentative_cc=gcc
2710     ;;
2711   *-*-solaris2*)
2712     host_makefile_frag="config/mh-solaris"
2713     ;;
2714   m68k-sun-sunos*)
2715     # Sun's C compiler needs the -J flag to be able to compile cp-parse.c
2716     # without overflowing the jump tables (-J says to use a 32 bit table)
2717     tentative_cc="cc -J"
2718     ;;
2719   *-hp-hpux*)
2720     tentative_cc="cc -Wp,-H256000"
2721     ;;
2722   *-*-hiux*)
2723     tentative_cc="cc -Wp,-H256000"
2724     ;;
2725   rs6000-*-lynxos*)
2726     # /bin/cc is less than useful for our purposes.  Always use GCC
2727     tentative_cc="/usr/cygnus/progressive/bin/gcc"
2728     host_makefile_frag="config/mh-lynxrs6k"
2729     ;;
2730   powerpc-*-darwin*)
2731     host_makefile_frag="config/mh-ppc-darwin"
2732     ;;
2733   powerpc-*-aix*)
2734     host_makefile_frag="config/mh-ppc-aix"
2735     ;;
2736   rs6000-*-aix*)
2737     host_makefile_frag="config/mh-ppc-aix"
2738     ;;
2739   *-*-lynxos*)
2740     # /bin/cc is less than useful for our purposes.  Always use GCC
2741     tentative_cc="/bin/gcc"
2742     ;;
2743   *-*-sysv4*)
2744     host_makefile_frag="config/mh-sysv4"
2745     ;;
2746   # This is placed last to prevent interfering with the cases above.
2747   i[3456789]86-*-*)
2748     # Build the stage2 and stage3 compilers with -fomit-frame-pointer.
2749     host_makefile_frag="config/mh-x86omitfp"
2750     ;;
2751 esac
2752 fi
2753
2754 # If we aren't going to be using gcc, see if we can extract a definition
2755 # of CC from the fragment.
2756 # Actually, use the 'pre-extracted' version above.
2757 if test -z "${CC}" && test "${build}" = "${host}" ; then
2758   IFS="${IFS=   }"; save_ifs="$IFS"; IFS="${IFS}:"
2759   found=
2760   for dir in $PATH; do
2761     test -z "$dir" && dir=.
2762     if test -f $dir/gcc; then
2763       found=yes
2764       break
2765     fi
2766   done
2767   IFS="$save_ifs"
2768   if test -z "${found}" && test -n "${tentative_cc}" ; then
2769     CC=$tentative_cc
2770   fi
2771 fi
2772
2773 if test "${build}" != "${host}" ; then
2774   CC_FOR_BUILD=${CC_FOR_BUILD-gcc}
2775 else
2776   CC_FOR_BUILD="\$(CC)"
2777 fi
2778
2779 ac_ext=c
2780 ac_cpp='$CPP $CPPFLAGS'
2781 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2782 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2783 ac_compiler_gnu=$ac_cv_c_compiler_gnu
2784 if test -n "$ac_tool_prefix"; then
2785   # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
2786 set dummy ${ac_tool_prefix}gcc; ac_word=$2
2787 echo "$as_me:$LINENO: checking for $ac_word" >&5
2788 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2789 if test "${ac_cv_prog_CC+set}" = set; then
2790   echo $ECHO_N "(cached) $ECHO_C" >&6
2791 else
2792   if test -n "$CC"; then
2793   ac_cv_prog_CC="$CC" # Let the user override the test.
2794 else
2795 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2796 for as_dir in $PATH
2797 do
2798   IFS=$as_save_IFS
2799   test -z "$as_dir" && as_dir=.
2800   for ac_exec_ext in '' $ac_executable_extensions; do
2801   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2802     ac_cv_prog_CC="${ac_tool_prefix}gcc"
2803     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2804     break 2
2805   fi
2806 done
2807 done
2808
2809 fi
2810 fi
2811 CC=$ac_cv_prog_CC
2812 if test -n "$CC"; then
2813   echo "$as_me:$LINENO: result: $CC" >&5
2814 echo "${ECHO_T}$CC" >&6
2815 else
2816   echo "$as_me:$LINENO: result: no" >&5
2817 echo "${ECHO_T}no" >&6
2818 fi
2819
2820 fi
2821 if test -z "$ac_cv_prog_CC"; then
2822   ac_ct_CC=$CC
2823   # Extract the first word of "gcc", so it can be a program name with args.
2824 set dummy gcc; ac_word=$2
2825 echo "$as_me:$LINENO: checking for $ac_word" >&5
2826 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2827 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2828   echo $ECHO_N "(cached) $ECHO_C" >&6
2829 else
2830   if test -n "$ac_ct_CC"; then
2831   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2832 else
2833 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2834 for as_dir in $PATH
2835 do
2836   IFS=$as_save_IFS
2837   test -z "$as_dir" && as_dir=.
2838   for ac_exec_ext in '' $ac_executable_extensions; do
2839   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2840     ac_cv_prog_ac_ct_CC="gcc"
2841     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2842     break 2
2843   fi
2844 done
2845 done
2846
2847 fi
2848 fi
2849 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2850 if test -n "$ac_ct_CC"; then
2851   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2852 echo "${ECHO_T}$ac_ct_CC" >&6
2853 else
2854   echo "$as_me:$LINENO: result: no" >&5
2855 echo "${ECHO_T}no" >&6
2856 fi
2857
2858   CC=$ac_ct_CC
2859 else
2860   CC="$ac_cv_prog_CC"
2861 fi
2862
2863 if test -z "$CC"; then
2864   if test -n "$ac_tool_prefix"; then
2865   # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
2866 set dummy ${ac_tool_prefix}cc; ac_word=$2
2867 echo "$as_me:$LINENO: checking for $ac_word" >&5
2868 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2869 if test "${ac_cv_prog_CC+set}" = set; then
2870   echo $ECHO_N "(cached) $ECHO_C" >&6
2871 else
2872   if test -n "$CC"; then
2873   ac_cv_prog_CC="$CC" # Let the user override the test.
2874 else
2875 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2876 for as_dir in $PATH
2877 do
2878   IFS=$as_save_IFS
2879   test -z "$as_dir" && as_dir=.
2880   for ac_exec_ext in '' $ac_executable_extensions; do
2881   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2882     ac_cv_prog_CC="${ac_tool_prefix}cc"
2883     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2884     break 2
2885   fi
2886 done
2887 done
2888
2889 fi
2890 fi
2891 CC=$ac_cv_prog_CC
2892 if test -n "$CC"; then
2893   echo "$as_me:$LINENO: result: $CC" >&5
2894 echo "${ECHO_T}$CC" >&6
2895 else
2896   echo "$as_me:$LINENO: result: no" >&5
2897 echo "${ECHO_T}no" >&6
2898 fi
2899
2900 fi
2901 if test -z "$ac_cv_prog_CC"; then
2902   ac_ct_CC=$CC
2903   # Extract the first word of "cc", so it can be a program name with args.
2904 set dummy cc; ac_word=$2
2905 echo "$as_me:$LINENO: checking for $ac_word" >&5
2906 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2907 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2908   echo $ECHO_N "(cached) $ECHO_C" >&6
2909 else
2910   if test -n "$ac_ct_CC"; then
2911   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2912 else
2913 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2914 for as_dir in $PATH
2915 do
2916   IFS=$as_save_IFS
2917   test -z "$as_dir" && as_dir=.
2918   for ac_exec_ext in '' $ac_executable_extensions; do
2919   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2920     ac_cv_prog_ac_ct_CC="cc"
2921     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2922     break 2
2923   fi
2924 done
2925 done
2926
2927 fi
2928 fi
2929 ac_ct_CC=$ac_cv_prog_ac_ct_CC
2930 if test -n "$ac_ct_CC"; then
2931   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
2932 echo "${ECHO_T}$ac_ct_CC" >&6
2933 else
2934   echo "$as_me:$LINENO: result: no" >&5
2935 echo "${ECHO_T}no" >&6
2936 fi
2937
2938   CC=$ac_ct_CC
2939 else
2940   CC="$ac_cv_prog_CC"
2941 fi
2942
2943 fi
2944 if test -z "$CC"; then
2945   # Extract the first word of "cc", so it can be a program name with args.
2946 set dummy cc; ac_word=$2
2947 echo "$as_me:$LINENO: checking for $ac_word" >&5
2948 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
2949 if test "${ac_cv_prog_CC+set}" = set; then
2950   echo $ECHO_N "(cached) $ECHO_C" >&6
2951 else
2952   if test -n "$CC"; then
2953   ac_cv_prog_CC="$CC" # Let the user override the test.
2954 else
2955   ac_prog_rejected=no
2956 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2957 for as_dir in $PATH
2958 do
2959   IFS=$as_save_IFS
2960   test -z "$as_dir" && as_dir=.
2961   for ac_exec_ext in '' $ac_executable_extensions; do
2962   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
2963     if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
2964        ac_prog_rejected=yes
2965        continue
2966      fi
2967     ac_cv_prog_CC="cc"
2968     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2969     break 2
2970   fi
2971 done
2972 done
2973
2974 if test $ac_prog_rejected = yes; then
2975   # We found a bogon in the path, so make sure we never use it.
2976   set dummy $ac_cv_prog_CC
2977   shift
2978   if test $# != 0; then
2979     # We chose a different compiler from the bogus one.
2980     # However, it has the same basename, so the bogon will be chosen
2981     # first if we set CC to just the basename; use the full file name.
2982     shift
2983     ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
2984   fi
2985 fi
2986 fi
2987 fi
2988 CC=$ac_cv_prog_CC
2989 if test -n "$CC"; then
2990   echo "$as_me:$LINENO: result: $CC" >&5
2991 echo "${ECHO_T}$CC" >&6
2992 else
2993   echo "$as_me:$LINENO: result: no" >&5
2994 echo "${ECHO_T}no" >&6
2995 fi
2996
2997 fi
2998 if test -z "$CC"; then
2999   if test -n "$ac_tool_prefix"; then
3000   for ac_prog in cl
3001   do
3002     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3003 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3004 echo "$as_me:$LINENO: checking for $ac_word" >&5
3005 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3006 if test "${ac_cv_prog_CC+set}" = set; then
3007   echo $ECHO_N "(cached) $ECHO_C" >&6
3008 else
3009   if test -n "$CC"; then
3010   ac_cv_prog_CC="$CC" # Let the user override the test.
3011 else
3012 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3013 for as_dir in $PATH
3014 do
3015   IFS=$as_save_IFS
3016   test -z "$as_dir" && as_dir=.
3017   for ac_exec_ext in '' $ac_executable_extensions; do
3018   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3019     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3020     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3021     break 2
3022   fi
3023 done
3024 done
3025
3026 fi
3027 fi
3028 CC=$ac_cv_prog_CC
3029 if test -n "$CC"; then
3030   echo "$as_me:$LINENO: result: $CC" >&5
3031 echo "${ECHO_T}$CC" >&6
3032 else
3033   echo "$as_me:$LINENO: result: no" >&5
3034 echo "${ECHO_T}no" >&6
3035 fi
3036
3037     test -n "$CC" && break
3038   done
3039 fi
3040 if test -z "$CC"; then
3041   ac_ct_CC=$CC
3042   for ac_prog in cl
3043 do
3044   # Extract the first word of "$ac_prog", so it can be a program name with args.
3045 set dummy $ac_prog; ac_word=$2
3046 echo "$as_me:$LINENO: checking for $ac_word" >&5
3047 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3048 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3049   echo $ECHO_N "(cached) $ECHO_C" >&6
3050 else
3051   if test -n "$ac_ct_CC"; then
3052   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3053 else
3054 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3055 for as_dir in $PATH
3056 do
3057   IFS=$as_save_IFS
3058   test -z "$as_dir" && as_dir=.
3059   for ac_exec_ext in '' $ac_executable_extensions; do
3060   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3061     ac_cv_prog_ac_ct_CC="$ac_prog"
3062     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3063     break 2
3064   fi
3065 done
3066 done
3067
3068 fi
3069 fi
3070 ac_ct_CC=$ac_cv_prog_ac_ct_CC
3071 if test -n "$ac_ct_CC"; then
3072   echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3073 echo "${ECHO_T}$ac_ct_CC" >&6
3074 else
3075   echo "$as_me:$LINENO: result: no" >&5
3076 echo "${ECHO_T}no" >&6
3077 fi
3078
3079   test -n "$ac_ct_CC" && break
3080 done
3081
3082   CC=$ac_ct_CC
3083 fi
3084
3085 fi
3086
3087
3088 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3089 See \`config.log' for more details." >&5
3090 echo "$as_me: error: no acceptable C compiler found in \$PATH
3091 See \`config.log' for more details." >&2;}
3092    { (exit 1); exit 1; }; }
3093
3094 # Provide some information about the compiler.
3095 echo "$as_me:$LINENO:" \
3096      "checking for C compiler version" >&5
3097 ac_compiler=`set X $ac_compile; echo $2`
3098 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3099   (eval $ac_compiler --version </dev/null >&5) 2>&5
3100   ac_status=$?
3101   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3102   (exit $ac_status); }
3103 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3104   (eval $ac_compiler -v </dev/null >&5) 2>&5
3105   ac_status=$?
3106   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3107   (exit $ac_status); }
3108 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3109   (eval $ac_compiler -V </dev/null >&5) 2>&5
3110   ac_status=$?
3111   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3112   (exit $ac_status); }
3113
3114 cat >conftest.$ac_ext <<_ACEOF
3115 /* confdefs.h.  */
3116 _ACEOF
3117 cat confdefs.h >>conftest.$ac_ext
3118 cat >>conftest.$ac_ext <<_ACEOF
3119 /* end confdefs.h.  */
3120
3121 int
3122 main ()
3123 {
3124
3125   ;
3126   return 0;
3127 }
3128 _ACEOF
3129 ac_clean_files_save=$ac_clean_files
3130 ac_clean_files="$ac_clean_files a.out a.exe b.out"
3131 # Try to create an executable without -o first, disregard a.out.
3132 # It will help us diagnose broken compilers, and finding out an intuition
3133 # of exeext.
3134 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
3135 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6
3136 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
3137 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5
3138   (eval $ac_link_default) 2>&5
3139   ac_status=$?
3140   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3141   (exit $ac_status); }; then
3142   # Find the output, starting from the most likely.  This scheme is
3143 # not robust to junk in `.', hence go to wildcards (a.*) only as a last
3144 # resort.
3145
3146 # Be careful to initialize this variable, since it used to be cached.
3147 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.
3148 ac_cv_exeext=
3149 # b.out is created by i960 compilers.
3150 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out
3151 do
3152   test -f "$ac_file" || continue
3153   case $ac_file in
3154     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )
3155         ;;
3156     conftest.$ac_ext )
3157         # This is the source file.
3158         ;;
3159     [ab].out )
3160         # We found the default executable, but exeext='' is most
3161         # certainly right.
3162         break;;
3163     *.* )
3164         ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3165         # FIXME: I believe we export ac_cv_exeext for Libtool,
3166         # but it would be cool to find out if it's true.  Does anybody
3167         # maintain Libtool? --akim.
3168         export ac_cv_exeext
3169         break;;
3170     * )
3171         break;;
3172   esac
3173 done
3174 else
3175   echo "$as_me: failed program was:" >&5
3176 sed 's/^/| /' conftest.$ac_ext >&5
3177
3178 { { echo "$as_me:$LINENO: error: C compiler cannot create executables
3179 See \`config.log' for more details." >&5
3180 echo "$as_me: error: C compiler cannot create executables
3181 See \`config.log' for more details." >&2;}
3182    { (exit 77); exit 77; }; }
3183 fi
3184
3185 ac_exeext=$ac_cv_exeext
3186 echo "$as_me:$LINENO: result: $ac_file" >&5
3187 echo "${ECHO_T}$ac_file" >&6
3188
3189 # Check the compiler produces executables we can run.  If not, either
3190 # the compiler is broken, or we cross compile.
3191 echo "$as_me:$LINENO: checking whether the C compiler works" >&5
3192 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6
3193 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0
3194 # If not cross compiling, check that we can run a simple program.
3195 if test "$cross_compiling" != yes; then
3196   if { ac_try='./$ac_file'
3197   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3198   (eval $ac_try) 2>&5
3199   ac_status=$?
3200   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3201   (exit $ac_status); }; }; then
3202     cross_compiling=no
3203   else
3204     if test "$cross_compiling" = maybe; then
3205         cross_compiling=yes
3206     else
3207         { { echo "$as_me:$LINENO: error: cannot run C compiled programs.
3208 If you meant to cross compile, use \`--host'.
3209 See \`config.log' for more details." >&5
3210 echo "$as_me: error: cannot run C compiled programs.
3211 If you meant to cross compile, use \`--host'.
3212 See \`config.log' for more details." >&2;}
3213    { (exit 1); exit 1; }; }
3214     fi
3215   fi
3216 fi
3217 echo "$as_me:$LINENO: result: yes" >&5
3218 echo "${ECHO_T}yes" >&6
3219
3220 rm -f a.out a.exe conftest$ac_cv_exeext b.out
3221 ac_clean_files=$ac_clean_files_save
3222 # Check the compiler produces executables we can run.  If not, either
3223 # the compiler is broken, or we cross compile.
3224 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5
3225 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6
3226 echo "$as_me:$LINENO: result: $cross_compiling" >&5
3227 echo "${ECHO_T}$cross_compiling" >&6
3228
3229 echo "$as_me:$LINENO: checking for suffix of executables" >&5
3230 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6
3231 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
3232   (eval $ac_link) 2>&5
3233   ac_status=$?
3234   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3235   (exit $ac_status); }; then
3236   # If both `conftest.exe' and `conftest' are `present' (well, observable)
3237 # catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
3238 # work properly (i.e., refer to `conftest.exe'), while it won't with
3239 # `rm'.
3240 for ac_file in conftest.exe conftest conftest.*; do
3241   test -f "$ac_file" || continue
3242   case $ac_file in
3243     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;
3244     *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
3245           export ac_cv_exeext
3246           break;;
3247     * ) break;;
3248   esac
3249 done
3250 else
3251   { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link
3252 See \`config.log' for more details." >&5
3253 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link
3254 See \`config.log' for more details." >&2;}
3255    { (exit 1); exit 1; }; }
3256 fi
3257
3258 rm -f conftest$ac_cv_exeext
3259 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5
3260 echo "${ECHO_T}$ac_cv_exeext" >&6
3261
3262 rm -f conftest.$ac_ext
3263 EXEEXT=$ac_cv_exeext
3264 ac_exeext=$EXEEXT
3265 echo "$as_me:$LINENO: checking for suffix of object files" >&5
3266 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6
3267 if test "${ac_cv_objext+set}" = set; then
3268   echo $ECHO_N "(cached) $ECHO_C" >&6
3269 else
3270   cat >conftest.$ac_ext <<_ACEOF
3271 /* confdefs.h.  */
3272 _ACEOF
3273 cat confdefs.h >>conftest.$ac_ext
3274 cat >>conftest.$ac_ext <<_ACEOF
3275 /* end confdefs.h.  */
3276
3277 int
3278 main ()
3279 {
3280
3281   ;
3282   return 0;
3283 }
3284 _ACEOF
3285 rm -f conftest.o conftest.obj
3286 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3287   (eval $ac_compile) 2>&5
3288   ac_status=$?
3289   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3290   (exit $ac_status); }; then
3291   for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do
3292   case $ac_file in
3293     *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;
3294     *) ac_cv_objext=`expr "$ac_file" : '.*\.\(.*\)'`
3295        break;;
3296   esac
3297 done
3298 else
3299   echo "$as_me: failed program was:" >&5
3300 sed 's/^/| /' conftest.$ac_ext >&5
3301
3302 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile
3303 See \`config.log' for more details." >&5
3304 echo "$as_me: error: cannot compute suffix of object files: cannot compile
3305 See \`config.log' for more details." >&2;}
3306    { (exit 1); exit 1; }; }
3307 fi
3308
3309 rm -f conftest.$ac_cv_objext conftest.$ac_ext
3310 fi
3311 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5
3312 echo "${ECHO_T}$ac_cv_objext" >&6
3313 OBJEXT=$ac_cv_objext
3314 ac_objext=$OBJEXT
3315 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3316 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
3317 if test "${ac_cv_c_compiler_gnu+set}" = set; then
3318   echo $ECHO_N "(cached) $ECHO_C" >&6
3319 else
3320   cat >conftest.$ac_ext <<_ACEOF
3321 /* confdefs.h.  */
3322 _ACEOF
3323 cat confdefs.h >>conftest.$ac_ext
3324 cat >>conftest.$ac_ext <<_ACEOF
3325 /* end confdefs.h.  */
3326
3327 int
3328 main ()
3329 {
3330 #ifndef __GNUC__
3331        choke me
3332 #endif
3333
3334   ;
3335   return 0;
3336 }
3337 _ACEOF
3338 rm -f conftest.$ac_objext
3339 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3340   (eval $ac_compile) 2>conftest.er1
3341   ac_status=$?
3342   grep -v '^ *+' conftest.er1 >conftest.err
3343   rm -f conftest.er1
3344   cat conftest.err >&5
3345   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3346   (exit $ac_status); } &&
3347          { ac_try='test -z "$ac_c_werror_flag"
3348                          || test ! -s conftest.err'
3349   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3350   (eval $ac_try) 2>&5
3351   ac_status=$?
3352   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3353   (exit $ac_status); }; } &&
3354          { ac_try='test -s conftest.$ac_objext'
3355   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3356   (eval $ac_try) 2>&5
3357   ac_status=$?
3358   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3359   (exit $ac_status); }; }; then
3360   ac_compiler_gnu=yes
3361 else
3362   echo "$as_me: failed program was:" >&5
3363 sed 's/^/| /' conftest.$ac_ext >&5
3364
3365 ac_compiler_gnu=no
3366 fi
3367 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3368 ac_cv_c_compiler_gnu=$ac_compiler_gnu
3369
3370 fi
3371 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
3372 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
3373 GCC=`test $ac_compiler_gnu = yes && echo yes`
3374 ac_test_CFLAGS=${CFLAGS+set}
3375 ac_save_CFLAGS=$CFLAGS
3376 CFLAGS="-g"
3377 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
3378 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
3379 if test "${ac_cv_prog_cc_g+set}" = set; then
3380   echo $ECHO_N "(cached) $ECHO_C" >&6
3381 else
3382   cat >conftest.$ac_ext <<_ACEOF
3383 /* confdefs.h.  */
3384 _ACEOF
3385 cat confdefs.h >>conftest.$ac_ext
3386 cat >>conftest.$ac_ext <<_ACEOF
3387 /* end confdefs.h.  */
3388
3389 int
3390 main ()
3391 {
3392
3393   ;
3394   return 0;
3395 }
3396 _ACEOF
3397 rm -f conftest.$ac_objext
3398 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3399   (eval $ac_compile) 2>conftest.er1
3400   ac_status=$?
3401   grep -v '^ *+' conftest.er1 >conftest.err
3402   rm -f conftest.er1
3403   cat conftest.err >&5
3404   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3405   (exit $ac_status); } &&
3406          { ac_try='test -z "$ac_c_werror_flag"
3407                          || test ! -s conftest.err'
3408   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3409   (eval $ac_try) 2>&5
3410   ac_status=$?
3411   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3412   (exit $ac_status); }; } &&
3413          { ac_try='test -s conftest.$ac_objext'
3414   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3415   (eval $ac_try) 2>&5
3416   ac_status=$?
3417   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3418   (exit $ac_status); }; }; then
3419   ac_cv_prog_cc_g=yes
3420 else
3421   echo "$as_me: failed program was:" >&5
3422 sed 's/^/| /' conftest.$ac_ext >&5
3423
3424 ac_cv_prog_cc_g=no
3425 fi
3426 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3427 fi
3428 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
3429 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
3430 if test "$ac_test_CFLAGS" = set; then
3431   CFLAGS=$ac_save_CFLAGS
3432 elif test $ac_cv_prog_cc_g = yes; then
3433   if test "$GCC" = yes; then
3434     CFLAGS="-g -O2"
3435   else
3436     CFLAGS="-g"
3437   fi
3438 else
3439   if test "$GCC" = yes; then
3440     CFLAGS="-O2"
3441   else
3442     CFLAGS=
3443   fi
3444 fi
3445 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
3446 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
3447 if test "${ac_cv_prog_cc_stdc+set}" = set; then
3448   echo $ECHO_N "(cached) $ECHO_C" >&6
3449 else
3450   ac_cv_prog_cc_stdc=no
3451 ac_save_CC=$CC
3452 cat >conftest.$ac_ext <<_ACEOF
3453 /* confdefs.h.  */
3454 _ACEOF
3455 cat confdefs.h >>conftest.$ac_ext
3456 cat >>conftest.$ac_ext <<_ACEOF
3457 /* end confdefs.h.  */
3458 #include <stdarg.h>
3459 #include <stdio.h>
3460 #include <sys/types.h>
3461 #include <sys/stat.h>
3462 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
3463 struct buf { int x; };
3464 FILE * (*rcsopen) (struct buf *, struct stat *, int);
3465 static char *e (p, i)
3466      char **p;
3467      int i;
3468 {
3469   return p[i];
3470 }
3471 static char *f (char * (*g) (char **, int), char **p, ...)
3472 {
3473   char *s;
3474   va_list v;
3475   va_start (v,p);
3476   s = g (p, va_arg (v,int));
3477   va_end (v);
3478   return s;
3479 }
3480
3481 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
3482    function prototypes and stuff, but not '\xHH' hex character constants.
3483    These don't provoke an error unfortunately, instead are silently treated
3484    as 'x'.  The following induces an error, until -std1 is added to get
3485    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
3486    array size at least.  It's necessary to write '\x00'==0 to get something
3487    that's true only with -std1.  */
3488 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
3489
3490 int test (int i, double x);
3491 struct s1 {int (*f) (int a);};
3492 struct s2 {int (*f) (double a);};
3493 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
3494 int argc;
3495 char **argv;
3496 int
3497 main ()
3498 {
3499 return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
3500   ;
3501   return 0;
3502 }
3503 _ACEOF
3504 # Don't try gcc -ansi; that turns off useful extensions and
3505 # breaks some systems' header files.
3506 # AIX                   -qlanglvl=ansi
3507 # Ultrix and OSF/1      -std1
3508 # HP-UX 10.20 and later -Ae
3509 # HP-UX older versions  -Aa -D_HPUX_SOURCE
3510 # SVR4                  -Xc -D__EXTENSIONS__
3511 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
3512 do
3513   CC="$ac_save_CC $ac_arg"
3514   rm -f conftest.$ac_objext
3515 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3516   (eval $ac_compile) 2>conftest.er1
3517   ac_status=$?
3518   grep -v '^ *+' conftest.er1 >conftest.err
3519   rm -f conftest.er1
3520   cat conftest.err >&5
3521   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3522   (exit $ac_status); } &&
3523          { ac_try='test -z "$ac_c_werror_flag"
3524                          || test ! -s conftest.err'
3525   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3526   (eval $ac_try) 2>&5
3527   ac_status=$?
3528   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3529   (exit $ac_status); }; } &&
3530          { ac_try='test -s conftest.$ac_objext'
3531   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3532   (eval $ac_try) 2>&5
3533   ac_status=$?
3534   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3535   (exit $ac_status); }; }; then
3536   ac_cv_prog_cc_stdc=$ac_arg
3537 break
3538 else
3539   echo "$as_me: failed program was:" >&5
3540 sed 's/^/| /' conftest.$ac_ext >&5
3541
3542 fi
3543 rm -f conftest.err conftest.$ac_objext
3544 done
3545 rm -f conftest.$ac_ext conftest.$ac_objext
3546 CC=$ac_save_CC
3547
3548 fi
3549
3550 case "x$ac_cv_prog_cc_stdc" in
3551   x|xno)
3552     echo "$as_me:$LINENO: result: none needed" >&5
3553 echo "${ECHO_T}none needed" >&6 ;;
3554   *)
3555     echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
3556 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
3557     CC="$CC $ac_cv_prog_cc_stdc" ;;
3558 esac
3559
3560 # Some people use a C++ compiler to compile C.  Since we use `exit',
3561 # in C++ we need to declare it.  In case someone uses the same compiler
3562 # for both compiling C and C++ we need to have the C++ compiler decide
3563 # the declaration of exit, since it's the most demanding environment.
3564 cat >conftest.$ac_ext <<_ACEOF
3565 #ifndef __cplusplus
3566   choke me
3567 #endif
3568 _ACEOF
3569 rm -f conftest.$ac_objext
3570 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3571   (eval $ac_compile) 2>conftest.er1
3572   ac_status=$?
3573   grep -v '^ *+' conftest.er1 >conftest.err
3574   rm -f conftest.er1
3575   cat conftest.err >&5
3576   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3577   (exit $ac_status); } &&
3578          { ac_try='test -z "$ac_c_werror_flag"
3579                          || test ! -s conftest.err'
3580   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3581   (eval $ac_try) 2>&5
3582   ac_status=$?
3583   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3584   (exit $ac_status); }; } &&
3585          { ac_try='test -s conftest.$ac_objext'
3586   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3587   (eval $ac_try) 2>&5
3588   ac_status=$?
3589   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3590   (exit $ac_status); }; }; then
3591   for ac_declaration in \
3592    '' \
3593    'extern "C" void std::exit (int) throw (); using std::exit;' \
3594    'extern "C" void std::exit (int); using std::exit;' \
3595    'extern "C" void exit (int) throw ();' \
3596    'extern "C" void exit (int);' \
3597    'void exit (int);'
3598 do
3599   cat >conftest.$ac_ext <<_ACEOF
3600 /* confdefs.h.  */
3601 _ACEOF
3602 cat confdefs.h >>conftest.$ac_ext
3603 cat >>conftest.$ac_ext <<_ACEOF
3604 /* end confdefs.h.  */
3605 $ac_declaration
3606 #include <stdlib.h>
3607 int
3608 main ()
3609 {
3610 exit (42);
3611   ;
3612   return 0;
3613 }
3614 _ACEOF
3615 rm -f conftest.$ac_objext
3616 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3617   (eval $ac_compile) 2>conftest.er1
3618   ac_status=$?
3619   grep -v '^ *+' conftest.er1 >conftest.err
3620   rm -f conftest.er1
3621   cat conftest.err >&5
3622   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3623   (exit $ac_status); } &&
3624          { ac_try='test -z "$ac_c_werror_flag"
3625                          || test ! -s conftest.err'
3626   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3627   (eval $ac_try) 2>&5
3628   ac_status=$?
3629   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3630   (exit $ac_status); }; } &&
3631          { ac_try='test -s conftest.$ac_objext'
3632   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3633   (eval $ac_try) 2>&5
3634   ac_status=$?
3635   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3636   (exit $ac_status); }; }; then
3637   :
3638 else
3639   echo "$as_me: failed program was:" >&5
3640 sed 's/^/| /' conftest.$ac_ext >&5
3641
3642 continue
3643 fi
3644 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3645   cat >conftest.$ac_ext <<_ACEOF
3646 /* confdefs.h.  */
3647 _ACEOF
3648 cat confdefs.h >>conftest.$ac_ext
3649 cat >>conftest.$ac_ext <<_ACEOF
3650 /* end confdefs.h.  */
3651 $ac_declaration
3652 int
3653 main ()
3654 {
3655 exit (42);
3656   ;
3657   return 0;
3658 }
3659 _ACEOF
3660 rm -f conftest.$ac_objext
3661 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3662   (eval $ac_compile) 2>conftest.er1
3663   ac_status=$?
3664   grep -v '^ *+' conftest.er1 >conftest.err
3665   rm -f conftest.er1
3666   cat conftest.err >&5
3667   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3668   (exit $ac_status); } &&
3669          { ac_try='test -z "$ac_c_werror_flag"
3670                          || test ! -s conftest.err'
3671   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3672   (eval $ac_try) 2>&5
3673   ac_status=$?
3674   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3675   (exit $ac_status); }; } &&
3676          { ac_try='test -s conftest.$ac_objext'
3677   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3678   (eval $ac_try) 2>&5
3679   ac_status=$?
3680   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3681   (exit $ac_status); }; }; then
3682   break
3683 else
3684   echo "$as_me: failed program was:" >&5
3685 sed 's/^/| /' conftest.$ac_ext >&5
3686
3687 fi
3688 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3689 done
3690 rm -f conftest*
3691 if test -n "$ac_declaration"; then
3692   echo '#ifdef __cplusplus' >>confdefs.h
3693   echo $ac_declaration      >>confdefs.h
3694   echo '#endif'             >>confdefs.h
3695 fi
3696
3697 else
3698   echo "$as_me: failed program was:" >&5
3699 sed 's/^/| /' conftest.$ac_ext >&5
3700
3701 fi
3702 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3703 ac_ext=c
3704 ac_cpp='$CPP $CPPFLAGS'
3705 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3706 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3707 ac_compiler_gnu=$ac_cv_c_compiler_gnu
3708
3709 ac_ext=cc
3710 ac_cpp='$CXXCPP $CPPFLAGS'
3711 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3712 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3713 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
3714 if test -n "$ac_tool_prefix"; then
3715   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3716   do
3717     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3718 set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3719 echo "$as_me:$LINENO: checking for $ac_word" >&5
3720 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3721 if test "${ac_cv_prog_CXX+set}" = set; then
3722   echo $ECHO_N "(cached) $ECHO_C" >&6
3723 else
3724   if test -n "$CXX"; then
3725   ac_cv_prog_CXX="$CXX" # Let the user override the test.
3726 else
3727 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3728 for as_dir in $PATH
3729 do
3730   IFS=$as_save_IFS
3731   test -z "$as_dir" && as_dir=.
3732   for ac_exec_ext in '' $ac_executable_extensions; do
3733   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3734     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
3735     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3736     break 2
3737   fi
3738 done
3739 done
3740
3741 fi
3742 fi
3743 CXX=$ac_cv_prog_CXX
3744 if test -n "$CXX"; then
3745   echo "$as_me:$LINENO: result: $CXX" >&5
3746 echo "${ECHO_T}$CXX" >&6
3747 else
3748   echo "$as_me:$LINENO: result: no" >&5
3749 echo "${ECHO_T}no" >&6
3750 fi
3751
3752     test -n "$CXX" && break
3753   done
3754 fi
3755 if test -z "$CXX"; then
3756   ac_ct_CXX=$CXX
3757   for ac_prog in $CCC g++ c++ gpp aCC CC cxx cc++ cl FCC KCC RCC xlC_r xlC
3758 do
3759   # Extract the first word of "$ac_prog", so it can be a program name with args.
3760 set dummy $ac_prog; ac_word=$2
3761 echo "$as_me:$LINENO: checking for $ac_word" >&5
3762 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3763 if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
3764   echo $ECHO_N "(cached) $ECHO_C" >&6
3765 else
3766   if test -n "$ac_ct_CXX"; then
3767   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
3768 else
3769 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3770 for as_dir in $PATH
3771 do
3772   IFS=$as_save_IFS
3773   test -z "$as_dir" && as_dir=.
3774   for ac_exec_ext in '' $ac_executable_extensions; do
3775   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3776     ac_cv_prog_ac_ct_CXX="$ac_prog"
3777     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3778     break 2
3779   fi
3780 done
3781 done
3782
3783 fi
3784 fi
3785 ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
3786 if test -n "$ac_ct_CXX"; then
3787   echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
3788 echo "${ECHO_T}$ac_ct_CXX" >&6
3789 else
3790   echo "$as_me:$LINENO: result: no" >&5
3791 echo "${ECHO_T}no" >&6
3792 fi
3793
3794   test -n "$ac_ct_CXX" && break
3795 done
3796 test -n "$ac_ct_CXX" || ac_ct_CXX="g++"
3797
3798   CXX=$ac_ct_CXX
3799 fi
3800
3801
3802 # Provide some information about the compiler.
3803 echo "$as_me:$LINENO:" \
3804      "checking for C++ compiler version" >&5
3805 ac_compiler=`set X $ac_compile; echo $2`
3806 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
3807   (eval $ac_compiler --version </dev/null >&5) 2>&5
3808   ac_status=$?
3809   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3810   (exit $ac_status); }
3811 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
3812   (eval $ac_compiler -v </dev/null >&5) 2>&5
3813   ac_status=$?
3814   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3815   (exit $ac_status); }
3816 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
3817   (eval $ac_compiler -V </dev/null >&5) 2>&5
3818   ac_status=$?
3819   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3820   (exit $ac_status); }
3821
3822 echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
3823 echo $ECHO_N "checking whether we are using the GNU C++ compiler... $ECHO_C" >&6
3824 if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
3825   echo $ECHO_N "(cached) $ECHO_C" >&6
3826 else
3827   cat >conftest.$ac_ext <<_ACEOF
3828 /* confdefs.h.  */
3829 _ACEOF
3830 cat confdefs.h >>conftest.$ac_ext
3831 cat >>conftest.$ac_ext <<_ACEOF
3832 /* end confdefs.h.  */
3833
3834 int
3835 main ()
3836 {
3837 #ifndef __GNUC__
3838        choke me
3839 #endif
3840
3841   ;
3842   return 0;
3843 }
3844 _ACEOF
3845 rm -f conftest.$ac_objext
3846 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3847   (eval $ac_compile) 2>conftest.er1
3848   ac_status=$?
3849   grep -v '^ *+' conftest.er1 >conftest.err
3850   rm -f conftest.er1
3851   cat conftest.err >&5
3852   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3853   (exit $ac_status); } &&
3854          { ac_try='test -z "$ac_cxx_werror_flag"
3855                          || test ! -s conftest.err'
3856   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3857   (eval $ac_try) 2>&5
3858   ac_status=$?
3859   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3860   (exit $ac_status); }; } &&
3861          { ac_try='test -s conftest.$ac_objext'
3862   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3863   (eval $ac_try) 2>&5
3864   ac_status=$?
3865   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3866   (exit $ac_status); }; }; then
3867   ac_compiler_gnu=yes
3868 else
3869   echo "$as_me: failed program was:" >&5
3870 sed 's/^/| /' conftest.$ac_ext >&5
3871
3872 ac_compiler_gnu=no
3873 fi
3874 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3875 ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
3876
3877 fi
3878 echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
3879 echo "${ECHO_T}$ac_cv_cxx_compiler_gnu" >&6
3880 GXX=`test $ac_compiler_gnu = yes && echo yes`
3881 ac_test_CXXFLAGS=${CXXFLAGS+set}
3882 ac_save_CXXFLAGS=$CXXFLAGS
3883 CXXFLAGS="-g"
3884 echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
3885 echo $ECHO_N "checking whether $CXX accepts -g... $ECHO_C" >&6
3886 if test "${ac_cv_prog_cxx_g+set}" = set; then
3887   echo $ECHO_N "(cached) $ECHO_C" >&6
3888 else
3889   cat >conftest.$ac_ext <<_ACEOF
3890 /* confdefs.h.  */
3891 _ACEOF
3892 cat confdefs.h >>conftest.$ac_ext
3893 cat >>conftest.$ac_ext <<_ACEOF
3894 /* end confdefs.h.  */
3895
3896 int
3897 main ()
3898 {
3899
3900   ;
3901   return 0;
3902 }
3903 _ACEOF
3904 rm -f conftest.$ac_objext
3905 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3906   (eval $ac_compile) 2>conftest.er1
3907   ac_status=$?
3908   grep -v '^ *+' conftest.er1 >conftest.err
3909   rm -f conftest.er1
3910   cat conftest.err >&5
3911   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3912   (exit $ac_status); } &&
3913          { ac_try='test -z "$ac_cxx_werror_flag"
3914                          || test ! -s conftest.err'
3915   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3916   (eval $ac_try) 2>&5
3917   ac_status=$?
3918   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3919   (exit $ac_status); }; } &&
3920          { ac_try='test -s conftest.$ac_objext'
3921   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3922   (eval $ac_try) 2>&5
3923   ac_status=$?
3924   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3925   (exit $ac_status); }; }; then
3926   ac_cv_prog_cxx_g=yes
3927 else
3928   echo "$as_me: failed program was:" >&5
3929 sed 's/^/| /' conftest.$ac_ext >&5
3930
3931 ac_cv_prog_cxx_g=no
3932 fi
3933 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
3934 fi
3935 echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
3936 echo "${ECHO_T}$ac_cv_prog_cxx_g" >&6
3937 if test "$ac_test_CXXFLAGS" = set; then
3938   CXXFLAGS=$ac_save_CXXFLAGS
3939 elif test $ac_cv_prog_cxx_g = yes; then
3940   if test "$GXX" = yes; then
3941     CXXFLAGS="-g -O2"
3942   else
3943     CXXFLAGS="-g"
3944   fi
3945 else
3946   if test "$GXX" = yes; then
3947     CXXFLAGS="-O2"
3948   else
3949     CXXFLAGS=
3950   fi
3951 fi
3952 for ac_declaration in \
3953    '' \
3954    'extern "C" void std::exit (int) throw (); using std::exit;' \
3955    'extern "C" void std::exit (int); using std::exit;' \
3956    'extern "C" void exit (int) throw ();' \
3957    'extern "C" void exit (int);' \
3958    'void exit (int);'
3959 do
3960   cat >conftest.$ac_ext <<_ACEOF
3961 /* confdefs.h.  */
3962 _ACEOF
3963 cat confdefs.h >>conftest.$ac_ext
3964 cat >>conftest.$ac_ext <<_ACEOF
3965 /* end confdefs.h.  */
3966 $ac_declaration
3967 #include <stdlib.h>
3968 int
3969 main ()
3970 {
3971 exit (42);
3972   ;
3973   return 0;
3974 }
3975 _ACEOF
3976 rm -f conftest.$ac_objext
3977 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
3978   (eval $ac_compile) 2>conftest.er1
3979   ac_status=$?
3980   grep -v '^ *+' conftest.er1 >conftest.err
3981   rm -f conftest.er1
3982   cat conftest.err >&5
3983   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3984   (exit $ac_status); } &&
3985          { ac_try='test -z "$ac_cxx_werror_flag"
3986                          || test ! -s conftest.err'
3987   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3988   (eval $ac_try) 2>&5
3989   ac_status=$?
3990   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3991   (exit $ac_status); }; } &&
3992          { ac_try='test -s conftest.$ac_objext'
3993   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
3994   (eval $ac_try) 2>&5
3995   ac_status=$?
3996   echo "$as_me:$LINENO: \$? = $ac_status" >&5
3997   (exit $ac_status); }; }; then
3998   :
3999 else
4000   echo "$as_me: failed program was:" >&5
4001 sed 's/^/| /' conftest.$ac_ext >&5
4002
4003 continue
4004 fi
4005 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4006   cat >conftest.$ac_ext <<_ACEOF
4007 /* confdefs.h.  */
4008 _ACEOF
4009 cat confdefs.h >>conftest.$ac_ext
4010 cat >>conftest.$ac_ext <<_ACEOF
4011 /* end confdefs.h.  */
4012 $ac_declaration
4013 int
4014 main ()
4015 {
4016 exit (42);
4017   ;
4018   return 0;
4019 }
4020 _ACEOF
4021 rm -f conftest.$ac_objext
4022 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4023   (eval $ac_compile) 2>conftest.er1
4024   ac_status=$?
4025   grep -v '^ *+' conftest.er1 >conftest.err
4026   rm -f conftest.er1
4027   cat conftest.err >&5
4028   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4029   (exit $ac_status); } &&
4030          { ac_try='test -z "$ac_cxx_werror_flag"
4031                          || test ! -s conftest.err'
4032   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4033   (eval $ac_try) 2>&5
4034   ac_status=$?
4035   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4036   (exit $ac_status); }; } &&
4037          { ac_try='test -s conftest.$ac_objext'
4038   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4039   (eval $ac_try) 2>&5
4040   ac_status=$?
4041   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4042   (exit $ac_status); }; }; then
4043   break
4044 else
4045   echo "$as_me: failed program was:" >&5
4046 sed 's/^/| /' conftest.$ac_ext >&5
4047
4048 fi
4049 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4050 done
4051 rm -f conftest*
4052 if test -n "$ac_declaration"; then
4053   echo '#ifdef __cplusplus' >>confdefs.h
4054   echo $ac_declaration      >>confdefs.h
4055   echo '#endif'             >>confdefs.h
4056 fi
4057
4058 ac_ext=c
4059 ac_cpp='$CPP $CPPFLAGS'
4060 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4061 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4062 ac_compiler_gnu=$ac_cv_c_compiler_gnu
4063
4064
4065 # We must set the default linker to the linker used by gcc for the correct
4066 # operation of libtool.  If LD is not defined and we are using gcc, try to
4067 # set the LD default to the ld used by gcc.
4068 if test -z "$LD"; then
4069   if test "$GCC" = yes; then
4070     case $build in
4071     *-*-mingw*)
4072       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1 | tr -d '\015'` ;;
4073     *)
4074       gcc_prog_ld=`$CC -print-prog-name=ld 2>&1` ;;
4075     esac
4076     case $gcc_prog_ld in
4077     # Accept absolute paths.
4078     [\\/]* | [A-Za-z]:[\\/]*)
4079       LD="$gcc_prog_ld" ;;
4080     esac
4081   fi
4082 fi
4083
4084
4085
4086
4087 if test -n "$ac_tool_prefix"; then
4088   # Extract the first word of "${ac_tool_prefix}gnatbind", so it can be a program name with args.
4089 set dummy ${ac_tool_prefix}gnatbind; ac_word=$2
4090 echo "$as_me:$LINENO: checking for $ac_word" >&5
4091 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4092 if test "${ac_cv_prog_GNATBIND+set}" = set; then
4093   echo $ECHO_N "(cached) $ECHO_C" >&6
4094 else
4095   if test -n "$GNATBIND"; then
4096   ac_cv_prog_GNATBIND="$GNATBIND" # Let the user override the test.
4097 else
4098 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4099 for as_dir in $PATH
4100 do
4101   IFS=$as_save_IFS
4102   test -z "$as_dir" && as_dir=.
4103   for ac_exec_ext in '' $ac_executable_extensions; do
4104   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4105     ac_cv_prog_GNATBIND="${ac_tool_prefix}gnatbind"
4106     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4107     break 2
4108   fi
4109 done
4110 done
4111
4112 fi
4113 fi
4114 GNATBIND=$ac_cv_prog_GNATBIND
4115 if test -n "$GNATBIND"; then
4116   echo "$as_me:$LINENO: result: $GNATBIND" >&5
4117 echo "${ECHO_T}$GNATBIND" >&6
4118 else
4119   echo "$as_me:$LINENO: result: no" >&5
4120 echo "${ECHO_T}no" >&6
4121 fi
4122
4123 fi
4124 if test -z "$ac_cv_prog_GNATBIND"; then
4125   ac_ct_GNATBIND=$GNATBIND
4126   # Extract the first word of "gnatbind", so it can be a program name with args.
4127 set dummy gnatbind; ac_word=$2
4128 echo "$as_me:$LINENO: checking for $ac_word" >&5
4129 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4130 if test "${ac_cv_prog_ac_ct_GNATBIND+set}" = set; then
4131   echo $ECHO_N "(cached) $ECHO_C" >&6
4132 else
4133   if test -n "$ac_ct_GNATBIND"; then
4134   ac_cv_prog_ac_ct_GNATBIND="$ac_ct_GNATBIND" # Let the user override the test.
4135 else
4136 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4137 for as_dir in $PATH
4138 do
4139   IFS=$as_save_IFS
4140   test -z "$as_dir" && as_dir=.
4141   for ac_exec_ext in '' $ac_executable_extensions; do
4142   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4143     ac_cv_prog_ac_ct_GNATBIND="gnatbind"
4144     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4145     break 2
4146   fi
4147 done
4148 done
4149
4150   test -z "$ac_cv_prog_ac_ct_GNATBIND" && ac_cv_prog_ac_ct_GNATBIND="no"
4151 fi
4152 fi
4153 ac_ct_GNATBIND=$ac_cv_prog_ac_ct_GNATBIND
4154 if test -n "$ac_ct_GNATBIND"; then
4155   echo "$as_me:$LINENO: result: $ac_ct_GNATBIND" >&5
4156 echo "${ECHO_T}$ac_ct_GNATBIND" >&6
4157 else
4158   echo "$as_me:$LINENO: result: no" >&5
4159 echo "${ECHO_T}no" >&6
4160 fi
4161
4162   GNATBIND=$ac_ct_GNATBIND
4163 else
4164   GNATBIND="$ac_cv_prog_GNATBIND"
4165 fi
4166
4167 if test -n "$ac_tool_prefix"; then
4168   # Extract the first word of "${ac_tool_prefix}gnatmake", so it can be a program name with args.
4169 set dummy ${ac_tool_prefix}gnatmake; ac_word=$2
4170 echo "$as_me:$LINENO: checking for $ac_word" >&5
4171 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4172 if test "${ac_cv_prog_GNATMAKE+set}" = set; then
4173   echo $ECHO_N "(cached) $ECHO_C" >&6
4174 else
4175   if test -n "$GNATMAKE"; then
4176   ac_cv_prog_GNATMAKE="$GNATMAKE" # Let the user override the test.
4177 else
4178 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4179 for as_dir in $PATH
4180 do
4181   IFS=$as_save_IFS
4182   test -z "$as_dir" && as_dir=.
4183   for ac_exec_ext in '' $ac_executable_extensions; do
4184   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4185     ac_cv_prog_GNATMAKE="${ac_tool_prefix}gnatmake"
4186     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4187     break 2
4188   fi
4189 done
4190 done
4191
4192 fi
4193 fi
4194 GNATMAKE=$ac_cv_prog_GNATMAKE
4195 if test -n "$GNATMAKE"; then
4196   echo "$as_me:$LINENO: result: $GNATMAKE" >&5
4197 echo "${ECHO_T}$GNATMAKE" >&6
4198 else
4199   echo "$as_me:$LINENO: result: no" >&5
4200 echo "${ECHO_T}no" >&6
4201 fi
4202
4203 fi
4204 if test -z "$ac_cv_prog_GNATMAKE"; then
4205   ac_ct_GNATMAKE=$GNATMAKE
4206   # Extract the first word of "gnatmake", so it can be a program name with args.
4207 set dummy gnatmake; ac_word=$2
4208 echo "$as_me:$LINENO: checking for $ac_word" >&5
4209 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4210 if test "${ac_cv_prog_ac_ct_GNATMAKE+set}" = set; then
4211   echo $ECHO_N "(cached) $ECHO_C" >&6
4212 else
4213   if test -n "$ac_ct_GNATMAKE"; then
4214   ac_cv_prog_ac_ct_GNATMAKE="$ac_ct_GNATMAKE" # Let the user override the test.
4215 else
4216 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4217 for as_dir in $PATH
4218 do
4219   IFS=$as_save_IFS
4220   test -z "$as_dir" && as_dir=.
4221   for ac_exec_ext in '' $ac_executable_extensions; do
4222   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4223     ac_cv_prog_ac_ct_GNATMAKE="gnatmake"
4224     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4225     break 2
4226   fi
4227 done
4228 done
4229
4230   test -z "$ac_cv_prog_ac_ct_GNATMAKE" && ac_cv_prog_ac_ct_GNATMAKE="no"
4231 fi
4232 fi
4233 ac_ct_GNATMAKE=$ac_cv_prog_ac_ct_GNATMAKE
4234 if test -n "$ac_ct_GNATMAKE"; then
4235   echo "$as_me:$LINENO: result: $ac_ct_GNATMAKE" >&5
4236 echo "${ECHO_T}$ac_ct_GNATMAKE" >&6
4237 else
4238   echo "$as_me:$LINENO: result: no" >&5
4239 echo "${ECHO_T}no" >&6
4240 fi
4241
4242   GNATMAKE=$ac_ct_GNATMAKE
4243 else
4244   GNATMAKE="$ac_cv_prog_GNATMAKE"
4245 fi
4246
4247 echo "$as_me:$LINENO: checking whether compiler driver understands Ada" >&5
4248 echo $ECHO_N "checking whether compiler driver understands Ada... $ECHO_C" >&6
4249 if test "${acx_cv_cc_gcc_supports_ada+set}" = set; then
4250   echo $ECHO_N "(cached) $ECHO_C" >&6
4251 else
4252   cat >conftest.adb <<EOF
4253 procedure conftest is begin null; end conftest;
4254 EOF
4255 acx_cv_cc_gcc_supports_ada=no
4256 # There is a bug in old released versions of GCC which causes the
4257 # driver to exit successfully when the appropriate language module
4258 # has not been installed.  This is fixed in 2.95.4, 3.0.2, and 3.1.
4259 # Therefore we must check for the error message as well as an
4260 # unsuccessful exit.
4261 # Other compilers, like HP Tru64 UNIX cc, exit successfully when
4262 # given a .adb file, but produce no object file.  So we must check
4263 # if an object file was really produced to guard against this.
4264 errors=`(${CC} -c conftest.adb) 2>&1 || echo failure`
4265 if test x"$errors" = x && test -f conftest.$ac_objext; then
4266   acx_cv_cc_gcc_supports_ada=yes
4267 fi
4268 rm -f conftest.*
4269 fi
4270 echo "$as_me:$LINENO: result: $acx_cv_cc_gcc_supports_ada" >&5
4271 echo "${ECHO_T}$acx_cv_cc_gcc_supports_ada" >&6
4272
4273 if test x$GNATBIND != xno && test x$GNATMAKE != xno && test x$acx_cv_cc_gcc_supports_ada != xno; then
4274   have_gnat=yes
4275 else
4276   have_gnat=no
4277 fi
4278
4279 echo "$as_me:$LINENO: checking how to compare bootstrapped objects" >&5
4280 echo $ECHO_N "checking how to compare bootstrapped objects... $ECHO_C" >&6
4281 if test "${gcc_cv_prog_cmp_skip+set}" = set; then
4282   echo $ECHO_N "(cached) $ECHO_C" >&6
4283 else
4284    echo abfoo >t1
4285   echo cdfoo >t2
4286   gcc_cv_prog_cmp_skip='tail +16c $$f1 > tmp-foo1; tail +16c $$f2 > tmp-foo2; cmp tmp-foo1 tmp-foo2'
4287   if cmp t1 t2 2 2 > /dev/null 2>&1; then
4288     if cmp t1 t2 1 1 > /dev/null 2>&1; then
4289       :
4290     else
4291       gcc_cv_prog_cmp_skip='cmp $$f1 $$f2 16 16'
4292     fi
4293   fi
4294   if cmp --ignore-initial=2 t1 t2 > /dev/null 2>&1; then
4295     if cmp --ignore-initial=1 t1 t2 > /dev/null 2>&1; then
4296       :
4297     else
4298       gcc_cv_prog_cmp_skip='cmp --ignore-initial=16 $$f1 $$f2'
4299     fi
4300   fi
4301   rm t1 t2
4302
4303 fi
4304 echo "$as_me:$LINENO: result: $gcc_cv_prog_cmp_skip" >&5
4305 echo "${ECHO_T}$gcc_cv_prog_cmp_skip" >&6
4306 do_compare="$gcc_cv_prog_cmp_skip"
4307
4308
4309
4310 # Check for GMP and MPFR
4311 gmplibs="-lmpfr -lgmp"
4312 gmpinc=
4313 have_gmp=no
4314
4315 # Specify a location for mpfr
4316 # check for this first so it ends up on the link line before gmp.
4317
4318 # Check whether --with-mpfr-dir or --without-mpfr-dir was given.
4319 if test "${with_mpfr_dir+set}" = set; then
4320   withval="$with_mpfr_dir"
4321   { { echo "$as_me:$LINENO: error: The --with-mpfr-dir=PATH option has been removed.
4322 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&5
4323 echo "$as_me: error: The --with-mpfr-dir=PATH option has been removed.
4324 Use --with-mpfr=PATH or --with-mpfr-include=PATH plus --with-mpfr-lib=PATH" >&2;}
4325    { (exit 1); exit 1; }; }
4326 fi;
4327
4328
4329 # Check whether --with-mpfr or --without-mpfr was given.
4330 if test "${with_mpfr+set}" = set; then
4331   withval="$with_mpfr"
4332
4333 fi;
4334
4335 # Check whether --with-mpfr_include or --without-mpfr_include was given.
4336 if test "${with_mpfr_include+set}" = set; then
4337   withval="$with_mpfr_include"
4338
4339 fi;
4340
4341 # Check whether --with-mpfr_lib or --without-mpfr_lib was given.
4342 if test "${with_mpfr_lib+set}" = set; then
4343   withval="$with_mpfr_lib"
4344
4345 fi;
4346
4347 if test "x$with_mpfr" != x; then
4348   gmplibs="-L$with_mpfr/lib $gmplibs"
4349   gmpinc="-I$with_mpfr/include"
4350 fi
4351 if test "x$with_mpfr_include" != x; then
4352   gmpinc="-I$with_mpfr_include"
4353 fi
4354 if test "x$with_mpfr_lib" != x; then
4355   gmplibs="-L$with_mpfr_lib $gmplibs"
4356 fi
4357 if test "x$with_mpfr$with_mpfr_include$with_mpfr_lib" = x && test -d ${srcdir}/mpfr; then
4358   gmplibs='-L$$r/$(HOST_SUBDIR)/mpfr/.libs -L$$r/$(HOST_SUBDIR)/mpfr/_libs '"$gmplibs"
4359   gmpinc='-I$$r/$(HOST_SUBDIR)/mpfr -I$$s/mpfr '"$gmpinc"
4360   # Do not test the mpfr version.  Assume that it is sufficient, since
4361   # it is in the source tree, and the library has not been built yet
4362   # but it would be included on the link line in the version check below
4363   # hence making the test fail.
4364   have_gmp=yes
4365 fi
4366
4367 # Specify a location for gmp
4368
4369 # Check whether --with-gmp-dir or --without-gmp-dir was given.
4370 if test "${with_gmp_dir+set}" = set; then
4371   withval="$with_gmp_dir"
4372   { { echo "$as_me:$LINENO: error: The --with-gmp-dir=PATH option has been removed.
4373 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&5
4374 echo "$as_me: error: The --with-gmp-dir=PATH option has been removed.
4375 Use --with-gmp=PATH or --with-gmp-include=PATH plus --with-gmp-lib=PATH" >&2;}
4376    { (exit 1); exit 1; }; }
4377 fi;
4378
4379
4380 # Check whether --with-gmp or --without-gmp was given.
4381 if test "${with_gmp+set}" = set; then
4382   withval="$with_gmp"
4383
4384 fi;
4385
4386 # Check whether --with-gmp_include or --without-gmp_include was given.
4387 if test "${with_gmp_include+set}" = set; then
4388   withval="$with_gmp_include"
4389
4390 fi;
4391
4392 # Check whether --with-gmp_lib or --without-gmp_lib was given.
4393 if test "${with_gmp_lib+set}" = set; then
4394   withval="$with_gmp_lib"
4395
4396 fi;
4397
4398
4399 if test "x$with_gmp" != x; then
4400   gmplibs="-L$with_gmp/lib $gmplibs"
4401   gmpinc="-I$with_gmp/include $gmpinc"
4402 fi
4403 if test "x$with_gmp_include" != x; then
4404   gmpinc="-I$with_gmp_include $gmpinc"
4405 fi
4406 if test "x$with_gmp_lib" != x; then
4407   gmplibs="-L$with_gmp_lib $gmplibs"
4408 fi
4409 if test "x$with_gmp$with_gmp_include$with_gmp_lib" = x && test -d ${srcdir}/gmp; then
4410   gmplibs='-L$$r/$(HOST_SUBDIR)/gmp/.libs -L$$r/$(HOST_SUBDIR)/gmp/_libs '"$gmplibs"
4411   gmpinc='-I$$r/$(HOST_SUBDIR)/gmp -I$$s/gmp '"$gmpinc"
4412   # Do not test the gmp version.  Assume that it is sufficient, since
4413   # it is in the source tree, and the library has not been built yet
4414   # but it would be included on the link line in the version check below
4415   # hence making the test fail.
4416   have_gmp=yes
4417 fi
4418
4419 if test -d ${srcdir}/gcc && test "x$have_gmp" = xno; then
4420   have_gmp=yes
4421   saved_CFLAGS="$CFLAGS"
4422   CFLAGS="$CFLAGS $gmpinc"
4423   # Check GMP actually works
4424   echo "$as_me:$LINENO: checking for correct version of gmp.h" >&5
4425 echo $ECHO_N "checking for correct version of gmp.h... $ECHO_C" >&6
4426
4427 cat >conftest.$ac_ext <<_ACEOF
4428 /* confdefs.h.  */
4429 _ACEOF
4430 cat confdefs.h >>conftest.$ac_ext
4431 cat >>conftest.$ac_ext <<_ACEOF
4432 /* end confdefs.h.  */
4433 #include "gmp.h"
4434 int
4435 main ()
4436 {
4437
4438   #if __GNU_MP_VERSION < 4 || (__GNU_MP_VERSION == 4 && __GNU_MP_VERSION_MINOR < 1)
4439   choke me
4440   #endif
4441
4442   ;
4443   return 0;
4444 }
4445 _ACEOF
4446 rm -f conftest.$ac_objext
4447 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4448   (eval $ac_compile) 2>conftest.er1
4449   ac_status=$?
4450   grep -v '^ *+' conftest.er1 >conftest.err
4451   rm -f conftest.er1
4452   cat conftest.err >&5
4453   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4454   (exit $ac_status); } &&
4455          { ac_try='test -z "$ac_c_werror_flag"
4456                          || test ! -s conftest.err'
4457   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4458   (eval $ac_try) 2>&5
4459   ac_status=$?
4460   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4461   (exit $ac_status); }; } &&
4462          { ac_try='test -s conftest.$ac_objext'
4463   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4464   (eval $ac_try) 2>&5
4465   ac_status=$?
4466   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4467   (exit $ac_status); }; }; then
4468   echo "$as_me:$LINENO: result: yes" >&5
4469 echo "${ECHO_T}yes" >&6
4470 else
4471   echo "$as_me: failed program was:" >&5
4472 sed 's/^/| /' conftest.$ac_ext >&5
4473
4474 echo "$as_me:$LINENO: result: no" >&5
4475 echo "${ECHO_T}no" >&6; have_gmp=no
4476 fi
4477 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4478
4479   if test x"$have_gmp" = xyes; then
4480     saved_LIBS="$LIBS"
4481     LIBS="$LIBS $gmplibs"
4482         echo "$as_me:$LINENO: checking for correct version of mpfr.h" >&5
4483 echo $ECHO_N "checking for correct version of mpfr.h... $ECHO_C" >&6
4484     cat >conftest.$ac_ext <<_ACEOF
4485 /* confdefs.h.  */
4486 _ACEOF
4487 cat confdefs.h >>conftest.$ac_ext
4488 cat >>conftest.$ac_ext <<_ACEOF
4489 /* end confdefs.h.  */
4490 #include <gmp.h>
4491     #include <mpfr.h>
4492 int
4493 main ()
4494 {
4495
4496     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,0)
4497     choke me
4498     #endif
4499     mpfr_t n;
4500     mpfr_t x;
4501     int t;
4502     mpfr_init (n);
4503     mpfr_init (x);
4504     mpfr_atan2 (n, n, x, GMP_RNDN);
4505     mpfr_erfc (n, x, GMP_RNDN);
4506     mpfr_subnormalize (x, t, GMP_RNDN);
4507
4508   ;
4509   return 0;
4510 }
4511 _ACEOF
4512 rm -f conftest.$ac_objext conftest$ac_exeext
4513 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4514   (eval $ac_link) 2>conftest.er1
4515   ac_status=$?
4516   grep -v '^ *+' conftest.er1 >conftest.err
4517   rm -f conftest.er1
4518   cat conftest.err >&5
4519   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4520   (exit $ac_status); } &&
4521          { ac_try='test -z "$ac_c_werror_flag"
4522                          || test ! -s conftest.err'
4523   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4524   (eval $ac_try) 2>&5
4525   ac_status=$?
4526   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4527   (exit $ac_status); }; } &&
4528          { ac_try='test -s conftest$ac_exeext'
4529   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4530   (eval $ac_try) 2>&5
4531   ac_status=$?
4532   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4533   (exit $ac_status); }; }; then
4534   cat >conftest.$ac_ext <<_ACEOF
4535 /* confdefs.h.  */
4536 _ACEOF
4537 cat confdefs.h >>conftest.$ac_ext
4538 cat >>conftest.$ac_ext <<_ACEOF
4539 /* end confdefs.h.  */
4540 #include <gmp.h>
4541     #include <mpfr.h>
4542 int
4543 main ()
4544 {
4545
4546     #if MPFR_VERSION < MPFR_VERSION_NUM(2,2,1)
4547     choke me
4548     #endif
4549     mpfr_t n; mpfr_init(n);
4550
4551   ;
4552   return 0;
4553 }
4554 _ACEOF
4555 rm -f conftest.$ac_objext conftest$ac_exeext
4556 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
4557   (eval $ac_link) 2>conftest.er1
4558   ac_status=$?
4559   grep -v '^ *+' conftest.er1 >conftest.err
4560   rm -f conftest.er1
4561   cat conftest.err >&5
4562   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4563   (exit $ac_status); } &&
4564          { ac_try='test -z "$ac_c_werror_flag"
4565                          || test ! -s conftest.err'
4566   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4567   (eval $ac_try) 2>&5
4568   ac_status=$?
4569   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4570   (exit $ac_status); }; } &&
4571          { ac_try='test -s conftest$ac_exeext'
4572   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4573   (eval $ac_try) 2>&5
4574   ac_status=$?
4575   echo "$as_me:$LINENO: \$? = $ac_status" >&5
4576   (exit $ac_status); }; }; then
4577   echo "$as_me:$LINENO: result: yes" >&5
4578 echo "${ECHO_T}yes" >&6
4579 else
4580   echo "$as_me: failed program was:" >&5
4581 sed 's/^/| /' conftest.$ac_ext >&5
4582
4583 echo "$as_me:$LINENO: result: buggy but acceptable" >&5
4584 echo "${ECHO_T}buggy but acceptable" >&6
4585 fi
4586 rm -f conftest.err conftest.$ac_objext \
4587       conftest$ac_exeext conftest.$ac_ext
4588 else
4589   echo "$as_me: failed program was:" >&5
4590 sed 's/^/| /' conftest.$ac_ext >&5
4591
4592 echo "$as_me:$LINENO: result: no" >&5
4593 echo "${ECHO_T}no" >&6; have_gmp=no
4594 fi
4595 rm -f conftest.err conftest.$ac_objext \
4596       conftest$ac_exeext conftest.$ac_ext
4597       LIBS="$saved_LIBS"
4598   fi
4599   CFLAGS="$saved_CFLAGS"
4600
4601   if test x$have_gmp != xyes; then
4602     { { echo "$as_me:$LINENO: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4603 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4604 Copies of these libraries' source code can be found at their respective
4605 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4606 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4607 If you obtained GMP and/or MPFR from a vendor distribution package, make
4608 sure that you have installed both the libraries and the header files.
4609 They may be located in separate packages." >&5
4610 echo "$as_me: error: Building GCC requires GMP 4.1+ and MPFR 2.2.1+.
4611 Try the --with-gmp and/or --with-mpfr options to specify their locations.
4612 Copies of these libraries' source code can be found at their respective
4613 hosting sites as well as at ftp://gcc.gnu.org/pub/gcc/infrastructure/.
4614 See also http://gcc.gnu.org/install/prerequisites.html for additional info.
4615 If you obtained GMP and/or MPFR from a vendor distribution package, make
4616 sure that you have installed both the libraries and the header files.
4617 They may be located in separate packages." >&2;}
4618    { (exit 1); exit 1; }; }
4619   fi
4620 fi
4621
4622 # Flags needed for both GMP and/or MPFR
4623
4624
4625
4626 # By default, C is the only stage 1 language.
4627 stage1_languages=,c,
4628
4629 # Figure out what language subdirectories are present.
4630 # Look if the user specified --enable-languages="..."; if not, use
4631 # the environment variable $LANGUAGES if defined. $LANGUAGES might
4632 # go away some day.
4633 # NB:  embedded tabs in this IF block -- do not untabify
4634 if test -d ${srcdir}/gcc; then
4635   if test x"${enable_languages+set}" != xset; then
4636     if test x"${LANGUAGES+set}" = xset; then
4637       enable_languages="${LANGUAGES}"
4638         echo configure.in: warning: setting LANGUAGES is deprecated, use --enable-languages instead 1>&2
4639     else
4640       enable_languages=all
4641     fi
4642   else
4643     if test x"${enable_languages}" = x ||
4644        test x"${enable_languages}" = xyes;
4645        then
4646       echo configure.in: --enable-languages needs at least one language argument 1>&2
4647       exit 1
4648     fi
4649   fi
4650   enable_languages=`echo "${enable_languages}" | sed -e 's/[    ,][     ,]*/,/g' -e 's/,$//'`
4651
4652   # 'f95' is the old name for the 'fortran' language. We issue a warning
4653   # and make the substitution.
4654   case ,${enable_languages}, in
4655     *,f95,*)
4656       echo configure.in: warning: 'f95' as language name is deprecated, use 'fortran' instead 1>&2
4657       enable_languages=`echo "${enable_languages}" | sed -e 's/f95/fortran/g'`
4658       ;;
4659   esac
4660
4661   # First scan to see if an enabled language requires some other language.
4662   # We assume that a given config-lang.in will list all the language
4663   # front ends it requires, even if some are required indirectly.
4664   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4665     case ${lang_frag} in
4666       ..) ;;
4667       # The odd quoting in the next line works around
4668       # an apparent bug in bash 1.12 on linux.
4669       ${srcdir}/gcc/[*]/config-lang.in) ;;
4670       *)
4671         # From the config-lang.in, get $language, $lang_requires
4672         language=
4673         lang_requires=
4674         . ${lang_frag}
4675         for other in ${lang_requires} ; do
4676           case ,${enable_languages}, in
4677             *,$other,*) ;;
4678             *,all,*) ;;
4679             *,$language,*)
4680               echo " \`$other' language required by \`$language'; enabling" 1>&2
4681               enable_languages="${enable_languages},${other}"
4682               ;;
4683           esac
4684         done
4685         ;;
4686     esac
4687   done
4688
4689   new_enable_languages=,c,
4690   missing_languages=`echo ",$enable_languages," | sed -e s/,all,/,/ -e s/,c,/,/ `
4691   potential_languages=,c,
4692
4693   for lang_frag in ${srcdir}/gcc/*/config-lang.in .. ; do
4694     case ${lang_frag} in
4695       ..) ;;
4696       # The odd quoting in the next line works around
4697       # an apparent bug in bash 1.12 on linux.
4698       ${srcdir}/gcc/[*]/config-lang.in) ;;
4699       *)
4700         # From the config-lang.in, get $language, $target_libs,
4701         # $lang_dirs, $boot_language, and $build_by_default
4702         language=
4703         target_libs=
4704         lang_dirs=
4705         subdir_requires=
4706         boot_language=no
4707         build_by_default=yes
4708         . ${lang_frag}
4709         if test x${language} = x; then
4710           echo "${lang_frag} doesn't set \$language." 1>&2
4711           exit 1
4712         fi
4713
4714         case ,${enable_languages}, in
4715           *,${language},*)
4716             # Language was explicitly selected; include it.
4717             add_this_lang=yes
4718             ;;
4719           *,all,*)
4720             # 'all' was selected, select it if it is a default language
4721             add_this_lang=${build_by_default}
4722             ;;
4723           *)
4724             add_this_lang=no
4725             ;;
4726         esac
4727
4728         # Disable languages that need other directories if these aren't available.
4729         for i in $subdir_requires; do
4730           test -f "$srcdir/gcc/$i/config-lang.in" && continue
4731           case ,${enable_languages}, in
4732             *,${language},*)
4733               # Specifically requested language; tell them.
4734               { { echo "$as_me:$LINENO: error: The gcc/$i directory contains parts of $language but is missing" >&5
4735 echo "$as_me: error: The gcc/$i directory contains parts of $language but is missing" >&2;}
4736    { (exit 1); exit 1; }; }
4737               ;;
4738             *)
4739               # Silently disable.
4740               add_this_lang=unsupported
4741               ;;
4742           esac
4743         done
4744
4745         # Disable Ada if no preexisting GNAT is available.
4746         case ,${enable_languages},:${language}:${have_gnat} in
4747           *,${language},*:ada:no)
4748             # Specifically requested language; tell them.
4749             { { echo "$as_me:$LINENO: error: GNAT is required to build $language" >&5
4750 echo "$as_me: error: GNAT is required to build $language" >&2;}
4751    { (exit 1); exit 1; }; }
4752             ;;
4753           *:ada:no)
4754             # Silently disable.
4755             add_this_lang=unsupported
4756             ;;
4757         esac
4758
4759         # Disable a language that is unsupported by the target.
4760         case " $unsupported_languages " in
4761           *" $language "*)
4762             add_this_lang=unsupported
4763             ;;
4764         esac
4765
4766         case $add_this_lang in
4767           unsupported)
4768             # Remove language-dependent dirs.
4769             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4770             ;;
4771           no)
4772             # Remove language-dependent dirs; still show language as supported.
4773             eval noconfigdirs='"$noconfigdirs "'\"$target_libs $lang_dirs\"
4774             potential_languages="${potential_languages}${language},"
4775             ;;
4776           yes)
4777             new_enable_languages="${new_enable_languages}${language},"
4778             potential_languages="${potential_languages}${language},"
4779             missing_languages=`echo "$missing_languages" | sed "s/,$language,/,/"`
4780             case ${boot_language} in
4781               yes)
4782                 # Add to (comma-separated) list of stage 1 languages.
4783                 stage1_languages="${stage1_languages}${language},"
4784                 ;;
4785             esac
4786             ;;
4787         esac
4788         ;;
4789     esac
4790   done
4791
4792   # Check whether --enable-stage1-languages or --disable-stage1-languages was given.
4793 if test "${enable_stage1_languages+set}" = set; then
4794   enableval="$enable_stage1_languages"
4795   case ,${enable_stage1_languages}, in
4796     ,no,|,,)
4797       # Set it to something that will have no effect in the loop below
4798       enable_stage1_languages=c ;;
4799     ,yes,)
4800       enable_stage1_languages=`echo $new_enable_languages | \
4801         sed -e "s/^,//" -e "s/,$//" ` ;;
4802     *,all,*)
4803       enable_stage1_languages=`echo ,$enable_stage1_languages, | \
4804         sed -e "s/,all,/$new_enable_languages/" -e "s/^,//" -e "s/,$//" ` ;;
4805   esac
4806
4807   # Add "good" languages from enable_stage1_languages to stage1_languages,
4808   # while "bad" languages go in missing_languages.  Leave no duplicates.
4809   for i in `echo $enable_stage1_languages | sed 's/,/ /g' `; do
4810     case $potential_languages in
4811       *,$i,*)
4812         case $stage1_languages in
4813           *,$i,*) ;;
4814           *) stage1_languages="$stage1_languages$i," ;;
4815         esac ;;
4816       *)
4817         case $missing_languages in
4818           *,$i,*) ;;
4819           *) missing_languages="$missing_languages$i," ;;
4820         esac ;;
4821      esac
4822   done
4823 fi;
4824
4825   # Remove leading/trailing commas that were added for simplicity
4826   potential_languages=`echo "$potential_languages" | sed -e "s/^,//" -e "s/,$//"`
4827   missing_languages=`echo "$missing_languages" | sed -e "s/^,//" -e "s/,$//"`
4828   stage1_languages=`echo "$stage1_languages" | sed -e "s/^,//" -e "s/,$//"`
4829   new_enable_languages=`echo "$new_enable_languages" | sed -e "s/^,//" -e "s/,$//"`
4830
4831   if test "x$missing_languages" != x; then
4832     { { echo "$as_me:$LINENO: error:
4833 The following requested languages could not be built: ${missing_languages}
4834 Supported languages are: ${potential_languages}" >&5
4835 echo "$as_me: error:
4836 The following requested languages could not be built: ${missing_languages}
4837 Supported languages are: ${potential_languages}" >&2;}
4838    { (exit 1); exit 1; }; }
4839   fi
4840   if test "x$new_enable_languages" != "x$enable_languages"; then
4841     echo The following languages will be built: ${new_enable_languages}
4842     enable_languages="$new_enable_languages"
4843   fi
4844
4845
4846   ac_configure_args=`echo " $ac_configure_args" | sed -e "s/ '--enable-languages=[^ ]*'//g" -e "s/$/ '--enable-languages="$enable_languages"'/" `
4847 fi
4848
4849 # Handle --disable-<component> generically.
4850 for dir in $configdirs $build_configdirs $target_configdirs ; do
4851   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g -e s/-/_/g`
4852   if eval test x\${enable_${dirname}} "=" xno ; then
4853     noconfigdirs="$noconfigdirs $dir"
4854   fi
4855 done
4856
4857 # Check for Boehm's garbage collector
4858 # Check whether --enable-objc-gc or --disable-objc-gc was given.
4859 if test "${enable_objc_gc+set}" = set; then
4860   enableval="$enable_objc_gc"
4861   case ,${enable_languages},:${enable_objc_gc}:${noconfigdirs} in
4862   *,objc,*:*:yes:*target-boehm-gc*)
4863     { { echo "$as_me:$LINENO: error: Boehm's garbage collector was requested yet not supported in this configuration" >&5
4864 echo "$as_me: error: Boehm's garbage collector was requested yet not supported in this configuration" >&2;}
4865    { (exit 1); exit 1; }; }
4866     ;;
4867 esac
4868 fi;
4869
4870 # Make sure we only build Boehm's garbage collector if required.
4871 case ,${enable_languages},:${enable_objc_gc} in
4872   *,objc,*:yes)
4873     # Keep target-boehm-gc if requested for Objective-C.
4874     ;;
4875   *)
4876     # Otherwise remove target-boehm-gc depending on target-libjava.
4877     if echo " ${noconfigdirs} " | grep "target-libjava" >/dev/null 2>&1; then
4878       noconfigdirs="$noconfigdirs target-boehm-gc"
4879     fi
4880     ;;
4881 esac
4882
4883 # Remove the entries in $skipdirs and $noconfigdirs from $configdirs,
4884 # $build_configdirs and $target_configdirs.
4885 # If we have the source for $noconfigdirs entries, add them to $notsupp.
4886
4887 notsupp=""
4888 for dir in . $skipdirs $noconfigdirs ; do
4889   dirname=`echo $dir | sed -e s/target-//g -e s/build-//g`
4890   if test $dir != .  && echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4891     configdirs=`echo " ${configdirs} " | sed -e "s/ ${dir} / /"`
4892     if test -r $srcdir/$dirname/configure ; then
4893       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4894         true
4895       else
4896         notsupp="$notsupp $dir"
4897       fi
4898     fi
4899   fi
4900   if test $dir != .  && echo " ${build_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4901     build_configdirs=`echo " ${build_configdirs} " | sed -e "s/ ${dir} / /"`
4902     if test -r $srcdir/$dirname/configure ; then
4903       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4904         true
4905       else
4906         notsupp="$notsupp $dir"
4907       fi
4908     fi
4909   fi
4910   if test $dir != . && echo " ${target_configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4911     target_configdirs=`echo " ${target_configdirs} " | sed -e "s/ ${dir} / /"`
4912     if test -r $srcdir/$dirname/configure ; then
4913       if echo " ${skipdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4914         true
4915       else
4916         notsupp="$notsupp $dir"
4917       fi
4918     fi
4919   fi
4920 done
4921
4922 # Sometimes the tools are distributed with libiberty but with no other
4923 # libraries.  In that case, we don't want to build target-libiberty.
4924 # Don't let libgcc imply libiberty either.
4925 if test -n "${target_configdirs}" ; then
4926   libgcc=
4927   others=
4928   for i in `echo ${target_configdirs} | sed -e s/target-//g` ; do
4929     if test "$i" = "libgcc"; then
4930       libgcc=target-libgcc
4931     elif test "$i" != "libiberty" ; then
4932       if test -r $srcdir/$i/configure ; then
4933         others=yes;
4934         break;
4935       fi
4936     fi
4937   done
4938   if test -z "${others}" ; then
4939     target_configdirs=$libgcc
4940   fi
4941 fi
4942
4943 # Quietly strip out all directories which aren't configurable in this tree.
4944 # This relies on all configurable subdirectories being autoconfiscated, which
4945 # is now the case.
4946 build_configdirs_all="$build_configdirs"
4947 build_configdirs=
4948 for i in ${build_configdirs_all} ; do
4949   j=`echo $i | sed -e s/build-//g`
4950   if test -f ${srcdir}/$j/configure ; then
4951     build_configdirs="${build_configdirs} $i"
4952   fi
4953 done
4954
4955 configdirs_all="$configdirs"
4956 configdirs=
4957 for i in ${configdirs_all} ; do
4958   if test -f ${srcdir}/$i/configure ; then
4959     configdirs="${configdirs} $i"
4960   fi
4961 done
4962
4963 target_configdirs_all="$target_configdirs"
4964 target_configdirs=
4965 for i in ${target_configdirs_all} ; do
4966   j=`echo $i | sed -e s/target-//g`
4967   if test -f ${srcdir}/$j/configure ; then
4968     target_configdirs="${target_configdirs} $i"
4969   fi
4970 done
4971
4972 # Produce a warning message for the subdirs we can't configure.
4973 # This isn't especially interesting in the Cygnus tree, but in the individual
4974 # FSF releases, it's important to let people know when their machine isn't
4975 # supported by the one or two programs in a package.
4976
4977 if test -n "${notsupp}" && test -z "${norecursion}" ; then
4978   # If $appdirs is non-empty, at least one of those directories must still
4979   # be configured, or we error out.  (E.g., if the gas release supports a
4980   # specified target in some subdirs but not the gas subdir, we shouldn't
4981   # pretend that all is well.)
4982   if test -n "$appdirs" ; then
4983     for dir in $appdirs ; do
4984       if test -r $dir/Makefile.in ; then
4985         if echo " ${configdirs} " | grep " ${dir} " >/dev/null 2>&1; then
4986           appdirs=""
4987           break
4988         fi
4989         if echo " ${target_configdirs} " | grep " target-${dir} " >/dev/null 2>&1; then
4990           appdirs=""
4991           break
4992         fi
4993       fi
4994     done
4995     if test -n "$appdirs" ; then
4996       echo "*** This configuration is not supported by this package." 1>&2
4997       exit 1
4998     fi
4999   fi
5000   # Okay, some application will build, or we don't care to check.  Still
5001   # notify of subdirs not getting built.
5002   echo "*** This configuration is not supported in the following subdirectories:" 1>&2
5003   echo "    ${notsupp}" 1>&2
5004   echo "    (Any other directories should still work fine.)" 1>&2
5005 fi
5006
5007 case "$host" in
5008   *msdosdjgpp*)
5009     enable_gdbtk=no ;;
5010 esac
5011
5012 # To find our prefix, in gcc_cv_tool_prefix.
5013
5014 # The user is always right.
5015 if test "${PATH_SEPARATOR+set}" != set; then
5016   echo "#! /bin/sh" >conf$$.sh
5017   echo  "exit 0"   >>conf$$.sh
5018   chmod +x conf$$.sh
5019   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
5020     PATH_SEPARATOR=';'
5021   else
5022     PATH_SEPARATOR=:
5023   fi
5024   rm -f conf$$.sh
5025 fi
5026
5027
5028
5029 if test "x$exec_prefix" = xNONE; then
5030         if test "x$prefix" = xNONE; then
5031                 gcc_cv_tool_prefix=$ac_default_prefix
5032         else
5033                 gcc_cv_tool_prefix=$prefix
5034         fi
5035 else
5036         gcc_cv_tool_prefix=$exec_prefix
5037 fi
5038
5039 # If there is no compiler in the tree, use the PATH only.  In any
5040 # case, if there is no compiler in the tree nobody should use
5041 # AS_FOR_TARGET and LD_FOR_TARGET.
5042 if test x$host = x$build && test -f $srcdir/gcc/BASE-VER; then
5043     gcc_version=`cat $srcdir/gcc/BASE-VER`
5044     gcc_cv_tool_dirs="$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5045     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/libexec/gcc/$target_noncanonical$PATH_SEPARATOR"
5046     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5047     gcc_cv_tool_dirs="$gcc_cv_tool_dirs/usr/lib/gcc/$target_noncanonical$PATH_SEPARATOR"
5048     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin/$target_noncanonical/$gcc_version$PATH_SEPARATOR"
5049     gcc_cv_tool_dirs="$gcc_cv_tool_dirs$gcc_cv_tool_prefix/$target_noncanonical/bin$PATH_SEPARATOR"
5050 else
5051     gcc_cv_tool_dirs=
5052 fi
5053
5054 if test x$build = x$target && test -n "$md_exec_prefix"; then
5055         gcc_cv_tool_dirs="$gcc_cv_tool_dirs$md_exec_prefix$PATH_SEPARATOR"
5056 fi
5057
5058
5059
5060 copy_dirs=
5061
5062
5063 # Check whether --with-build-sysroot or --without-build-sysroot was given.
5064 if test "${with_build_sysroot+set}" = set; then
5065   withval="$with_build_sysroot"
5066   if test x"$withval" != x ; then
5067      SYSROOT_CFLAGS_FOR_TARGET="--sysroot=$withval"
5068    fi
5069 else
5070   SYSROOT_CFLAGS_FOR_TARGET=
5071 fi;
5072
5073
5074
5075 # Check whether --with-debug-prefix-map or --without-debug-prefix-map was given.
5076 if test "${with_debug_prefix_map+set}" = set; then
5077   withval="$with_debug_prefix_map"
5078   if test x"$withval" != x; then
5079      DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5080      for debug_map in $withval; do
5081        DEBUG_PREFIX_CFLAGS_FOR_TARGET="$DEBUG_PREFIX_CFLAGS_FOR_TARGET -fdebug-prefix-map=$debug_map"
5082      done
5083    fi
5084 else
5085   DEBUG_PREFIX_CFLAGS_FOR_TARGET=
5086 fi;
5087
5088
5089 # Handle --with-headers=XXX.  If the value is not "yes", the contents of
5090 # the named directory are copied to $(tooldir)/sys-include.
5091 if test x"${with_headers}" != x && test x"${with_headers}" != xno ; then
5092   if test x${is_cross_compiler} = xno ; then
5093     echo 1>&2 '***' --with-headers is only supported when cross compiling
5094     exit 1
5095   fi
5096   if test x"${with_headers}" != xyes ; then
5097     x=${gcc_cv_tool_prefix}
5098     copy_dirs="${copy_dirs} ${with_headers} $x/${target_noncanonical}/sys-include"
5099   fi
5100 fi
5101
5102 # Handle --with-libs=XXX.  If the value is not "yes", the contents of
5103 # the name directories are copied to $(tooldir)/lib.  Multiple directories
5104 # are permitted.
5105 if test x"${with_libs}" != x && test x"${with_libs}" != xno ; then
5106   if test x${is_cross_compiler} = xno ; then
5107     echo 1>&2 '***' --with-libs is only supported when cross compiling
5108     exit 1
5109   fi
5110   if test x"${with_libs}" != xyes ; then
5111     # Copy the libraries in reverse order, so that files in the first named
5112     # library override files in subsequent libraries.
5113     x=${gcc_cv_tool_prefix}
5114     for l in ${with_libs}; do
5115       copy_dirs="$l $x/${target_noncanonical}/lib ${copy_dirs}"
5116     done
5117   fi
5118 fi
5119
5120 # Set with_gnu_as and with_gnu_ld as appropriate.
5121 #
5122 # This is done by determining whether or not the appropriate directory
5123 # is available, and by checking whether or not specific configurations
5124 # have requested that this magic not happen.
5125 #
5126 # The command line options always override the explicit settings in
5127 # configure.in, and the settings in configure.in override this magic.
5128 #
5129 # If the default for a toolchain is to use GNU as and ld, and you don't
5130 # want to do that, then you should use the --without-gnu-as and
5131 # --without-gnu-ld options for the configure script.
5132
5133 if test x${use_gnu_as} = x &&
5134    echo " ${configdirs} " | grep " gas " > /dev/null 2>&1 ; then
5135   with_gnu_as=yes
5136   extra_host_args="$extra_host_args --with-gnu-as"
5137 fi
5138
5139 if test x${use_gnu_ld} = x &&
5140    echo " ${configdirs} " | grep " ld " > /dev/null 2>&1 ; then
5141   with_gnu_ld=yes
5142   extra_host_args="$extra_host_args --with-gnu-ld"
5143 fi
5144
5145 # If using newlib, add --with-newlib to the extra_host_args so that gcc/configure
5146 # can detect this case.
5147
5148 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " target-newlib " > /dev/null 2>&1 ; then
5149   with_newlib=yes
5150   extra_host_args="$extra_host_args --with-newlib"
5151 fi
5152
5153 # Handle ${copy_dirs}
5154 set fnord ${copy_dirs}
5155 shift
5156 while test $# != 0 ; do
5157   if test -f $2/COPIED && test x"`cat $2/COPIED`" = x"$1" ; then
5158     :
5159   else
5160     echo Copying $1 to $2
5161
5162     # Use the install script to create the directory and all required
5163     # parent directories.
5164     if test -d $2 ; then
5165       :
5166     else
5167       echo >config.temp
5168       ${srcdir}/install-sh -c -m 644 config.temp $2/COPIED
5169     fi
5170
5171     # Copy the directory, assuming we have tar.
5172     # FIXME: Should we use B in the second tar?  Not all systems support it.
5173     (cd $1; tar -cf - .) | (cd $2; tar -xpf -)
5174
5175     # It is the responsibility of the user to correctly adjust all
5176     # symlinks.  If somebody can figure out how to handle them correctly
5177     # here, feel free to add the code.
5178
5179     echo $1 > $2/COPIED
5180   fi
5181   shift; shift
5182 done
5183
5184 # Determine a target-dependent exec_prefix that the installed
5185 # gcc will search in.  Keep this list sorted by triplet, with
5186 # the *-*-osname triplets last.
5187 md_exec_prefix=
5188 case "${target}" in
5189   alpha*-*-*vms*)
5190     md_exec_prefix=/gnu/lib/gcc-lib
5191     ;;
5192   i[34567]86-pc-msdosdjgpp*)
5193     md_exec_prefix=/dev/env/DJDIR/bin
5194     ;;
5195   i[34567]86-*-sco3.2v5*)
5196     if test $with_gnu_as = yes; then
5197       md_exec_prefix=/usr/gnu/bin
5198     else
5199       md_exec_prefix=/usr/ccs/bin/elf
5200     fi
5201     ;;
5202
5203   mn10300-*-* | \
5204   powerpc-*-chorusos* | \
5205   powerpc*-*-eabi* | \
5206   powerpc*-*-sysv* | \
5207   powerpc*-*-kaos* | \
5208   s390x-ibm-tpf*)
5209     md_exec_prefix=/usr/ccs/bin
5210     ;;
5211   sparc64-*-elf*)
5212     ;;
5213   v850*-*-*)
5214     md_exec_prefix=/usr/ccs/bin
5215     ;;
5216   xtensa-*-elf*)
5217     ;;
5218
5219   *-*-beos* | \
5220   *-*-elf* | \
5221   *-*-hpux* | \
5222   *-*-netware* | \
5223   *-*-nto-qnx* | \
5224   *-*-rtems* | \
5225   *-*-solaris2* | \
5226   *-*-sysv[45]* | \
5227   *-*-vxworks* | \
5228   *-wrs-windiss)
5229     md_exec_prefix=/usr/ccs/bin
5230     ;;
5231 esac
5232
5233 extra_arflags_for_target=
5234 extra_nmflags_for_target=
5235 extra_ranlibflags_for_target=
5236 target_makefile_frag=/dev/null
5237 case "${target}" in
5238   mep*-*-*)
5239     target_makefile_frag="config/mt-mep"
5240     ;;
5241   spu-*-*)
5242     target_makefile_frag="config/mt-spu"
5243     ;;
5244   mips*-sde-elf*)
5245     target_makefile_frag="config/mt-sde"
5246     ;;
5247   *-*-netware*)
5248     target_makefile_frag="config/mt-netware"
5249     ;;
5250   *-*-linux* | *-*-gnu* | *-*-k*bsd*-gnu)
5251     target_makefile_frag="config/mt-gnu"
5252     ;;
5253   *-*-aix4.[3456789]* | *-*-aix[56789].*)
5254     # nm and ar from AIX 4.3 and above require -X32_64 flag to all ar and nm
5255     # commands to handle both 32-bit and 64-bit objects.  These flags are
5256     # harmless if we're using GNU nm or ar.
5257     extra_arflags_for_target=" -X32_64"
5258     extra_nmflags_for_target=" -B -X32_64"
5259     ;;
5260   *-*-darwin*)
5261     # ranlib from Darwin requires the -c flag to look at common symbols.
5262     extra_ranlibflags_for_target=" -c"
5263     ;;
5264   mips*-*-pe | sh*-*-pe | *arm-wince-pe)
5265     target_makefile_frag="config/mt-wince"
5266     ;;
5267 esac
5268
5269 alphaieee_frag=/dev/null
5270 case $target in
5271   alpha*-*-*)
5272     # This just makes sure to use the -mieee option to build target libs.
5273     # This should probably be set individually by each library.
5274     alphaieee_frag="config/mt-alphaieee"
5275     ;;
5276 esac
5277
5278 # If --enable-target-optspace always use -Os instead of -O2 to build
5279 # the target libraries, similarly if it is not specified, use -Os
5280 # on selected platforms.
5281 ospace_frag=/dev/null
5282 case "${enable_target_optspace}:${target}" in
5283   yes:*)
5284     ospace_frag="config/mt-ospace"
5285     ;;
5286   :d30v-*)
5287     ospace_frag="config/mt-d30v"
5288     ;;
5289   :m32r-* | :d10v-* | :fr30-*)
5290     ospace_frag="config/mt-ospace"
5291     ;;
5292   no:* | :*)
5293     ;;
5294   *)
5295     echo "*** bad value \"${enable_target_optspace}\" for --enable-target-optspace flag; ignored" 1>&2
5296     ;;
5297 esac
5298
5299 # Default to using --with-stabs for certain targets.
5300 if test x${with_stabs} = x ; then
5301   case "${target}" in
5302   mips*-*-irix[56]*)
5303     ;;
5304   mips*-*-* | alpha*-*-osf*)
5305     with_stabs=yes;
5306     extra_host_args="${extra_host_args} --with-stabs"
5307     ;;
5308   esac
5309 fi
5310
5311 # hpux11 in 64bit mode has libraries in a weird place.  Arrange to find
5312 # them automatically.
5313 case "${host}" in
5314   hppa*64*-*-hpux11*)
5315     extra_host_args="$extra_host_args -x-libraries=/usr/lib/pa20_64 -x-includes=/usr/X11R6/include"
5316     ;;
5317 esac
5318
5319 # Some systems (e.g., one of the i386-aix systems the gas testers are
5320 # using) don't handle "\$" correctly, so don't use it here.
5321 tooldir='${exec_prefix}'/${target_noncanonical}
5322 build_tooldir=${tooldir}
5323
5324 # Create a .gdbinit file which runs the one in srcdir
5325 # and tells GDB to look there for source files.
5326
5327 if test -r ${srcdir}/.gdbinit ; then
5328   case ${srcdir} in
5329     .) ;;
5330     *) cat > ./.gdbinit <<EOF
5331 # ${NO_EDIT}
5332 dir ${srcdir}
5333 dir .
5334 source ${srcdir}/.gdbinit
5335 EOF
5336     ;;
5337   esac
5338 fi
5339
5340 # Make sure that the compiler is able to generate an executable.  If it
5341 # can't, we are probably in trouble.  We don't care whether we can run the
5342 # executable--we might be using a cross compiler--we only care whether it
5343 # can be created.  At this point the main configure script has set CC.
5344 we_are_ok=no
5345 echo "int main () { return 0; }" > conftest.c
5346 ${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c
5347 if test $? = 0 ; then
5348   if test -s conftest || test -s conftest.exe ; then
5349     we_are_ok=yes
5350   fi
5351 fi
5352 case $we_are_ok in
5353   no)
5354     echo 1>&2 "*** The command '${CC} -o conftest ${CFLAGS} ${CPPFLAGS} ${LDFLAGS} conftest.c' failed."
5355     echo 1>&2 "*** You must set the environment variable CC to a working compiler."
5356     rm -f conftest*
5357     exit 1
5358     ;;
5359 esac
5360 rm -f conftest*
5361
5362 # The Solaris /usr/ucb/cc compiler does not appear to work.
5363 case "${host}" in
5364   sparc-sun-solaris2*)
5365       CCBASE="`echo ${CC-cc} | sed 's/ .*$//'`"
5366       if test "`type $CCBASE | sed 's/^[^/]*//'`" = "/usr/ucb/cc" ; then
5367           could_use=
5368           test -d /opt/SUNWspro/bin && could_use="/opt/SUNWspro/bin"
5369           if test -d /opt/cygnus/bin ; then
5370               if test "$could_use" = "" ; then
5371                   could_use="/opt/cygnus/bin"
5372               else
5373                   could_use="$could_use or /opt/cygnus/bin"
5374               fi
5375           fi
5376         if test "$could_use" = "" ; then
5377             echo "Warning: compilation may fail because you're using"
5378             echo "/usr/ucb/cc.  You should change your PATH or CC "
5379             echo "variable and rerun configure."
5380         else
5381             echo "Warning: compilation may fail because you're using"
5382             echo "/usr/ucb/cc, when you should use the C compiler from"
5383             echo "$could_use.  You should change your"
5384             echo "PATH or CC variable and rerun configure."
5385         fi
5386       fi
5387   ;;
5388 esac
5389
5390 case "${host}" in
5391   *-*-hpux*) RPATH_ENVVAR=SHLIB_PATH ;;
5392   *-*-darwin* | *-*-rhapsody* ) RPATH_ENVVAR=DYLD_LIBRARY_PATH ;;
5393   *) RPATH_ENVVAR=LD_LIBRARY_PATH ;;
5394 esac
5395
5396 # Record target_configdirs and the configure arguments for target and
5397 # build configuration in Makefile.
5398 target_configdirs=`echo "${target_configdirs}" | sed -e 's/target-//g'`
5399 build_configdirs=`echo "${build_configdirs}" | sed -e 's/build-//g'`
5400
5401 # Determine whether gdb needs tk/tcl or not.
5402 # Use 'maybe' since enable_gdbtk might be true even if tk isn't available
5403 # and in that case we want gdb to be built without tk.  Ugh!
5404 # In fact I believe gdb is the *only* package directly dependent on tk,
5405 # so we should be able to put the 'maybe's in unconditionally and
5406 # leave out the maybe dependencies when enable_gdbtk is false.  I'm not
5407 # 100% sure that that's safe though.
5408
5409 gdb_tk="maybe-all-tcl maybe-all-tk maybe-all-itcl maybe-all-libgui"
5410 case "$enable_gdbtk" in
5411   no)
5412     GDB_TK="" ;;
5413   yes)
5414     GDB_TK="${gdb_tk}" ;;
5415   *)
5416     # Only add the dependency on gdbtk when GDBtk is part of the gdb
5417     # distro.  Eventually someone will fix this and move Insight, nee
5418     # gdbtk to a separate directory.
5419     if test -d ${srcdir}/gdb/gdbtk ; then
5420       GDB_TK="${gdb_tk}"
5421     else
5422       GDB_TK=""
5423     fi
5424     ;;
5425 esac
5426 CONFIGURE_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-configure-/g`
5427 INSTALL_GDB_TK=`echo ${GDB_TK} | sed s/-all-/-install-/g`
5428
5429 # Strip out unwanted targets.
5430
5431 # While at that, we remove Makefiles if we were started for recursive
5432 # configuration, so that the top-level Makefile reconfigures them,
5433 # like we used to do when configure itself was recursive.
5434
5435 # Loop over modules.  $extrasub must be used with care, limiting as
5436 # much as possible the usage of range addresses.  That's because autoconf
5437 # splits the sed script to overcome limits in the number of commands,
5438 # and relying on carefully-timed sed passes may turn out to be very hard
5439 # to maintain later.  In this particular case, you just have to be careful
5440 # not to nest @if/@endif pairs, because configure will not warn you at all.
5441
5442 # Check whether --enable-bootstrap or --disable-bootstrap was given.
5443 if test "${enable_bootstrap+set}" = set; then
5444   enableval="$enable_bootstrap"
5445
5446 else
5447   enable_bootstrap=default
5448 fi;
5449
5450 # Issue errors and warnings for invalid/strange bootstrap combinations.
5451 case "$configdirs" in
5452   *gcc*) have_compiler=yes ;;
5453   *) have_compiler=no ;;
5454 esac
5455
5456 case "$have_compiler:$host:$target:$enable_bootstrap" in
5457   *:*:*:no) ;;
5458
5459   # Default behavior.  Enable bootstrap if we have a compiler
5460   # and we are in a native configuration.
5461   yes:$build:$build:default)
5462     enable_bootstrap=yes ;;
5463
5464   *:*:*:default)
5465     enable_bootstrap=no ;;
5466
5467   # We have a compiler and we are in a native configuration, bootstrap is ok
5468   yes:$build:$build:yes)
5469     ;;
5470
5471   # Other configurations, but we have a compiler.  Assume the user knows
5472   # what he's doing.
5473   yes:*:*:yes)
5474     { echo "$as_me:$LINENO: WARNING: trying to bootstrap a cross compiler" >&5
5475 echo "$as_me: WARNING: trying to bootstrap a cross compiler" >&2;}
5476     ;;
5477
5478   # No compiler: if they passed --enable-bootstrap explicitly, fail
5479   no:*:*:yes)
5480     { { echo "$as_me:$LINENO: error: cannot bootstrap without a compiler" >&5
5481 echo "$as_me: error: cannot bootstrap without a compiler" >&2;}
5482    { (exit 1); exit 1; }; } ;;
5483
5484   # Fail if wrong command line
5485   *)
5486     { { echo "$as_me:$LINENO: error: invalid option for --enable-bootstrap" >&5
5487 echo "$as_me: error: invalid option for --enable-bootstrap" >&2;}
5488    { (exit 1); exit 1; }; }
5489     ;;
5490 esac
5491
5492 # Adjust the toplevel makefile according to whether bootstrap was selected.
5493 case "$enable_bootstrap" in
5494   yes)
5495     bootstrap_suffix=bootstrap ;;
5496   no)
5497     bootstrap_suffix=no-bootstrap ;;
5498 esac
5499
5500 for module in ${build_configdirs} ; do
5501   if test -z "${no_recursion}" \
5502      && test -f ${build_subdir}/${module}/Makefile; then
5503     echo 1>&2 "*** removing ${build_subdir}/${module}/Makefile to force reconfigure"
5504     rm -f ${build_subdir}/${module}/Makefile
5505   fi
5506   extrasub="$extrasub
5507 /^@if build-$module\$/d
5508 /^@endif build-$module\$/d
5509 /^@if build-$module-$bootstrap_suffix\$/d
5510 /^@endif build-$module-$bootstrap_suffix\$/d"
5511 done
5512 for module in ${configdirs} ; do
5513   if test -z "${no_recursion}"; then
5514     for file in stage*-${module}/Makefile prev-${module}/Makefile ${module}/Makefile; do
5515       if test -f ${file}; then
5516         echo 1>&2 "*** removing ${file} to force reconfigure"
5517         rm -f ${file}
5518       fi
5519     done
5520   fi
5521   extrasub="$extrasub
5522 /^@if $module\$/d
5523 /^@endif $module\$/d
5524 /^@if $module-$bootstrap_suffix\$/d
5525 /^@endif $module-$bootstrap_suffix\$/d"
5526 done
5527 for module in ${target_configdirs} ; do
5528   if test -z "${no_recursion}" \
5529      && test -f ${target_subdir}/${module}/Makefile; then
5530     echo 1>&2 "*** removing ${target_subdir}/${module}/Makefile to force reconfigure"
5531     rm -f ${target_subdir}/${module}/Makefile
5532   fi
5533   extrasub="$extrasub
5534 /^@if target-$module\$/d
5535 /^@endif target-$module\$/d
5536 /^@if target-$module-$bootstrap_suffix\$/d
5537 /^@endif target-$module-$bootstrap_suffix\$/d"
5538 done
5539
5540 extrasub="$extrasub
5541 /^@if /,/^@endif /d"
5542
5543 # Create the serialization dependencies.  This uses a temporary file.
5544
5545 # Check whether --enable-serial-configure or --disable-serial-configure was given.
5546 if test "${enable_serial_configure+set}" = set; then
5547   enableval="$enable_serial_configure"
5548
5549 fi;
5550
5551 case ${enable_serial_configure} in
5552   yes)
5553     enable_serial_build_configure=yes
5554     enable_serial_host_configure=yes
5555     enable_serial_target_configure=yes
5556     ;;
5557 esac
5558
5559 # These force 'configure's to be done one at a time, to avoid problems
5560 # with contention over a shared config.cache.
5561 rm -f serdep.tmp
5562 echo '# serdep.tmp' > serdep.tmp
5563 olditem=
5564 test "x${enable_serial_build_configure}" = xyes &&
5565 for item in ${build_configdirs} ; do
5566   case ${olditem} in
5567     "") ;;
5568     *) echo "configure-build-${item}: configure-build-${olditem}" >> serdep.tmp ;;
5569   esac
5570   olditem=${item}
5571 done
5572 olditem=
5573 test "x${enable_serial_host_configure}" = xyes &&
5574 for item in ${configdirs} ; do
5575   case ${olditem} in
5576     "") ;;
5577     *) echo "configure-${item}: configure-${olditem}" >> serdep.tmp ;;
5578   esac
5579   olditem=${item}
5580 done
5581 olditem=
5582 test "x${enable_serial_target_configure}" = xyes &&
5583 for item in ${target_configdirs} ; do
5584   case ${olditem} in
5585     "") ;;
5586     *) echo "configure-target-${item}: configure-target-${olditem}" >> serdep.tmp ;;
5587   esac
5588   olditem=${item}
5589 done
5590 serialization_dependencies=serdep.tmp
5591
5592
5593 # Base args.  Strip norecursion, cache-file, srcdir, host, build,
5594 # target, nonopt, and variable assignments.  These are the ones we
5595 # might not want to pass down to subconfigures.  Also strip
5596 # program-prefix, program-suffix, and program-transform-name, so that
5597 # we can pass down a consistent program-transform-name.
5598 baseargs=
5599 keep_next=no
5600 skip_next=no
5601 eval "set -- $ac_configure_args"
5602 for ac_arg
5603 do
5604   if test X"$skip_next" = X"yes"; then
5605     skip_next=no
5606     continue
5607   fi
5608   if test X"$keep_next" = X"yes"; then
5609     case $ac_arg in
5610       *\'*)
5611         ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5612     esac
5613     baseargs="$baseargs '$ac_arg'"
5614     keep_next=no
5615     continue
5616   fi
5617
5618   # Handle separated arguments.  Based on the logic generated by
5619   # autoconf 2.59.
5620   case $ac_arg in
5621     *=* | --config-cache | -C | -disable-* | --disable-* \
5622       | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
5623       | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
5624       | -with-* | --with-* | -without-* | --without-* | --x)
5625       separate_arg=no
5626       ;;
5627     -*)
5628       separate_arg=yes
5629       ;;
5630     *)
5631       separate_arg=no
5632       ;;
5633   esac
5634
5635   case "$ac_arg" in
5636     --no*)
5637       continue
5638       ;;
5639     --c* | \
5640     --sr* | \
5641     --ho* | \
5642     --bu* | \
5643     --t* | \
5644     --program-* | \
5645     -cache_file* | \
5646     -srcdir* | \
5647     -host* | \
5648     -build* | \
5649     -target* | \
5650     -program-prefix* | \
5651     -program-suffix* | \
5652     -program-transform-name* )
5653       skip_next=$separate_arg
5654       continue
5655       ;;
5656     -*)
5657       # An option.  Add it.
5658       case $ac_arg in
5659         *\'*)
5660           ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
5661       esac
5662       baseargs="$baseargs '$ac_arg'"
5663       keep_next=$separate_arg
5664       ;;
5665     *)
5666       # Either a variable assignment, or a nonopt (triplet).  Don't
5667       # pass it down; let the Makefile handle this.
5668       continue
5669       ;;
5670   esac
5671 done
5672 # Remove the initial space we just introduced and, as these will be
5673 # expanded by make, quote '$'.
5674 baseargs=`echo "x$baseargs" | sed -e 's/^x *//' -e 's,\\$,$$,g'`
5675
5676 # Add in --program-transform-name, after --program-prefix and
5677 # --program-suffix have been applied to it.  Autoconf has already
5678 # doubled dollar signs and backslashes in program_transform_name; we want
5679 # the backslashes un-doubled, and then the entire thing wrapped in single
5680 # quotes, because this will be expanded first by make and then by the shell.
5681 # Also, because we want to override the logic in subdir configure scripts to
5682 # choose program_transform_name, replace any s,x,x, with s,y,y,.
5683 sed -e "s,\\\\\\\\,\\\\,g; s,','\\\\'',g; s/s,x,x,/s,y,y,/" <<EOF_SED > conftestsed.out
5684 ${program_transform_name}
5685 EOF_SED
5686 gcc_transform_name=`cat conftestsed.out`
5687 rm -f conftestsed.out
5688 baseargs="$baseargs --program-transform-name='${gcc_transform_name}'"
5689 if test "$silent" = yes; then
5690   baseargs="$baseargs --silent"
5691 fi
5692
5693 # For the build-side libraries, we just need to pretend we're native,
5694 # and not use the same cache file.  Multilibs are neither needed nor
5695 # desired.
5696 build_configargs="--cache-file=../config.cache ${baseargs}"
5697
5698 # For host modules, accept cache file option, or specification as blank.
5699 case "${cache_file}" in
5700 "") # empty
5701   cache_file_option="" ;;
5702 /* | [A-Za-z]:[\\/]* ) # absolute path
5703   cache_file_option="--cache-file=${cache_file}" ;;
5704 *) # relative path
5705   cache_file_option="--cache-file=../${cache_file}" ;;
5706 esac
5707
5708 # Host dirs don't like to share a cache file either, horribly enough.
5709 # This seems to be due to autoconf 2.5x stupidity.
5710 host_configargs="--cache-file=./config.cache ${extra_host_args} ${baseargs}"
5711
5712 target_configargs=${baseargs}
5713
5714 # Passing a --with-cross-host argument lets the target libraries know
5715 # whether they are being built with a cross-compiler or being built
5716 # native.  However, it would be better to use other mechanisms to make the
5717 # sorts of decisions they want to make on this basis.  Please consider
5718 # this option to be deprecated.  FIXME.
5719 if test x${is_cross_compiler} = xyes ; then
5720   target_configargs="--with-cross-host=${host_noncanonical} ${target_configargs}"
5721 fi
5722
5723 # Default to --enable-multilib.
5724 if test x${enable_multilib} = x ; then
5725   target_configargs="--enable-multilib ${target_configargs}"
5726 fi
5727
5728 # Pass --with-newlib if appropriate.  Note that target_configdirs has
5729 # changed from the earlier setting of with_newlib.
5730 if test x${with_newlib} != xno && echo " ${target_configdirs} " | grep " newlib " > /dev/null 2>&1 && test -d ${srcdir}/newlib ; then
5731   target_configargs="--with-newlib ${target_configargs}"
5732 fi
5733
5734 # Different target subdirs use different values of certain variables
5735 # (notably CXX).  Worse, multilibs use *lots* of different values.
5736 # Worse yet, autoconf 2.5x makes some of these 'precious', meaning that
5737 # it doesn't automatically accept command-line overrides of them.
5738 # This means it's not safe for target subdirs to share a cache file,
5739 # which is disgusting, but there you have it.  Hopefully this can be
5740 # fixed in future.  It's still worthwhile to use a cache file for each
5741 # directory.  I think.
5742
5743 # Pass the appropriate --build, --host, --target and --cache-file arguments.
5744 # We need to pass --target, as newer autoconf's requires consistency
5745 # for target_alias and gcc doesn't manage it consistently.
5746 target_configargs="--cache-file=./config.cache ${target_configargs}"
5747
5748 FLAGS_FOR_TARGET=
5749 case " $target_configdirs " in
5750  *" newlib "*)
5751   case " $target_configargs " in
5752   *" --with-newlib "*)
5753    case "$target" in
5754    *-cygwin*)
5755      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' ;;
5756    esac
5757
5758    # If we're not building GCC, don't discard standard headers.
5759    if test -d ${srcdir}/gcc; then
5760      FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -nostdinc'
5761
5762      if test "${build}" != "${host}"; then
5763        # On Canadian crosses, CC_FOR_TARGET will have already been set
5764        # by `configure', so we won't have an opportunity to add -Bgcc/
5765        # to it.  This is right: we don't want to search that directory
5766        # for binaries, but we want the header files in there, so add
5767        # them explicitly.
5768        FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -isystem $$r/$(HOST_SUBDIR)/gcc/include'
5769
5770        # Someone might think of using the pre-installed headers on
5771        # Canadian crosses, in case the installed compiler is not fully
5772        # compatible with the compiler being built.  In this case, it
5773        # would be better to flag an error than risking having
5774        # incompatible object files being constructed.  We can't
5775        # guarantee that an error will be flagged, but let's hope the
5776        # compiler will do it, when presented with incompatible header
5777        # files.
5778      fi
5779    fi
5780
5781    case "${target}-${is_cross_compiler}" in
5782    i[3456789]86-*-linux*-no)
5783       # Here host == target, so we don't need to build gcc,
5784       # so we don't want to discard standard headers.
5785       FLAGS_FOR_TARGET=`echo " $FLAGS_FOR_TARGET " | sed -e 's/ -nostdinc / /'`
5786       ;;
5787    *)
5788       # If we're building newlib, use its generic headers last, but search
5789       # for any libc-related directories first (so make it the last -B
5790       # switch).
5791       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/newlib/ -isystem $$r/$(TARGET_SUBDIR)/newlib/targ-include -isystem $$s/newlib/libc/include'
5792       ;;
5793    esac
5794    ;;
5795   esac
5796   ;;
5797 esac
5798 case "$target" in
5799 *-mingw*)
5800   # Can't be handled as Cygwin above since Mingw does not use newlib.
5801   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' ;;
5802 esac
5803
5804 # Allow the user to override the flags for
5805 # our build compiler if desired.
5806 CFLAGS_FOR_BUILD=${CFLAGS_FOR_BUILD-${CFLAGS}}
5807
5808 # On Canadian crosses, we'll be searching the right directories for
5809 # the previously-installed cross compiler, so don't bother to add
5810 # flags for directories within the install tree of the compiler
5811 # being built; programs in there won't even run.
5812 if test "${build}" = "${host}" && test -d ${srcdir}/gcc; then
5813   # Search for pre-installed headers if nothing else fits.
5814   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$(build_tooldir)/bin/ -B$(build_tooldir)/lib/ -isystem $(build_tooldir)/include -isystem $(build_tooldir)/sys-include'
5815 fi
5816
5817 if test "x${use_gnu_ld}" = x &&
5818    echo " ${configdirs} " | grep " ld " > /dev/null ; then
5819   # Arrange for us to find uninstalled linker scripts.
5820   FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(HOST_SUBDIR)/ld'
5821 fi
5822
5823 # Search for other target-specific linker scripts and such.
5824 case "${target}" in
5825   m32c-*-* )
5826     if test -d ${srcdir}/libgloss/m32c; then
5827       # This is for crt0.o
5828       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -B$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5829       # This is for r8c.ld
5830       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/m32c'
5831       # This is for libnosys.a
5832       FLAGS_FOR_TARGET=$FLAGS_FOR_TARGET' -L$$r/$(TARGET_SUBDIR)/libgloss/libnosys'
5833     fi
5834     ;;
5835   mep*)
5836     FLAGS_FOR_TARGET="$FLAGS_FOR_TARGET -mlibrary"
5837     ;;
5838 esac
5839
5840 # Makefile fragments.
5841 for frag in host_makefile_frag target_makefile_frag alphaieee_frag ospace_frag;
5842 do
5843   eval fragval=\$$frag
5844   if test $fragval != /dev/null; then
5845     eval $frag=${srcdir}/$fragval
5846   fi
5847 done
5848
5849
5850
5851
5852
5853 # Miscellanea: directories, flags, etc.
5854
5855
5856
5857
5858
5859
5860
5861 # Build module lists & subconfigure args.
5862
5863
5864
5865 # Host module lists & subconfigure args.
5866
5867
5868
5869 # Target module lists & subconfigure args.
5870
5871
5872
5873 # Build tools.
5874
5875
5876
5877 # Generate default definitions for YACC, M4, LEX and other programs that run
5878 # on the build machine.  These are used if the Makefile can't locate these
5879 # programs in objdir.
5880 MISSING=`cd $ac_aux_dir && ${PWDCMD-pwd}`/missing
5881
5882 for ac_prog in 'bison -y' byacc yacc
5883 do
5884   # Extract the first word of "$ac_prog", so it can be a program name with args.
5885 set dummy $ac_prog; ac_word=$2
5886 echo "$as_me:$LINENO: checking for $ac_word" >&5
5887 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5888 if test "${ac_cv_prog_YACC+set}" = set; then
5889   echo $ECHO_N "(cached) $ECHO_C" >&6
5890 else
5891   if test -n "$YACC"; then
5892   ac_cv_prog_YACC="$YACC" # Let the user override the test.
5893 else
5894 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5895 for as_dir in $PATH
5896 do
5897   IFS=$as_save_IFS
5898   test -z "$as_dir" && as_dir=.
5899   for ac_exec_ext in '' $ac_executable_extensions; do
5900   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5901     ac_cv_prog_YACC="$ac_prog"
5902     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5903     break 2
5904   fi
5905 done
5906 done
5907
5908 fi
5909 fi
5910 YACC=$ac_cv_prog_YACC
5911 if test -n "$YACC"; then
5912   echo "$as_me:$LINENO: result: $YACC" >&5
5913 echo "${ECHO_T}$YACC" >&6
5914 else
5915   echo "$as_me:$LINENO: result: no" >&5
5916 echo "${ECHO_T}no" >&6
5917 fi
5918
5919   test -n "$YACC" && break
5920 done
5921 test -n "$YACC" || YACC="$MISSING bison -y"
5922
5923 case " $build_configdirs " in
5924   *" bison "*) YACC='$$r/$(BUILD_SUBDIR)/bison/tests/bison -y' ;;
5925   *" byacc "*) YACC='$$r/$(BUILD_SUBDIR)/byacc/byacc' ;;
5926 esac
5927
5928 for ac_prog in bison
5929 do
5930   # Extract the first word of "$ac_prog", so it can be a program name with args.
5931 set dummy $ac_prog; ac_word=$2
5932 echo "$as_me:$LINENO: checking for $ac_word" >&5
5933 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5934 if test "${ac_cv_prog_BISON+set}" = set; then
5935   echo $ECHO_N "(cached) $ECHO_C" >&6
5936 else
5937   if test -n "$BISON"; then
5938   ac_cv_prog_BISON="$BISON" # Let the user override the test.
5939 else
5940 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5941 for as_dir in $PATH
5942 do
5943   IFS=$as_save_IFS
5944   test -z "$as_dir" && as_dir=.
5945   for ac_exec_ext in '' $ac_executable_extensions; do
5946   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5947     ac_cv_prog_BISON="$ac_prog"
5948     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5949     break 2
5950   fi
5951 done
5952 done
5953
5954 fi
5955 fi
5956 BISON=$ac_cv_prog_BISON
5957 if test -n "$BISON"; then
5958   echo "$as_me:$LINENO: result: $BISON" >&5
5959 echo "${ECHO_T}$BISON" >&6
5960 else
5961   echo "$as_me:$LINENO: result: no" >&5
5962 echo "${ECHO_T}no" >&6
5963 fi
5964
5965   test -n "$BISON" && break
5966 done
5967 test -n "$BISON" || BISON="$MISSING bison"
5968
5969 case " $build_configdirs " in
5970   *" bison "*) BISON='$$r/$(BUILD_SUBDIR)/bison/tests/bison' ;;
5971 esac
5972
5973 for ac_prog in gm4 gnum4 m4
5974 do
5975   # Extract the first word of "$ac_prog", so it can be a program name with args.
5976 set dummy $ac_prog; ac_word=$2
5977 echo "$as_me:$LINENO: checking for $ac_word" >&5
5978 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
5979 if test "${ac_cv_prog_M4+set}" = set; then
5980   echo $ECHO_N "(cached) $ECHO_C" >&6
5981 else
5982   if test -n "$M4"; then
5983   ac_cv_prog_M4="$M4" # Let the user override the test.
5984 else
5985 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
5986 for as_dir in $PATH
5987 do
5988   IFS=$as_save_IFS
5989   test -z "$as_dir" && as_dir=.
5990   for ac_exec_ext in '' $ac_executable_extensions; do
5991   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
5992     ac_cv_prog_M4="$ac_prog"
5993     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
5994     break 2
5995   fi
5996 done
5997 done
5998
5999 fi
6000 fi
6001 M4=$ac_cv_prog_M4
6002 if test -n "$M4"; then
6003   echo "$as_me:$LINENO: result: $M4" >&5
6004 echo "${ECHO_T}$M4" >&6
6005 else
6006   echo "$as_me:$LINENO: result: no" >&5
6007 echo "${ECHO_T}no" >&6
6008 fi
6009
6010   test -n "$M4" && break
6011 done
6012 test -n "$M4" || M4="$MISSING m4"
6013
6014 case " $build_configdirs " in
6015   *" m4 "*) M4='$$r/$(BUILD_SUBDIR)/m4/m4' ;;
6016 esac
6017
6018 for ac_prog in flex lex
6019 do
6020   # Extract the first word of "$ac_prog", so it can be a program name with args.
6021 set dummy $ac_prog; ac_word=$2
6022 echo "$as_me:$LINENO: checking for $ac_word" >&5
6023 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6024 if test "${ac_cv_prog_LEX+set}" = set; then
6025   echo $ECHO_N "(cached) $ECHO_C" >&6
6026 else
6027   if test -n "$LEX"; then
6028   ac_cv_prog_LEX="$LEX" # Let the user override the test.
6029 else
6030 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6031 for as_dir in $PATH
6032 do
6033   IFS=$as_save_IFS
6034   test -z "$as_dir" && as_dir=.
6035   for ac_exec_ext in '' $ac_executable_extensions; do
6036   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6037     ac_cv_prog_LEX="$ac_prog"
6038     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6039     break 2
6040   fi
6041 done
6042 done
6043
6044 fi
6045 fi
6046 LEX=$ac_cv_prog_LEX
6047 if test -n "$LEX"; then
6048   echo "$as_me:$LINENO: result: $LEX" >&5
6049 echo "${ECHO_T}$LEX" >&6
6050 else
6051   echo "$as_me:$LINENO: result: no" >&5
6052 echo "${ECHO_T}no" >&6
6053 fi
6054
6055   test -n "$LEX" && break
6056 done
6057 test -n "$LEX" || LEX="$MISSING flex"
6058
6059 case " $build_configdirs " in
6060   *" flex "*) LEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6061   *" lex "*) LEX='$$r/$(BUILD_SUBDIR)/lex/lex' ;;
6062 esac
6063
6064 for ac_prog in flex
6065 do
6066   # Extract the first word of "$ac_prog", so it can be a program name with args.
6067 set dummy $ac_prog; ac_word=$2
6068 echo "$as_me:$LINENO: checking for $ac_word" >&5
6069 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6070 if test "${ac_cv_prog_FLEX+set}" = set; then
6071   echo $ECHO_N "(cached) $ECHO_C" >&6
6072 else
6073   if test -n "$FLEX"; then
6074   ac_cv_prog_FLEX="$FLEX" # Let the user override the test.
6075 else
6076 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6077 for as_dir in $PATH
6078 do
6079   IFS=$as_save_IFS
6080   test -z "$as_dir" && as_dir=.
6081   for ac_exec_ext in '' $ac_executable_extensions; do
6082   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6083     ac_cv_prog_FLEX="$ac_prog"
6084     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6085     break 2
6086   fi
6087 done
6088 done
6089
6090 fi
6091 fi
6092 FLEX=$ac_cv_prog_FLEX
6093 if test -n "$FLEX"; then
6094   echo "$as_me:$LINENO: result: $FLEX" >&5
6095 echo "${ECHO_T}$FLEX" >&6
6096 else
6097   echo "$as_me:$LINENO: result: no" >&5
6098 echo "${ECHO_T}no" >&6
6099 fi
6100
6101   test -n "$FLEX" && break
6102 done
6103 test -n "$FLEX" || FLEX="$MISSING flex"
6104
6105 case " $build_configdirs " in
6106   *" flex "*) FLEX='$$r/$(BUILD_SUBDIR)/flex/flex' ;;
6107 esac
6108
6109 for ac_prog in makeinfo
6110 do
6111   # Extract the first word of "$ac_prog", so it can be a program name with args.
6112 set dummy $ac_prog; ac_word=$2
6113 echo "$as_me:$LINENO: checking for $ac_word" >&5
6114 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6115 if test "${ac_cv_prog_MAKEINFO+set}" = set; then
6116   echo $ECHO_N "(cached) $ECHO_C" >&6
6117 else
6118   if test -n "$MAKEINFO"; then
6119   ac_cv_prog_MAKEINFO="$MAKEINFO" # Let the user override the test.
6120 else
6121 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6122 for as_dir in $PATH
6123 do
6124   IFS=$as_save_IFS
6125   test -z "$as_dir" && as_dir=.
6126   for ac_exec_ext in '' $ac_executable_extensions; do
6127   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6128     ac_cv_prog_MAKEINFO="$ac_prog"
6129     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6130     break 2
6131   fi
6132 done
6133 done
6134
6135 fi
6136 fi
6137 MAKEINFO=$ac_cv_prog_MAKEINFO
6138 if test -n "$MAKEINFO"; then
6139   echo "$as_me:$LINENO: result: $MAKEINFO" >&5
6140 echo "${ECHO_T}$MAKEINFO" >&6
6141 else
6142   echo "$as_me:$LINENO: result: no" >&5
6143 echo "${ECHO_T}no" >&6
6144 fi
6145
6146   test -n "$MAKEINFO" && break
6147 done
6148 test -n "$MAKEINFO" || MAKEINFO="$MISSING makeinfo"
6149
6150 case " $build_configdirs " in
6151   *" texinfo "*) MAKEINFO='$$r/$(BUILD_SUBDIR)/texinfo/makeinfo/makeinfo' ;;
6152   *)
6153
6154     # For an installed makeinfo, we require it to be from texinfo 4.4 or
6155     # higher, else we use the "missing" dummy.
6156     if ${MAKEINFO} --version \
6157        | egrep 'texinfo[^0-9]*([1-3][0-9]|4\.[4-9]|[5-9])' >/dev/null 2>&1; then
6158       :
6159     else
6160       MAKEINFO="$MISSING makeinfo"
6161     fi
6162     ;;
6163
6164 esac
6165
6166 # FIXME: expect and dejagnu may become build tools?
6167
6168 for ac_prog in expect
6169 do
6170   # Extract the first word of "$ac_prog", so it can be a program name with args.
6171 set dummy $ac_prog; ac_word=$2
6172 echo "$as_me:$LINENO: checking for $ac_word" >&5
6173 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6174 if test "${ac_cv_prog_EXPECT+set}" = set; then
6175   echo $ECHO_N "(cached) $ECHO_C" >&6
6176 else
6177   if test -n "$EXPECT"; then
6178   ac_cv_prog_EXPECT="$EXPECT" # Let the user override the test.
6179 else
6180 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6181 for as_dir in $PATH
6182 do
6183   IFS=$as_save_IFS
6184   test -z "$as_dir" && as_dir=.
6185   for ac_exec_ext in '' $ac_executable_extensions; do
6186   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6187     ac_cv_prog_EXPECT="$ac_prog"
6188     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6189     break 2
6190   fi
6191 done
6192 done
6193
6194 fi
6195 fi
6196 EXPECT=$ac_cv_prog_EXPECT
6197 if test -n "$EXPECT"; then
6198   echo "$as_me:$LINENO: result: $EXPECT" >&5
6199 echo "${ECHO_T}$EXPECT" >&6
6200 else
6201   echo "$as_me:$LINENO: result: no" >&5
6202 echo "${ECHO_T}no" >&6
6203 fi
6204
6205   test -n "$EXPECT" && break
6206 done
6207 test -n "$EXPECT" || EXPECT="expect"
6208
6209 case " $configdirs " in
6210   *" expect "*)
6211     test $host = $build && EXPECT='$$r/$(HOST_SUBDIR)/expect/expect'
6212     ;;
6213 esac
6214
6215 for ac_prog in runtest
6216 do
6217   # Extract the first word of "$ac_prog", so it can be a program name with args.
6218 set dummy $ac_prog; ac_word=$2
6219 echo "$as_me:$LINENO: checking for $ac_word" >&5
6220 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6221 if test "${ac_cv_prog_RUNTEST+set}" = set; then
6222   echo $ECHO_N "(cached) $ECHO_C" >&6
6223 else
6224   if test -n "$RUNTEST"; then
6225   ac_cv_prog_RUNTEST="$RUNTEST" # Let the user override the test.
6226 else
6227 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6228 for as_dir in $PATH
6229 do
6230   IFS=$as_save_IFS
6231   test -z "$as_dir" && as_dir=.
6232   for ac_exec_ext in '' $ac_executable_extensions; do
6233   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6234     ac_cv_prog_RUNTEST="$ac_prog"
6235     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6236     break 2
6237   fi
6238 done
6239 done
6240
6241 fi
6242 fi
6243 RUNTEST=$ac_cv_prog_RUNTEST
6244 if test -n "$RUNTEST"; then
6245   echo "$as_me:$LINENO: result: $RUNTEST" >&5
6246 echo "${ECHO_T}$RUNTEST" >&6
6247 else
6248   echo "$as_me:$LINENO: result: no" >&5
6249 echo "${ECHO_T}no" >&6
6250 fi
6251
6252   test -n "$RUNTEST" && break
6253 done
6254 test -n "$RUNTEST" || RUNTEST="runtest"
6255
6256 case " $configdirs " in
6257   *" dejagnu "*)
6258     test $host = $build && RUNTEST='$$s/$(HOST_SUBDIR)/dejagnu/runtest'
6259     ;;
6260 esac
6261
6262
6263 # Host tools.
6264 ncn_tool_prefix=
6265 test -n "$host_alias" && ncn_tool_prefix=$host_alias-
6266 ncn_target_tool_prefix=
6267 test -n "$target_alias" && ncn_target_tool_prefix=$target_alias-
6268
6269
6270
6271 if test -n "$AR"; then
6272   ac_cv_prog_AR=$AR
6273 elif test -n "$ac_cv_prog_AR"; then
6274   AR=$ac_cv_prog_AR
6275 fi
6276
6277 if test -n "$ac_cv_prog_AR"; then
6278   for ncn_progname in ar; do
6279     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6280 set dummy ${ncn_progname}; ac_word=$2
6281 echo "$as_me:$LINENO: checking for $ac_word" >&5
6282 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6283 if test "${ac_cv_prog_AR+set}" = set; then
6284   echo $ECHO_N "(cached) $ECHO_C" >&6
6285 else
6286   if test -n "$AR"; then
6287   ac_cv_prog_AR="$AR" # Let the user override the test.
6288 else
6289 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6290 for as_dir in $PATH
6291 do
6292   IFS=$as_save_IFS
6293   test -z "$as_dir" && as_dir=.
6294   for ac_exec_ext in '' $ac_executable_extensions; do
6295   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6296     ac_cv_prog_AR="${ncn_progname}"
6297     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6298     break 2
6299   fi
6300 done
6301 done
6302
6303 fi
6304 fi
6305 AR=$ac_cv_prog_AR
6306 if test -n "$AR"; then
6307   echo "$as_me:$LINENO: result: $AR" >&5
6308 echo "${ECHO_T}$AR" >&6
6309 else
6310   echo "$as_me:$LINENO: result: no" >&5
6311 echo "${ECHO_T}no" >&6
6312 fi
6313
6314   done
6315 fi
6316
6317 for ncn_progname in ar; do
6318   if test -n "$ncn_tool_prefix"; then
6319     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6320 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6321 echo "$as_me:$LINENO: checking for $ac_word" >&5
6322 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6323 if test "${ac_cv_prog_AR+set}" = set; then
6324   echo $ECHO_N "(cached) $ECHO_C" >&6
6325 else
6326   if test -n "$AR"; then
6327   ac_cv_prog_AR="$AR" # Let the user override the test.
6328 else
6329 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6330 for as_dir in $PATH
6331 do
6332   IFS=$as_save_IFS
6333   test -z "$as_dir" && as_dir=.
6334   for ac_exec_ext in '' $ac_executable_extensions; do
6335   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6336     ac_cv_prog_AR="${ncn_tool_prefix}${ncn_progname}"
6337     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6338     break 2
6339   fi
6340 done
6341 done
6342
6343 fi
6344 fi
6345 AR=$ac_cv_prog_AR
6346 if test -n "$AR"; then
6347   echo "$as_me:$LINENO: result: $AR" >&5
6348 echo "${ECHO_T}$AR" >&6
6349 else
6350   echo "$as_me:$LINENO: result: no" >&5
6351 echo "${ECHO_T}no" >&6
6352 fi
6353
6354   fi
6355   if test -z "$ac_cv_prog_AR" && test $build = $host ; then
6356     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6357 set dummy ${ncn_progname}; ac_word=$2
6358 echo "$as_me:$LINENO: checking for $ac_word" >&5
6359 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6360 if test "${ac_cv_prog_AR+set}" = set; then
6361   echo $ECHO_N "(cached) $ECHO_C" >&6
6362 else
6363   if test -n "$AR"; then
6364   ac_cv_prog_AR="$AR" # Let the user override the test.
6365 else
6366 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6367 for as_dir in $PATH
6368 do
6369   IFS=$as_save_IFS
6370   test -z "$as_dir" && as_dir=.
6371   for ac_exec_ext in '' $ac_executable_extensions; do
6372   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6373     ac_cv_prog_AR="${ncn_progname}"
6374     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6375     break 2
6376   fi
6377 done
6378 done
6379
6380 fi
6381 fi
6382 AR=$ac_cv_prog_AR
6383 if test -n "$AR"; then
6384   echo "$as_me:$LINENO: result: $AR" >&5
6385 echo "${ECHO_T}$AR" >&6
6386 else
6387   echo "$as_me:$LINENO: result: no" >&5
6388 echo "${ECHO_T}no" >&6
6389 fi
6390
6391   fi
6392   test -n "$ac_cv_prog_AR" && break
6393 done
6394
6395 if test -z "$ac_cv_prog_AR" ; then
6396   set dummy ar
6397   if test $build = $host ; then
6398     AR="$2"
6399   else
6400     AR="${ncn_tool_prefix}$2"
6401   fi
6402 fi
6403
6404
6405
6406 if test -n "$AS"; then
6407   ac_cv_prog_AS=$AS
6408 elif test -n "$ac_cv_prog_AS"; then
6409   AS=$ac_cv_prog_AS
6410 fi
6411
6412 if test -n "$ac_cv_prog_AS"; then
6413   for ncn_progname in as; do
6414     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6415 set dummy ${ncn_progname}; ac_word=$2
6416 echo "$as_me:$LINENO: checking for $ac_word" >&5
6417 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6418 if test "${ac_cv_prog_AS+set}" = set; then
6419   echo $ECHO_N "(cached) $ECHO_C" >&6
6420 else
6421   if test -n "$AS"; then
6422   ac_cv_prog_AS="$AS" # Let the user override the test.
6423 else
6424 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6425 for as_dir in $PATH
6426 do
6427   IFS=$as_save_IFS
6428   test -z "$as_dir" && as_dir=.
6429   for ac_exec_ext in '' $ac_executable_extensions; do
6430   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6431     ac_cv_prog_AS="${ncn_progname}"
6432     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6433     break 2
6434   fi
6435 done
6436 done
6437
6438 fi
6439 fi
6440 AS=$ac_cv_prog_AS
6441 if test -n "$AS"; then
6442   echo "$as_me:$LINENO: result: $AS" >&5
6443 echo "${ECHO_T}$AS" >&6
6444 else
6445   echo "$as_me:$LINENO: result: no" >&5
6446 echo "${ECHO_T}no" >&6
6447 fi
6448
6449   done
6450 fi
6451
6452 for ncn_progname in as; do
6453   if test -n "$ncn_tool_prefix"; then
6454     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6455 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6456 echo "$as_me:$LINENO: checking for $ac_word" >&5
6457 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6458 if test "${ac_cv_prog_AS+set}" = set; then
6459   echo $ECHO_N "(cached) $ECHO_C" >&6
6460 else
6461   if test -n "$AS"; then
6462   ac_cv_prog_AS="$AS" # Let the user override the test.
6463 else
6464 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6465 for as_dir in $PATH
6466 do
6467   IFS=$as_save_IFS
6468   test -z "$as_dir" && as_dir=.
6469   for ac_exec_ext in '' $ac_executable_extensions; do
6470   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6471     ac_cv_prog_AS="${ncn_tool_prefix}${ncn_progname}"
6472     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6473     break 2
6474   fi
6475 done
6476 done
6477
6478 fi
6479 fi
6480 AS=$ac_cv_prog_AS
6481 if test -n "$AS"; then
6482   echo "$as_me:$LINENO: result: $AS" >&5
6483 echo "${ECHO_T}$AS" >&6
6484 else
6485   echo "$as_me:$LINENO: result: no" >&5
6486 echo "${ECHO_T}no" >&6
6487 fi
6488
6489   fi
6490   if test -z "$ac_cv_prog_AS" && test $build = $host ; then
6491     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6492 set dummy ${ncn_progname}; ac_word=$2
6493 echo "$as_me:$LINENO: checking for $ac_word" >&5
6494 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6495 if test "${ac_cv_prog_AS+set}" = set; then
6496   echo $ECHO_N "(cached) $ECHO_C" >&6
6497 else
6498   if test -n "$AS"; then
6499   ac_cv_prog_AS="$AS" # Let the user override the test.
6500 else
6501 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6502 for as_dir in $PATH
6503 do
6504   IFS=$as_save_IFS
6505   test -z "$as_dir" && as_dir=.
6506   for ac_exec_ext in '' $ac_executable_extensions; do
6507   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6508     ac_cv_prog_AS="${ncn_progname}"
6509     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6510     break 2
6511   fi
6512 done
6513 done
6514
6515 fi
6516 fi
6517 AS=$ac_cv_prog_AS
6518 if test -n "$AS"; then
6519   echo "$as_me:$LINENO: result: $AS" >&5
6520 echo "${ECHO_T}$AS" >&6
6521 else
6522   echo "$as_me:$LINENO: result: no" >&5
6523 echo "${ECHO_T}no" >&6
6524 fi
6525
6526   fi
6527   test -n "$ac_cv_prog_AS" && break
6528 done
6529
6530 if test -z "$ac_cv_prog_AS" ; then
6531   set dummy as
6532   if test $build = $host ; then
6533     AS="$2"
6534   else
6535     AS="${ncn_tool_prefix}$2"
6536   fi
6537 fi
6538
6539
6540
6541 if test -n "$DLLTOOL"; then
6542   ac_cv_prog_DLLTOOL=$DLLTOOL
6543 elif test -n "$ac_cv_prog_DLLTOOL"; then
6544   DLLTOOL=$ac_cv_prog_DLLTOOL
6545 fi
6546
6547 if test -n "$ac_cv_prog_DLLTOOL"; then
6548   for ncn_progname in dlltool; do
6549     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6550 set dummy ${ncn_progname}; ac_word=$2
6551 echo "$as_me:$LINENO: checking for $ac_word" >&5
6552 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6553 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6554   echo $ECHO_N "(cached) $ECHO_C" >&6
6555 else
6556   if test -n "$DLLTOOL"; then
6557   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6558 else
6559 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6560 for as_dir in $PATH
6561 do
6562   IFS=$as_save_IFS
6563   test -z "$as_dir" && as_dir=.
6564   for ac_exec_ext in '' $ac_executable_extensions; do
6565   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6566     ac_cv_prog_DLLTOOL="${ncn_progname}"
6567     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6568     break 2
6569   fi
6570 done
6571 done
6572
6573 fi
6574 fi
6575 DLLTOOL=$ac_cv_prog_DLLTOOL
6576 if test -n "$DLLTOOL"; then
6577   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6578 echo "${ECHO_T}$DLLTOOL" >&6
6579 else
6580   echo "$as_me:$LINENO: result: no" >&5
6581 echo "${ECHO_T}no" >&6
6582 fi
6583
6584   done
6585 fi
6586
6587 for ncn_progname in dlltool; do
6588   if test -n "$ncn_tool_prefix"; then
6589     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6590 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6591 echo "$as_me:$LINENO: checking for $ac_word" >&5
6592 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6593 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6594   echo $ECHO_N "(cached) $ECHO_C" >&6
6595 else
6596   if test -n "$DLLTOOL"; then
6597   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6598 else
6599 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6600 for as_dir in $PATH
6601 do
6602   IFS=$as_save_IFS
6603   test -z "$as_dir" && as_dir=.
6604   for ac_exec_ext in '' $ac_executable_extensions; do
6605   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6606     ac_cv_prog_DLLTOOL="${ncn_tool_prefix}${ncn_progname}"
6607     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6608     break 2
6609   fi
6610 done
6611 done
6612
6613 fi
6614 fi
6615 DLLTOOL=$ac_cv_prog_DLLTOOL
6616 if test -n "$DLLTOOL"; then
6617   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6618 echo "${ECHO_T}$DLLTOOL" >&6
6619 else
6620   echo "$as_me:$LINENO: result: no" >&5
6621 echo "${ECHO_T}no" >&6
6622 fi
6623
6624   fi
6625   if test -z "$ac_cv_prog_DLLTOOL" && test $build = $host ; then
6626     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6627 set dummy ${ncn_progname}; ac_word=$2
6628 echo "$as_me:$LINENO: checking for $ac_word" >&5
6629 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6630 if test "${ac_cv_prog_DLLTOOL+set}" = set; then
6631   echo $ECHO_N "(cached) $ECHO_C" >&6
6632 else
6633   if test -n "$DLLTOOL"; then
6634   ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
6635 else
6636 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6637 for as_dir in $PATH
6638 do
6639   IFS=$as_save_IFS
6640   test -z "$as_dir" && as_dir=.
6641   for ac_exec_ext in '' $ac_executable_extensions; do
6642   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6643     ac_cv_prog_DLLTOOL="${ncn_progname}"
6644     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6645     break 2
6646   fi
6647 done
6648 done
6649
6650 fi
6651 fi
6652 DLLTOOL=$ac_cv_prog_DLLTOOL
6653 if test -n "$DLLTOOL"; then
6654   echo "$as_me:$LINENO: result: $DLLTOOL" >&5
6655 echo "${ECHO_T}$DLLTOOL" >&6
6656 else
6657   echo "$as_me:$LINENO: result: no" >&5
6658 echo "${ECHO_T}no" >&6
6659 fi
6660
6661   fi
6662   test -n "$ac_cv_prog_DLLTOOL" && break
6663 done
6664
6665 if test -z "$ac_cv_prog_DLLTOOL" ; then
6666   set dummy dlltool
6667   if test $build = $host ; then
6668     DLLTOOL="$2"
6669   else
6670     DLLTOOL="${ncn_tool_prefix}$2"
6671   fi
6672 fi
6673
6674
6675
6676 if test -n "$LD"; then
6677   ac_cv_prog_LD=$LD
6678 elif test -n "$ac_cv_prog_LD"; then
6679   LD=$ac_cv_prog_LD
6680 fi
6681
6682 if test -n "$ac_cv_prog_LD"; then
6683   for ncn_progname in ld; do
6684     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6685 set dummy ${ncn_progname}; ac_word=$2
6686 echo "$as_me:$LINENO: checking for $ac_word" >&5
6687 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6688 if test "${ac_cv_prog_LD+set}" = set; then
6689   echo $ECHO_N "(cached) $ECHO_C" >&6
6690 else
6691   if test -n "$LD"; then
6692   ac_cv_prog_LD="$LD" # Let the user override the test.
6693 else
6694 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6695 for as_dir in $PATH
6696 do
6697   IFS=$as_save_IFS
6698   test -z "$as_dir" && as_dir=.
6699   for ac_exec_ext in '' $ac_executable_extensions; do
6700   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6701     ac_cv_prog_LD="${ncn_progname}"
6702     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6703     break 2
6704   fi
6705 done
6706 done
6707
6708 fi
6709 fi
6710 LD=$ac_cv_prog_LD
6711 if test -n "$LD"; then
6712   echo "$as_me:$LINENO: result: $LD" >&5
6713 echo "${ECHO_T}$LD" >&6
6714 else
6715   echo "$as_me:$LINENO: result: no" >&5
6716 echo "${ECHO_T}no" >&6
6717 fi
6718
6719   done
6720 fi
6721
6722 for ncn_progname in ld; do
6723   if test -n "$ncn_tool_prefix"; then
6724     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6725 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6726 echo "$as_me:$LINENO: checking for $ac_word" >&5
6727 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6728 if test "${ac_cv_prog_LD+set}" = set; then
6729   echo $ECHO_N "(cached) $ECHO_C" >&6
6730 else
6731   if test -n "$LD"; then
6732   ac_cv_prog_LD="$LD" # Let the user override the test.
6733 else
6734 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6735 for as_dir in $PATH
6736 do
6737   IFS=$as_save_IFS
6738   test -z "$as_dir" && as_dir=.
6739   for ac_exec_ext in '' $ac_executable_extensions; do
6740   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6741     ac_cv_prog_LD="${ncn_tool_prefix}${ncn_progname}"
6742     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6743     break 2
6744   fi
6745 done
6746 done
6747
6748 fi
6749 fi
6750 LD=$ac_cv_prog_LD
6751 if test -n "$LD"; then
6752   echo "$as_me:$LINENO: result: $LD" >&5
6753 echo "${ECHO_T}$LD" >&6
6754 else
6755   echo "$as_me:$LINENO: result: no" >&5
6756 echo "${ECHO_T}no" >&6
6757 fi
6758
6759   fi
6760   if test -z "$ac_cv_prog_LD" && test $build = $host ; then
6761     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6762 set dummy ${ncn_progname}; ac_word=$2
6763 echo "$as_me:$LINENO: checking for $ac_word" >&5
6764 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6765 if test "${ac_cv_prog_LD+set}" = set; then
6766   echo $ECHO_N "(cached) $ECHO_C" >&6
6767 else
6768   if test -n "$LD"; then
6769   ac_cv_prog_LD="$LD" # Let the user override the test.
6770 else
6771 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6772 for as_dir in $PATH
6773 do
6774   IFS=$as_save_IFS
6775   test -z "$as_dir" && as_dir=.
6776   for ac_exec_ext in '' $ac_executable_extensions; do
6777   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6778     ac_cv_prog_LD="${ncn_progname}"
6779     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6780     break 2
6781   fi
6782 done
6783 done
6784
6785 fi
6786 fi
6787 LD=$ac_cv_prog_LD
6788 if test -n "$LD"; then
6789   echo "$as_me:$LINENO: result: $LD" >&5
6790 echo "${ECHO_T}$LD" >&6
6791 else
6792   echo "$as_me:$LINENO: result: no" >&5
6793 echo "${ECHO_T}no" >&6
6794 fi
6795
6796   fi
6797   test -n "$ac_cv_prog_LD" && break
6798 done
6799
6800 if test -z "$ac_cv_prog_LD" ; then
6801   set dummy ld
6802   if test $build = $host ; then
6803     LD="$2"
6804   else
6805     LD="${ncn_tool_prefix}$2"
6806   fi
6807 fi
6808
6809
6810
6811 if test -n "$LIPO"; then
6812   ac_cv_prog_LIPO=$LIPO
6813 elif test -n "$ac_cv_prog_LIPO"; then
6814   LIPO=$ac_cv_prog_LIPO
6815 fi
6816
6817 if test -n "$ac_cv_prog_LIPO"; then
6818   for ncn_progname in lipo; do
6819     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6820 set dummy ${ncn_progname}; ac_word=$2
6821 echo "$as_me:$LINENO: checking for $ac_word" >&5
6822 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6823 if test "${ac_cv_prog_LIPO+set}" = set; then
6824   echo $ECHO_N "(cached) $ECHO_C" >&6
6825 else
6826   if test -n "$LIPO"; then
6827   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6828 else
6829 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6830 for as_dir in $PATH
6831 do
6832   IFS=$as_save_IFS
6833   test -z "$as_dir" && as_dir=.
6834   for ac_exec_ext in '' $ac_executable_extensions; do
6835   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6836     ac_cv_prog_LIPO="${ncn_progname}"
6837     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6838     break 2
6839   fi
6840 done
6841 done
6842
6843 fi
6844 fi
6845 LIPO=$ac_cv_prog_LIPO
6846 if test -n "$LIPO"; then
6847   echo "$as_me:$LINENO: result: $LIPO" >&5
6848 echo "${ECHO_T}$LIPO" >&6
6849 else
6850   echo "$as_me:$LINENO: result: no" >&5
6851 echo "${ECHO_T}no" >&6
6852 fi
6853
6854   done
6855 fi
6856
6857 for ncn_progname in lipo; do
6858   if test -n "$ncn_tool_prefix"; then
6859     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6860 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6861 echo "$as_me:$LINENO: checking for $ac_word" >&5
6862 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6863 if test "${ac_cv_prog_LIPO+set}" = set; then
6864   echo $ECHO_N "(cached) $ECHO_C" >&6
6865 else
6866   if test -n "$LIPO"; then
6867   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6868 else
6869 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6870 for as_dir in $PATH
6871 do
6872   IFS=$as_save_IFS
6873   test -z "$as_dir" && as_dir=.
6874   for ac_exec_ext in '' $ac_executable_extensions; do
6875   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6876     ac_cv_prog_LIPO="${ncn_tool_prefix}${ncn_progname}"
6877     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6878     break 2
6879   fi
6880 done
6881 done
6882
6883 fi
6884 fi
6885 LIPO=$ac_cv_prog_LIPO
6886 if test -n "$LIPO"; then
6887   echo "$as_me:$LINENO: result: $LIPO" >&5
6888 echo "${ECHO_T}$LIPO" >&6
6889 else
6890   echo "$as_me:$LINENO: result: no" >&5
6891 echo "${ECHO_T}no" >&6
6892 fi
6893
6894   fi
6895   if test -z "$ac_cv_prog_LIPO" && test $build = $host ; then
6896     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6897 set dummy ${ncn_progname}; ac_word=$2
6898 echo "$as_me:$LINENO: checking for $ac_word" >&5
6899 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6900 if test "${ac_cv_prog_LIPO+set}" = set; then
6901   echo $ECHO_N "(cached) $ECHO_C" >&6
6902 else
6903   if test -n "$LIPO"; then
6904   ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
6905 else
6906 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6907 for as_dir in $PATH
6908 do
6909   IFS=$as_save_IFS
6910   test -z "$as_dir" && as_dir=.
6911   for ac_exec_ext in '' $ac_executable_extensions; do
6912   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6913     ac_cv_prog_LIPO="${ncn_progname}"
6914     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6915     break 2
6916   fi
6917 done
6918 done
6919
6920 fi
6921 fi
6922 LIPO=$ac_cv_prog_LIPO
6923 if test -n "$LIPO"; then
6924   echo "$as_me:$LINENO: result: $LIPO" >&5
6925 echo "${ECHO_T}$LIPO" >&6
6926 else
6927   echo "$as_me:$LINENO: result: no" >&5
6928 echo "${ECHO_T}no" >&6
6929 fi
6930
6931   fi
6932   test -n "$ac_cv_prog_LIPO" && break
6933 done
6934
6935 if test -z "$ac_cv_prog_LIPO" ; then
6936   set dummy lipo
6937   if test $build = $host ; then
6938     LIPO="$2"
6939   else
6940     LIPO="${ncn_tool_prefix}$2"
6941   fi
6942 fi
6943
6944
6945
6946 if test -n "$NM"; then
6947   ac_cv_prog_NM=$NM
6948 elif test -n "$ac_cv_prog_NM"; then
6949   NM=$ac_cv_prog_NM
6950 fi
6951
6952 if test -n "$ac_cv_prog_NM"; then
6953   for ncn_progname in nm; do
6954     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
6955 set dummy ${ncn_progname}; ac_word=$2
6956 echo "$as_me:$LINENO: checking for $ac_word" >&5
6957 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6958 if test "${ac_cv_prog_NM+set}" = set; then
6959   echo $ECHO_N "(cached) $ECHO_C" >&6
6960 else
6961   if test -n "$NM"; then
6962   ac_cv_prog_NM="$NM" # Let the user override the test.
6963 else
6964 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
6965 for as_dir in $PATH
6966 do
6967   IFS=$as_save_IFS
6968   test -z "$as_dir" && as_dir=.
6969   for ac_exec_ext in '' $ac_executable_extensions; do
6970   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
6971     ac_cv_prog_NM="${ncn_progname}"
6972     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
6973     break 2
6974   fi
6975 done
6976 done
6977
6978 fi
6979 fi
6980 NM=$ac_cv_prog_NM
6981 if test -n "$NM"; then
6982   echo "$as_me:$LINENO: result: $NM" >&5
6983 echo "${ECHO_T}$NM" >&6
6984 else
6985   echo "$as_me:$LINENO: result: no" >&5
6986 echo "${ECHO_T}no" >&6
6987 fi
6988
6989   done
6990 fi
6991
6992 for ncn_progname in nm; do
6993   if test -n "$ncn_tool_prefix"; then
6994     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
6995 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
6996 echo "$as_me:$LINENO: checking for $ac_word" >&5
6997 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
6998 if test "${ac_cv_prog_NM+set}" = set; then
6999   echo $ECHO_N "(cached) $ECHO_C" >&6
7000 else
7001   if test -n "$NM"; then
7002   ac_cv_prog_NM="$NM" # Let the user override the test.
7003 else
7004 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7005 for as_dir in $PATH
7006 do
7007   IFS=$as_save_IFS
7008   test -z "$as_dir" && as_dir=.
7009   for ac_exec_ext in '' $ac_executable_extensions; do
7010   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7011     ac_cv_prog_NM="${ncn_tool_prefix}${ncn_progname}"
7012     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7013     break 2
7014   fi
7015 done
7016 done
7017
7018 fi
7019 fi
7020 NM=$ac_cv_prog_NM
7021 if test -n "$NM"; then
7022   echo "$as_me:$LINENO: result: $NM" >&5
7023 echo "${ECHO_T}$NM" >&6
7024 else
7025   echo "$as_me:$LINENO: result: no" >&5
7026 echo "${ECHO_T}no" >&6
7027 fi
7028
7029   fi
7030   if test -z "$ac_cv_prog_NM" && test $build = $host ; then
7031     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7032 set dummy ${ncn_progname}; ac_word=$2
7033 echo "$as_me:$LINENO: checking for $ac_word" >&5
7034 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7035 if test "${ac_cv_prog_NM+set}" = set; then
7036   echo $ECHO_N "(cached) $ECHO_C" >&6
7037 else
7038   if test -n "$NM"; then
7039   ac_cv_prog_NM="$NM" # Let the user override the test.
7040 else
7041 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7042 for as_dir in $PATH
7043 do
7044   IFS=$as_save_IFS
7045   test -z "$as_dir" && as_dir=.
7046   for ac_exec_ext in '' $ac_executable_extensions; do
7047   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7048     ac_cv_prog_NM="${ncn_progname}"
7049     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7050     break 2
7051   fi
7052 done
7053 done
7054
7055 fi
7056 fi
7057 NM=$ac_cv_prog_NM
7058 if test -n "$NM"; then
7059   echo "$as_me:$LINENO: result: $NM" >&5
7060 echo "${ECHO_T}$NM" >&6
7061 else
7062   echo "$as_me:$LINENO: result: no" >&5
7063 echo "${ECHO_T}no" >&6
7064 fi
7065
7066   fi
7067   test -n "$ac_cv_prog_NM" && break
7068 done
7069
7070 if test -z "$ac_cv_prog_NM" ; then
7071   set dummy nm
7072   if test $build = $host ; then
7073     NM="$2"
7074   else
7075     NM="${ncn_tool_prefix}$2"
7076   fi
7077 fi
7078
7079
7080
7081 if test -n "$RANLIB"; then
7082   ac_cv_prog_RANLIB=$RANLIB
7083 elif test -n "$ac_cv_prog_RANLIB"; then
7084   RANLIB=$ac_cv_prog_RANLIB
7085 fi
7086
7087 if test -n "$ac_cv_prog_RANLIB"; then
7088   for ncn_progname in ranlib; do
7089     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7090 set dummy ${ncn_progname}; ac_word=$2
7091 echo "$as_me:$LINENO: checking for $ac_word" >&5
7092 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7093 if test "${ac_cv_prog_RANLIB+set}" = set; then
7094   echo $ECHO_N "(cached) $ECHO_C" >&6
7095 else
7096   if test -n "$RANLIB"; then
7097   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7098 else
7099 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7100 for as_dir in $PATH
7101 do
7102   IFS=$as_save_IFS
7103   test -z "$as_dir" && as_dir=.
7104   for ac_exec_ext in '' $ac_executable_extensions; do
7105   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7106     ac_cv_prog_RANLIB="${ncn_progname}"
7107     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7108     break 2
7109   fi
7110 done
7111 done
7112
7113 fi
7114 fi
7115 RANLIB=$ac_cv_prog_RANLIB
7116 if test -n "$RANLIB"; then
7117   echo "$as_me:$LINENO: result: $RANLIB" >&5
7118 echo "${ECHO_T}$RANLIB" >&6
7119 else
7120   echo "$as_me:$LINENO: result: no" >&5
7121 echo "${ECHO_T}no" >&6
7122 fi
7123
7124   done
7125 fi
7126
7127 for ncn_progname in ranlib; do
7128   if test -n "$ncn_tool_prefix"; then
7129     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7130 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7131 echo "$as_me:$LINENO: checking for $ac_word" >&5
7132 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7133 if test "${ac_cv_prog_RANLIB+set}" = set; then
7134   echo $ECHO_N "(cached) $ECHO_C" >&6
7135 else
7136   if test -n "$RANLIB"; then
7137   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7138 else
7139 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7140 for as_dir in $PATH
7141 do
7142   IFS=$as_save_IFS
7143   test -z "$as_dir" && as_dir=.
7144   for ac_exec_ext in '' $ac_executable_extensions; do
7145   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7146     ac_cv_prog_RANLIB="${ncn_tool_prefix}${ncn_progname}"
7147     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7148     break 2
7149   fi
7150 done
7151 done
7152
7153 fi
7154 fi
7155 RANLIB=$ac_cv_prog_RANLIB
7156 if test -n "$RANLIB"; then
7157   echo "$as_me:$LINENO: result: $RANLIB" >&5
7158 echo "${ECHO_T}$RANLIB" >&6
7159 else
7160   echo "$as_me:$LINENO: result: no" >&5
7161 echo "${ECHO_T}no" >&6
7162 fi
7163
7164   fi
7165   if test -z "$ac_cv_prog_RANLIB" && test $build = $host ; then
7166     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7167 set dummy ${ncn_progname}; ac_word=$2
7168 echo "$as_me:$LINENO: checking for $ac_word" >&5
7169 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7170 if test "${ac_cv_prog_RANLIB+set}" = set; then
7171   echo $ECHO_N "(cached) $ECHO_C" >&6
7172 else
7173   if test -n "$RANLIB"; then
7174   ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
7175 else
7176 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7177 for as_dir in $PATH
7178 do
7179   IFS=$as_save_IFS
7180   test -z "$as_dir" && as_dir=.
7181   for ac_exec_ext in '' $ac_executable_extensions; do
7182   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7183     ac_cv_prog_RANLIB="${ncn_progname}"
7184     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7185     break 2
7186   fi
7187 done
7188 done
7189
7190 fi
7191 fi
7192 RANLIB=$ac_cv_prog_RANLIB
7193 if test -n "$RANLIB"; then
7194   echo "$as_me:$LINENO: result: $RANLIB" >&5
7195 echo "${ECHO_T}$RANLIB" >&6
7196 else
7197   echo "$as_me:$LINENO: result: no" >&5
7198 echo "${ECHO_T}no" >&6
7199 fi
7200
7201   fi
7202   test -n "$ac_cv_prog_RANLIB" && break
7203 done
7204
7205 if test -z "$ac_cv_prog_RANLIB" ; then
7206   RANLIB=":"
7207 fi
7208
7209
7210
7211 if test -n "$STRIP"; then
7212   ac_cv_prog_STRIP=$STRIP
7213 elif test -n "$ac_cv_prog_STRIP"; then
7214   STRIP=$ac_cv_prog_STRIP
7215 fi
7216
7217 if test -n "$ac_cv_prog_STRIP"; then
7218   for ncn_progname in strip; do
7219     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7220 set dummy ${ncn_progname}; ac_word=$2
7221 echo "$as_me:$LINENO: checking for $ac_word" >&5
7222 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7223 if test "${ac_cv_prog_STRIP+set}" = set; then
7224   echo $ECHO_N "(cached) $ECHO_C" >&6
7225 else
7226   if test -n "$STRIP"; then
7227   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7228 else
7229 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7230 for as_dir in $PATH
7231 do
7232   IFS=$as_save_IFS
7233   test -z "$as_dir" && as_dir=.
7234   for ac_exec_ext in '' $ac_executable_extensions; do
7235   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7236     ac_cv_prog_STRIP="${ncn_progname}"
7237     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7238     break 2
7239   fi
7240 done
7241 done
7242
7243 fi
7244 fi
7245 STRIP=$ac_cv_prog_STRIP
7246 if test -n "$STRIP"; then
7247   echo "$as_me:$LINENO: result: $STRIP" >&5
7248 echo "${ECHO_T}$STRIP" >&6
7249 else
7250   echo "$as_me:$LINENO: result: no" >&5
7251 echo "${ECHO_T}no" >&6
7252 fi
7253
7254   done
7255 fi
7256
7257 for ncn_progname in strip; do
7258   if test -n "$ncn_tool_prefix"; then
7259     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7260 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7261 echo "$as_me:$LINENO: checking for $ac_word" >&5
7262 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7263 if test "${ac_cv_prog_STRIP+set}" = set; then
7264   echo $ECHO_N "(cached) $ECHO_C" >&6
7265 else
7266   if test -n "$STRIP"; then
7267   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7268 else
7269 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7270 for as_dir in $PATH
7271 do
7272   IFS=$as_save_IFS
7273   test -z "$as_dir" && as_dir=.
7274   for ac_exec_ext in '' $ac_executable_extensions; do
7275   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7276     ac_cv_prog_STRIP="${ncn_tool_prefix}${ncn_progname}"
7277     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7278     break 2
7279   fi
7280 done
7281 done
7282
7283 fi
7284 fi
7285 STRIP=$ac_cv_prog_STRIP
7286 if test -n "$STRIP"; then
7287   echo "$as_me:$LINENO: result: $STRIP" >&5
7288 echo "${ECHO_T}$STRIP" >&6
7289 else
7290   echo "$as_me:$LINENO: result: no" >&5
7291 echo "${ECHO_T}no" >&6
7292 fi
7293
7294   fi
7295   if test -z "$ac_cv_prog_STRIP" && test $build = $host ; then
7296     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7297 set dummy ${ncn_progname}; ac_word=$2
7298 echo "$as_me:$LINENO: checking for $ac_word" >&5
7299 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7300 if test "${ac_cv_prog_STRIP+set}" = set; then
7301   echo $ECHO_N "(cached) $ECHO_C" >&6
7302 else
7303   if test -n "$STRIP"; then
7304   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
7305 else
7306 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7307 for as_dir in $PATH
7308 do
7309   IFS=$as_save_IFS
7310   test -z "$as_dir" && as_dir=.
7311   for ac_exec_ext in '' $ac_executable_extensions; do
7312   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7313     ac_cv_prog_STRIP="${ncn_progname}"
7314     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7315     break 2
7316   fi
7317 done
7318 done
7319
7320 fi
7321 fi
7322 STRIP=$ac_cv_prog_STRIP
7323 if test -n "$STRIP"; then
7324   echo "$as_me:$LINENO: result: $STRIP" >&5
7325 echo "${ECHO_T}$STRIP" >&6
7326 else
7327   echo "$as_me:$LINENO: result: no" >&5
7328 echo "${ECHO_T}no" >&6
7329 fi
7330
7331   fi
7332   test -n "$ac_cv_prog_STRIP" && break
7333 done
7334
7335 if test -z "$ac_cv_prog_STRIP" ; then
7336   STRIP=":"
7337 fi
7338
7339
7340
7341 if test -n "$WINDRES"; then
7342   ac_cv_prog_WINDRES=$WINDRES
7343 elif test -n "$ac_cv_prog_WINDRES"; then
7344   WINDRES=$ac_cv_prog_WINDRES
7345 fi
7346
7347 if test -n "$ac_cv_prog_WINDRES"; then
7348   for ncn_progname in windres; do
7349     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7350 set dummy ${ncn_progname}; ac_word=$2
7351 echo "$as_me:$LINENO: checking for $ac_word" >&5
7352 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7353 if test "${ac_cv_prog_WINDRES+set}" = set; then
7354   echo $ECHO_N "(cached) $ECHO_C" >&6
7355 else
7356   if test -n "$WINDRES"; then
7357   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7358 else
7359 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7360 for as_dir in $PATH
7361 do
7362   IFS=$as_save_IFS
7363   test -z "$as_dir" && as_dir=.
7364   for ac_exec_ext in '' $ac_executable_extensions; do
7365   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7366     ac_cv_prog_WINDRES="${ncn_progname}"
7367     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7368     break 2
7369   fi
7370 done
7371 done
7372
7373 fi
7374 fi
7375 WINDRES=$ac_cv_prog_WINDRES
7376 if test -n "$WINDRES"; then
7377   echo "$as_me:$LINENO: result: $WINDRES" >&5
7378 echo "${ECHO_T}$WINDRES" >&6
7379 else
7380   echo "$as_me:$LINENO: result: no" >&5
7381 echo "${ECHO_T}no" >&6
7382 fi
7383
7384   done
7385 fi
7386
7387 for ncn_progname in windres; do
7388   if test -n "$ncn_tool_prefix"; then
7389     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7390 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7391 echo "$as_me:$LINENO: checking for $ac_word" >&5
7392 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7393 if test "${ac_cv_prog_WINDRES+set}" = set; then
7394   echo $ECHO_N "(cached) $ECHO_C" >&6
7395 else
7396   if test -n "$WINDRES"; then
7397   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7398 else
7399 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7400 for as_dir in $PATH
7401 do
7402   IFS=$as_save_IFS
7403   test -z "$as_dir" && as_dir=.
7404   for ac_exec_ext in '' $ac_executable_extensions; do
7405   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7406     ac_cv_prog_WINDRES="${ncn_tool_prefix}${ncn_progname}"
7407     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7408     break 2
7409   fi
7410 done
7411 done
7412
7413 fi
7414 fi
7415 WINDRES=$ac_cv_prog_WINDRES
7416 if test -n "$WINDRES"; then
7417   echo "$as_me:$LINENO: result: $WINDRES" >&5
7418 echo "${ECHO_T}$WINDRES" >&6
7419 else
7420   echo "$as_me:$LINENO: result: no" >&5
7421 echo "${ECHO_T}no" >&6
7422 fi
7423
7424   fi
7425   if test -z "$ac_cv_prog_WINDRES" && test $build = $host ; then
7426     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7427 set dummy ${ncn_progname}; ac_word=$2
7428 echo "$as_me:$LINENO: checking for $ac_word" >&5
7429 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7430 if test "${ac_cv_prog_WINDRES+set}" = set; then
7431   echo $ECHO_N "(cached) $ECHO_C" >&6
7432 else
7433   if test -n "$WINDRES"; then
7434   ac_cv_prog_WINDRES="$WINDRES" # Let the user override the test.
7435 else
7436 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7437 for as_dir in $PATH
7438 do
7439   IFS=$as_save_IFS
7440   test -z "$as_dir" && as_dir=.
7441   for ac_exec_ext in '' $ac_executable_extensions; do
7442   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7443     ac_cv_prog_WINDRES="${ncn_progname}"
7444     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7445     break 2
7446   fi
7447 done
7448 done
7449
7450 fi
7451 fi
7452 WINDRES=$ac_cv_prog_WINDRES
7453 if test -n "$WINDRES"; then
7454   echo "$as_me:$LINENO: result: $WINDRES" >&5
7455 echo "${ECHO_T}$WINDRES" >&6
7456 else
7457   echo "$as_me:$LINENO: result: no" >&5
7458 echo "${ECHO_T}no" >&6
7459 fi
7460
7461   fi
7462   test -n "$ac_cv_prog_WINDRES" && break
7463 done
7464
7465 if test -z "$ac_cv_prog_WINDRES" ; then
7466   set dummy windres
7467   if test $build = $host ; then
7468     WINDRES="$2"
7469   else
7470     WINDRES="${ncn_tool_prefix}$2"
7471   fi
7472 fi
7473
7474
7475
7476 if test -n "$WINDMC"; then
7477   ac_cv_prog_WINDMC=$WINDMC
7478 elif test -n "$ac_cv_prog_WINDMC"; then
7479   WINDMC=$ac_cv_prog_WINDMC
7480 fi
7481
7482 if test -n "$ac_cv_prog_WINDMC"; then
7483   for ncn_progname in windmc; do
7484     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7485 set dummy ${ncn_progname}; ac_word=$2
7486 echo "$as_me:$LINENO: checking for $ac_word" >&5
7487 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7488 if test "${ac_cv_prog_WINDMC+set}" = set; then
7489   echo $ECHO_N "(cached) $ECHO_C" >&6
7490 else
7491   if test -n "$WINDMC"; then
7492   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7493 else
7494 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7495 for as_dir in $PATH
7496 do
7497   IFS=$as_save_IFS
7498   test -z "$as_dir" && as_dir=.
7499   for ac_exec_ext in '' $ac_executable_extensions; do
7500   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7501     ac_cv_prog_WINDMC="${ncn_progname}"
7502     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7503     break 2
7504   fi
7505 done
7506 done
7507
7508 fi
7509 fi
7510 WINDMC=$ac_cv_prog_WINDMC
7511 if test -n "$WINDMC"; then
7512   echo "$as_me:$LINENO: result: $WINDMC" >&5
7513 echo "${ECHO_T}$WINDMC" >&6
7514 else
7515   echo "$as_me:$LINENO: result: no" >&5
7516 echo "${ECHO_T}no" >&6
7517 fi
7518
7519   done
7520 fi
7521
7522 for ncn_progname in windmc; do
7523   if test -n "$ncn_tool_prefix"; then
7524     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7525 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7526 echo "$as_me:$LINENO: checking for $ac_word" >&5
7527 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7528 if test "${ac_cv_prog_WINDMC+set}" = set; then
7529   echo $ECHO_N "(cached) $ECHO_C" >&6
7530 else
7531   if test -n "$WINDMC"; then
7532   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7533 else
7534 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7535 for as_dir in $PATH
7536 do
7537   IFS=$as_save_IFS
7538   test -z "$as_dir" && as_dir=.
7539   for ac_exec_ext in '' $ac_executable_extensions; do
7540   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7541     ac_cv_prog_WINDMC="${ncn_tool_prefix}${ncn_progname}"
7542     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7543     break 2
7544   fi
7545 done
7546 done
7547
7548 fi
7549 fi
7550 WINDMC=$ac_cv_prog_WINDMC
7551 if test -n "$WINDMC"; then
7552   echo "$as_me:$LINENO: result: $WINDMC" >&5
7553 echo "${ECHO_T}$WINDMC" >&6
7554 else
7555   echo "$as_me:$LINENO: result: no" >&5
7556 echo "${ECHO_T}no" >&6
7557 fi
7558
7559   fi
7560   if test -z "$ac_cv_prog_WINDMC" && test $build = $host ; then
7561     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7562 set dummy ${ncn_progname}; ac_word=$2
7563 echo "$as_me:$LINENO: checking for $ac_word" >&5
7564 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7565 if test "${ac_cv_prog_WINDMC+set}" = set; then
7566   echo $ECHO_N "(cached) $ECHO_C" >&6
7567 else
7568   if test -n "$WINDMC"; then
7569   ac_cv_prog_WINDMC="$WINDMC" # Let the user override the test.
7570 else
7571 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7572 for as_dir in $PATH
7573 do
7574   IFS=$as_save_IFS
7575   test -z "$as_dir" && as_dir=.
7576   for ac_exec_ext in '' $ac_executable_extensions; do
7577   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7578     ac_cv_prog_WINDMC="${ncn_progname}"
7579     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7580     break 2
7581   fi
7582 done
7583 done
7584
7585 fi
7586 fi
7587 WINDMC=$ac_cv_prog_WINDMC
7588 if test -n "$WINDMC"; then
7589   echo "$as_me:$LINENO: result: $WINDMC" >&5
7590 echo "${ECHO_T}$WINDMC" >&6
7591 else
7592   echo "$as_me:$LINENO: result: no" >&5
7593 echo "${ECHO_T}no" >&6
7594 fi
7595
7596   fi
7597   test -n "$ac_cv_prog_WINDMC" && break
7598 done
7599
7600 if test -z "$ac_cv_prog_WINDMC" ; then
7601   set dummy windmc
7602   if test $build = $host ; then
7603     WINDMC="$2"
7604   else
7605     WINDMC="${ncn_tool_prefix}$2"
7606   fi
7607 fi
7608
7609
7610
7611 if test -n "$OBJCOPY"; then
7612   ac_cv_prog_OBJCOPY=$OBJCOPY
7613 elif test -n "$ac_cv_prog_OBJCOPY"; then
7614   OBJCOPY=$ac_cv_prog_OBJCOPY
7615 fi
7616
7617 if test -n "$ac_cv_prog_OBJCOPY"; then
7618   for ncn_progname in objcopy; do
7619     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7620 set dummy ${ncn_progname}; ac_word=$2
7621 echo "$as_me:$LINENO: checking for $ac_word" >&5
7622 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7623 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7624   echo $ECHO_N "(cached) $ECHO_C" >&6
7625 else
7626   if test -n "$OBJCOPY"; then
7627   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7628 else
7629 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7630 for as_dir in $PATH
7631 do
7632   IFS=$as_save_IFS
7633   test -z "$as_dir" && as_dir=.
7634   for ac_exec_ext in '' $ac_executable_extensions; do
7635   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7636     ac_cv_prog_OBJCOPY="${ncn_progname}"
7637     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7638     break 2
7639   fi
7640 done
7641 done
7642
7643 fi
7644 fi
7645 OBJCOPY=$ac_cv_prog_OBJCOPY
7646 if test -n "$OBJCOPY"; then
7647   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7648 echo "${ECHO_T}$OBJCOPY" >&6
7649 else
7650   echo "$as_me:$LINENO: result: no" >&5
7651 echo "${ECHO_T}no" >&6
7652 fi
7653
7654   done
7655 fi
7656
7657 for ncn_progname in objcopy; do
7658   if test -n "$ncn_tool_prefix"; then
7659     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7660 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7661 echo "$as_me:$LINENO: checking for $ac_word" >&5
7662 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7663 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7664   echo $ECHO_N "(cached) $ECHO_C" >&6
7665 else
7666   if test -n "$OBJCOPY"; then
7667   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7668 else
7669 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7670 for as_dir in $PATH
7671 do
7672   IFS=$as_save_IFS
7673   test -z "$as_dir" && as_dir=.
7674   for ac_exec_ext in '' $ac_executable_extensions; do
7675   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7676     ac_cv_prog_OBJCOPY="${ncn_tool_prefix}${ncn_progname}"
7677     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7678     break 2
7679   fi
7680 done
7681 done
7682
7683 fi
7684 fi
7685 OBJCOPY=$ac_cv_prog_OBJCOPY
7686 if test -n "$OBJCOPY"; then
7687   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7688 echo "${ECHO_T}$OBJCOPY" >&6
7689 else
7690   echo "$as_me:$LINENO: result: no" >&5
7691 echo "${ECHO_T}no" >&6
7692 fi
7693
7694   fi
7695   if test -z "$ac_cv_prog_OBJCOPY" && test $build = $host ; then
7696     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7697 set dummy ${ncn_progname}; ac_word=$2
7698 echo "$as_me:$LINENO: checking for $ac_word" >&5
7699 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7700 if test "${ac_cv_prog_OBJCOPY+set}" = set; then
7701   echo $ECHO_N "(cached) $ECHO_C" >&6
7702 else
7703   if test -n "$OBJCOPY"; then
7704   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
7705 else
7706 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7707 for as_dir in $PATH
7708 do
7709   IFS=$as_save_IFS
7710   test -z "$as_dir" && as_dir=.
7711   for ac_exec_ext in '' $ac_executable_extensions; do
7712   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7713     ac_cv_prog_OBJCOPY="${ncn_progname}"
7714     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7715     break 2
7716   fi
7717 done
7718 done
7719
7720 fi
7721 fi
7722 OBJCOPY=$ac_cv_prog_OBJCOPY
7723 if test -n "$OBJCOPY"; then
7724   echo "$as_me:$LINENO: result: $OBJCOPY" >&5
7725 echo "${ECHO_T}$OBJCOPY" >&6
7726 else
7727   echo "$as_me:$LINENO: result: no" >&5
7728 echo "${ECHO_T}no" >&6
7729 fi
7730
7731   fi
7732   test -n "$ac_cv_prog_OBJCOPY" && break
7733 done
7734
7735 if test -z "$ac_cv_prog_OBJCOPY" ; then
7736   set dummy objcopy
7737   if test $build = $host ; then
7738     OBJCOPY="$2"
7739   else
7740     OBJCOPY="${ncn_tool_prefix}$2"
7741   fi
7742 fi
7743
7744
7745
7746 if test -n "$OBJDUMP"; then
7747   ac_cv_prog_OBJDUMP=$OBJDUMP
7748 elif test -n "$ac_cv_prog_OBJDUMP"; then
7749   OBJDUMP=$ac_cv_prog_OBJDUMP
7750 fi
7751
7752 if test -n "$ac_cv_prog_OBJDUMP"; then
7753   for ncn_progname in objdump; do
7754     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7755 set dummy ${ncn_progname}; ac_word=$2
7756 echo "$as_me:$LINENO: checking for $ac_word" >&5
7757 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7758 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7759   echo $ECHO_N "(cached) $ECHO_C" >&6
7760 else
7761   if test -n "$OBJDUMP"; then
7762   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7763 else
7764 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7765 for as_dir in $PATH
7766 do
7767   IFS=$as_save_IFS
7768   test -z "$as_dir" && as_dir=.
7769   for ac_exec_ext in '' $ac_executable_extensions; do
7770   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7771     ac_cv_prog_OBJDUMP="${ncn_progname}"
7772     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7773     break 2
7774   fi
7775 done
7776 done
7777
7778 fi
7779 fi
7780 OBJDUMP=$ac_cv_prog_OBJDUMP
7781 if test -n "$OBJDUMP"; then
7782   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7783 echo "${ECHO_T}$OBJDUMP" >&6
7784 else
7785   echo "$as_me:$LINENO: result: no" >&5
7786 echo "${ECHO_T}no" >&6
7787 fi
7788
7789   done
7790 fi
7791
7792 for ncn_progname in objdump; do
7793   if test -n "$ncn_tool_prefix"; then
7794     # Extract the first word of "${ncn_tool_prefix}${ncn_progname}", so it can be a program name with args.
7795 set dummy ${ncn_tool_prefix}${ncn_progname}; ac_word=$2
7796 echo "$as_me:$LINENO: checking for $ac_word" >&5
7797 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7798 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7799   echo $ECHO_N "(cached) $ECHO_C" >&6
7800 else
7801   if test -n "$OBJDUMP"; then
7802   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7803 else
7804 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7805 for as_dir in $PATH
7806 do
7807   IFS=$as_save_IFS
7808   test -z "$as_dir" && as_dir=.
7809   for ac_exec_ext in '' $ac_executable_extensions; do
7810   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7811     ac_cv_prog_OBJDUMP="${ncn_tool_prefix}${ncn_progname}"
7812     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7813     break 2
7814   fi
7815 done
7816 done
7817
7818 fi
7819 fi
7820 OBJDUMP=$ac_cv_prog_OBJDUMP
7821 if test -n "$OBJDUMP"; then
7822   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7823 echo "${ECHO_T}$OBJDUMP" >&6
7824 else
7825   echo "$as_me:$LINENO: result: no" >&5
7826 echo "${ECHO_T}no" >&6
7827 fi
7828
7829   fi
7830   if test -z "$ac_cv_prog_OBJDUMP" && test $build = $host ; then
7831     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7832 set dummy ${ncn_progname}; ac_word=$2
7833 echo "$as_me:$LINENO: checking for $ac_word" >&5
7834 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7835 if test "${ac_cv_prog_OBJDUMP+set}" = set; then
7836   echo $ECHO_N "(cached) $ECHO_C" >&6
7837 else
7838   if test -n "$OBJDUMP"; then
7839   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
7840 else
7841 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7842 for as_dir in $PATH
7843 do
7844   IFS=$as_save_IFS
7845   test -z "$as_dir" && as_dir=.
7846   for ac_exec_ext in '' $ac_executable_extensions; do
7847   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7848     ac_cv_prog_OBJDUMP="${ncn_progname}"
7849     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7850     break 2
7851   fi
7852 done
7853 done
7854
7855 fi
7856 fi
7857 OBJDUMP=$ac_cv_prog_OBJDUMP
7858 if test -n "$OBJDUMP"; then
7859   echo "$as_me:$LINENO: result: $OBJDUMP" >&5
7860 echo "${ECHO_T}$OBJDUMP" >&6
7861 else
7862   echo "$as_me:$LINENO: result: no" >&5
7863 echo "${ECHO_T}no" >&6
7864 fi
7865
7866   fi
7867   test -n "$ac_cv_prog_OBJDUMP" && break
7868 done
7869
7870 if test -z "$ac_cv_prog_OBJDUMP" ; then
7871   set dummy objdump
7872   if test $build = $host ; then
7873     OBJDUMP="$2"
7874   else
7875     OBJDUMP="${ncn_tool_prefix}$2"
7876   fi
7877 fi
7878
7879
7880
7881
7882
7883
7884
7885 # Target tools.
7886
7887 # Check whether --with-build-time-tools or --without-build-time-tools was given.
7888 if test "${with_build_time_tools+set}" = set; then
7889   withval="$with_build_time_tools"
7890   case x"$withval" in
7891      x/*) ;;
7892      *)
7893        with_build_time_tools=
7894        { echo "$as_me:$LINENO: WARNING: argument to --with-build-time-tools must be an absolute path" >&5
7895 echo "$as_me: WARNING: argument to --with-build-time-tools must be an absolute path" >&2;}
7896        ;;
7897    esac
7898 else
7899   with_build_time_tools=
7900 fi;
7901
7902
7903
7904 if test -n "$CC_FOR_TARGET"; then
7905   ac_cv_prog_CC_FOR_TARGET=$CC_FOR_TARGET
7906 elif test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7907   CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7908 fi
7909
7910 if test -n "$ac_cv_prog_CC_FOR_TARGET"; then
7911   for ncn_progname in cc gcc; do
7912     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
7913 set dummy ${ncn_progname}; ac_word=$2
7914 echo "$as_me:$LINENO: checking for $ac_word" >&5
7915 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7916 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7917   echo $ECHO_N "(cached) $ECHO_C" >&6
7918 else
7919   if test -n "$CC_FOR_TARGET"; then
7920   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7921 else
7922 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7923 for as_dir in $PATH
7924 do
7925   IFS=$as_save_IFS
7926   test -z "$as_dir" && as_dir=.
7927   for ac_exec_ext in '' $ac_executable_extensions; do
7928   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7929     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
7930     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7931     break 2
7932   fi
7933 done
7934 done
7935
7936 fi
7937 fi
7938 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7939 if test -n "$CC_FOR_TARGET"; then
7940   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7941 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7942 else
7943   echo "$as_me:$LINENO: result: no" >&5
7944 echo "${ECHO_T}no" >&6
7945 fi
7946
7947   done
7948 fi
7949
7950 if test -z "$ac_cv_prog_CC_FOR_TARGET" && test -n "$with_build_time_tools"; then
7951   for ncn_progname in cc gcc; do
7952     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
7953 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
7954     if test -x $with_build_time_tools/${ncn_progname}; then
7955       ac_cv_prog_CC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
7956       echo "$as_me:$LINENO: result: yes" >&5
7957 echo "${ECHO_T}yes" >&6
7958       break
7959     else
7960       echo "$as_me:$LINENO: result: no" >&5
7961 echo "${ECHO_T}no" >&6
7962     fi
7963   done
7964 fi
7965
7966 if test -z "$ac_cv_prog_CC_FOR_TARGET"; then
7967   for ncn_progname in cc gcc; do
7968     if test -n "$ncn_target_tool_prefix"; then
7969       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
7970 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
7971 echo "$as_me:$LINENO: checking for $ac_word" >&5
7972 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
7973 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
7974   echo $ECHO_N "(cached) $ECHO_C" >&6
7975 else
7976   if test -n "$CC_FOR_TARGET"; then
7977   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
7978 else
7979 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
7980 for as_dir in $PATH
7981 do
7982   IFS=$as_save_IFS
7983   test -z "$as_dir" && as_dir=.
7984   for ac_exec_ext in '' $ac_executable_extensions; do
7985   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
7986     ac_cv_prog_CC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
7987     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
7988     break 2
7989   fi
7990 done
7991 done
7992
7993 fi
7994 fi
7995 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
7996 if test -n "$CC_FOR_TARGET"; then
7997   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
7998 echo "${ECHO_T}$CC_FOR_TARGET" >&6
7999 else
8000   echo "$as_me:$LINENO: result: no" >&5
8001 echo "${ECHO_T}no" >&6
8002 fi
8003
8004     fi
8005     if test -z "$ac_cv_prog_CC_FOR_TARGET" && test $build = $target ; then
8006       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8007 set dummy ${ncn_progname}; ac_word=$2
8008 echo "$as_me:$LINENO: checking for $ac_word" >&5
8009 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8010 if test "${ac_cv_prog_CC_FOR_TARGET+set}" = set; then
8011   echo $ECHO_N "(cached) $ECHO_C" >&6
8012 else
8013   if test -n "$CC_FOR_TARGET"; then
8014   ac_cv_prog_CC_FOR_TARGET="$CC_FOR_TARGET" # Let the user override the test.
8015 else
8016 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8017 for as_dir in $PATH
8018 do
8019   IFS=$as_save_IFS
8020   test -z "$as_dir" && as_dir=.
8021   for ac_exec_ext in '' $ac_executable_extensions; do
8022   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8023     ac_cv_prog_CC_FOR_TARGET="${ncn_progname}"
8024     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8025     break 2
8026   fi
8027 done
8028 done
8029
8030 fi
8031 fi
8032 CC_FOR_TARGET=$ac_cv_prog_CC_FOR_TARGET
8033 if test -n "$CC_FOR_TARGET"; then
8034   echo "$as_me:$LINENO: result: $CC_FOR_TARGET" >&5
8035 echo "${ECHO_T}$CC_FOR_TARGET" >&6
8036 else
8037   echo "$as_me:$LINENO: result: no" >&5
8038 echo "${ECHO_T}no" >&6
8039 fi
8040
8041     fi
8042     test -n "$ac_cv_prog_CC_FOR_TARGET" && break
8043   done
8044 fi
8045
8046 if test -z "$ac_cv_prog_CC_FOR_TARGET" ; then
8047   set dummy cc gcc
8048   if test $build = $target ; then
8049     CC_FOR_TARGET="$2"
8050   else
8051     CC_FOR_TARGET="${ncn_target_tool_prefix}$2"
8052   fi
8053 else
8054   CC_FOR_TARGET="$ac_cv_prog_CC_FOR_TARGET"
8055 fi
8056
8057
8058
8059 if test -n "$CXX_FOR_TARGET"; then
8060   ac_cv_prog_CXX_FOR_TARGET=$CXX_FOR_TARGET
8061 elif test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8062   CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8063 fi
8064
8065 if test -n "$ac_cv_prog_CXX_FOR_TARGET"; then
8066   for ncn_progname in c++ g++ cxx gxx; do
8067     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8068 set dummy ${ncn_progname}; ac_word=$2
8069 echo "$as_me:$LINENO: checking for $ac_word" >&5
8070 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8071 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8072   echo $ECHO_N "(cached) $ECHO_C" >&6
8073 else
8074   if test -n "$CXX_FOR_TARGET"; then
8075   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8076 else
8077 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8078 for as_dir in $PATH
8079 do
8080   IFS=$as_save_IFS
8081   test -z "$as_dir" && as_dir=.
8082   for ac_exec_ext in '' $ac_executable_extensions; do
8083   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8084     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8085     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8086     break 2
8087   fi
8088 done
8089 done
8090
8091 fi
8092 fi
8093 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8094 if test -n "$CXX_FOR_TARGET"; then
8095   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8096 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8097 else
8098   echo "$as_me:$LINENO: result: no" >&5
8099 echo "${ECHO_T}no" >&6
8100 fi
8101
8102   done
8103 fi
8104
8105 if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test -n "$with_build_time_tools"; then
8106   for ncn_progname in c++ g++ cxx gxx; do
8107     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8108 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8109     if test -x $with_build_time_tools/${ncn_progname}; then
8110       ac_cv_prog_CXX_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8111       echo "$as_me:$LINENO: result: yes" >&5
8112 echo "${ECHO_T}yes" >&6
8113       break
8114     else
8115       echo "$as_me:$LINENO: result: no" >&5
8116 echo "${ECHO_T}no" >&6
8117     fi
8118   done
8119 fi
8120
8121 if test -z "$ac_cv_prog_CXX_FOR_TARGET"; then
8122   for ncn_progname in c++ g++ cxx gxx; do
8123     if test -n "$ncn_target_tool_prefix"; then
8124       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8125 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8126 echo "$as_me:$LINENO: checking for $ac_word" >&5
8127 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8128 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8129   echo $ECHO_N "(cached) $ECHO_C" >&6
8130 else
8131   if test -n "$CXX_FOR_TARGET"; then
8132   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8133 else
8134 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8135 for as_dir in $PATH
8136 do
8137   IFS=$as_save_IFS
8138   test -z "$as_dir" && as_dir=.
8139   for ac_exec_ext in '' $ac_executable_extensions; do
8140   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8141     ac_cv_prog_CXX_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8142     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8143     break 2
8144   fi
8145 done
8146 done
8147
8148 fi
8149 fi
8150 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8151 if test -n "$CXX_FOR_TARGET"; then
8152   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8153 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8154 else
8155   echo "$as_me:$LINENO: result: no" >&5
8156 echo "${ECHO_T}no" >&6
8157 fi
8158
8159     fi
8160     if test -z "$ac_cv_prog_CXX_FOR_TARGET" && test $build = $target ; then
8161       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8162 set dummy ${ncn_progname}; ac_word=$2
8163 echo "$as_me:$LINENO: checking for $ac_word" >&5
8164 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8165 if test "${ac_cv_prog_CXX_FOR_TARGET+set}" = set; then
8166   echo $ECHO_N "(cached) $ECHO_C" >&6
8167 else
8168   if test -n "$CXX_FOR_TARGET"; then
8169   ac_cv_prog_CXX_FOR_TARGET="$CXX_FOR_TARGET" # Let the user override the test.
8170 else
8171 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8172 for as_dir in $PATH
8173 do
8174   IFS=$as_save_IFS
8175   test -z "$as_dir" && as_dir=.
8176   for ac_exec_ext in '' $ac_executable_extensions; do
8177   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8178     ac_cv_prog_CXX_FOR_TARGET="${ncn_progname}"
8179     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8180     break 2
8181   fi
8182 done
8183 done
8184
8185 fi
8186 fi
8187 CXX_FOR_TARGET=$ac_cv_prog_CXX_FOR_TARGET
8188 if test -n "$CXX_FOR_TARGET"; then
8189   echo "$as_me:$LINENO: result: $CXX_FOR_TARGET" >&5
8190 echo "${ECHO_T}$CXX_FOR_TARGET" >&6
8191 else
8192   echo "$as_me:$LINENO: result: no" >&5
8193 echo "${ECHO_T}no" >&6
8194 fi
8195
8196     fi
8197     test -n "$ac_cv_prog_CXX_FOR_TARGET" && break
8198   done
8199 fi
8200
8201 if test -z "$ac_cv_prog_CXX_FOR_TARGET" ; then
8202   set dummy c++ g++ cxx gxx
8203   if test $build = $target ; then
8204     CXX_FOR_TARGET="$2"
8205   else
8206     CXX_FOR_TARGET="${ncn_target_tool_prefix}$2"
8207   fi
8208 else
8209   CXX_FOR_TARGET="$ac_cv_prog_CXX_FOR_TARGET"
8210 fi
8211
8212
8213
8214 if test -n "$GCC_FOR_TARGET"; then
8215   ac_cv_prog_GCC_FOR_TARGET=$GCC_FOR_TARGET
8216 elif test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8217   GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8218 fi
8219
8220 if test -n "$ac_cv_prog_GCC_FOR_TARGET"; then
8221   for ncn_progname in gcc; do
8222     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8223 set dummy ${ncn_progname}; ac_word=$2
8224 echo "$as_me:$LINENO: checking for $ac_word" >&5
8225 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8226 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8227   echo $ECHO_N "(cached) $ECHO_C" >&6
8228 else
8229   if test -n "$GCC_FOR_TARGET"; then
8230   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8231 else
8232 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8233 for as_dir in $PATH
8234 do
8235   IFS=$as_save_IFS
8236   test -z "$as_dir" && as_dir=.
8237   for ac_exec_ext in '' $ac_executable_extensions; do
8238   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8239     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8240     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8241     break 2
8242   fi
8243 done
8244 done
8245
8246 fi
8247 fi
8248 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8249 if test -n "$GCC_FOR_TARGET"; then
8250   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8251 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8252 else
8253   echo "$as_me:$LINENO: result: no" >&5
8254 echo "${ECHO_T}no" >&6
8255 fi
8256
8257   done
8258 fi
8259
8260 if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test -n "$with_build_time_tools"; then
8261   for ncn_progname in gcc; do
8262     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8263 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8264     if test -x $with_build_time_tools/${ncn_progname}; then
8265       ac_cv_prog_GCC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8266       echo "$as_me:$LINENO: result: yes" >&5
8267 echo "${ECHO_T}yes" >&6
8268       break
8269     else
8270       echo "$as_me:$LINENO: result: no" >&5
8271 echo "${ECHO_T}no" >&6
8272     fi
8273   done
8274 fi
8275
8276 if test -z "$ac_cv_prog_GCC_FOR_TARGET"; then
8277   for ncn_progname in gcc; do
8278     if test -n "$ncn_target_tool_prefix"; then
8279       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8280 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8281 echo "$as_me:$LINENO: checking for $ac_word" >&5
8282 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8283 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8284   echo $ECHO_N "(cached) $ECHO_C" >&6
8285 else
8286   if test -n "$GCC_FOR_TARGET"; then
8287   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8288 else
8289 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8290 for as_dir in $PATH
8291 do
8292   IFS=$as_save_IFS
8293   test -z "$as_dir" && as_dir=.
8294   for ac_exec_ext in '' $ac_executable_extensions; do
8295   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8296     ac_cv_prog_GCC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8297     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8298     break 2
8299   fi
8300 done
8301 done
8302
8303 fi
8304 fi
8305 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8306 if test -n "$GCC_FOR_TARGET"; then
8307   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8308 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8309 else
8310   echo "$as_me:$LINENO: result: no" >&5
8311 echo "${ECHO_T}no" >&6
8312 fi
8313
8314     fi
8315     if test -z "$ac_cv_prog_GCC_FOR_TARGET" && test $build = $target ; then
8316       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8317 set dummy ${ncn_progname}; ac_word=$2
8318 echo "$as_me:$LINENO: checking for $ac_word" >&5
8319 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8320 if test "${ac_cv_prog_GCC_FOR_TARGET+set}" = set; then
8321   echo $ECHO_N "(cached) $ECHO_C" >&6
8322 else
8323   if test -n "$GCC_FOR_TARGET"; then
8324   ac_cv_prog_GCC_FOR_TARGET="$GCC_FOR_TARGET" # Let the user override the test.
8325 else
8326 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8327 for as_dir in $PATH
8328 do
8329   IFS=$as_save_IFS
8330   test -z "$as_dir" && as_dir=.
8331   for ac_exec_ext in '' $ac_executable_extensions; do
8332   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8333     ac_cv_prog_GCC_FOR_TARGET="${ncn_progname}"
8334     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8335     break 2
8336   fi
8337 done
8338 done
8339
8340 fi
8341 fi
8342 GCC_FOR_TARGET=$ac_cv_prog_GCC_FOR_TARGET
8343 if test -n "$GCC_FOR_TARGET"; then
8344   echo "$as_me:$LINENO: result: $GCC_FOR_TARGET" >&5
8345 echo "${ECHO_T}$GCC_FOR_TARGET" >&6
8346 else
8347   echo "$as_me:$LINENO: result: no" >&5
8348 echo "${ECHO_T}no" >&6
8349 fi
8350
8351     fi
8352     test -n "$ac_cv_prog_GCC_FOR_TARGET" && break
8353   done
8354 fi
8355
8356 if test -z "$ac_cv_prog_GCC_FOR_TARGET" ; then
8357   GCC_FOR_TARGET="${CC_FOR_TARGET}"
8358 else
8359   GCC_FOR_TARGET="$ac_cv_prog_GCC_FOR_TARGET"
8360 fi
8361
8362
8363
8364 if test -n "$GCJ_FOR_TARGET"; then
8365   ac_cv_prog_GCJ_FOR_TARGET=$GCJ_FOR_TARGET
8366 elif test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8367   GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8368 fi
8369
8370 if test -n "$ac_cv_prog_GCJ_FOR_TARGET"; then
8371   for ncn_progname in gcj; do
8372     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8373 set dummy ${ncn_progname}; ac_word=$2
8374 echo "$as_me:$LINENO: checking for $ac_word" >&5
8375 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8376 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8377   echo $ECHO_N "(cached) $ECHO_C" >&6
8378 else
8379   if test -n "$GCJ_FOR_TARGET"; then
8380   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8381 else
8382 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8383 for as_dir in $PATH
8384 do
8385   IFS=$as_save_IFS
8386   test -z "$as_dir" && as_dir=.
8387   for ac_exec_ext in '' $ac_executable_extensions; do
8388   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8389     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8390     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8391     break 2
8392   fi
8393 done
8394 done
8395
8396 fi
8397 fi
8398 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8399 if test -n "$GCJ_FOR_TARGET"; then
8400   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8401 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8402 else
8403   echo "$as_me:$LINENO: result: no" >&5
8404 echo "${ECHO_T}no" >&6
8405 fi
8406
8407   done
8408 fi
8409
8410 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test -n "$with_build_time_tools"; then
8411   for ncn_progname in gcj; do
8412     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8413 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8414     if test -x $with_build_time_tools/${ncn_progname}; then
8415       ac_cv_prog_GCJ_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8416       echo "$as_me:$LINENO: result: yes" >&5
8417 echo "${ECHO_T}yes" >&6
8418       break
8419     else
8420       echo "$as_me:$LINENO: result: no" >&5
8421 echo "${ECHO_T}no" >&6
8422     fi
8423   done
8424 fi
8425
8426 if test -z "$ac_cv_prog_GCJ_FOR_TARGET"; then
8427   for ncn_progname in gcj; do
8428     if test -n "$ncn_target_tool_prefix"; then
8429       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8430 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8431 echo "$as_me:$LINENO: checking for $ac_word" >&5
8432 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8433 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8434   echo $ECHO_N "(cached) $ECHO_C" >&6
8435 else
8436   if test -n "$GCJ_FOR_TARGET"; then
8437   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8438 else
8439 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8440 for as_dir in $PATH
8441 do
8442   IFS=$as_save_IFS
8443   test -z "$as_dir" && as_dir=.
8444   for ac_exec_ext in '' $ac_executable_extensions; do
8445   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8446     ac_cv_prog_GCJ_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8447     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8448     break 2
8449   fi
8450 done
8451 done
8452
8453 fi
8454 fi
8455 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8456 if test -n "$GCJ_FOR_TARGET"; then
8457   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8458 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8459 else
8460   echo "$as_me:$LINENO: result: no" >&5
8461 echo "${ECHO_T}no" >&6
8462 fi
8463
8464     fi
8465     if test -z "$ac_cv_prog_GCJ_FOR_TARGET" && test $build = $target ; then
8466       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8467 set dummy ${ncn_progname}; ac_word=$2
8468 echo "$as_me:$LINENO: checking for $ac_word" >&5
8469 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8470 if test "${ac_cv_prog_GCJ_FOR_TARGET+set}" = set; then
8471   echo $ECHO_N "(cached) $ECHO_C" >&6
8472 else
8473   if test -n "$GCJ_FOR_TARGET"; then
8474   ac_cv_prog_GCJ_FOR_TARGET="$GCJ_FOR_TARGET" # Let the user override the test.
8475 else
8476 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8477 for as_dir in $PATH
8478 do
8479   IFS=$as_save_IFS
8480   test -z "$as_dir" && as_dir=.
8481   for ac_exec_ext in '' $ac_executable_extensions; do
8482   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8483     ac_cv_prog_GCJ_FOR_TARGET="${ncn_progname}"
8484     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8485     break 2
8486   fi
8487 done
8488 done
8489
8490 fi
8491 fi
8492 GCJ_FOR_TARGET=$ac_cv_prog_GCJ_FOR_TARGET
8493 if test -n "$GCJ_FOR_TARGET"; then
8494   echo "$as_me:$LINENO: result: $GCJ_FOR_TARGET" >&5
8495 echo "${ECHO_T}$GCJ_FOR_TARGET" >&6
8496 else
8497   echo "$as_me:$LINENO: result: no" >&5
8498 echo "${ECHO_T}no" >&6
8499 fi
8500
8501     fi
8502     test -n "$ac_cv_prog_GCJ_FOR_TARGET" && break
8503   done
8504 fi
8505
8506 if test -z "$ac_cv_prog_GCJ_FOR_TARGET" ; then
8507   set dummy gcj
8508   if test $build = $target ; then
8509     GCJ_FOR_TARGET="$2"
8510   else
8511     GCJ_FOR_TARGET="${ncn_target_tool_prefix}$2"
8512   fi
8513 else
8514   GCJ_FOR_TARGET="$ac_cv_prog_GCJ_FOR_TARGET"
8515 fi
8516
8517
8518
8519 if test -n "$GFORTRAN_FOR_TARGET"; then
8520   ac_cv_prog_GFORTRAN_FOR_TARGET=$GFORTRAN_FOR_TARGET
8521 elif test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8522   GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8523 fi
8524
8525 if test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8526   for ncn_progname in gfortran; do
8527     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8528 set dummy ${ncn_progname}; ac_word=$2
8529 echo "$as_me:$LINENO: checking for $ac_word" >&5
8530 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8531 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8532   echo $ECHO_N "(cached) $ECHO_C" >&6
8533 else
8534   if test -n "$GFORTRAN_FOR_TARGET"; then
8535   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8536 else
8537 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8538 for as_dir in $PATH
8539 do
8540   IFS=$as_save_IFS
8541   test -z "$as_dir" && as_dir=.
8542   for ac_exec_ext in '' $ac_executable_extensions; do
8543   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8544     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8545     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8546     break 2
8547   fi
8548 done
8549 done
8550
8551 fi
8552 fi
8553 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8554 if test -n "$GFORTRAN_FOR_TARGET"; then
8555   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8556 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8557 else
8558   echo "$as_me:$LINENO: result: no" >&5
8559 echo "${ECHO_T}no" >&6
8560 fi
8561
8562   done
8563 fi
8564
8565 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test -n "$with_build_time_tools"; then
8566   for ncn_progname in gfortran; do
8567     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8568 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8569     if test -x $with_build_time_tools/${ncn_progname}; then
8570       ac_cv_prog_GFORTRAN_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8571       echo "$as_me:$LINENO: result: yes" >&5
8572 echo "${ECHO_T}yes" >&6
8573       break
8574     else
8575       echo "$as_me:$LINENO: result: no" >&5
8576 echo "${ECHO_T}no" >&6
8577     fi
8578   done
8579 fi
8580
8581 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET"; then
8582   for ncn_progname in gfortran; do
8583     if test -n "$ncn_target_tool_prefix"; then
8584       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8585 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8586 echo "$as_me:$LINENO: checking for $ac_word" >&5
8587 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8588 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8589   echo $ECHO_N "(cached) $ECHO_C" >&6
8590 else
8591   if test -n "$GFORTRAN_FOR_TARGET"; then
8592   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8593 else
8594 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8595 for as_dir in $PATH
8596 do
8597   IFS=$as_save_IFS
8598   test -z "$as_dir" && as_dir=.
8599   for ac_exec_ext in '' $ac_executable_extensions; do
8600   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8601     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8602     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8603     break 2
8604   fi
8605 done
8606 done
8607
8608 fi
8609 fi
8610 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8611 if test -n "$GFORTRAN_FOR_TARGET"; then
8612   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8613 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8614 else
8615   echo "$as_me:$LINENO: result: no" >&5
8616 echo "${ECHO_T}no" >&6
8617 fi
8618
8619     fi
8620     if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" && test $build = $target ; then
8621       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8622 set dummy ${ncn_progname}; ac_word=$2
8623 echo "$as_me:$LINENO: checking for $ac_word" >&5
8624 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8625 if test "${ac_cv_prog_GFORTRAN_FOR_TARGET+set}" = set; then
8626   echo $ECHO_N "(cached) $ECHO_C" >&6
8627 else
8628   if test -n "$GFORTRAN_FOR_TARGET"; then
8629   ac_cv_prog_GFORTRAN_FOR_TARGET="$GFORTRAN_FOR_TARGET" # Let the user override the test.
8630 else
8631 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8632 for as_dir in $PATH
8633 do
8634   IFS=$as_save_IFS
8635   test -z "$as_dir" && as_dir=.
8636   for ac_exec_ext in '' $ac_executable_extensions; do
8637   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8638     ac_cv_prog_GFORTRAN_FOR_TARGET="${ncn_progname}"
8639     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8640     break 2
8641   fi
8642 done
8643 done
8644
8645 fi
8646 fi
8647 GFORTRAN_FOR_TARGET=$ac_cv_prog_GFORTRAN_FOR_TARGET
8648 if test -n "$GFORTRAN_FOR_TARGET"; then
8649   echo "$as_me:$LINENO: result: $GFORTRAN_FOR_TARGET" >&5
8650 echo "${ECHO_T}$GFORTRAN_FOR_TARGET" >&6
8651 else
8652   echo "$as_me:$LINENO: result: no" >&5
8653 echo "${ECHO_T}no" >&6
8654 fi
8655
8656     fi
8657     test -n "$ac_cv_prog_GFORTRAN_FOR_TARGET" && break
8658   done
8659 fi
8660
8661 if test -z "$ac_cv_prog_GFORTRAN_FOR_TARGET" ; then
8662   set dummy gfortran
8663   if test $build = $target ; then
8664     GFORTRAN_FOR_TARGET="$2"
8665   else
8666     GFORTRAN_FOR_TARGET="${ncn_target_tool_prefix}$2"
8667   fi
8668 else
8669   GFORTRAN_FOR_TARGET="$ac_cv_prog_GFORTRAN_FOR_TARGET"
8670 fi
8671
8672
8673
8674 cat > conftest.c << \EOF
8675 #ifdef __GNUC__
8676   gcc_yay;
8677 #endif
8678 EOF
8679 if ($GCC_FOR_TARGET -E conftest.c | grep gcc_yay) > /dev/null 2>&1; then
8680   have_gcc_for_target=yes
8681 else
8682   GCC_FOR_TARGET=${ncn_target_tool_prefix}gcc
8683   have_gcc_for_target=no
8684 fi
8685 rm conftest.c
8686
8687
8688
8689
8690 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8691   if test -n "$with_build_time_tools"; then
8692     echo "$as_me:$LINENO: checking for ar in $with_build_time_tools" >&5
8693 echo $ECHO_N "checking for ar in $with_build_time_tools... $ECHO_C" >&6
8694     if test -x $with_build_time_tools/ar; then
8695       AR_FOR_TARGET=`cd $with_build_time_tools && pwd`/ar
8696       ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8697       echo "$as_me:$LINENO: result: $ac_cv_path_AR_FOR_TARGET" >&5
8698 echo "${ECHO_T}$ac_cv_path_AR_FOR_TARGET" >&6
8699     else
8700       echo "$as_me:$LINENO: result: no" >&5
8701 echo "${ECHO_T}no" >&6
8702     fi
8703   elif test $build != $host && test $have_gcc_for_target = yes; then
8704     AR_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ar`
8705     test $AR_FOR_TARGET = ar && AR_FOR_TARGET=
8706     test -n "$AR_FOR_TARGET" && ac_cv_path_AR_FOR_TARGET=$AR_FOR_TARGET
8707   fi
8708 fi
8709 if test -z "$ac_cv_path_AR_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8710   # Extract the first word of "ar", so it can be a program name with args.
8711 set dummy ar; ac_word=$2
8712 echo "$as_me:$LINENO: checking for $ac_word" >&5
8713 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8714 if test "${ac_cv_path_AR_FOR_TARGET+set}" = set; then
8715   echo $ECHO_N "(cached) $ECHO_C" >&6
8716 else
8717   case $AR_FOR_TARGET in
8718   [\\/]* | ?:[\\/]*)
8719   ac_cv_path_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test with a path.
8720   ;;
8721   *)
8722   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8723 for as_dir in $gcc_cv_tool_dirs
8724 do
8725   IFS=$as_save_IFS
8726   test -z "$as_dir" && as_dir=.
8727   for ac_exec_ext in '' $ac_executable_extensions; do
8728   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8729     ac_cv_path_AR_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8730     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8731     break 2
8732   fi
8733 done
8734 done
8735
8736   ;;
8737 esac
8738 fi
8739 AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8740
8741 if test -n "$AR_FOR_TARGET"; then
8742   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8743 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8744 else
8745   echo "$as_me:$LINENO: result: no" >&5
8746 echo "${ECHO_T}no" >&6
8747 fi
8748
8749 fi
8750 if test -z "$ac_cv_path_AR_FOR_TARGET" ; then
8751
8752
8753 if test -n "$AR_FOR_TARGET"; then
8754   ac_cv_prog_AR_FOR_TARGET=$AR_FOR_TARGET
8755 elif test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8756   AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8757 fi
8758
8759 if test -n "$ac_cv_prog_AR_FOR_TARGET"; then
8760   for ncn_progname in ar; do
8761     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8762 set dummy ${ncn_progname}; ac_word=$2
8763 echo "$as_me:$LINENO: checking for $ac_word" >&5
8764 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8765 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8766   echo $ECHO_N "(cached) $ECHO_C" >&6
8767 else
8768   if test -n "$AR_FOR_TARGET"; then
8769   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8770 else
8771 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8772 for as_dir in $PATH
8773 do
8774   IFS=$as_save_IFS
8775   test -z "$as_dir" && as_dir=.
8776   for ac_exec_ext in '' $ac_executable_extensions; do
8777   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8778     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8779     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8780     break 2
8781   fi
8782 done
8783 done
8784
8785 fi
8786 fi
8787 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8788 if test -n "$AR_FOR_TARGET"; then
8789   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8790 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8791 else
8792   echo "$as_me:$LINENO: result: no" >&5
8793 echo "${ECHO_T}no" >&6
8794 fi
8795
8796   done
8797 fi
8798
8799 if test -z "$ac_cv_prog_AR_FOR_TARGET" && test -n "$with_build_time_tools"; then
8800   for ncn_progname in ar; do
8801     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
8802 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
8803     if test -x $with_build_time_tools/${ncn_progname}; then
8804       ac_cv_prog_AR_FOR_TARGET=$with_build_time_tools/${ncn_progname}
8805       echo "$as_me:$LINENO: result: yes" >&5
8806 echo "${ECHO_T}yes" >&6
8807       break
8808     else
8809       echo "$as_me:$LINENO: result: no" >&5
8810 echo "${ECHO_T}no" >&6
8811     fi
8812   done
8813 fi
8814
8815 if test -z "$ac_cv_prog_AR_FOR_TARGET"; then
8816   for ncn_progname in ar; do
8817     if test -n "$ncn_target_tool_prefix"; then
8818       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
8819 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
8820 echo "$as_me:$LINENO: checking for $ac_word" >&5
8821 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8822 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8823   echo $ECHO_N "(cached) $ECHO_C" >&6
8824 else
8825   if test -n "$AR_FOR_TARGET"; then
8826   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8827 else
8828 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8829 for as_dir in $PATH
8830 do
8831   IFS=$as_save_IFS
8832   test -z "$as_dir" && as_dir=.
8833   for ac_exec_ext in '' $ac_executable_extensions; do
8834   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8835     ac_cv_prog_AR_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
8836     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8837     break 2
8838   fi
8839 done
8840 done
8841
8842 fi
8843 fi
8844 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8845 if test -n "$AR_FOR_TARGET"; then
8846   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8847 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8848 else
8849   echo "$as_me:$LINENO: result: no" >&5
8850 echo "${ECHO_T}no" >&6
8851 fi
8852
8853     fi
8854     if test -z "$ac_cv_prog_AR_FOR_TARGET" && test $build = $target ; then
8855       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8856 set dummy ${ncn_progname}; ac_word=$2
8857 echo "$as_me:$LINENO: checking for $ac_word" >&5
8858 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8859 if test "${ac_cv_prog_AR_FOR_TARGET+set}" = set; then
8860   echo $ECHO_N "(cached) $ECHO_C" >&6
8861 else
8862   if test -n "$AR_FOR_TARGET"; then
8863   ac_cv_prog_AR_FOR_TARGET="$AR_FOR_TARGET" # Let the user override the test.
8864 else
8865 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8866 for as_dir in $PATH
8867 do
8868   IFS=$as_save_IFS
8869   test -z "$as_dir" && as_dir=.
8870   for ac_exec_ext in '' $ac_executable_extensions; do
8871   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8872     ac_cv_prog_AR_FOR_TARGET="${ncn_progname}"
8873     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8874     break 2
8875   fi
8876 done
8877 done
8878
8879 fi
8880 fi
8881 AR_FOR_TARGET=$ac_cv_prog_AR_FOR_TARGET
8882 if test -n "$AR_FOR_TARGET"; then
8883   echo "$as_me:$LINENO: result: $AR_FOR_TARGET" >&5
8884 echo "${ECHO_T}$AR_FOR_TARGET" >&6
8885 else
8886   echo "$as_me:$LINENO: result: no" >&5
8887 echo "${ECHO_T}no" >&6
8888 fi
8889
8890     fi
8891     test -n "$ac_cv_prog_AR_FOR_TARGET" && break
8892   done
8893 fi
8894
8895 if test -z "$ac_cv_prog_AR_FOR_TARGET" ; then
8896   set dummy ar
8897   if test $build = $target ; then
8898     AR_FOR_TARGET="$2"
8899   else
8900     AR_FOR_TARGET="${ncn_target_tool_prefix}$2"
8901   fi
8902 else
8903   AR_FOR_TARGET="$ac_cv_prog_AR_FOR_TARGET"
8904 fi
8905
8906 else
8907   AR_FOR_TARGET=$ac_cv_path_AR_FOR_TARGET
8908 fi
8909
8910
8911
8912
8913 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8914   if test -n "$with_build_time_tools"; then
8915     echo "$as_me:$LINENO: checking for as in $with_build_time_tools" >&5
8916 echo $ECHO_N "checking for as in $with_build_time_tools... $ECHO_C" >&6
8917     if test -x $with_build_time_tools/as; then
8918       AS_FOR_TARGET=`cd $with_build_time_tools && pwd`/as
8919       ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8920       echo "$as_me:$LINENO: result: $ac_cv_path_AS_FOR_TARGET" >&5
8921 echo "${ECHO_T}$ac_cv_path_AS_FOR_TARGET" >&6
8922     else
8923       echo "$as_me:$LINENO: result: no" >&5
8924 echo "${ECHO_T}no" >&6
8925     fi
8926   elif test $build != $host && test $have_gcc_for_target = yes; then
8927     AS_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=as`
8928     test $AS_FOR_TARGET = as && AS_FOR_TARGET=
8929     test -n "$AS_FOR_TARGET" && ac_cv_path_AS_FOR_TARGET=$AS_FOR_TARGET
8930   fi
8931 fi
8932 if test -z "$ac_cv_path_AS_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
8933   # Extract the first word of "as", so it can be a program name with args.
8934 set dummy as; ac_word=$2
8935 echo "$as_me:$LINENO: checking for $ac_word" >&5
8936 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8937 if test "${ac_cv_path_AS_FOR_TARGET+set}" = set; then
8938   echo $ECHO_N "(cached) $ECHO_C" >&6
8939 else
8940   case $AS_FOR_TARGET in
8941   [\\/]* | ?:[\\/]*)
8942   ac_cv_path_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test with a path.
8943   ;;
8944   *)
8945   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8946 for as_dir in $gcc_cv_tool_dirs
8947 do
8948   IFS=$as_save_IFS
8949   test -z "$as_dir" && as_dir=.
8950   for ac_exec_ext in '' $ac_executable_extensions; do
8951   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
8952     ac_cv_path_AS_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
8953     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
8954     break 2
8955   fi
8956 done
8957 done
8958
8959   ;;
8960 esac
8961 fi
8962 AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
8963
8964 if test -n "$AS_FOR_TARGET"; then
8965   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
8966 echo "${ECHO_T}$AS_FOR_TARGET" >&6
8967 else
8968   echo "$as_me:$LINENO: result: no" >&5
8969 echo "${ECHO_T}no" >&6
8970 fi
8971
8972 fi
8973 if test -z "$ac_cv_path_AS_FOR_TARGET" ; then
8974
8975
8976 if test -n "$AS_FOR_TARGET"; then
8977   ac_cv_prog_AS_FOR_TARGET=$AS_FOR_TARGET
8978 elif test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8979   AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
8980 fi
8981
8982 if test -n "$ac_cv_prog_AS_FOR_TARGET"; then
8983   for ncn_progname in as; do
8984     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
8985 set dummy ${ncn_progname}; ac_word=$2
8986 echo "$as_me:$LINENO: checking for $ac_word" >&5
8987 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
8988 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
8989   echo $ECHO_N "(cached) $ECHO_C" >&6
8990 else
8991   if test -n "$AS_FOR_TARGET"; then
8992   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
8993 else
8994 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
8995 for as_dir in $PATH
8996 do
8997   IFS=$as_save_IFS
8998   test -z "$as_dir" && as_dir=.
8999   for ac_exec_ext in '' $ac_executable_extensions; do
9000   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9001     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9002     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9003     break 2
9004   fi
9005 done
9006 done
9007
9008 fi
9009 fi
9010 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9011 if test -n "$AS_FOR_TARGET"; then
9012   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9013 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9014 else
9015   echo "$as_me:$LINENO: result: no" >&5
9016 echo "${ECHO_T}no" >&6
9017 fi
9018
9019   done
9020 fi
9021
9022 if test -z "$ac_cv_prog_AS_FOR_TARGET" && test -n "$with_build_time_tools"; then
9023   for ncn_progname in as; do
9024     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9025 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9026     if test -x $with_build_time_tools/${ncn_progname}; then
9027       ac_cv_prog_AS_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9028       echo "$as_me:$LINENO: result: yes" >&5
9029 echo "${ECHO_T}yes" >&6
9030       break
9031     else
9032       echo "$as_me:$LINENO: result: no" >&5
9033 echo "${ECHO_T}no" >&6
9034     fi
9035   done
9036 fi
9037
9038 if test -z "$ac_cv_prog_AS_FOR_TARGET"; then
9039   for ncn_progname in as; do
9040     if test -n "$ncn_target_tool_prefix"; then
9041       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9042 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9043 echo "$as_me:$LINENO: checking for $ac_word" >&5
9044 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9045 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9046   echo $ECHO_N "(cached) $ECHO_C" >&6
9047 else
9048   if test -n "$AS_FOR_TARGET"; then
9049   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9050 else
9051 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9052 for as_dir in $PATH
9053 do
9054   IFS=$as_save_IFS
9055   test -z "$as_dir" && as_dir=.
9056   for ac_exec_ext in '' $ac_executable_extensions; do
9057   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9058     ac_cv_prog_AS_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9059     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9060     break 2
9061   fi
9062 done
9063 done
9064
9065 fi
9066 fi
9067 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9068 if test -n "$AS_FOR_TARGET"; then
9069   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9070 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9071 else
9072   echo "$as_me:$LINENO: result: no" >&5
9073 echo "${ECHO_T}no" >&6
9074 fi
9075
9076     fi
9077     if test -z "$ac_cv_prog_AS_FOR_TARGET" && test $build = $target ; then
9078       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9079 set dummy ${ncn_progname}; ac_word=$2
9080 echo "$as_me:$LINENO: checking for $ac_word" >&5
9081 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9082 if test "${ac_cv_prog_AS_FOR_TARGET+set}" = set; then
9083   echo $ECHO_N "(cached) $ECHO_C" >&6
9084 else
9085   if test -n "$AS_FOR_TARGET"; then
9086   ac_cv_prog_AS_FOR_TARGET="$AS_FOR_TARGET" # Let the user override the test.
9087 else
9088 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9089 for as_dir in $PATH
9090 do
9091   IFS=$as_save_IFS
9092   test -z "$as_dir" && as_dir=.
9093   for ac_exec_ext in '' $ac_executable_extensions; do
9094   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9095     ac_cv_prog_AS_FOR_TARGET="${ncn_progname}"
9096     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9097     break 2
9098   fi
9099 done
9100 done
9101
9102 fi
9103 fi
9104 AS_FOR_TARGET=$ac_cv_prog_AS_FOR_TARGET
9105 if test -n "$AS_FOR_TARGET"; then
9106   echo "$as_me:$LINENO: result: $AS_FOR_TARGET" >&5
9107 echo "${ECHO_T}$AS_FOR_TARGET" >&6
9108 else
9109   echo "$as_me:$LINENO: result: no" >&5
9110 echo "${ECHO_T}no" >&6
9111 fi
9112
9113     fi
9114     test -n "$ac_cv_prog_AS_FOR_TARGET" && break
9115   done
9116 fi
9117
9118 if test -z "$ac_cv_prog_AS_FOR_TARGET" ; then
9119   set dummy as
9120   if test $build = $target ; then
9121     AS_FOR_TARGET="$2"
9122   else
9123     AS_FOR_TARGET="${ncn_target_tool_prefix}$2"
9124   fi
9125 else
9126   AS_FOR_TARGET="$ac_cv_prog_AS_FOR_TARGET"
9127 fi
9128
9129 else
9130   AS_FOR_TARGET=$ac_cv_path_AS_FOR_TARGET
9131 fi
9132
9133
9134
9135
9136 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9137   if test -n "$with_build_time_tools"; then
9138     echo "$as_me:$LINENO: checking for dlltool in $with_build_time_tools" >&5
9139 echo $ECHO_N "checking for dlltool in $with_build_time_tools... $ECHO_C" >&6
9140     if test -x $with_build_time_tools/dlltool; then
9141       DLLTOOL_FOR_TARGET=`cd $with_build_time_tools && pwd`/dlltool
9142       ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9143       echo "$as_me:$LINENO: result: $ac_cv_path_DLLTOOL_FOR_TARGET" >&5
9144 echo "${ECHO_T}$ac_cv_path_DLLTOOL_FOR_TARGET" >&6
9145     else
9146       echo "$as_me:$LINENO: result: no" >&5
9147 echo "${ECHO_T}no" >&6
9148     fi
9149   elif test $build != $host && test $have_gcc_for_target = yes; then
9150     DLLTOOL_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=dlltool`
9151     test $DLLTOOL_FOR_TARGET = dlltool && DLLTOOL_FOR_TARGET=
9152     test -n "$DLLTOOL_FOR_TARGET" && ac_cv_path_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9153   fi
9154 fi
9155 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9156   # Extract the first word of "dlltool", so it can be a program name with args.
9157 set dummy dlltool; ac_word=$2
9158 echo "$as_me:$LINENO: checking for $ac_word" >&5
9159 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9160 if test "${ac_cv_path_DLLTOOL_FOR_TARGET+set}" = set; then
9161   echo $ECHO_N "(cached) $ECHO_C" >&6
9162 else
9163   case $DLLTOOL_FOR_TARGET in
9164   [\\/]* | ?:[\\/]*)
9165   ac_cv_path_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test with a path.
9166   ;;
9167   *)
9168   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9169 for as_dir in $gcc_cv_tool_dirs
9170 do
9171   IFS=$as_save_IFS
9172   test -z "$as_dir" && as_dir=.
9173   for ac_exec_ext in '' $ac_executable_extensions; do
9174   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9175     ac_cv_path_DLLTOOL_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9176     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9177     break 2
9178   fi
9179 done
9180 done
9181
9182   ;;
9183 esac
9184 fi
9185 DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9186
9187 if test -n "$DLLTOOL_FOR_TARGET"; then
9188   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9189 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9190 else
9191   echo "$as_me:$LINENO: result: no" >&5
9192 echo "${ECHO_T}no" >&6
9193 fi
9194
9195 fi
9196 if test -z "$ac_cv_path_DLLTOOL_FOR_TARGET" ; then
9197
9198
9199 if test -n "$DLLTOOL_FOR_TARGET"; then
9200   ac_cv_prog_DLLTOOL_FOR_TARGET=$DLLTOOL_FOR_TARGET
9201 elif test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9202   DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9203 fi
9204
9205 if test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9206   for ncn_progname in dlltool; do
9207     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9208 set dummy ${ncn_progname}; ac_word=$2
9209 echo "$as_me:$LINENO: checking for $ac_word" >&5
9210 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9211 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9212   echo $ECHO_N "(cached) $ECHO_C" >&6
9213 else
9214   if test -n "$DLLTOOL_FOR_TARGET"; then
9215   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9216 else
9217 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9218 for as_dir in $PATH
9219 do
9220   IFS=$as_save_IFS
9221   test -z "$as_dir" && as_dir=.
9222   for ac_exec_ext in '' $ac_executable_extensions; do
9223   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9224     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9225     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9226     break 2
9227   fi
9228 done
9229 done
9230
9231 fi
9232 fi
9233 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9234 if test -n "$DLLTOOL_FOR_TARGET"; then
9235   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9236 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9237 else
9238   echo "$as_me:$LINENO: result: no" >&5
9239 echo "${ECHO_T}no" >&6
9240 fi
9241
9242   done
9243 fi
9244
9245 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test -n "$with_build_time_tools"; then
9246   for ncn_progname in dlltool; do
9247     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9248 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9249     if test -x $with_build_time_tools/${ncn_progname}; then
9250       ac_cv_prog_DLLTOOL_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9251       echo "$as_me:$LINENO: result: yes" >&5
9252 echo "${ECHO_T}yes" >&6
9253       break
9254     else
9255       echo "$as_me:$LINENO: result: no" >&5
9256 echo "${ECHO_T}no" >&6
9257     fi
9258   done
9259 fi
9260
9261 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET"; then
9262   for ncn_progname in dlltool; do
9263     if test -n "$ncn_target_tool_prefix"; then
9264       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9265 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9266 echo "$as_me:$LINENO: checking for $ac_word" >&5
9267 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9268 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9269   echo $ECHO_N "(cached) $ECHO_C" >&6
9270 else
9271   if test -n "$DLLTOOL_FOR_TARGET"; then
9272   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9273 else
9274 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9275 for as_dir in $PATH
9276 do
9277   IFS=$as_save_IFS
9278   test -z "$as_dir" && as_dir=.
9279   for ac_exec_ext in '' $ac_executable_extensions; do
9280   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9281     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9282     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9283     break 2
9284   fi
9285 done
9286 done
9287
9288 fi
9289 fi
9290 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9291 if test -n "$DLLTOOL_FOR_TARGET"; then
9292   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9293 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9294 else
9295   echo "$as_me:$LINENO: result: no" >&5
9296 echo "${ECHO_T}no" >&6
9297 fi
9298
9299     fi
9300     if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" && test $build = $target ; then
9301       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9302 set dummy ${ncn_progname}; ac_word=$2
9303 echo "$as_me:$LINENO: checking for $ac_word" >&5
9304 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9305 if test "${ac_cv_prog_DLLTOOL_FOR_TARGET+set}" = set; then
9306   echo $ECHO_N "(cached) $ECHO_C" >&6
9307 else
9308   if test -n "$DLLTOOL_FOR_TARGET"; then
9309   ac_cv_prog_DLLTOOL_FOR_TARGET="$DLLTOOL_FOR_TARGET" # Let the user override the test.
9310 else
9311 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9312 for as_dir in $PATH
9313 do
9314   IFS=$as_save_IFS
9315   test -z "$as_dir" && as_dir=.
9316   for ac_exec_ext in '' $ac_executable_extensions; do
9317   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9318     ac_cv_prog_DLLTOOL_FOR_TARGET="${ncn_progname}"
9319     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9320     break 2
9321   fi
9322 done
9323 done
9324
9325 fi
9326 fi
9327 DLLTOOL_FOR_TARGET=$ac_cv_prog_DLLTOOL_FOR_TARGET
9328 if test -n "$DLLTOOL_FOR_TARGET"; then
9329   echo "$as_me:$LINENO: result: $DLLTOOL_FOR_TARGET" >&5
9330 echo "${ECHO_T}$DLLTOOL_FOR_TARGET" >&6
9331 else
9332   echo "$as_me:$LINENO: result: no" >&5
9333 echo "${ECHO_T}no" >&6
9334 fi
9335
9336     fi
9337     test -n "$ac_cv_prog_DLLTOOL_FOR_TARGET" && break
9338   done
9339 fi
9340
9341 if test -z "$ac_cv_prog_DLLTOOL_FOR_TARGET" ; then
9342   set dummy dlltool
9343   if test $build = $target ; then
9344     DLLTOOL_FOR_TARGET="$2"
9345   else
9346     DLLTOOL_FOR_TARGET="${ncn_target_tool_prefix}$2"
9347   fi
9348 else
9349   DLLTOOL_FOR_TARGET="$ac_cv_prog_DLLTOOL_FOR_TARGET"
9350 fi
9351
9352 else
9353   DLLTOOL_FOR_TARGET=$ac_cv_path_DLLTOOL_FOR_TARGET
9354 fi
9355
9356
9357
9358
9359 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9360   if test -n "$with_build_time_tools"; then
9361     echo "$as_me:$LINENO: checking for ld in $with_build_time_tools" >&5
9362 echo $ECHO_N "checking for ld in $with_build_time_tools... $ECHO_C" >&6
9363     if test -x $with_build_time_tools/ld; then
9364       LD_FOR_TARGET=`cd $with_build_time_tools && pwd`/ld
9365       ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9366       echo "$as_me:$LINENO: result: $ac_cv_path_LD_FOR_TARGET" >&5
9367 echo "${ECHO_T}$ac_cv_path_LD_FOR_TARGET" >&6
9368     else
9369       echo "$as_me:$LINENO: result: no" >&5
9370 echo "${ECHO_T}no" >&6
9371     fi
9372   elif test $build != $host && test $have_gcc_for_target = yes; then
9373     LD_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ld`
9374     test $LD_FOR_TARGET = ld && LD_FOR_TARGET=
9375     test -n "$LD_FOR_TARGET" && ac_cv_path_LD_FOR_TARGET=$LD_FOR_TARGET
9376   fi
9377 fi
9378 if test -z "$ac_cv_path_LD_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9379   # Extract the first word of "ld", so it can be a program name with args.
9380 set dummy ld; ac_word=$2
9381 echo "$as_me:$LINENO: checking for $ac_word" >&5
9382 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9383 if test "${ac_cv_path_LD_FOR_TARGET+set}" = set; then
9384   echo $ECHO_N "(cached) $ECHO_C" >&6
9385 else
9386   case $LD_FOR_TARGET in
9387   [\\/]* | ?:[\\/]*)
9388   ac_cv_path_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test with a path.
9389   ;;
9390   *)
9391   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9392 for as_dir in $gcc_cv_tool_dirs
9393 do
9394   IFS=$as_save_IFS
9395   test -z "$as_dir" && as_dir=.
9396   for ac_exec_ext in '' $ac_executable_extensions; do
9397   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9398     ac_cv_path_LD_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9399     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9400     break 2
9401   fi
9402 done
9403 done
9404
9405   ;;
9406 esac
9407 fi
9408 LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9409
9410 if test -n "$LD_FOR_TARGET"; then
9411   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9412 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9413 else
9414   echo "$as_me:$LINENO: result: no" >&5
9415 echo "${ECHO_T}no" >&6
9416 fi
9417
9418 fi
9419 if test -z "$ac_cv_path_LD_FOR_TARGET" ; then
9420
9421
9422 if test -n "$LD_FOR_TARGET"; then
9423   ac_cv_prog_LD_FOR_TARGET=$LD_FOR_TARGET
9424 elif test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9425   LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9426 fi
9427
9428 if test -n "$ac_cv_prog_LD_FOR_TARGET"; then
9429   for ncn_progname in ld; do
9430     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9431 set dummy ${ncn_progname}; ac_word=$2
9432 echo "$as_me:$LINENO: checking for $ac_word" >&5
9433 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9434 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9435   echo $ECHO_N "(cached) $ECHO_C" >&6
9436 else
9437   if test -n "$LD_FOR_TARGET"; then
9438   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9439 else
9440 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9441 for as_dir in $PATH
9442 do
9443   IFS=$as_save_IFS
9444   test -z "$as_dir" && as_dir=.
9445   for ac_exec_ext in '' $ac_executable_extensions; do
9446   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9447     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9448     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9449     break 2
9450   fi
9451 done
9452 done
9453
9454 fi
9455 fi
9456 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9457 if test -n "$LD_FOR_TARGET"; then
9458   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9459 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9460 else
9461   echo "$as_me:$LINENO: result: no" >&5
9462 echo "${ECHO_T}no" >&6
9463 fi
9464
9465   done
9466 fi
9467
9468 if test -z "$ac_cv_prog_LD_FOR_TARGET" && test -n "$with_build_time_tools"; then
9469   for ncn_progname in ld; do
9470     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9471 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9472     if test -x $with_build_time_tools/${ncn_progname}; then
9473       ac_cv_prog_LD_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9474       echo "$as_me:$LINENO: result: yes" >&5
9475 echo "${ECHO_T}yes" >&6
9476       break
9477     else
9478       echo "$as_me:$LINENO: result: no" >&5
9479 echo "${ECHO_T}no" >&6
9480     fi
9481   done
9482 fi
9483
9484 if test -z "$ac_cv_prog_LD_FOR_TARGET"; then
9485   for ncn_progname in ld; do
9486     if test -n "$ncn_target_tool_prefix"; then
9487       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9488 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9489 echo "$as_me:$LINENO: checking for $ac_word" >&5
9490 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9491 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9492   echo $ECHO_N "(cached) $ECHO_C" >&6
9493 else
9494   if test -n "$LD_FOR_TARGET"; then
9495   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9496 else
9497 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9498 for as_dir in $PATH
9499 do
9500   IFS=$as_save_IFS
9501   test -z "$as_dir" && as_dir=.
9502   for ac_exec_ext in '' $ac_executable_extensions; do
9503   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9504     ac_cv_prog_LD_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9505     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9506     break 2
9507   fi
9508 done
9509 done
9510
9511 fi
9512 fi
9513 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9514 if test -n "$LD_FOR_TARGET"; then
9515   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9516 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9517 else
9518   echo "$as_me:$LINENO: result: no" >&5
9519 echo "${ECHO_T}no" >&6
9520 fi
9521
9522     fi
9523     if test -z "$ac_cv_prog_LD_FOR_TARGET" && test $build = $target ; then
9524       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9525 set dummy ${ncn_progname}; ac_word=$2
9526 echo "$as_me:$LINENO: checking for $ac_word" >&5
9527 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9528 if test "${ac_cv_prog_LD_FOR_TARGET+set}" = set; then
9529   echo $ECHO_N "(cached) $ECHO_C" >&6
9530 else
9531   if test -n "$LD_FOR_TARGET"; then
9532   ac_cv_prog_LD_FOR_TARGET="$LD_FOR_TARGET" # Let the user override the test.
9533 else
9534 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9535 for as_dir in $PATH
9536 do
9537   IFS=$as_save_IFS
9538   test -z "$as_dir" && as_dir=.
9539   for ac_exec_ext in '' $ac_executable_extensions; do
9540   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9541     ac_cv_prog_LD_FOR_TARGET="${ncn_progname}"
9542     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9543     break 2
9544   fi
9545 done
9546 done
9547
9548 fi
9549 fi
9550 LD_FOR_TARGET=$ac_cv_prog_LD_FOR_TARGET
9551 if test -n "$LD_FOR_TARGET"; then
9552   echo "$as_me:$LINENO: result: $LD_FOR_TARGET" >&5
9553 echo "${ECHO_T}$LD_FOR_TARGET" >&6
9554 else
9555   echo "$as_me:$LINENO: result: no" >&5
9556 echo "${ECHO_T}no" >&6
9557 fi
9558
9559     fi
9560     test -n "$ac_cv_prog_LD_FOR_TARGET" && break
9561   done
9562 fi
9563
9564 if test -z "$ac_cv_prog_LD_FOR_TARGET" ; then
9565   set dummy ld
9566   if test $build = $target ; then
9567     LD_FOR_TARGET="$2"
9568   else
9569     LD_FOR_TARGET="${ncn_target_tool_prefix}$2"
9570   fi
9571 else
9572   LD_FOR_TARGET="$ac_cv_prog_LD_FOR_TARGET"
9573 fi
9574
9575 else
9576   LD_FOR_TARGET=$ac_cv_path_LD_FOR_TARGET
9577 fi
9578
9579
9580
9581
9582 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9583   if test -n "$with_build_time_tools"; then
9584     echo "$as_me:$LINENO: checking for lipo in $with_build_time_tools" >&5
9585 echo $ECHO_N "checking for lipo in $with_build_time_tools... $ECHO_C" >&6
9586     if test -x $with_build_time_tools/lipo; then
9587       LIPO_FOR_TARGET=`cd $with_build_time_tools && pwd`/lipo
9588       ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9589       echo "$as_me:$LINENO: result: $ac_cv_path_LIPO_FOR_TARGET" >&5
9590 echo "${ECHO_T}$ac_cv_path_LIPO_FOR_TARGET" >&6
9591     else
9592       echo "$as_me:$LINENO: result: no" >&5
9593 echo "${ECHO_T}no" >&6
9594     fi
9595   elif test $build != $host && test $have_gcc_for_target = yes; then
9596     LIPO_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=lipo`
9597     test $LIPO_FOR_TARGET = lipo && LIPO_FOR_TARGET=
9598     test -n "$LIPO_FOR_TARGET" && ac_cv_path_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9599   fi
9600 fi
9601 if test -z "$ac_cv_path_LIPO_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9602   # Extract the first word of "lipo", so it can be a program name with args.
9603 set dummy lipo; ac_word=$2
9604 echo "$as_me:$LINENO: checking for $ac_word" >&5
9605 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9606 if test "${ac_cv_path_LIPO_FOR_TARGET+set}" = set; then
9607   echo $ECHO_N "(cached) $ECHO_C" >&6
9608 else
9609   case $LIPO_FOR_TARGET in
9610   [\\/]* | ?:[\\/]*)
9611   ac_cv_path_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test with a path.
9612   ;;
9613   *)
9614   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9615 for as_dir in $gcc_cv_tool_dirs
9616 do
9617   IFS=$as_save_IFS
9618   test -z "$as_dir" && as_dir=.
9619   for ac_exec_ext in '' $ac_executable_extensions; do
9620   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9621     ac_cv_path_LIPO_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9622     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9623     break 2
9624   fi
9625 done
9626 done
9627
9628   ;;
9629 esac
9630 fi
9631 LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9632
9633 if test -n "$LIPO_FOR_TARGET"; then
9634   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9635 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9636 else
9637   echo "$as_me:$LINENO: result: no" >&5
9638 echo "${ECHO_T}no" >&6
9639 fi
9640
9641 fi
9642 if test -z "$ac_cv_path_LIPO_FOR_TARGET" ; then
9643
9644
9645 if test -n "$LIPO_FOR_TARGET"; then
9646   ac_cv_prog_LIPO_FOR_TARGET=$LIPO_FOR_TARGET
9647 elif test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9648   LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9649 fi
9650
9651 if test -n "$ac_cv_prog_LIPO_FOR_TARGET"; then
9652   for ncn_progname in lipo; do
9653     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9654 set dummy ${ncn_progname}; ac_word=$2
9655 echo "$as_me:$LINENO: checking for $ac_word" >&5
9656 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9657 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9658   echo $ECHO_N "(cached) $ECHO_C" >&6
9659 else
9660   if test -n "$LIPO_FOR_TARGET"; then
9661   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9662 else
9663 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9664 for as_dir in $PATH
9665 do
9666   IFS=$as_save_IFS
9667   test -z "$as_dir" && as_dir=.
9668   for ac_exec_ext in '' $ac_executable_extensions; do
9669   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9670     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9671     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9672     break 2
9673   fi
9674 done
9675 done
9676
9677 fi
9678 fi
9679 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9680 if test -n "$LIPO_FOR_TARGET"; then
9681   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9682 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9683 else
9684   echo "$as_me:$LINENO: result: no" >&5
9685 echo "${ECHO_T}no" >&6
9686 fi
9687
9688   done
9689 fi
9690
9691 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test -n "$with_build_time_tools"; then
9692   for ncn_progname in lipo; do
9693     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9694 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9695     if test -x $with_build_time_tools/${ncn_progname}; then
9696       ac_cv_prog_LIPO_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9697       echo "$as_me:$LINENO: result: yes" >&5
9698 echo "${ECHO_T}yes" >&6
9699       break
9700     else
9701       echo "$as_me:$LINENO: result: no" >&5
9702 echo "${ECHO_T}no" >&6
9703     fi
9704   done
9705 fi
9706
9707 if test -z "$ac_cv_prog_LIPO_FOR_TARGET"; then
9708   for ncn_progname in lipo; do
9709     if test -n "$ncn_target_tool_prefix"; then
9710       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9711 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9712 echo "$as_me:$LINENO: checking for $ac_word" >&5
9713 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9714 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9715   echo $ECHO_N "(cached) $ECHO_C" >&6
9716 else
9717   if test -n "$LIPO_FOR_TARGET"; then
9718   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9719 else
9720 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9721 for as_dir in $PATH
9722 do
9723   IFS=$as_save_IFS
9724   test -z "$as_dir" && as_dir=.
9725   for ac_exec_ext in '' $ac_executable_extensions; do
9726   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9727     ac_cv_prog_LIPO_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9728     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9729     break 2
9730   fi
9731 done
9732 done
9733
9734 fi
9735 fi
9736 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9737 if test -n "$LIPO_FOR_TARGET"; then
9738   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9739 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9740 else
9741   echo "$as_me:$LINENO: result: no" >&5
9742 echo "${ECHO_T}no" >&6
9743 fi
9744
9745     fi
9746     if test -z "$ac_cv_prog_LIPO_FOR_TARGET" && test $build = $target ; then
9747       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9748 set dummy ${ncn_progname}; ac_word=$2
9749 echo "$as_me:$LINENO: checking for $ac_word" >&5
9750 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9751 if test "${ac_cv_prog_LIPO_FOR_TARGET+set}" = set; then
9752   echo $ECHO_N "(cached) $ECHO_C" >&6
9753 else
9754   if test -n "$LIPO_FOR_TARGET"; then
9755   ac_cv_prog_LIPO_FOR_TARGET="$LIPO_FOR_TARGET" # Let the user override the test.
9756 else
9757 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9758 for as_dir in $PATH
9759 do
9760   IFS=$as_save_IFS
9761   test -z "$as_dir" && as_dir=.
9762   for ac_exec_ext in '' $ac_executable_extensions; do
9763   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9764     ac_cv_prog_LIPO_FOR_TARGET="${ncn_progname}"
9765     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9766     break 2
9767   fi
9768 done
9769 done
9770
9771 fi
9772 fi
9773 LIPO_FOR_TARGET=$ac_cv_prog_LIPO_FOR_TARGET
9774 if test -n "$LIPO_FOR_TARGET"; then
9775   echo "$as_me:$LINENO: result: $LIPO_FOR_TARGET" >&5
9776 echo "${ECHO_T}$LIPO_FOR_TARGET" >&6
9777 else
9778   echo "$as_me:$LINENO: result: no" >&5
9779 echo "${ECHO_T}no" >&6
9780 fi
9781
9782     fi
9783     test -n "$ac_cv_prog_LIPO_FOR_TARGET" && break
9784   done
9785 fi
9786
9787 if test -z "$ac_cv_prog_LIPO_FOR_TARGET" ; then
9788   set dummy lipo
9789   if test $build = $target ; then
9790     LIPO_FOR_TARGET="$2"
9791   else
9792     LIPO_FOR_TARGET="${ncn_target_tool_prefix}$2"
9793   fi
9794 else
9795   LIPO_FOR_TARGET="$ac_cv_prog_LIPO_FOR_TARGET"
9796 fi
9797
9798 else
9799   LIPO_FOR_TARGET=$ac_cv_path_LIPO_FOR_TARGET
9800 fi
9801
9802
9803
9804
9805 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9806   if test -n "$with_build_time_tools"; then
9807     echo "$as_me:$LINENO: checking for nm in $with_build_time_tools" >&5
9808 echo $ECHO_N "checking for nm in $with_build_time_tools... $ECHO_C" >&6
9809     if test -x $with_build_time_tools/nm; then
9810       NM_FOR_TARGET=`cd $with_build_time_tools && pwd`/nm
9811       ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9812       echo "$as_me:$LINENO: result: $ac_cv_path_NM_FOR_TARGET" >&5
9813 echo "${ECHO_T}$ac_cv_path_NM_FOR_TARGET" >&6
9814     else
9815       echo "$as_me:$LINENO: result: no" >&5
9816 echo "${ECHO_T}no" >&6
9817     fi
9818   elif test $build != $host && test $have_gcc_for_target = yes; then
9819     NM_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=nm`
9820     test $NM_FOR_TARGET = nm && NM_FOR_TARGET=
9821     test -n "$NM_FOR_TARGET" && ac_cv_path_NM_FOR_TARGET=$NM_FOR_TARGET
9822   fi
9823 fi
9824 if test -z "$ac_cv_path_NM_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
9825   # Extract the first word of "nm", so it can be a program name with args.
9826 set dummy nm; ac_word=$2
9827 echo "$as_me:$LINENO: checking for $ac_word" >&5
9828 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9829 if test "${ac_cv_path_NM_FOR_TARGET+set}" = set; then
9830   echo $ECHO_N "(cached) $ECHO_C" >&6
9831 else
9832   case $NM_FOR_TARGET in
9833   [\\/]* | ?:[\\/]*)
9834   ac_cv_path_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test with a path.
9835   ;;
9836   *)
9837   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9838 for as_dir in $gcc_cv_tool_dirs
9839 do
9840   IFS=$as_save_IFS
9841   test -z "$as_dir" && as_dir=.
9842   for ac_exec_ext in '' $ac_executable_extensions; do
9843   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9844     ac_cv_path_NM_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
9845     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9846     break 2
9847   fi
9848 done
9849 done
9850
9851   ;;
9852 esac
9853 fi
9854 NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
9855
9856 if test -n "$NM_FOR_TARGET"; then
9857   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9858 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9859 else
9860   echo "$as_me:$LINENO: result: no" >&5
9861 echo "${ECHO_T}no" >&6
9862 fi
9863
9864 fi
9865 if test -z "$ac_cv_path_NM_FOR_TARGET" ; then
9866
9867
9868 if test -n "$NM_FOR_TARGET"; then
9869   ac_cv_prog_NM_FOR_TARGET=$NM_FOR_TARGET
9870 elif test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9871   NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9872 fi
9873
9874 if test -n "$ac_cv_prog_NM_FOR_TARGET"; then
9875   for ncn_progname in nm; do
9876     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9877 set dummy ${ncn_progname}; ac_word=$2
9878 echo "$as_me:$LINENO: checking for $ac_word" >&5
9879 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9880 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9881   echo $ECHO_N "(cached) $ECHO_C" >&6
9882 else
9883   if test -n "$NM_FOR_TARGET"; then
9884   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9885 else
9886 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9887 for as_dir in $PATH
9888 do
9889   IFS=$as_save_IFS
9890   test -z "$as_dir" && as_dir=.
9891   for ac_exec_ext in '' $ac_executable_extensions; do
9892   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9893     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9894     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9895     break 2
9896   fi
9897 done
9898 done
9899
9900 fi
9901 fi
9902 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9903 if test -n "$NM_FOR_TARGET"; then
9904   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9905 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9906 else
9907   echo "$as_me:$LINENO: result: no" >&5
9908 echo "${ECHO_T}no" >&6
9909 fi
9910
9911   done
9912 fi
9913
9914 if test -z "$ac_cv_prog_NM_FOR_TARGET" && test -n "$with_build_time_tools"; then
9915   for ncn_progname in nm; do
9916     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
9917 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
9918     if test -x $with_build_time_tools/${ncn_progname}; then
9919       ac_cv_prog_NM_FOR_TARGET=$with_build_time_tools/${ncn_progname}
9920       echo "$as_me:$LINENO: result: yes" >&5
9921 echo "${ECHO_T}yes" >&6
9922       break
9923     else
9924       echo "$as_me:$LINENO: result: no" >&5
9925 echo "${ECHO_T}no" >&6
9926     fi
9927   done
9928 fi
9929
9930 if test -z "$ac_cv_prog_NM_FOR_TARGET"; then
9931   for ncn_progname in nm; do
9932     if test -n "$ncn_target_tool_prefix"; then
9933       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
9934 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
9935 echo "$as_me:$LINENO: checking for $ac_word" >&5
9936 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9937 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9938   echo $ECHO_N "(cached) $ECHO_C" >&6
9939 else
9940   if test -n "$NM_FOR_TARGET"; then
9941   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9942 else
9943 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9944 for as_dir in $PATH
9945 do
9946   IFS=$as_save_IFS
9947   test -z "$as_dir" && as_dir=.
9948   for ac_exec_ext in '' $ac_executable_extensions; do
9949   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9950     ac_cv_prog_NM_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
9951     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9952     break 2
9953   fi
9954 done
9955 done
9956
9957 fi
9958 fi
9959 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9960 if test -n "$NM_FOR_TARGET"; then
9961   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9962 echo "${ECHO_T}$NM_FOR_TARGET" >&6
9963 else
9964   echo "$as_me:$LINENO: result: no" >&5
9965 echo "${ECHO_T}no" >&6
9966 fi
9967
9968     fi
9969     if test -z "$ac_cv_prog_NM_FOR_TARGET" && test $build = $target ; then
9970       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
9971 set dummy ${ncn_progname}; ac_word=$2
9972 echo "$as_me:$LINENO: checking for $ac_word" >&5
9973 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
9974 if test "${ac_cv_prog_NM_FOR_TARGET+set}" = set; then
9975   echo $ECHO_N "(cached) $ECHO_C" >&6
9976 else
9977   if test -n "$NM_FOR_TARGET"; then
9978   ac_cv_prog_NM_FOR_TARGET="$NM_FOR_TARGET" # Let the user override the test.
9979 else
9980 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
9981 for as_dir in $PATH
9982 do
9983   IFS=$as_save_IFS
9984   test -z "$as_dir" && as_dir=.
9985   for ac_exec_ext in '' $ac_executable_extensions; do
9986   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
9987     ac_cv_prog_NM_FOR_TARGET="${ncn_progname}"
9988     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
9989     break 2
9990   fi
9991 done
9992 done
9993
9994 fi
9995 fi
9996 NM_FOR_TARGET=$ac_cv_prog_NM_FOR_TARGET
9997 if test -n "$NM_FOR_TARGET"; then
9998   echo "$as_me:$LINENO: result: $NM_FOR_TARGET" >&5
9999 echo "${ECHO_T}$NM_FOR_TARGET" >&6
10000 else
10001   echo "$as_me:$LINENO: result: no" >&5
10002 echo "${ECHO_T}no" >&6
10003 fi
10004
10005     fi
10006     test -n "$ac_cv_prog_NM_FOR_TARGET" && break
10007   done
10008 fi
10009
10010 if test -z "$ac_cv_prog_NM_FOR_TARGET" ; then
10011   set dummy nm
10012   if test $build = $target ; then
10013     NM_FOR_TARGET="$2"
10014   else
10015     NM_FOR_TARGET="${ncn_target_tool_prefix}$2"
10016   fi
10017 else
10018   NM_FOR_TARGET="$ac_cv_prog_NM_FOR_TARGET"
10019 fi
10020
10021 else
10022   NM_FOR_TARGET=$ac_cv_path_NM_FOR_TARGET
10023 fi
10024
10025
10026
10027
10028 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10029   if test -n "$with_build_time_tools"; then
10030     echo "$as_me:$LINENO: checking for objdump in $with_build_time_tools" >&5
10031 echo $ECHO_N "checking for objdump in $with_build_time_tools... $ECHO_C" >&6
10032     if test -x $with_build_time_tools/objdump; then
10033       OBJDUMP_FOR_TARGET=`cd $with_build_time_tools && pwd`/objdump
10034       ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10035       echo "$as_me:$LINENO: result: $ac_cv_path_OBJDUMP_FOR_TARGET" >&5
10036 echo "${ECHO_T}$ac_cv_path_OBJDUMP_FOR_TARGET" >&6
10037     else
10038       echo "$as_me:$LINENO: result: no" >&5
10039 echo "${ECHO_T}no" >&6
10040     fi
10041   elif test $build != $host && test $have_gcc_for_target = yes; then
10042     OBJDUMP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=objdump`
10043     test $OBJDUMP_FOR_TARGET = objdump && OBJDUMP_FOR_TARGET=
10044     test -n "$OBJDUMP_FOR_TARGET" && ac_cv_path_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10045   fi
10046 fi
10047 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10048   # Extract the first word of "objdump", so it can be a program name with args.
10049 set dummy objdump; ac_word=$2
10050 echo "$as_me:$LINENO: checking for $ac_word" >&5
10051 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10052 if test "${ac_cv_path_OBJDUMP_FOR_TARGET+set}" = set; then
10053   echo $ECHO_N "(cached) $ECHO_C" >&6
10054 else
10055   case $OBJDUMP_FOR_TARGET in
10056   [\\/]* | ?:[\\/]*)
10057   ac_cv_path_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test with a path.
10058   ;;
10059   *)
10060   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10061 for as_dir in $gcc_cv_tool_dirs
10062 do
10063   IFS=$as_save_IFS
10064   test -z "$as_dir" && as_dir=.
10065   for ac_exec_ext in '' $ac_executable_extensions; do
10066   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10067     ac_cv_path_OBJDUMP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10068     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10069     break 2
10070   fi
10071 done
10072 done
10073
10074   ;;
10075 esac
10076 fi
10077 OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10078
10079 if test -n "$OBJDUMP_FOR_TARGET"; then
10080   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10081 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10082 else
10083   echo "$as_me:$LINENO: result: no" >&5
10084 echo "${ECHO_T}no" >&6
10085 fi
10086
10087 fi
10088 if test -z "$ac_cv_path_OBJDUMP_FOR_TARGET" ; then
10089
10090
10091 if test -n "$OBJDUMP_FOR_TARGET"; then
10092   ac_cv_prog_OBJDUMP_FOR_TARGET=$OBJDUMP_FOR_TARGET
10093 elif test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10094   OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10095 fi
10096
10097 if test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10098   for ncn_progname in objdump; do
10099     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10100 set dummy ${ncn_progname}; ac_word=$2
10101 echo "$as_me:$LINENO: checking for $ac_word" >&5
10102 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10103 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10104   echo $ECHO_N "(cached) $ECHO_C" >&6
10105 else
10106   if test -n "$OBJDUMP_FOR_TARGET"; then
10107   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10108 else
10109 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10110 for as_dir in $PATH
10111 do
10112   IFS=$as_save_IFS
10113   test -z "$as_dir" && as_dir=.
10114   for ac_exec_ext in '' $ac_executable_extensions; do
10115   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10116     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10117     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10118     break 2
10119   fi
10120 done
10121 done
10122
10123 fi
10124 fi
10125 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10126 if test -n "$OBJDUMP_FOR_TARGET"; then
10127   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10128 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10129 else
10130   echo "$as_me:$LINENO: result: no" >&5
10131 echo "${ECHO_T}no" >&6
10132 fi
10133
10134   done
10135 fi
10136
10137 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10138   for ncn_progname in objdump; do
10139     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10140 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10141     if test -x $with_build_time_tools/${ncn_progname}; then
10142       ac_cv_prog_OBJDUMP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10143       echo "$as_me:$LINENO: result: yes" >&5
10144 echo "${ECHO_T}yes" >&6
10145       break
10146     else
10147       echo "$as_me:$LINENO: result: no" >&5
10148 echo "${ECHO_T}no" >&6
10149     fi
10150   done
10151 fi
10152
10153 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET"; then
10154   for ncn_progname in objdump; do
10155     if test -n "$ncn_target_tool_prefix"; then
10156       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10157 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10158 echo "$as_me:$LINENO: checking for $ac_word" >&5
10159 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10160 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10161   echo $ECHO_N "(cached) $ECHO_C" >&6
10162 else
10163   if test -n "$OBJDUMP_FOR_TARGET"; then
10164   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10165 else
10166 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10167 for as_dir in $PATH
10168 do
10169   IFS=$as_save_IFS
10170   test -z "$as_dir" && as_dir=.
10171   for ac_exec_ext in '' $ac_executable_extensions; do
10172   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10173     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10174     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10175     break 2
10176   fi
10177 done
10178 done
10179
10180 fi
10181 fi
10182 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10183 if test -n "$OBJDUMP_FOR_TARGET"; then
10184   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10185 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10186 else
10187   echo "$as_me:$LINENO: result: no" >&5
10188 echo "${ECHO_T}no" >&6
10189 fi
10190
10191     fi
10192     if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" && test $build = $target ; then
10193       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10194 set dummy ${ncn_progname}; ac_word=$2
10195 echo "$as_me:$LINENO: checking for $ac_word" >&5
10196 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10197 if test "${ac_cv_prog_OBJDUMP_FOR_TARGET+set}" = set; then
10198   echo $ECHO_N "(cached) $ECHO_C" >&6
10199 else
10200   if test -n "$OBJDUMP_FOR_TARGET"; then
10201   ac_cv_prog_OBJDUMP_FOR_TARGET="$OBJDUMP_FOR_TARGET" # Let the user override the test.
10202 else
10203 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10204 for as_dir in $PATH
10205 do
10206   IFS=$as_save_IFS
10207   test -z "$as_dir" && as_dir=.
10208   for ac_exec_ext in '' $ac_executable_extensions; do
10209   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10210     ac_cv_prog_OBJDUMP_FOR_TARGET="${ncn_progname}"
10211     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10212     break 2
10213   fi
10214 done
10215 done
10216
10217 fi
10218 fi
10219 OBJDUMP_FOR_TARGET=$ac_cv_prog_OBJDUMP_FOR_TARGET
10220 if test -n "$OBJDUMP_FOR_TARGET"; then
10221   echo "$as_me:$LINENO: result: $OBJDUMP_FOR_TARGET" >&5
10222 echo "${ECHO_T}$OBJDUMP_FOR_TARGET" >&6
10223 else
10224   echo "$as_me:$LINENO: result: no" >&5
10225 echo "${ECHO_T}no" >&6
10226 fi
10227
10228     fi
10229     test -n "$ac_cv_prog_OBJDUMP_FOR_TARGET" && break
10230   done
10231 fi
10232
10233 if test -z "$ac_cv_prog_OBJDUMP_FOR_TARGET" ; then
10234   set dummy objdump
10235   if test $build = $target ; then
10236     OBJDUMP_FOR_TARGET="$2"
10237   else
10238     OBJDUMP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10239   fi
10240 else
10241   OBJDUMP_FOR_TARGET="$ac_cv_prog_OBJDUMP_FOR_TARGET"
10242 fi
10243
10244 else
10245   OBJDUMP_FOR_TARGET=$ac_cv_path_OBJDUMP_FOR_TARGET
10246 fi
10247
10248
10249
10250
10251 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10252   if test -n "$with_build_time_tools"; then
10253     echo "$as_me:$LINENO: checking for ranlib in $with_build_time_tools" >&5
10254 echo $ECHO_N "checking for ranlib in $with_build_time_tools... $ECHO_C" >&6
10255     if test -x $with_build_time_tools/ranlib; then
10256       RANLIB_FOR_TARGET=`cd $with_build_time_tools && pwd`/ranlib
10257       ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10258       echo "$as_me:$LINENO: result: $ac_cv_path_RANLIB_FOR_TARGET" >&5
10259 echo "${ECHO_T}$ac_cv_path_RANLIB_FOR_TARGET" >&6
10260     else
10261       echo "$as_me:$LINENO: result: no" >&5
10262 echo "${ECHO_T}no" >&6
10263     fi
10264   elif test $build != $host && test $have_gcc_for_target = yes; then
10265     RANLIB_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=ranlib`
10266     test $RANLIB_FOR_TARGET = ranlib && RANLIB_FOR_TARGET=
10267     test -n "$RANLIB_FOR_TARGET" && ac_cv_path_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10268   fi
10269 fi
10270 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10271   # Extract the first word of "ranlib", so it can be a program name with args.
10272 set dummy ranlib; ac_word=$2
10273 echo "$as_me:$LINENO: checking for $ac_word" >&5
10274 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10275 if test "${ac_cv_path_RANLIB_FOR_TARGET+set}" = set; then
10276   echo $ECHO_N "(cached) $ECHO_C" >&6
10277 else
10278   case $RANLIB_FOR_TARGET in
10279   [\\/]* | ?:[\\/]*)
10280   ac_cv_path_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test with a path.
10281   ;;
10282   *)
10283   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10284 for as_dir in $gcc_cv_tool_dirs
10285 do
10286   IFS=$as_save_IFS
10287   test -z "$as_dir" && as_dir=.
10288   for ac_exec_ext in '' $ac_executable_extensions; do
10289   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10290     ac_cv_path_RANLIB_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10291     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10292     break 2
10293   fi
10294 done
10295 done
10296
10297   ;;
10298 esac
10299 fi
10300 RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10301
10302 if test -n "$RANLIB_FOR_TARGET"; then
10303   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10304 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10305 else
10306   echo "$as_me:$LINENO: result: no" >&5
10307 echo "${ECHO_T}no" >&6
10308 fi
10309
10310 fi
10311 if test -z "$ac_cv_path_RANLIB_FOR_TARGET" ; then
10312
10313
10314 if test -n "$RANLIB_FOR_TARGET"; then
10315   ac_cv_prog_RANLIB_FOR_TARGET=$RANLIB_FOR_TARGET
10316 elif test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10317   RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10318 fi
10319
10320 if test -n "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10321   for ncn_progname in ranlib; do
10322     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10323 set dummy ${ncn_progname}; ac_word=$2
10324 echo "$as_me:$LINENO: checking for $ac_word" >&5
10325 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10326 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10327   echo $ECHO_N "(cached) $ECHO_C" >&6
10328 else
10329   if test -n "$RANLIB_FOR_TARGET"; then
10330   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10331 else
10332 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10333 for as_dir in $PATH
10334 do
10335   IFS=$as_save_IFS
10336   test -z "$as_dir" && as_dir=.
10337   for ac_exec_ext in '' $ac_executable_extensions; do
10338   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10339     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10340     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10341     break 2
10342   fi
10343 done
10344 done
10345
10346 fi
10347 fi
10348 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10349 if test -n "$RANLIB_FOR_TARGET"; then
10350   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10351 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10352 else
10353   echo "$as_me:$LINENO: result: no" >&5
10354 echo "${ECHO_T}no" >&6
10355 fi
10356
10357   done
10358 fi
10359
10360 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test -n "$with_build_time_tools"; then
10361   for ncn_progname in ranlib; do
10362     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10363 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10364     if test -x $with_build_time_tools/${ncn_progname}; then
10365       ac_cv_prog_RANLIB_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10366       echo "$as_me:$LINENO: result: yes" >&5
10367 echo "${ECHO_T}yes" >&6
10368       break
10369     else
10370       echo "$as_me:$LINENO: result: no" >&5
10371 echo "${ECHO_T}no" >&6
10372     fi
10373   done
10374 fi
10375
10376 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET"; then
10377   for ncn_progname in ranlib; do
10378     if test -n "$ncn_target_tool_prefix"; then
10379       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10380 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10381 echo "$as_me:$LINENO: checking for $ac_word" >&5
10382 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10383 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10384   echo $ECHO_N "(cached) $ECHO_C" >&6
10385 else
10386   if test -n "$RANLIB_FOR_TARGET"; then
10387   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10388 else
10389 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10390 for as_dir in $PATH
10391 do
10392   IFS=$as_save_IFS
10393   test -z "$as_dir" && as_dir=.
10394   for ac_exec_ext in '' $ac_executable_extensions; do
10395   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10396     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10397     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10398     break 2
10399   fi
10400 done
10401 done
10402
10403 fi
10404 fi
10405 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10406 if test -n "$RANLIB_FOR_TARGET"; then
10407   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10408 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10409 else
10410   echo "$as_me:$LINENO: result: no" >&5
10411 echo "${ECHO_T}no" >&6
10412 fi
10413
10414     fi
10415     if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" && test $build = $target ; then
10416       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10417 set dummy ${ncn_progname}; ac_word=$2
10418 echo "$as_me:$LINENO: checking for $ac_word" >&5
10419 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10420 if test "${ac_cv_prog_RANLIB_FOR_TARGET+set}" = set; then
10421   echo $ECHO_N "(cached) $ECHO_C" >&6
10422 else
10423   if test -n "$RANLIB_FOR_TARGET"; then
10424   ac_cv_prog_RANLIB_FOR_TARGET="$RANLIB_FOR_TARGET" # Let the user override the test.
10425 else
10426 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10427 for as_dir in $PATH
10428 do
10429   IFS=$as_save_IFS
10430   test -z "$as_dir" && as_dir=.
10431   for ac_exec_ext in '' $ac_executable_extensions; do
10432   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10433     ac_cv_prog_RANLIB_FOR_TARGET="${ncn_progname}"
10434     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10435     break 2
10436   fi
10437 done
10438 done
10439
10440 fi
10441 fi
10442 RANLIB_FOR_TARGET=$ac_cv_prog_RANLIB_FOR_TARGET
10443 if test -n "$RANLIB_FOR_TARGET"; then
10444   echo "$as_me:$LINENO: result: $RANLIB_FOR_TARGET" >&5
10445 echo "${ECHO_T}$RANLIB_FOR_TARGET" >&6
10446 else
10447   echo "$as_me:$LINENO: result: no" >&5
10448 echo "${ECHO_T}no" >&6
10449 fi
10450
10451     fi
10452     test -n "$ac_cv_prog_RANLIB_FOR_TARGET" && break
10453   done
10454 fi
10455
10456 if test -z "$ac_cv_prog_RANLIB_FOR_TARGET" ; then
10457   set dummy ranlib
10458   if test $build = $target ; then
10459     RANLIB_FOR_TARGET="$2"
10460   else
10461     RANLIB_FOR_TARGET="${ncn_target_tool_prefix}$2"
10462   fi
10463 else
10464   RANLIB_FOR_TARGET="$ac_cv_prog_RANLIB_FOR_TARGET"
10465 fi
10466
10467 else
10468   RANLIB_FOR_TARGET=$ac_cv_path_RANLIB_FOR_TARGET
10469 fi
10470
10471
10472
10473
10474 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10475   if test -n "$with_build_time_tools"; then
10476     echo "$as_me:$LINENO: checking for strip in $with_build_time_tools" >&5
10477 echo $ECHO_N "checking for strip in $with_build_time_tools... $ECHO_C" >&6
10478     if test -x $with_build_time_tools/strip; then
10479       STRIP_FOR_TARGET=`cd $with_build_time_tools && pwd`/strip
10480       ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10481       echo "$as_me:$LINENO: result: $ac_cv_path_STRIP_FOR_TARGET" >&5
10482 echo "${ECHO_T}$ac_cv_path_STRIP_FOR_TARGET" >&6
10483     else
10484       echo "$as_me:$LINENO: result: no" >&5
10485 echo "${ECHO_T}no" >&6
10486     fi
10487   elif test $build != $host && test $have_gcc_for_target = yes; then
10488     STRIP_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=strip`
10489     test $STRIP_FOR_TARGET = strip && STRIP_FOR_TARGET=
10490     test -n "$STRIP_FOR_TARGET" && ac_cv_path_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10491   fi
10492 fi
10493 if test -z "$ac_cv_path_STRIP_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10494   # Extract the first word of "strip", so it can be a program name with args.
10495 set dummy strip; ac_word=$2
10496 echo "$as_me:$LINENO: checking for $ac_word" >&5
10497 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10498 if test "${ac_cv_path_STRIP_FOR_TARGET+set}" = set; then
10499   echo $ECHO_N "(cached) $ECHO_C" >&6
10500 else
10501   case $STRIP_FOR_TARGET in
10502   [\\/]* | ?:[\\/]*)
10503   ac_cv_path_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test with a path.
10504   ;;
10505   *)
10506   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10507 for as_dir in $gcc_cv_tool_dirs
10508 do
10509   IFS=$as_save_IFS
10510   test -z "$as_dir" && as_dir=.
10511   for ac_exec_ext in '' $ac_executable_extensions; do
10512   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10513     ac_cv_path_STRIP_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10514     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10515     break 2
10516   fi
10517 done
10518 done
10519
10520   ;;
10521 esac
10522 fi
10523 STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10524
10525 if test -n "$STRIP_FOR_TARGET"; then
10526   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10527 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10528 else
10529   echo "$as_me:$LINENO: result: no" >&5
10530 echo "${ECHO_T}no" >&6
10531 fi
10532
10533 fi
10534 if test -z "$ac_cv_path_STRIP_FOR_TARGET" ; then
10535
10536
10537 if test -n "$STRIP_FOR_TARGET"; then
10538   ac_cv_prog_STRIP_FOR_TARGET=$STRIP_FOR_TARGET
10539 elif test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10540   STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10541 fi
10542
10543 if test -n "$ac_cv_prog_STRIP_FOR_TARGET"; then
10544   for ncn_progname in strip; do
10545     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10546 set dummy ${ncn_progname}; ac_word=$2
10547 echo "$as_me:$LINENO: checking for $ac_word" >&5
10548 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10549 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10550   echo $ECHO_N "(cached) $ECHO_C" >&6
10551 else
10552   if test -n "$STRIP_FOR_TARGET"; then
10553   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10554 else
10555 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10556 for as_dir in $PATH
10557 do
10558   IFS=$as_save_IFS
10559   test -z "$as_dir" && as_dir=.
10560   for ac_exec_ext in '' $ac_executable_extensions; do
10561   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10562     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10563     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10564     break 2
10565   fi
10566 done
10567 done
10568
10569 fi
10570 fi
10571 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10572 if test -n "$STRIP_FOR_TARGET"; then
10573   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10574 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10575 else
10576   echo "$as_me:$LINENO: result: no" >&5
10577 echo "${ECHO_T}no" >&6
10578 fi
10579
10580   done
10581 fi
10582
10583 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test -n "$with_build_time_tools"; then
10584   for ncn_progname in strip; do
10585     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10586 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10587     if test -x $with_build_time_tools/${ncn_progname}; then
10588       ac_cv_prog_STRIP_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10589       echo "$as_me:$LINENO: result: yes" >&5
10590 echo "${ECHO_T}yes" >&6
10591       break
10592     else
10593       echo "$as_me:$LINENO: result: no" >&5
10594 echo "${ECHO_T}no" >&6
10595     fi
10596   done
10597 fi
10598
10599 if test -z "$ac_cv_prog_STRIP_FOR_TARGET"; then
10600   for ncn_progname in strip; do
10601     if test -n "$ncn_target_tool_prefix"; then
10602       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10603 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10604 echo "$as_me:$LINENO: checking for $ac_word" >&5
10605 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10606 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10607   echo $ECHO_N "(cached) $ECHO_C" >&6
10608 else
10609   if test -n "$STRIP_FOR_TARGET"; then
10610   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10611 else
10612 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10613 for as_dir in $PATH
10614 do
10615   IFS=$as_save_IFS
10616   test -z "$as_dir" && as_dir=.
10617   for ac_exec_ext in '' $ac_executable_extensions; do
10618   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10619     ac_cv_prog_STRIP_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10620     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10621     break 2
10622   fi
10623 done
10624 done
10625
10626 fi
10627 fi
10628 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10629 if test -n "$STRIP_FOR_TARGET"; then
10630   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10631 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10632 else
10633   echo "$as_me:$LINENO: result: no" >&5
10634 echo "${ECHO_T}no" >&6
10635 fi
10636
10637     fi
10638     if test -z "$ac_cv_prog_STRIP_FOR_TARGET" && test $build = $target ; then
10639       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10640 set dummy ${ncn_progname}; ac_word=$2
10641 echo "$as_me:$LINENO: checking for $ac_word" >&5
10642 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10643 if test "${ac_cv_prog_STRIP_FOR_TARGET+set}" = set; then
10644   echo $ECHO_N "(cached) $ECHO_C" >&6
10645 else
10646   if test -n "$STRIP_FOR_TARGET"; then
10647   ac_cv_prog_STRIP_FOR_TARGET="$STRIP_FOR_TARGET" # Let the user override the test.
10648 else
10649 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10650 for as_dir in $PATH
10651 do
10652   IFS=$as_save_IFS
10653   test -z "$as_dir" && as_dir=.
10654   for ac_exec_ext in '' $ac_executable_extensions; do
10655   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10656     ac_cv_prog_STRIP_FOR_TARGET="${ncn_progname}"
10657     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10658     break 2
10659   fi
10660 done
10661 done
10662
10663 fi
10664 fi
10665 STRIP_FOR_TARGET=$ac_cv_prog_STRIP_FOR_TARGET
10666 if test -n "$STRIP_FOR_TARGET"; then
10667   echo "$as_me:$LINENO: result: $STRIP_FOR_TARGET" >&5
10668 echo "${ECHO_T}$STRIP_FOR_TARGET" >&6
10669 else
10670   echo "$as_me:$LINENO: result: no" >&5
10671 echo "${ECHO_T}no" >&6
10672 fi
10673
10674     fi
10675     test -n "$ac_cv_prog_STRIP_FOR_TARGET" && break
10676   done
10677 fi
10678
10679 if test -z "$ac_cv_prog_STRIP_FOR_TARGET" ; then
10680   set dummy strip
10681   if test $build = $target ; then
10682     STRIP_FOR_TARGET="$2"
10683   else
10684     STRIP_FOR_TARGET="${ncn_target_tool_prefix}$2"
10685   fi
10686 else
10687   STRIP_FOR_TARGET="$ac_cv_prog_STRIP_FOR_TARGET"
10688 fi
10689
10690 else
10691   STRIP_FOR_TARGET=$ac_cv_path_STRIP_FOR_TARGET
10692 fi
10693
10694
10695
10696
10697 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10698   if test -n "$with_build_time_tools"; then
10699     echo "$as_me:$LINENO: checking for windres in $with_build_time_tools" >&5
10700 echo $ECHO_N "checking for windres in $with_build_time_tools... $ECHO_C" >&6
10701     if test -x $with_build_time_tools/windres; then
10702       WINDRES_FOR_TARGET=`cd $with_build_time_tools && pwd`/windres
10703       ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10704       echo "$as_me:$LINENO: result: $ac_cv_path_WINDRES_FOR_TARGET" >&5
10705 echo "${ECHO_T}$ac_cv_path_WINDRES_FOR_TARGET" >&6
10706     else
10707       echo "$as_me:$LINENO: result: no" >&5
10708 echo "${ECHO_T}no" >&6
10709     fi
10710   elif test $build != $host && test $have_gcc_for_target = yes; then
10711     WINDRES_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windres`
10712     test $WINDRES_FOR_TARGET = windres && WINDRES_FOR_TARGET=
10713     test -n "$WINDRES_FOR_TARGET" && ac_cv_path_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10714   fi
10715 fi
10716 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10717   # Extract the first word of "windres", so it can be a program name with args.
10718 set dummy windres; ac_word=$2
10719 echo "$as_me:$LINENO: checking for $ac_word" >&5
10720 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10721 if test "${ac_cv_path_WINDRES_FOR_TARGET+set}" = set; then
10722   echo $ECHO_N "(cached) $ECHO_C" >&6
10723 else
10724   case $WINDRES_FOR_TARGET in
10725   [\\/]* | ?:[\\/]*)
10726   ac_cv_path_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test with a path.
10727   ;;
10728   *)
10729   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10730 for as_dir in $gcc_cv_tool_dirs
10731 do
10732   IFS=$as_save_IFS
10733   test -z "$as_dir" && as_dir=.
10734   for ac_exec_ext in '' $ac_executable_extensions; do
10735   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10736     ac_cv_path_WINDRES_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10737     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10738     break 2
10739   fi
10740 done
10741 done
10742
10743   ;;
10744 esac
10745 fi
10746 WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10747
10748 if test -n "$WINDRES_FOR_TARGET"; then
10749   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10750 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10751 else
10752   echo "$as_me:$LINENO: result: no" >&5
10753 echo "${ECHO_T}no" >&6
10754 fi
10755
10756 fi
10757 if test -z "$ac_cv_path_WINDRES_FOR_TARGET" ; then
10758
10759
10760 if test -n "$WINDRES_FOR_TARGET"; then
10761   ac_cv_prog_WINDRES_FOR_TARGET=$WINDRES_FOR_TARGET
10762 elif test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10763   WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10764 fi
10765
10766 if test -n "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10767   for ncn_progname in windres; do
10768     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10769 set dummy ${ncn_progname}; ac_word=$2
10770 echo "$as_me:$LINENO: checking for $ac_word" >&5
10771 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10772 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10773   echo $ECHO_N "(cached) $ECHO_C" >&6
10774 else
10775   if test -n "$WINDRES_FOR_TARGET"; then
10776   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10777 else
10778 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10779 for as_dir in $PATH
10780 do
10781   IFS=$as_save_IFS
10782   test -z "$as_dir" && as_dir=.
10783   for ac_exec_ext in '' $ac_executable_extensions; do
10784   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10785     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10786     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10787     break 2
10788   fi
10789 done
10790 done
10791
10792 fi
10793 fi
10794 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10795 if test -n "$WINDRES_FOR_TARGET"; then
10796   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10797 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10798 else
10799   echo "$as_me:$LINENO: result: no" >&5
10800 echo "${ECHO_T}no" >&6
10801 fi
10802
10803   done
10804 fi
10805
10806 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test -n "$with_build_time_tools"; then
10807   for ncn_progname in windres; do
10808     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
10809 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
10810     if test -x $with_build_time_tools/${ncn_progname}; then
10811       ac_cv_prog_WINDRES_FOR_TARGET=$with_build_time_tools/${ncn_progname}
10812       echo "$as_me:$LINENO: result: yes" >&5
10813 echo "${ECHO_T}yes" >&6
10814       break
10815     else
10816       echo "$as_me:$LINENO: result: no" >&5
10817 echo "${ECHO_T}no" >&6
10818     fi
10819   done
10820 fi
10821
10822 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET"; then
10823   for ncn_progname in windres; do
10824     if test -n "$ncn_target_tool_prefix"; then
10825       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
10826 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
10827 echo "$as_me:$LINENO: checking for $ac_word" >&5
10828 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10829 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10830   echo $ECHO_N "(cached) $ECHO_C" >&6
10831 else
10832   if test -n "$WINDRES_FOR_TARGET"; then
10833   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10834 else
10835 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10836 for as_dir in $PATH
10837 do
10838   IFS=$as_save_IFS
10839   test -z "$as_dir" && as_dir=.
10840   for ac_exec_ext in '' $ac_executable_extensions; do
10841   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10842     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
10843     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10844     break 2
10845   fi
10846 done
10847 done
10848
10849 fi
10850 fi
10851 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10852 if test -n "$WINDRES_FOR_TARGET"; then
10853   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10854 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10855 else
10856   echo "$as_me:$LINENO: result: no" >&5
10857 echo "${ECHO_T}no" >&6
10858 fi
10859
10860     fi
10861     if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" && test $build = $target ; then
10862       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10863 set dummy ${ncn_progname}; ac_word=$2
10864 echo "$as_me:$LINENO: checking for $ac_word" >&5
10865 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10866 if test "${ac_cv_prog_WINDRES_FOR_TARGET+set}" = set; then
10867   echo $ECHO_N "(cached) $ECHO_C" >&6
10868 else
10869   if test -n "$WINDRES_FOR_TARGET"; then
10870   ac_cv_prog_WINDRES_FOR_TARGET="$WINDRES_FOR_TARGET" # Let the user override the test.
10871 else
10872 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10873 for as_dir in $PATH
10874 do
10875   IFS=$as_save_IFS
10876   test -z "$as_dir" && as_dir=.
10877   for ac_exec_ext in '' $ac_executable_extensions; do
10878   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10879     ac_cv_prog_WINDRES_FOR_TARGET="${ncn_progname}"
10880     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10881     break 2
10882   fi
10883 done
10884 done
10885
10886 fi
10887 fi
10888 WINDRES_FOR_TARGET=$ac_cv_prog_WINDRES_FOR_TARGET
10889 if test -n "$WINDRES_FOR_TARGET"; then
10890   echo "$as_me:$LINENO: result: $WINDRES_FOR_TARGET" >&5
10891 echo "${ECHO_T}$WINDRES_FOR_TARGET" >&6
10892 else
10893   echo "$as_me:$LINENO: result: no" >&5
10894 echo "${ECHO_T}no" >&6
10895 fi
10896
10897     fi
10898     test -n "$ac_cv_prog_WINDRES_FOR_TARGET" && break
10899   done
10900 fi
10901
10902 if test -z "$ac_cv_prog_WINDRES_FOR_TARGET" ; then
10903   set dummy windres
10904   if test $build = $target ; then
10905     WINDRES_FOR_TARGET="$2"
10906   else
10907     WINDRES_FOR_TARGET="${ncn_target_tool_prefix}$2"
10908   fi
10909 else
10910   WINDRES_FOR_TARGET="$ac_cv_prog_WINDRES_FOR_TARGET"
10911 fi
10912
10913 else
10914   WINDRES_FOR_TARGET=$ac_cv_path_WINDRES_FOR_TARGET
10915 fi
10916
10917
10918
10919
10920 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
10921   if test -n "$with_build_time_tools"; then
10922     echo "$as_me:$LINENO: checking for windmc in $with_build_time_tools" >&5
10923 echo $ECHO_N "checking for windmc in $with_build_time_tools... $ECHO_C" >&6
10924     if test -x $with_build_time_tools/windmc; then
10925       WINDMC_FOR_TARGET=`cd $with_build_time_tools && pwd`/windmc
10926       ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10927       echo "$as_me:$LINENO: result: $ac_cv_path_WINDMC_FOR_TARGET" >&5
10928 echo "${ECHO_T}$ac_cv_path_WINDMC_FOR_TARGET" >&6
10929     else
10930       echo "$as_me:$LINENO: result: no" >&5
10931 echo "${ECHO_T}no" >&6
10932     fi
10933   elif test $build != $host && test $have_gcc_for_target = yes; then
10934     WINDMC_FOR_TARGET=`$GCC_FOR_TARGET --print-prog-name=windmc`
10935     test $WINDMC_FOR_TARGET = windmc && WINDMC_FOR_TARGET=
10936     test -n "$WINDMC_FOR_TARGET" && ac_cv_path_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10937   fi
10938 fi
10939 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" && test -n "$gcc_cv_tool_dirs"; then
10940   # Extract the first word of "windmc", so it can be a program name with args.
10941 set dummy windmc; ac_word=$2
10942 echo "$as_me:$LINENO: checking for $ac_word" >&5
10943 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10944 if test "${ac_cv_path_WINDMC_FOR_TARGET+set}" = set; then
10945   echo $ECHO_N "(cached) $ECHO_C" >&6
10946 else
10947   case $WINDMC_FOR_TARGET in
10948   [\\/]* | ?:[\\/]*)
10949   ac_cv_path_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test with a path.
10950   ;;
10951   *)
10952   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
10953 for as_dir in $gcc_cv_tool_dirs
10954 do
10955   IFS=$as_save_IFS
10956   test -z "$as_dir" && as_dir=.
10957   for ac_exec_ext in '' $ac_executable_extensions; do
10958   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
10959     ac_cv_path_WINDMC_FOR_TARGET="$as_dir/$ac_word$ac_exec_ext"
10960     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
10961     break 2
10962   fi
10963 done
10964 done
10965
10966   ;;
10967 esac
10968 fi
10969 WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
10970
10971 if test -n "$WINDMC_FOR_TARGET"; then
10972   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
10973 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
10974 else
10975   echo "$as_me:$LINENO: result: no" >&5
10976 echo "${ECHO_T}no" >&6
10977 fi
10978
10979 fi
10980 if test -z "$ac_cv_path_WINDMC_FOR_TARGET" ; then
10981
10982
10983 if test -n "$WINDMC_FOR_TARGET"; then
10984   ac_cv_prog_WINDMC_FOR_TARGET=$WINDMC_FOR_TARGET
10985 elif test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
10986   WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
10987 fi
10988
10989 if test -n "$ac_cv_prog_WINDMC_FOR_TARGET"; then
10990   for ncn_progname in windmc; do
10991     # Extract the first word of "${ncn_progname}", so it can be a program name with args.
10992 set dummy ${ncn_progname}; ac_word=$2
10993 echo "$as_me:$LINENO: checking for $ac_word" >&5
10994 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
10995 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
10996   echo $ECHO_N "(cached) $ECHO_C" >&6
10997 else
10998   if test -n "$WINDMC_FOR_TARGET"; then
10999   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11000 else
11001 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11002 for as_dir in $PATH
11003 do
11004   IFS=$as_save_IFS
11005   test -z "$as_dir" && as_dir=.
11006   for ac_exec_ext in '' $ac_executable_extensions; do
11007   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11008     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11009     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11010     break 2
11011   fi
11012 done
11013 done
11014
11015 fi
11016 fi
11017 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11018 if test -n "$WINDMC_FOR_TARGET"; then
11019   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11020 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11021 else
11022   echo "$as_me:$LINENO: result: no" >&5
11023 echo "${ECHO_T}no" >&6
11024 fi
11025
11026   done
11027 fi
11028
11029 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test -n "$with_build_time_tools"; then
11030   for ncn_progname in windmc; do
11031     echo "$as_me:$LINENO: checking for ${ncn_progname} in $with_build_time_tools" >&5
11032 echo $ECHO_N "checking for ${ncn_progname} in $with_build_time_tools... $ECHO_C" >&6
11033     if test -x $with_build_time_tools/${ncn_progname}; then
11034       ac_cv_prog_WINDMC_FOR_TARGET=$with_build_time_tools/${ncn_progname}
11035       echo "$as_me:$LINENO: result: yes" >&5
11036 echo "${ECHO_T}yes" >&6
11037       break
11038     else
11039       echo "$as_me:$LINENO: result: no" >&5
11040 echo "${ECHO_T}no" >&6
11041     fi
11042   done
11043 fi
11044
11045 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET"; then
11046   for ncn_progname in windmc; do
11047     if test -n "$ncn_target_tool_prefix"; then
11048       # Extract the first word of "${ncn_target_tool_prefix}${ncn_progname}", so it can be a program name with args.
11049 set dummy ${ncn_target_tool_prefix}${ncn_progname}; ac_word=$2
11050 echo "$as_me:$LINENO: checking for $ac_word" >&5
11051 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11052 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11053   echo $ECHO_N "(cached) $ECHO_C" >&6
11054 else
11055   if test -n "$WINDMC_FOR_TARGET"; then
11056   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11057 else
11058 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11059 for as_dir in $PATH
11060 do
11061   IFS=$as_save_IFS
11062   test -z "$as_dir" && as_dir=.
11063   for ac_exec_ext in '' $ac_executable_extensions; do
11064   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11065     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_target_tool_prefix}${ncn_progname}"
11066     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11067     break 2
11068   fi
11069 done
11070 done
11071
11072 fi
11073 fi
11074 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11075 if test -n "$WINDMC_FOR_TARGET"; then
11076   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11077 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11078 else
11079   echo "$as_me:$LINENO: result: no" >&5
11080 echo "${ECHO_T}no" >&6
11081 fi
11082
11083     fi
11084     if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" && test $build = $target ; then
11085       # Extract the first word of "${ncn_progname}", so it can be a program name with args.
11086 set dummy ${ncn_progname}; ac_word=$2
11087 echo "$as_me:$LINENO: checking for $ac_word" >&5
11088 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
11089 if test "${ac_cv_prog_WINDMC_FOR_TARGET+set}" = set; then
11090   echo $ECHO_N "(cached) $ECHO_C" >&6
11091 else
11092   if test -n "$WINDMC_FOR_TARGET"; then
11093   ac_cv_prog_WINDMC_FOR_TARGET="$WINDMC_FOR_TARGET" # Let the user override the test.
11094 else
11095 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
11096 for as_dir in $PATH
11097 do
11098   IFS=$as_save_IFS
11099   test -z "$as_dir" && as_dir=.
11100   for ac_exec_ext in '' $ac_executable_extensions; do
11101   if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
11102     ac_cv_prog_WINDMC_FOR_TARGET="${ncn_progname}"
11103     echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
11104     break 2
11105   fi
11106 done
11107 done
11108
11109 fi
11110 fi
11111 WINDMC_FOR_TARGET=$ac_cv_prog_WINDMC_FOR_TARGET
11112 if test -n "$WINDMC_FOR_TARGET"; then
11113   echo "$as_me:$LINENO: result: $WINDMC_FOR_TARGET" >&5
11114 echo "${ECHO_T}$WINDMC_FOR_TARGET" >&6
11115 else
11116   echo "$as_me:$LINENO: result: no" >&5
11117 echo "${ECHO_T}no" >&6
11118 fi
11119
11120     fi
11121     test -n "$ac_cv_prog_WINDMC_FOR_TARGET" && break
11122   done
11123 fi
11124
11125 if test -z "$ac_cv_prog_WINDMC_FOR_TARGET" ; then
11126   set dummy windmc
11127   if test $build = $target ; then
11128     WINDMC_FOR_TARGET="$2"
11129   else
11130     WINDMC_FOR_TARGET="${ncn_target_tool_prefix}$2"
11131   fi
11132 else
11133   WINDMC_FOR_TARGET="$ac_cv_prog_WINDMC_FOR_TARGET"
11134 fi
11135
11136 else
11137   WINDMC_FOR_TARGET=$ac_cv_path_WINDMC_FOR_TARGET
11138 fi
11139
11140
11141 RAW_CXX_FOR_TARGET="$CXX_FOR_TARGET"
11142
11143 echo "$as_me:$LINENO: checking where to find the target ar" >&5
11144 echo $ECHO_N "checking where to find the target ar... $ECHO_C" >&6
11145 if test "x${build}" != "x${host}" ; then
11146   if expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11147     # We already found the complete path
11148     ac_dir=`dirname $AR_FOR_TARGET`
11149     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11150 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11151   else
11152     # Canadian cross, just use what we found
11153     echo "$as_me:$LINENO: result: pre-installed" >&5
11154 echo "${ECHO_T}pre-installed" >&6
11155   fi
11156 else
11157   ok=yes
11158   case " ${configdirs} " in
11159     *" binutils "*) ;;
11160     *) ok=no ;;
11161   esac
11162
11163   if test $ok = yes; then
11164     # An in-tree tool is available and we can use it
11165     AR_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ar'
11166     echo "$as_me:$LINENO: result: just compiled" >&5
11167 echo "${ECHO_T}just compiled" >&6
11168   elif expr "x$AR_FOR_TARGET" : "x/" > /dev/null; then
11169     # We already found the complete path
11170     ac_dir=`dirname $AR_FOR_TARGET`
11171     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11172 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11173   elif test "x$target" = "x$host"; then
11174     # We can use an host tool
11175     AR_FOR_TARGET='$(AR)'
11176     echo "$as_me:$LINENO: result: host tool" >&5
11177 echo "${ECHO_T}host tool" >&6
11178   else
11179     # We need a cross tool
11180     echo "$as_me:$LINENO: result: pre-installed" >&5
11181 echo "${ECHO_T}pre-installed" >&6
11182   fi
11183 fi
11184
11185 echo "$as_me:$LINENO: checking where to find the target as" >&5
11186 echo $ECHO_N "checking where to find the target as... $ECHO_C" >&6
11187 if test "x${build}" != "x${host}" ; then
11188   if expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11189     # We already found the complete path
11190     ac_dir=`dirname $AS_FOR_TARGET`
11191     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11192 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11193   else
11194     # Canadian cross, just use what we found
11195     echo "$as_me:$LINENO: result: pre-installed" >&5
11196 echo "${ECHO_T}pre-installed" >&6
11197   fi
11198 else
11199   ok=yes
11200   case " ${configdirs} " in
11201     *" gas "*) ;;
11202     *) ok=no ;;
11203   esac
11204
11205   if test $ok = yes; then
11206     # An in-tree tool is available and we can use it
11207     AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gas/as-new'
11208     echo "$as_me:$LINENO: result: just compiled" >&5
11209 echo "${ECHO_T}just compiled" >&6
11210   elif expr "x$AS_FOR_TARGET" : "x/" > /dev/null; then
11211     # We already found the complete path
11212     ac_dir=`dirname $AS_FOR_TARGET`
11213     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11214 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11215   elif test "x$target" = "x$host"; then
11216     # We can use an host tool
11217     AS_FOR_TARGET='$(AS)'
11218     echo "$as_me:$LINENO: result: host tool" >&5
11219 echo "${ECHO_T}host tool" >&6
11220   else
11221     # We need a cross tool
11222     echo "$as_me:$LINENO: result: pre-installed" >&5
11223 echo "${ECHO_T}pre-installed" >&6
11224   fi
11225 fi
11226
11227 echo "$as_me:$LINENO: checking where to find the target cc" >&5
11228 echo $ECHO_N "checking where to find the target cc... $ECHO_C" >&6
11229 if test "x${build}" != "x${host}" ; then
11230   if expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11231     # We already found the complete path
11232     ac_dir=`dirname $CC_FOR_TARGET`
11233     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11234 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11235   else
11236     # Canadian cross, just use what we found
11237     echo "$as_me:$LINENO: result: pre-installed" >&5
11238 echo "${ECHO_T}pre-installed" >&6
11239   fi
11240 else
11241   ok=yes
11242   case " ${configdirs} " in
11243     *" gcc "*) ;;
11244     *) ok=no ;;
11245   esac
11246
11247   if test $ok = yes; then
11248     # An in-tree tool is available and we can use it
11249     CC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11250     echo "$as_me:$LINENO: result: just compiled" >&5
11251 echo "${ECHO_T}just compiled" >&6
11252   elif expr "x$CC_FOR_TARGET" : "x/" > /dev/null; then
11253     # We already found the complete path
11254     ac_dir=`dirname $CC_FOR_TARGET`
11255     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11256 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11257   elif test "x$target" = "x$host"; then
11258     # We can use an host tool
11259     CC_FOR_TARGET='$(CC)'
11260     echo "$as_me:$LINENO: result: host tool" >&5
11261 echo "${ECHO_T}host tool" >&6
11262   else
11263     # We need a cross tool
11264     echo "$as_me:$LINENO: result: pre-installed" >&5
11265 echo "${ECHO_T}pre-installed" >&6
11266   fi
11267 fi
11268
11269 echo "$as_me:$LINENO: checking where to find the target c++" >&5
11270 echo $ECHO_N "checking where to find the target c++... $ECHO_C" >&6
11271 if test "x${build}" != "x${host}" ; then
11272   if expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11273     # We already found the complete path
11274     ac_dir=`dirname $CXX_FOR_TARGET`
11275     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11276 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11277   else
11278     # Canadian cross, just use what we found
11279     echo "$as_me:$LINENO: result: pre-installed" >&5
11280 echo "${ECHO_T}pre-installed" >&6
11281   fi
11282 else
11283   ok=yes
11284   case " ${configdirs} " in
11285     *" gcc "*) ;;
11286     *) ok=no ;;
11287   esac
11288   case ,${enable_languages}, in
11289     *,c++,*) ;;
11290     *) ok=no ;;
11291   esac
11292   if test $ok = yes; then
11293     # An in-tree tool is available and we can use it
11294     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'
11295     echo "$as_me:$LINENO: result: just compiled" >&5
11296 echo "${ECHO_T}just compiled" >&6
11297   elif expr "x$CXX_FOR_TARGET" : "x/" > /dev/null; then
11298     # We already found the complete path
11299     ac_dir=`dirname $CXX_FOR_TARGET`
11300     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11301 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11302   elif test "x$target" = "x$host"; then
11303     # We can use an host tool
11304     CXX_FOR_TARGET='$(CXX)'
11305     echo "$as_me:$LINENO: result: host tool" >&5
11306 echo "${ECHO_T}host tool" >&6
11307   else
11308     # We need a cross tool
11309     echo "$as_me:$LINENO: result: pre-installed" >&5
11310 echo "${ECHO_T}pre-installed" >&6
11311   fi
11312 fi
11313
11314 echo "$as_me:$LINENO: checking where to find the target c++ for libstdc++" >&5
11315 echo $ECHO_N "checking where to find the target c++ for libstdc++... $ECHO_C" >&6
11316 if test "x${build}" != "x${host}" ; then
11317   if expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11318     # We already found the complete path
11319     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11320     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11321 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11322   else
11323     # Canadian cross, just use what we found
11324     echo "$as_me:$LINENO: result: pre-installed" >&5
11325 echo "${ECHO_T}pre-installed" >&6
11326   fi
11327 else
11328   ok=yes
11329   case " ${configdirs} " in
11330     *" gcc "*) ;;
11331     *) ok=no ;;
11332   esac
11333   case ,${enable_languages}, in
11334     *,c++,*) ;;
11335     *) ok=no ;;
11336   esac
11337   if test $ok = yes; then
11338     # An in-tree tool is available and we can use it
11339     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'
11340     echo "$as_me:$LINENO: result: just compiled" >&5
11341 echo "${ECHO_T}just compiled" >&6
11342   elif expr "x$RAW_CXX_FOR_TARGET" : "x/" > /dev/null; then
11343     # We already found the complete path
11344     ac_dir=`dirname $RAW_CXX_FOR_TARGET`
11345     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11346 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11347   elif test "x$target" = "x$host"; then
11348     # We can use an host tool
11349     RAW_CXX_FOR_TARGET='$(CXX)'
11350     echo "$as_me:$LINENO: result: host tool" >&5
11351 echo "${ECHO_T}host tool" >&6
11352   else
11353     # We need a cross tool
11354     echo "$as_me:$LINENO: result: pre-installed" >&5
11355 echo "${ECHO_T}pre-installed" >&6
11356   fi
11357 fi
11358
11359 echo "$as_me:$LINENO: checking where to find the target dlltool" >&5
11360 echo $ECHO_N "checking where to find the target dlltool... $ECHO_C" >&6
11361 if test "x${build}" != "x${host}" ; then
11362   if expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11363     # We already found the complete path
11364     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11365     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11366 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11367   else
11368     # Canadian cross, just use what we found
11369     echo "$as_me:$LINENO: result: pre-installed" >&5
11370 echo "${ECHO_T}pre-installed" >&6
11371   fi
11372 else
11373   ok=yes
11374   case " ${configdirs} " in
11375     *" binutils "*) ;;
11376     *) ok=no ;;
11377   esac
11378
11379   if test $ok = yes; then
11380     # An in-tree tool is available and we can use it
11381     DLLTOOL_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/dlltool'
11382     echo "$as_me:$LINENO: result: just compiled" >&5
11383 echo "${ECHO_T}just compiled" >&6
11384   elif expr "x$DLLTOOL_FOR_TARGET" : "x/" > /dev/null; then
11385     # We already found the complete path
11386     ac_dir=`dirname $DLLTOOL_FOR_TARGET`
11387     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11388 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11389   elif test "x$target" = "x$host"; then
11390     # We can use an host tool
11391     DLLTOOL_FOR_TARGET='$(DLLTOOL)'
11392     echo "$as_me:$LINENO: result: host tool" >&5
11393 echo "${ECHO_T}host tool" >&6
11394   else
11395     # We need a cross tool
11396     echo "$as_me:$LINENO: result: pre-installed" >&5
11397 echo "${ECHO_T}pre-installed" >&6
11398   fi
11399 fi
11400
11401 echo "$as_me:$LINENO: checking where to find the target gcc" >&5
11402 echo $ECHO_N "checking where to find the target gcc... $ECHO_C" >&6
11403 if test "x${build}" != "x${host}" ; then
11404   if expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11405     # We already found the complete path
11406     ac_dir=`dirname $GCC_FOR_TARGET`
11407     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11408 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11409   else
11410     # Canadian cross, just use what we found
11411     echo "$as_me:$LINENO: result: pre-installed" >&5
11412 echo "${ECHO_T}pre-installed" >&6
11413   fi
11414 else
11415   ok=yes
11416   case " ${configdirs} " in
11417     *" gcc "*) ;;
11418     *) ok=no ;;
11419   esac
11420
11421   if test $ok = yes; then
11422     # An in-tree tool is available and we can use it
11423     GCC_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/xgcc -B$$r/$(HOST_SUBDIR)/gcc/'
11424     echo "$as_me:$LINENO: result: just compiled" >&5
11425 echo "${ECHO_T}just compiled" >&6
11426   elif expr "x$GCC_FOR_TARGET" : "x/" > /dev/null; then
11427     # We already found the complete path
11428     ac_dir=`dirname $GCC_FOR_TARGET`
11429     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11430 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11431   elif test "x$target" = "x$host"; then
11432     # We can use an host tool
11433     GCC_FOR_TARGET='$()'
11434     echo "$as_me:$LINENO: result: host tool" >&5
11435 echo "${ECHO_T}host tool" >&6
11436   else
11437     # We need a cross tool
11438     echo "$as_me:$LINENO: result: pre-installed" >&5
11439 echo "${ECHO_T}pre-installed" >&6
11440   fi
11441 fi
11442
11443 echo "$as_me:$LINENO: checking where to find the target gcj" >&5
11444 echo $ECHO_N "checking where to find the target gcj... $ECHO_C" >&6
11445 if test "x${build}" != "x${host}" ; then
11446   if expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11447     # We already found the complete path
11448     ac_dir=`dirname $GCJ_FOR_TARGET`
11449     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11450 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11451   else
11452     # Canadian cross, just use what we found
11453     echo "$as_me:$LINENO: result: pre-installed" >&5
11454 echo "${ECHO_T}pre-installed" >&6
11455   fi
11456 else
11457   ok=yes
11458   case " ${configdirs} " in
11459     *" gcc "*) ;;
11460     *) ok=no ;;
11461   esac
11462   case ,${enable_languages}, in
11463     *,java,*) ;;
11464     *) ok=no ;;
11465   esac
11466   if test $ok = yes; then
11467     # An in-tree tool is available and we can use it
11468     GCJ_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gcj -B$$r/$(HOST_SUBDIR)/gcc/'
11469     echo "$as_me:$LINENO: result: just compiled" >&5
11470 echo "${ECHO_T}just compiled" >&6
11471   elif expr "x$GCJ_FOR_TARGET" : "x/" > /dev/null; then
11472     # We already found the complete path
11473     ac_dir=`dirname $GCJ_FOR_TARGET`
11474     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11475 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11476   elif test "x$target" = "x$host"; then
11477     # We can use an host tool
11478     GCJ_FOR_TARGET='$(GCJ)'
11479     echo "$as_me:$LINENO: result: host tool" >&5
11480 echo "${ECHO_T}host tool" >&6
11481   else
11482     # We need a cross tool
11483     echo "$as_me:$LINENO: result: pre-installed" >&5
11484 echo "${ECHO_T}pre-installed" >&6
11485   fi
11486 fi
11487
11488 echo "$as_me:$LINENO: checking where to find the target gfortran" >&5
11489 echo $ECHO_N "checking where to find the target gfortran... $ECHO_C" >&6
11490 if test "x${build}" != "x${host}" ; then
11491   if expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11492     # We already found the complete path
11493     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11494     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11495 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11496   else
11497     # Canadian cross, just use what we found
11498     echo "$as_me:$LINENO: result: pre-installed" >&5
11499 echo "${ECHO_T}pre-installed" >&6
11500   fi
11501 else
11502   ok=yes
11503   case " ${configdirs} " in
11504     *" gcc "*) ;;
11505     *) ok=no ;;
11506   esac
11507   case ,${enable_languages}, in
11508     *,fortran,*) ;;
11509     *) ok=no ;;
11510   esac
11511   if test $ok = yes; then
11512     # An in-tree tool is available and we can use it
11513     GFORTRAN_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/gfortran -B$$r/$(HOST_SUBDIR)/gcc/'
11514     echo "$as_me:$LINENO: result: just compiled" >&5
11515 echo "${ECHO_T}just compiled" >&6
11516   elif expr "x$GFORTRAN_FOR_TARGET" : "x/" > /dev/null; then
11517     # We already found the complete path
11518     ac_dir=`dirname $GFORTRAN_FOR_TARGET`
11519     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11520 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11521   elif test "x$target" = "x$host"; then
11522     # We can use an host tool
11523     GFORTRAN_FOR_TARGET='$(GFORTRAN)'
11524     echo "$as_me:$LINENO: result: host tool" >&5
11525 echo "${ECHO_T}host tool" >&6
11526   else
11527     # We need a cross tool
11528     echo "$as_me:$LINENO: result: pre-installed" >&5
11529 echo "${ECHO_T}pre-installed" >&6
11530   fi
11531 fi
11532
11533 echo "$as_me:$LINENO: checking where to find the target ld" >&5
11534 echo $ECHO_N "checking where to find the target ld... $ECHO_C" >&6
11535 if test "x${build}" != "x${host}" ; then
11536   if expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11537     # We already found the complete path
11538     ac_dir=`dirname $LD_FOR_TARGET`
11539     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11540 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11541   else
11542     # Canadian cross, just use what we found
11543     echo "$as_me:$LINENO: result: pre-installed" >&5
11544 echo "${ECHO_T}pre-installed" >&6
11545   fi
11546 else
11547   ok=yes
11548   case " ${configdirs} " in
11549     *" ld "*) ;;
11550     *) ok=no ;;
11551   esac
11552
11553   if test $ok = yes; then
11554     # An in-tree tool is available and we can use it
11555     LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/ld/ld-new'
11556     echo "$as_me:$LINENO: result: just compiled" >&5
11557 echo "${ECHO_T}just compiled" >&6
11558   elif expr "x$LD_FOR_TARGET" : "x/" > /dev/null; then
11559     # We already found the complete path
11560     ac_dir=`dirname $LD_FOR_TARGET`
11561     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11562 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11563   elif test "x$target" = "x$host"; then
11564     # We can use an host tool
11565     LD_FOR_TARGET='$(LD)'
11566     echo "$as_me:$LINENO: result: host tool" >&5
11567 echo "${ECHO_T}host tool" >&6
11568   else
11569     # We need a cross tool
11570     echo "$as_me:$LINENO: result: pre-installed" >&5
11571 echo "${ECHO_T}pre-installed" >&6
11572   fi
11573 fi
11574
11575 echo "$as_me:$LINENO: checking where to find the target lipo" >&5
11576 echo $ECHO_N "checking where to find the target lipo... $ECHO_C" >&6
11577 if test "x${build}" != "x${host}" ; then
11578   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11579     # We already found the complete path
11580     ac_dir=`dirname $LIPO_FOR_TARGET`
11581     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11582 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11583   else
11584     # Canadian cross, just use what we found
11585     echo "$as_me:$LINENO: result: pre-installed" >&5
11586 echo "${ECHO_T}pre-installed" >&6
11587   fi
11588 else
11589   if expr "x$LIPO_FOR_TARGET" : "x/" > /dev/null; then
11590     # We already found the complete path
11591     ac_dir=`dirname $LIPO_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     LIPO_FOR_TARGET='$(LIPO)'
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 nm" >&5
11607 echo $ECHO_N "checking where to find the target nm... $ECHO_C" >&6
11608 if test "x${build}" != "x${host}" ; then
11609   if expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11610     # We already found the complete path
11611     ac_dir=`dirname $NM_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   ok=yes
11621   case " ${configdirs} " in
11622     *" binutils "*) ;;
11623     *) ok=no ;;
11624   esac
11625
11626   if test $ok = yes; then
11627     # An in-tree tool is available and we can use it
11628     NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/nm-new'
11629     echo "$as_me:$LINENO: result: just compiled" >&5
11630 echo "${ECHO_T}just compiled" >&6
11631   elif expr "x$NM_FOR_TARGET" : "x/" > /dev/null; then
11632     # We already found the complete path
11633     ac_dir=`dirname $NM_FOR_TARGET`
11634     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11635 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11636   elif test "x$target" = "x$host"; then
11637     # We can use an host tool
11638     NM_FOR_TARGET='$(NM)'
11639     echo "$as_me:$LINENO: result: host tool" >&5
11640 echo "${ECHO_T}host tool" >&6
11641   else
11642     # We need a cross tool
11643     echo "$as_me:$LINENO: result: pre-installed" >&5
11644 echo "${ECHO_T}pre-installed" >&6
11645   fi
11646 fi
11647
11648 echo "$as_me:$LINENO: checking where to find the target objdump" >&5
11649 echo $ECHO_N "checking where to find the target objdump... $ECHO_C" >&6
11650 if test "x${build}" != "x${host}" ; then
11651   if expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11652     # We already found the complete path
11653     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11654     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11655 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11656   else
11657     # Canadian cross, just use what we found
11658     echo "$as_me:$LINENO: result: pre-installed" >&5
11659 echo "${ECHO_T}pre-installed" >&6
11660   fi
11661 else
11662   ok=yes
11663   case " ${configdirs} " in
11664     *" binutils "*) ;;
11665     *) ok=no ;;
11666   esac
11667
11668   if test $ok = yes; then
11669     # An in-tree tool is available and we can use it
11670     OBJDUMP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/objdump'
11671     echo "$as_me:$LINENO: result: just compiled" >&5
11672 echo "${ECHO_T}just compiled" >&6
11673   elif expr "x$OBJDUMP_FOR_TARGET" : "x/" > /dev/null; then
11674     # We already found the complete path
11675     ac_dir=`dirname $OBJDUMP_FOR_TARGET`
11676     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11677 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11678   elif test "x$target" = "x$host"; then
11679     # We can use an host tool
11680     OBJDUMP_FOR_TARGET='$(OBJDUMP)'
11681     echo "$as_me:$LINENO: result: host tool" >&5
11682 echo "${ECHO_T}host tool" >&6
11683   else
11684     # We need a cross tool
11685     echo "$as_me:$LINENO: result: pre-installed" >&5
11686 echo "${ECHO_T}pre-installed" >&6
11687   fi
11688 fi
11689
11690 echo "$as_me:$LINENO: checking where to find the target ranlib" >&5
11691 echo $ECHO_N "checking where to find the target ranlib... $ECHO_C" >&6
11692 if test "x${build}" != "x${host}" ; then
11693   if expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11694     # We already found the complete path
11695     ac_dir=`dirname $RANLIB_FOR_TARGET`
11696     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11697 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11698   else
11699     # Canadian cross, just use what we found
11700     echo "$as_me:$LINENO: result: pre-installed" >&5
11701 echo "${ECHO_T}pre-installed" >&6
11702   fi
11703 else
11704   ok=yes
11705   case " ${configdirs} " in
11706     *" binutils "*) ;;
11707     *) ok=no ;;
11708   esac
11709
11710   if test $ok = yes; then
11711     # An in-tree tool is available and we can use it
11712     RANLIB_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/ranlib'
11713     echo "$as_me:$LINENO: result: just compiled" >&5
11714 echo "${ECHO_T}just compiled" >&6
11715   elif expr "x$RANLIB_FOR_TARGET" : "x/" > /dev/null; then
11716     # We already found the complete path
11717     ac_dir=`dirname $RANLIB_FOR_TARGET`
11718     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11719 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11720   elif test "x$target" = "x$host"; then
11721     # We can use an host tool
11722     RANLIB_FOR_TARGET='$(RANLIB)'
11723     echo "$as_me:$LINENO: result: host tool" >&5
11724 echo "${ECHO_T}host tool" >&6
11725   else
11726     # We need a cross tool
11727     echo "$as_me:$LINENO: result: pre-installed" >&5
11728 echo "${ECHO_T}pre-installed" >&6
11729   fi
11730 fi
11731
11732 echo "$as_me:$LINENO: checking where to find the target strip" >&5
11733 echo $ECHO_N "checking where to find the target strip... $ECHO_C" >&6
11734 if test "x${build}" != "x${host}" ; then
11735   if expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11736     # We already found the complete path
11737     ac_dir=`dirname $STRIP_FOR_TARGET`
11738     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11739 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11740   else
11741     # Canadian cross, just use what we found
11742     echo "$as_me:$LINENO: result: pre-installed" >&5
11743 echo "${ECHO_T}pre-installed" >&6
11744   fi
11745 else
11746   ok=yes
11747   case " ${configdirs} " in
11748     *" binutils "*) ;;
11749     *) ok=no ;;
11750   esac
11751
11752   if test $ok = yes; then
11753     # An in-tree tool is available and we can use it
11754     STRIP_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/strip'
11755     echo "$as_me:$LINENO: result: just compiled" >&5
11756 echo "${ECHO_T}just compiled" >&6
11757   elif expr "x$STRIP_FOR_TARGET" : "x/" > /dev/null; then
11758     # We already found the complete path
11759     ac_dir=`dirname $STRIP_FOR_TARGET`
11760     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11761 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11762   elif test "x$target" = "x$host"; then
11763     # We can use an host tool
11764     STRIP_FOR_TARGET='$(STRIP)'
11765     echo "$as_me:$LINENO: result: host tool" >&5
11766 echo "${ECHO_T}host tool" >&6
11767   else
11768     # We need a cross tool
11769     echo "$as_me:$LINENO: result: pre-installed" >&5
11770 echo "${ECHO_T}pre-installed" >&6
11771   fi
11772 fi
11773
11774 echo "$as_me:$LINENO: checking where to find the target windres" >&5
11775 echo $ECHO_N "checking where to find the target windres... $ECHO_C" >&6
11776 if test "x${build}" != "x${host}" ; then
11777   if expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11778     # We already found the complete path
11779     ac_dir=`dirname $WINDRES_FOR_TARGET`
11780     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11781 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11782   else
11783     # Canadian cross, just use what we found
11784     echo "$as_me:$LINENO: result: pre-installed" >&5
11785 echo "${ECHO_T}pre-installed" >&6
11786   fi
11787 else
11788   ok=yes
11789   case " ${configdirs} " in
11790     *" binutils "*) ;;
11791     *) ok=no ;;
11792   esac
11793
11794   if test $ok = yes; then
11795     # An in-tree tool is available and we can use it
11796     WINDRES_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windres'
11797     echo "$as_me:$LINENO: result: just compiled" >&5
11798 echo "${ECHO_T}just compiled" >&6
11799   elif expr "x$WINDRES_FOR_TARGET" : "x/" > /dev/null; then
11800     # We already found the complete path
11801     ac_dir=`dirname $WINDRES_FOR_TARGET`
11802     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11803 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11804   elif test "x$target" = "x$host"; then
11805     # We can use an host tool
11806     WINDRES_FOR_TARGET='$(WINDRES)'
11807     echo "$as_me:$LINENO: result: host tool" >&5
11808 echo "${ECHO_T}host tool" >&6
11809   else
11810     # We need a cross tool
11811     echo "$as_me:$LINENO: result: pre-installed" >&5
11812 echo "${ECHO_T}pre-installed" >&6
11813   fi
11814 fi
11815
11816 echo "$as_me:$LINENO: checking where to find the target windmc" >&5
11817 echo $ECHO_N "checking where to find the target windmc... $ECHO_C" >&6
11818 if test "x${build}" != "x${host}" ; then
11819   if expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11820     # We already found the complete path
11821     ac_dir=`dirname $WINDMC_FOR_TARGET`
11822     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11823 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11824   else
11825     # Canadian cross, just use what we found
11826     echo "$as_me:$LINENO: result: pre-installed" >&5
11827 echo "${ECHO_T}pre-installed" >&6
11828   fi
11829 else
11830   ok=yes
11831   case " ${configdirs} " in
11832     *" binutils "*) ;;
11833     *) ok=no ;;
11834   esac
11835
11836   if test $ok = yes; then
11837     # An in-tree tool is available and we can use it
11838     WINDMC_FOR_TARGET='$$r/$(HOST_SUBDIR)/binutils/windmc'
11839     echo "$as_me:$LINENO: result: just compiled" >&5
11840 echo "${ECHO_T}just compiled" >&6
11841   elif expr "x$WINDMC_FOR_TARGET" : "x/" > /dev/null; then
11842     # We already found the complete path
11843     ac_dir=`dirname $WINDMC_FOR_TARGET`
11844     echo "$as_me:$LINENO: result: pre-installed in $ac_dir" >&5
11845 echo "${ECHO_T}pre-installed in $ac_dir" >&6
11846   elif test "x$target" = "x$host"; then
11847     # We can use an host tool
11848     WINDMC_FOR_TARGET='$(WINDMC)'
11849     echo "$as_me:$LINENO: result: host tool" >&5
11850 echo "${ECHO_T}host tool" >&6
11851   else
11852     # We need a cross tool
11853     echo "$as_me:$LINENO: result: pre-installed" >&5
11854 echo "${ECHO_T}pre-installed" >&6
11855   fi
11856 fi
11857
11858
11859
11860
11861
11862 # Certain tools may need extra flags.
11863 AR_FOR_TARGET=${AR_FOR_TARGET}${extra_arflags_for_target}
11864 RANLIB_FOR_TARGET=${RANLIB_FOR_TARGET}${extra_ranlibflags_for_target}
11865 NM_FOR_TARGET=${NM_FOR_TARGET}${extra_nmflags_for_target}
11866
11867 # When building target libraries, except in a Canadian cross, we use
11868 # the same toolchain as the compiler we just built.
11869 COMPILER_AS_FOR_TARGET='$(AS_FOR_TARGET)'
11870 COMPILER_LD_FOR_TARGET='$(LD_FOR_TARGET)'
11871 COMPILER_NM_FOR_TARGET='$(NM_FOR_TARGET)'
11872 if test $host = $build; then
11873   case " $configdirs " in
11874     *" gcc "*)
11875       COMPILER_AS_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/as'
11876       COMPILER_LD_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/collect-ld'
11877       COMPILER_NM_FOR_TARGET='$$r/$(HOST_SUBDIR)/gcc/nm'${extra_nmflags_for_target}
11878       ;;
11879   esac
11880 fi
11881
11882
11883
11884
11885
11886 echo "$as_me:$LINENO: checking whether to enable maintainer-specific portions of Makefiles" >&5
11887 echo $ECHO_N "checking whether to enable maintainer-specific portions of Makefiles... $ECHO_C" >&6
11888 # Check whether --enable-maintainer-mode or --disable-maintainer-mode was given.
11889 if test "${enable_maintainer_mode+set}" = set; then
11890   enableval="$enable_maintainer_mode"
11891   USE_MAINTAINER_MODE=$enableval
11892 else
11893   USE_MAINTAINER_MODE=no
11894 fi;
11895 echo "$as_me:$LINENO: result: $USE_MAINTAINER_MODE" >&5
11896 echo "${ECHO_T}$USE_MAINTAINER_MODE" >&6
11897
11898
11899 if test "$USE_MAINTAINER_MODE" = yes; then
11900   MAINTAINER_MODE_TRUE=
11901   MAINTAINER_MODE_FALSE='#'
11902 else
11903   MAINTAINER_MODE_TRUE='#'
11904   MAINTAINER_MODE_FALSE=
11905 fi
11906 MAINT=$MAINTAINER_MODE_TRUE
11907
11908 # ---------------------
11909 # GCC bootstrap support
11910 # ---------------------
11911
11912 # Stage specific cflags for build.
11913 stage1_cflags="-g"
11914 case $build in
11915   vax-*-*)
11916     case ${GCC} in
11917       yes) stage1_cflags="-g -Wa,-J" ;;
11918       *) stage1_cflags="-g -J" ;;
11919     esac ;;
11920 esac
11921
11922 # This is aimed to mimic bootstrap with a non-GCC compiler to catch problems.
11923 if test "$GCC" = yes; then
11924   saved_CFLAGS="$CFLAGS"
11925
11926   # Pass -fkeep-inline-functions for stage 1 if the GCC version supports it.
11927   CFLAGS="$CFLAGS -fkeep-inline-functions"
11928   echo "$as_me:$LINENO: checking whether -fkeep-inline-functions is supported" >&5
11929 echo $ECHO_N "checking whether -fkeep-inline-functions is supported... $ECHO_C" >&6
11930   cat >conftest.$ac_ext <<_ACEOF
11931 /* confdefs.h.  */
11932 _ACEOF
11933 cat confdefs.h >>conftest.$ac_ext
11934 cat >>conftest.$ac_ext <<_ACEOF
11935 /* end confdefs.h.  */
11936
11937 #if (__GNUC__ < 3) \
11938     || (__GNUC__ == 3 && (__GNUC_MINOR__ < 3 \
11939                           || (__GNUC_MINOR__ == 3 && __GNUC_PATCHLEVEL__ < 1)))
11940 #error http://gcc.gnu.org/PR29382
11941 #endif
11942
11943 int
11944 main ()
11945 {
11946
11947   ;
11948   return 0;
11949 }
11950 _ACEOF
11951 rm -f conftest.$ac_objext
11952 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
11953   (eval $ac_compile) 2>conftest.er1
11954   ac_status=$?
11955   grep -v '^ *+' conftest.er1 >conftest.err
11956   rm -f conftest.er1
11957   cat conftest.err >&5
11958   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11959   (exit $ac_status); } &&
11960          { ac_try='test -z "$ac_c_werror_flag"
11961                          || test ! -s conftest.err'
11962   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11963   (eval $ac_try) 2>&5
11964   ac_status=$?
11965   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11966   (exit $ac_status); }; } &&
11967          { ac_try='test -s conftest.$ac_objext'
11968   { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
11969   (eval $ac_try) 2>&5
11970   ac_status=$?
11971   echo "$as_me:$LINENO: \$? = $ac_status" >&5
11972   (exit $ac_status); }; }; then
11973   echo "$as_me:$LINENO: result: yes" >&5
11974 echo "${ECHO_T}yes" >&6; stage1_cflags="$stage1_cflags -fkeep-inline-functions"
11975 else
11976   echo "$as_me: failed program was:" >&5
11977 sed 's/^/| /' conftest.$ac_ext >&5
11978
11979 echo "$as_me:$LINENO: result: no" >&5
11980 echo "${ECHO_T}no" >&6
11981 fi
11982 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
11983
11984   CFLAGS="$saved_CFLAGS"
11985 fi
11986
11987
11988
11989 # Enable --enable-checking in stage1 of the compiler.
11990 # Check whether --enable-stage1-checking or --disable-stage1-checking was given.
11991 if test "${enable_stage1_checking+set}" = set; then
11992   enableval="$enable_stage1_checking"
11993   stage1_checking=--enable-checking=${enable_stage1_checking}
11994 else
11995   if test "x$enable_checking" = xno; then
11996   stage1_checking=--enable-checking=yes,types
11997 else
11998   stage1_checking=--enable-checking=types${enable_checking+,}$enable_checking
11999 fi
12000 fi;
12001
12002
12003 # Enable -Werror in bootstrap stage2 and later.
12004 # Check whether --enable-werror or --disable-werror was given.
12005 if test "${enable_werror+set}" = set; then
12006   enableval="$enable_werror"
12007
12008 else
12009   if test -d ${srcdir}/gcc && test x"`cat $srcdir/gcc/DEV-PHASE`" = xexperimental; then
12010   enable_werror=yes
12011 else
12012   enable_werror=no
12013 fi
12014 fi;
12015 case ${enable_werror} in
12016   yes) stage2_werror_flag="--enable-werror-always" ;;
12017   *) stage2_werror_flag="" ;;
12018 esac
12019
12020
12021 # Flags needed to enable html installing and building
12022
12023 # Check whether --with-datarootdir or --without-datarootdir was given.
12024 if test "${with_datarootdir+set}" = set; then
12025   withval="$with_datarootdir"
12026   datarootdir="\${prefix}/${withval}"
12027 else
12028   datarootdir="\${prefix}/share"
12029 fi;
12030
12031
12032 # Check whether --with-docdir or --without-docdir was given.
12033 if test "${with_docdir+set}" = set; then
12034   withval="$with_docdir"
12035   docdir="\${prefix}/${withval}"
12036 else
12037   docdir="\${datarootdir}/doc"
12038 fi;
12039
12040
12041 # Check whether --with-pdfdir or --without-pdfdir was given.
12042 if test "${with_pdfdir+set}" = set; then
12043   withval="$with_pdfdir"
12044   pdfdir="\${prefix}/${withval}"
12045 else
12046   pdfdir="\${docdir}"
12047 fi;
12048
12049
12050 # Check whether --with-htmldir or --without-htmldir was given.
12051 if test "${with_htmldir+set}" = set; then
12052   withval="$with_htmldir"
12053   htmldir="\${prefix}/${withval}"
12054 else
12055   htmldir="\${docdir}"
12056 fi;
12057
12058
12059
12060
12061
12062
12063           ac_config_files="$ac_config_files Makefile"
12064 cat >confcache <<\_ACEOF
12065 # This file is a shell script that caches the results of configure
12066 # tests run on this system so they can be shared between configure
12067 # scripts and configure runs, see configure's option --config-cache.
12068 # It is not useful on other systems.  If it contains results you don't
12069 # want to keep, you may remove or edit it.
12070 #
12071 # config.status only pays attention to the cache file if you give it
12072 # the --recheck option to rerun configure.
12073 #
12074 # `ac_cv_env_foo' variables (set or unset) will be overridden when
12075 # loading this file, other *unset* `ac_cv_foo' will be assigned the
12076 # following values.
12077
12078 _ACEOF
12079
12080 # The following way of writing the cache mishandles newlines in values,
12081 # but we know of no workaround that is simple, portable, and efficient.
12082 # So, don't put newlines in cache variables' values.
12083 # Ultrix sh set writes to stderr and can't be redirected directly,
12084 # and sets the high bit in the cache file unless we assign to the vars.
12085 {
12086   (set) 2>&1 |
12087     case `(ac_space=' '; set | grep ac_space) 2>&1` in
12088     *ac_space=\ *)
12089       # `set' does not quote correctly, so add quotes (double-quote
12090       # substitution turns \\\\ into \\, and sed turns \\ into \).
12091       sed -n \
12092         "s/'/'\\\\''/g;
12093           s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
12094       ;;
12095     *)
12096       # `set' quotes correctly as required by POSIX, so do not add quotes.
12097       sed -n \
12098         "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
12099       ;;
12100     esac;
12101 } |
12102   sed '
12103      t clear
12104      : clear
12105      s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
12106      t end
12107      /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
12108      : end' >>confcache
12109 if diff $cache_file confcache >/dev/null 2>&1; then :; else
12110   if test -w $cache_file; then
12111     test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
12112     cat confcache >$cache_file
12113   else
12114     echo "not updating unwritable cache $cache_file"
12115   fi
12116 fi
12117 rm -f confcache
12118
12119 test "x$prefix" = xNONE && prefix=$ac_default_prefix
12120 # Let make expand exec_prefix.
12121 test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
12122
12123 # VPATH may cause trouble with some makes, so we remove $(srcdir),
12124 # ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and
12125 # trailing colons and then remove the whole line if VPATH becomes empty
12126 # (actually we leave an empty line to preserve line numbers).
12127 if test "x$srcdir" = x.; then
12128   ac_vpsub='/^[  ]*VPATH[        ]*=/{
12129 s/:*\$(srcdir):*/:/;
12130 s/:*\${srcdir}:*/:/;
12131 s/:*@srcdir@:*/:/;
12132 s/^\([^=]*=[     ]*\):*/\1/;
12133 s/:*$//;
12134 s/^[^=]*=[       ]*$//;
12135 }'
12136 fi
12137
12138 # Transform confdefs.h into DEFS.
12139 # Protect against shell expansion while executing Makefile rules.
12140 # Protect against Makefile macro expansion.
12141 #
12142 # If the first sed substitution is executed (which looks for macros that
12143 # take arguments), then we branch to the quote section.  Otherwise,
12144 # look for a macro that doesn't take arguments.
12145 cat >confdef2opt.sed <<\_ACEOF
12146 t clear
12147 : clear
12148 s,^[     ]*#[    ]*define[       ][      ]*\([^  (][^    (]*([^)]*)\)[   ]*\(.*\),-D\1=\2,g
12149 t quote
12150 s,^[     ]*#[    ]*define[       ][      ]*\([^  ][^     ]*\)[   ]*\(.*\),-D\1=\2,g
12151 t quote
12152 d
12153 : quote
12154 s,[      `~#$^&*(){}\\|;'"<>?],\\&,g
12155 s,\[,\\&,g
12156 s,\],\\&,g
12157 s,\$,$$,g
12158 p
12159 _ACEOF
12160 # We use echo to avoid assuming a particular line-breaking character.
12161 # The extra dot is to prevent the shell from consuming trailing
12162 # line-breaks from the sub-command output.  A line-break within
12163 # single-quotes doesn't work because, if this script is created in a
12164 # platform that uses two characters for line-breaks (e.g., DOS), tr
12165 # would break.
12166 ac_LF_and_DOT=`echo; echo .`
12167 DEFS=`sed -n -f confdef2opt.sed confdefs.h | tr "$ac_LF_and_DOT" ' .'`
12168 rm -f confdef2opt.sed
12169
12170
12171 ac_libobjs=
12172 ac_ltlibobjs=
12173 for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
12174   # 1. Remove the extension, and $U if already installed.
12175   ac_i=`echo "$ac_i" |
12176          sed 's/\$U\././;s/\.o$//;s/\.obj$//'`
12177   # 2. Add them.
12178   ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"
12179   ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'
12180 done
12181 LIBOBJS=$ac_libobjs
12182
12183 LTLIBOBJS=$ac_ltlibobjs
12184
12185
12186
12187 : ${CONFIG_STATUS=./config.status}
12188 ac_clean_files_save=$ac_clean_files
12189 ac_clean_files="$ac_clean_files $CONFIG_STATUS"
12190 { echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5
12191 echo "$as_me: creating $CONFIG_STATUS" >&6;}
12192 cat >$CONFIG_STATUS <<_ACEOF
12193 #! $SHELL
12194 # Generated by $as_me.
12195 # Run this file to recreate the current configuration.
12196 # Compiler output produced by configure, useful for debugging
12197 # configure, is in config.log if it exists.
12198
12199 debug=false
12200 ac_cs_recheck=false
12201 ac_cs_silent=false
12202 SHELL=\${CONFIG_SHELL-$SHELL}
12203 _ACEOF
12204
12205 cat >>$CONFIG_STATUS <<\_ACEOF
12206 ## --------------------- ##
12207 ## M4sh Initialization.  ##
12208 ## --------------------- ##
12209
12210 # Be Bourne compatible
12211 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
12212   emulate sh
12213   NULLCMD=:
12214   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
12215   # is contrary to our usage.  Disable this feature.
12216   alias -g '${1+"$@"}'='"$@"'
12217 elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then
12218   set -o posix
12219 fi
12220 DUALCASE=1; export DUALCASE # for MKS sh
12221
12222 # Support unset when possible.
12223 if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
12224   as_unset=unset
12225 else
12226   as_unset=false
12227 fi
12228
12229
12230 # Work around bugs in pre-3.0 UWIN ksh.
12231 $as_unset ENV MAIL MAILPATH
12232 PS1='$ '
12233 PS2='> '
12234 PS4='+ '
12235
12236 # NLS nuisances.
12237 for as_var in \
12238   LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \
12239   LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \
12240   LC_TELEPHONE LC_TIME
12241 do
12242   if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then
12243     eval $as_var=C; export $as_var
12244   else
12245     $as_unset $as_var
12246   fi
12247 done
12248
12249 # Required to use basename.
12250 if expr a : '\(a\)' >/dev/null 2>&1; then
12251   as_expr=expr
12252 else
12253   as_expr=false
12254 fi
12255
12256 if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then
12257   as_basename=basename
12258 else
12259   as_basename=false
12260 fi
12261
12262
12263 # Name of the executable.
12264 as_me=`$as_basename "$0" ||
12265 $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
12266          X"$0" : 'X\(//\)$' \| \
12267          X"$0" : 'X\(/\)$' \| \
12268          .     : '\(.\)' 2>/dev/null ||
12269 echo X/"$0" |
12270     sed '/^.*\/\([^/][^/]*\)\/*$/{ s//\1/; q; }
12271           /^X\/\(\/\/\)$/{ s//\1/; q; }
12272           /^X\/\(\/\).*/{ s//\1/; q; }
12273           s/.*/./; q'`
12274
12275
12276 # PATH needs CR, and LINENO needs CR and PATH.
12277 # Avoid depending upon Character Ranges.
12278 as_cr_letters='abcdefghijklmnopqrstuvwxyz'
12279 as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
12280 as_cr_Letters=$as_cr_letters$as_cr_LETTERS
12281 as_cr_digits='0123456789'
12282 as_cr_alnum=$as_cr_Letters$as_cr_digits
12283
12284 # The user is always right.
12285 if test "${PATH_SEPARATOR+set}" != set; then
12286   echo "#! /bin/sh" >conf$$.sh
12287   echo  "exit 0"   >>conf$$.sh
12288   chmod +x conf$$.sh
12289   if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
12290     PATH_SEPARATOR=';'
12291   else
12292     PATH_SEPARATOR=:
12293   fi
12294   rm -f conf$$.sh
12295 fi
12296
12297
12298   as_lineno_1=$LINENO
12299   as_lineno_2=$LINENO
12300   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12301   test "x$as_lineno_1" != "x$as_lineno_2" &&
12302   test "x$as_lineno_3"  = "x$as_lineno_2"  || {
12303   # Find who we are.  Look in the path if we contain no path at all
12304   # relative or not.
12305   case $0 in
12306     *[\\/]* ) as_myself=$0 ;;
12307     *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12308 for as_dir in $PATH
12309 do
12310   IFS=$as_save_IFS
12311   test -z "$as_dir" && as_dir=.
12312   test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
12313 done
12314
12315        ;;
12316   esac
12317   # We did not find ourselves, most probably we were run as `sh COMMAND'
12318   # in which case we are not to be found in the path.
12319   if test "x$as_myself" = x; then
12320     as_myself=$0
12321   fi
12322   if test ! -f "$as_myself"; then
12323     { { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5
12324 echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}
12325    { (exit 1); exit 1; }; }
12326   fi
12327   case $CONFIG_SHELL in
12328   '')
12329     as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
12330 for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
12331 do
12332   IFS=$as_save_IFS
12333   test -z "$as_dir" && as_dir=.
12334   for as_base in sh bash ksh sh5; do
12335          case $as_dir in
12336          /*)
12337            if ("$as_dir/$as_base" -c '
12338   as_lineno_1=$LINENO
12339   as_lineno_2=$LINENO
12340   as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`
12341   test "x$as_lineno_1" != "x$as_lineno_2" &&
12342   test "x$as_lineno_3"  = "x$as_lineno_2" ') 2>/dev/null; then
12343              $as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }
12344              $as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }
12345              CONFIG_SHELL=$as_dir/$as_base
12346              export CONFIG_SHELL
12347              exec "$CONFIG_SHELL" "$0" ${1+"$@"}
12348            fi;;
12349          esac
12350        done
12351 done
12352 ;;
12353   esac
12354
12355   # Create $as_me.lineno as a copy of $as_myself, but with $LINENO
12356   # uniformly replaced by the line number.  The first 'sed' inserts a
12357   # line-number line before each line; the second 'sed' does the real
12358   # work.  The second script uses 'N' to pair each line-number line
12359   # with the numbered line, and appends trailing '-' during
12360   # substitution so that $LINENO is not a special case at line end.
12361   # (Raja R Harinath suggested sed '=', and Paul Eggert wrote the
12362   # second 'sed' script.  Blame Lee E. McMahon for sed's syntax.  :-)
12363   sed '=' <$as_myself |
12364     sed '
12365       N
12366       s,$,-,
12367       : loop
12368       s,^\(['$as_cr_digits']*\)\(.*\)[$]LINENO\([^'$as_cr_alnum'_]\),\1\2\1\3,
12369       t loop
12370       s,-$,,
12371       s,^['$as_cr_digits']*\n,,
12372     ' >$as_me.lineno &&
12373   chmod +x $as_me.lineno ||
12374     { { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5
12375 echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}
12376    { (exit 1); exit 1; }; }
12377
12378   # Don't try to exec as it changes $[0], causing all sort of problems
12379   # (the dirname of $[0] is not the place where we might find the
12380   # original and so on.  Autoconf is especially sensible to this).
12381   . ./$as_me.lineno
12382   # Exit status is that of the last command.
12383   exit
12384 }
12385
12386
12387 case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in
12388   *c*,-n*) ECHO_N= ECHO_C='
12389 ' ECHO_T='      ' ;;
12390   *c*,*  ) ECHO_N=-n ECHO_C= ECHO_T= ;;
12391   *)       ECHO_N= ECHO_C='\c' ECHO_T= ;;
12392 esac
12393
12394 if expr a : '\(a\)' >/dev/null 2>&1; then
12395   as_expr=expr
12396 else
12397   as_expr=false
12398 fi
12399
12400 rm -f conf$$ conf$$.exe conf$$.file
12401 echo >conf$$.file
12402 if ln -s conf$$.file conf$$ 2>/dev/null; then
12403   # We could just check for DJGPP; but this test a) works b) is more generic
12404   # and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).
12405   if test -f conf$$.exe; then
12406     # Don't use ln at all; we don't have any links
12407     as_ln_s='cp -p'
12408   else
12409     as_ln_s='ln -s'
12410   fi
12411 elif ln conf$$.file conf$$ 2>/dev/null; then
12412   as_ln_s=ln
12413 else
12414   as_ln_s='cp -p'
12415 fi
12416 rm -f conf$$ conf$$.exe conf$$.file
12417
12418 if mkdir -p . 2>/dev/null; then
12419   as_mkdir_p=:
12420 else
12421   test -d ./-p && rmdir ./-p
12422   as_mkdir_p=false
12423 fi
12424
12425 as_executable_p="test -f"
12426
12427 # Sed expression to map a string onto a valid CPP name.
12428 as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
12429
12430 # Sed expression to map a string onto a valid variable name.
12431 as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
12432
12433
12434 # IFS
12435 # We need space, tab and new line, in precisely that order.
12436 as_nl='
12437 '
12438 IFS="   $as_nl"
12439
12440 # CDPATH.
12441 $as_unset CDPATH
12442
12443 exec 6>&1
12444
12445 # Open the log real soon, to keep \$[0] and so on meaningful, and to
12446 # report actual input values of CONFIG_FILES etc. instead of their
12447 # values after options handling.  Logging --version etc. is OK.
12448 exec 5>>config.log
12449 {
12450   echo
12451   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
12452 ## Running $as_me. ##
12453 _ASBOX
12454 } >&5
12455 cat >&5 <<_CSEOF
12456
12457 This file was extended by $as_me, which was
12458 generated by GNU Autoconf 2.59.  Invocation command line was
12459
12460   CONFIG_FILES    = $CONFIG_FILES
12461   CONFIG_HEADERS  = $CONFIG_HEADERS
12462   CONFIG_LINKS    = $CONFIG_LINKS
12463   CONFIG_COMMANDS = $CONFIG_COMMANDS
12464   $ $0 $@
12465
12466 _CSEOF
12467 echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5
12468 echo >&5
12469 _ACEOF
12470
12471 # Files that config.status was made for.
12472 if test -n "$ac_config_files"; then
12473   echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS
12474 fi
12475
12476 if test -n "$ac_config_headers"; then
12477   echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS
12478 fi
12479
12480 if test -n "$ac_config_links"; then
12481   echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS
12482 fi
12483
12484 if test -n "$ac_config_commands"; then
12485   echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS
12486 fi
12487
12488 cat >>$CONFIG_STATUS <<\_ACEOF
12489
12490 ac_cs_usage="\
12491 \`$as_me' instantiates files from templates according to the
12492 current configuration.
12493
12494 Usage: $0 [OPTIONS] [FILE]...
12495
12496   -h, --help       print this help, then exit
12497   -V, --version    print version number, then exit
12498   -q, --quiet      do not print progress messages
12499   -d, --debug      don't remove temporary files
12500       --recheck    update $as_me by reconfiguring in the same conditions
12501   --file=FILE[:TEMPLATE]
12502                    instantiate the configuration file FILE
12503
12504 Configuration files:
12505 $config_files
12506
12507 Report bugs to <bug-autoconf@gnu.org>."
12508 _ACEOF
12509
12510 cat >>$CONFIG_STATUS <<_ACEOF
12511 ac_cs_version="\\
12512 config.status
12513 configured by $0, generated by GNU Autoconf 2.59,
12514   with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
12515
12516 Copyright (C) 2003 Free Software Foundation, Inc.
12517 This config.status script is free software; the Free Software Foundation
12518 gives unlimited permission to copy, distribute and modify it."
12519 srcdir=$srcdir
12520 INSTALL="$INSTALL"
12521 _ACEOF
12522
12523 cat >>$CONFIG_STATUS <<\_ACEOF
12524 # If no file are specified by the user, then we need to provide default
12525 # value.  By we need to know if files were specified by the user.
12526 ac_need_defaults=:
12527 while test $# != 0
12528 do
12529   case $1 in
12530   --*=*)
12531     ac_option=`expr "x$1" : 'x\([^=]*\)='`
12532     ac_optarg=`expr "x$1" : 'x[^=]*=\(.*\)'`
12533     ac_shift=:
12534     ;;
12535   -*)
12536     ac_option=$1
12537     ac_optarg=$2
12538     ac_shift=shift
12539     ;;
12540   *) # This is not an option, so the user has probably given explicit
12541      # arguments.
12542      ac_option=$1
12543      ac_need_defaults=false;;
12544   esac
12545
12546   case $ac_option in
12547   # Handling of the options.
12548 _ACEOF
12549 cat >>$CONFIG_STATUS <<\_ACEOF
12550   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
12551     ac_cs_recheck=: ;;
12552   --version | --vers* | -V )
12553     echo "$ac_cs_version"; exit 0 ;;
12554   --he | --h)
12555     # Conflict between --help and --header
12556     { { echo "$as_me:$LINENO: error: ambiguous option: $1
12557 Try \`$0 --help' for more information." >&5
12558 echo "$as_me: error: ambiguous option: $1
12559 Try \`$0 --help' for more information." >&2;}
12560    { (exit 1); exit 1; }; };;
12561   --help | --hel | -h )
12562     echo "$ac_cs_usage"; exit 0 ;;
12563   --debug | --d* | -d )
12564     debug=: ;;
12565   --file | --fil | --fi | --f )
12566     $ac_shift
12567     CONFIG_FILES="$CONFIG_FILES $ac_optarg"
12568     ac_need_defaults=false;;
12569   --header | --heade | --head | --hea )
12570     $ac_shift
12571     CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"
12572     ac_need_defaults=false;;
12573   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
12574   | -silent | --silent | --silen | --sile | --sil | --si | --s)
12575     ac_cs_silent=: ;;
12576
12577   # This is an error.
12578   -*) { { echo "$as_me:$LINENO: error: unrecognized option: $1
12579 Try \`$0 --help' for more information." >&5
12580 echo "$as_me: error: unrecognized option: $1
12581 Try \`$0 --help' for more information." >&2;}
12582    { (exit 1); exit 1; }; } ;;
12583
12584   *) ac_config_targets="$ac_config_targets $1" ;;
12585
12586   esac
12587   shift
12588 done
12589
12590 ac_configure_extra_args=
12591
12592 if $ac_cs_silent; then
12593   exec 6>/dev/null
12594   ac_configure_extra_args="$ac_configure_extra_args --silent"
12595 fi
12596
12597 _ACEOF
12598 cat >>$CONFIG_STATUS <<_ACEOF
12599 if \$ac_cs_recheck; then
12600   echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6
12601   exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
12602 fi
12603
12604 _ACEOF
12605
12606
12607
12608
12609
12610 cat >>$CONFIG_STATUS <<\_ACEOF
12611 for ac_config_target in $ac_config_targets
12612 do
12613   case "$ac_config_target" in
12614   # Handling of arguments.
12615   "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
12616   *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
12617 echo "$as_me: error: invalid argument: $ac_config_target" >&2;}
12618    { (exit 1); exit 1; }; };;
12619   esac
12620 done
12621
12622 # If the user did not use the arguments to specify the items to instantiate,
12623 # then the envvar interface is used.  Set only those that are not.
12624 # We use the long form for the default assignment because of an extremely
12625 # bizarre bug on SunOS 4.1.3.
12626 if $ac_need_defaults; then
12627   test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
12628 fi
12629
12630 # Have a temporary directory for convenience.  Make it in the build tree
12631 # simply because there is no reason to put it here, and in addition,
12632 # creating and moving files from /tmp can sometimes cause problems.
12633 # Create a temporary directory, and hook for its removal unless debugging.
12634 $debug ||
12635 {
12636   trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0
12637   trap '{ (exit 1); exit 1; }' 1 2 13 15
12638 }
12639
12640 # Create a (secure) tmp directory for tmp files.
12641
12642 {
12643   tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&
12644   test -n "$tmp" && test -d "$tmp"
12645 }  ||
12646 {
12647   tmp=./confstat$$-$RANDOM
12648   (umask 077 && mkdir $tmp)
12649 } ||
12650 {
12651    echo "$me: cannot create a temporary directory in ." >&2
12652    { (exit 1); exit 1; }
12653 }
12654
12655 _ACEOF
12656
12657 cat >>$CONFIG_STATUS <<_ACEOF
12658
12659 #
12660 # CONFIG_FILES section.
12661 #
12662
12663 # No need to generate the scripts if there are no CONFIG_FILES.
12664 # This happens for instance when ./config.status config.h
12665 if test -n "\$CONFIG_FILES"; then
12666   # Protect against being on the right side of a sed subst in config.status.
12667   sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;
12668    s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF
12669 s,@SHELL@,$SHELL,;t t
12670 s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t
12671 s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t
12672 s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t
12673 s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t
12674 s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t
12675 s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t
12676 s,@exec_prefix@,$exec_prefix,;t t
12677 s,@prefix@,$prefix,;t t
12678 s,@program_transform_name@,$program_transform_name,;t t
12679 s,@bindir@,$bindir,;t t
12680 s,@sbindir@,$sbindir,;t t
12681 s,@libexecdir@,$libexecdir,;t t
12682 s,@datadir@,$datadir,;t t
12683 s,@sysconfdir@,$sysconfdir,;t t
12684 s,@sharedstatedir@,$sharedstatedir,;t t
12685 s,@localstatedir@,$localstatedir,;t t
12686 s,@libdir@,$libdir,;t t
12687 s,@includedir@,$includedir,;t t
12688 s,@oldincludedir@,$oldincludedir,;t t
12689 s,@infodir@,$infodir,;t t
12690 s,@mandir@,$mandir,;t t
12691 s,@build_alias@,$build_alias,;t t
12692 s,@host_alias@,$host_alias,;t t
12693 s,@target_alias@,$target_alias,;t t
12694 s,@DEFS@,$DEFS,;t t
12695 s,@ECHO_C@,$ECHO_C,;t t
12696 s,@ECHO_N@,$ECHO_N,;t t
12697 s,@ECHO_T@,$ECHO_T,;t t
12698 s,@LIBS@,$LIBS,;t t
12699 s,@build@,$build,;t t
12700 s,@build_cpu@,$build_cpu,;t t
12701 s,@build_vendor@,$build_vendor,;t t
12702 s,@build_os@,$build_os,;t t
12703 s,@build_noncanonical@,$build_noncanonical,;t t
12704 s,@host_noncanonical@,$host_noncanonical,;t t
12705 s,@target_noncanonical@,$target_noncanonical,;t t
12706 s,@host@,$host,;t t
12707 s,@host_cpu@,$host_cpu,;t t
12708 s,@host_vendor@,$host_vendor,;t t
12709 s,@host_os@,$host_os,;t t
12710 s,@target@,$target,;t t
12711 s,@target_cpu@,$target_cpu,;t t
12712 s,@target_vendor@,$target_vendor,;t t
12713 s,@target_os@,$target_os,;t t
12714 s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t
12715 s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t
12716 s,@INSTALL_DATA@,$INSTALL_DATA,;t t
12717 s,@LN@,$LN,;t t
12718 s,@LN_S@,$LN_S,;t t
12719 s,@TOPLEVEL_CONFIGURE_ARGUMENTS@,$TOPLEVEL_CONFIGURE_ARGUMENTS,;t t
12720 s,@build_libsubdir@,$build_libsubdir,;t t
12721 s,@build_subdir@,$build_subdir,;t t
12722 s,@host_subdir@,$host_subdir,;t t
12723 s,@target_subdir@,$target_subdir,;t t
12724 s,@CC@,$CC,;t t
12725 s,@CFLAGS@,$CFLAGS,;t t
12726 s,@LDFLAGS@,$LDFLAGS,;t t
12727 s,@CPPFLAGS@,$CPPFLAGS,;t t
12728 s,@ac_ct_CC@,$ac_ct_CC,;t t
12729 s,@EXEEXT@,$EXEEXT,;t t
12730 s,@OBJEXT@,$OBJEXT,;t t
12731 s,@CXX@,$CXX,;t t
12732 s,@CXXFLAGS@,$CXXFLAGS,;t t
12733 s,@ac_ct_CXX@,$ac_ct_CXX,;t t
12734 s,@GNATBIND@,$GNATBIND,;t t
12735 s,@ac_ct_GNATBIND@,$ac_ct_GNATBIND,;t t
12736 s,@GNATMAKE@,$GNATMAKE,;t t
12737 s,@ac_ct_GNATMAKE@,$ac_ct_GNATMAKE,;t t
12738 s,@do_compare@,$do_compare,;t t
12739 s,@gmplibs@,$gmplibs,;t t
12740 s,@gmpinc@,$gmpinc,;t t
12741 s,@stage1_languages@,$stage1_languages,;t t
12742 s,@SYSROOT_CFLAGS_FOR_TARGET@,$SYSROOT_CFLAGS_FOR_TARGET,;t t
12743 s,@DEBUG_PREFIX_CFLAGS_FOR_TARGET@,$DEBUG_PREFIX_CFLAGS_FOR_TARGET,;t t
12744 s,@RPATH_ENVVAR@,$RPATH_ENVVAR,;t t
12745 s,@tooldir@,$tooldir,;t t
12746 s,@build_tooldir@,$build_tooldir,;t t
12747 s,@CONFIGURE_GDB_TK@,$CONFIGURE_GDB_TK,;t t
12748 s,@GDB_TK@,$GDB_TK,;t t
12749 s,@INSTALL_GDB_TK@,$INSTALL_GDB_TK,;t t
12750 s,@build_configargs@,$build_configargs,;t t
12751 s,@build_configdirs@,$build_configdirs,;t t
12752 s,@host_configargs@,$host_configargs,;t t
12753 s,@configdirs@,$configdirs,;t t
12754 s,@target_configargs@,$target_configargs,;t t
12755 s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
12756 s,@config_shell@,$config_shell,;t t
12757 s,@YACC@,$YACC,;t t
12758 s,@BISON@,$BISON,;t t
12759 s,@M4@,$M4,;t t
12760 s,@LEX@,$LEX,;t t
12761 s,@FLEX@,$FLEX,;t t
12762 s,@MAKEINFO@,$MAKEINFO,;t t
12763 s,@EXPECT@,$EXPECT,;t t
12764 s,@RUNTEST@,$RUNTEST,;t t
12765 s,@AR@,$AR,;t t
12766 s,@AS@,$AS,;t t
12767 s,@DLLTOOL@,$DLLTOOL,;t t
12768 s,@LD@,$LD,;t t
12769 s,@LIPO@,$LIPO,;t t
12770 s,@NM@,$NM,;t t
12771 s,@RANLIB@,$RANLIB,;t t
12772 s,@STRIP@,$STRIP,;t t
12773 s,@WINDRES@,$WINDRES,;t t
12774 s,@WINDMC@,$WINDMC,;t t
12775 s,@OBJCOPY@,$OBJCOPY,;t t
12776 s,@OBJDUMP@,$OBJDUMP,;t t
12777 s,@CFLAGS_FOR_BUILD@,$CFLAGS_FOR_BUILD,;t t
12778 s,@CC_FOR_TARGET@,$CC_FOR_TARGET,;t t
12779 s,@CXX_FOR_TARGET@,$CXX_FOR_TARGET,;t t
12780 s,@GCC_FOR_TARGET@,$GCC_FOR_TARGET,;t t
12781 s,@GCJ_FOR_TARGET@,$GCJ_FOR_TARGET,;t t
12782 s,@GFORTRAN_FOR_TARGET@,$GFORTRAN_FOR_TARGET,;t t
12783 s,@AR_FOR_TARGET@,$AR_FOR_TARGET,;t t
12784 s,@AS_FOR_TARGET@,$AS_FOR_TARGET,;t t
12785 s,@DLLTOOL_FOR_TARGET@,$DLLTOOL_FOR_TARGET,;t t
12786 s,@LD_FOR_TARGET@,$LD_FOR_TARGET,;t t
12787 s,@LIPO_FOR_TARGET@,$LIPO_FOR_TARGET,;t t
12788 s,@NM_FOR_TARGET@,$NM_FOR_TARGET,;t t
12789 s,@OBJDUMP_FOR_TARGET@,$OBJDUMP_FOR_TARGET,;t t
12790 s,@RANLIB_FOR_TARGET@,$RANLIB_FOR_TARGET,;t t
12791 s,@STRIP_FOR_TARGET@,$STRIP_FOR_TARGET,;t t
12792 s,@WINDRES_FOR_TARGET@,$WINDRES_FOR_TARGET,;t t
12793 s,@WINDMC_FOR_TARGET@,$WINDMC_FOR_TARGET,;t t
12794 s,@RAW_CXX_FOR_TARGET@,$RAW_CXX_FOR_TARGET,;t t
12795 s,@FLAGS_FOR_TARGET@,$FLAGS_FOR_TARGET,;t t
12796 s,@COMPILER_AS_FOR_TARGET@,$COMPILER_AS_FOR_TARGET,;t t
12797 s,@COMPILER_LD_FOR_TARGET@,$COMPILER_LD_FOR_TARGET,;t t
12798 s,@COMPILER_NM_FOR_TARGET@,$COMPILER_NM_FOR_TARGET,;t t
12799 s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
12800 s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
12801 s,@MAINT@,$MAINT,;t t
12802 s,@stage1_cflags@,$stage1_cflags,;t t
12803 s,@stage1_checking@,$stage1_checking,;t t
12804 s,@stage2_werror_flag@,$stage2_werror_flag,;t t
12805 s,@datarootdir@,$datarootdir,;t t
12806 s,@docdir@,$docdir,;t t
12807 s,@pdfdir@,$pdfdir,;t t
12808 s,@htmldir@,$htmldir,;t t
12809 s,@LIBOBJS@,$LIBOBJS,;t t
12810 s,@LTLIBOBJS@,$LTLIBOBJS,;t t
12811 /@serialization_dependencies@/r $serialization_dependencies
12812 s,@serialization_dependencies@,,;t t
12813 /@host_makefile_frag@/r $host_makefile_frag
12814 s,@host_makefile_frag@,,;t t
12815 /@target_makefile_frag@/r $target_makefile_frag
12816 s,@target_makefile_frag@,,;t t
12817 /@alphaieee_frag@/r $alphaieee_frag
12818 s,@alphaieee_frag@,,;t t
12819 /@ospace_frag@/r $ospace_frag
12820 s,@ospace_frag@,,;t t
12821 CEOF
12822
12823 _ACEOF
12824
12825   cat >>$CONFIG_STATUS <<\_ACEOF
12826   # Split the substitutions into bite-sized pieces for seds with
12827   # small command number limits, like on Digital OSF/1 and HP-UX.
12828   ac_max_sed_lines=48
12829   ac_sed_frag=1 # Number of current file.
12830   ac_beg=1 # First line for current file.
12831   ac_end=$ac_max_sed_lines # Line after last line for current file.
12832   ac_more_lines=:
12833   ac_sed_cmds=
12834   while $ac_more_lines; do
12835     if test $ac_beg -gt 1; then
12836       sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12837     else
12838       sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag
12839     fi
12840     if test ! -s $tmp/subs.frag; then
12841       ac_more_lines=false
12842     else
12843       # The purpose of the label and of the branching condition is to
12844       # speed up the sed processing (if there are no `@' at all, there
12845       # is no need to browse any of the substitutions).
12846       # These are the two extra sed commands mentioned above.
12847       (echo ':t
12848   /@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed
12849       if test -z "$ac_sed_cmds"; then
12850         ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"
12851       else
12852         ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"
12853       fi
12854       ac_sed_frag=`expr $ac_sed_frag + 1`
12855       ac_beg=$ac_end
12856       ac_end=`expr $ac_end + $ac_max_sed_lines`
12857     fi
12858   done
12859   if test -z "$ac_sed_cmds"; then
12860     ac_sed_cmds=cat
12861   fi
12862 fi # test -n "$CONFIG_FILES"
12863
12864 _ACEOF
12865 cat >>$CONFIG_STATUS <<\_ACEOF
12866 for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue
12867   # Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".
12868   case $ac_file in
12869   - | *:- | *:-:* ) # input from stdin
12870         cat >$tmp/stdin
12871         ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12872         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12873   *:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`
12874         ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;
12875   * )   ac_file_in=$ac_file.in ;;
12876   esac
12877
12878   # Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.
12879   ac_dir=`(dirname "$ac_file") 2>/dev/null ||
12880 $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12881          X"$ac_file" : 'X\(//\)[^/]' \| \
12882          X"$ac_file" : 'X\(//\)$' \| \
12883          X"$ac_file" : 'X\(/\)' \| \
12884          .     : '\(.\)' 2>/dev/null ||
12885 echo X"$ac_file" |
12886     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12887           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12888           /^X\(\/\/\)$/{ s//\1/; q; }
12889           /^X\(\/\).*/{ s//\1/; q; }
12890           s/.*/./; q'`
12891   { if $as_mkdir_p; then
12892     mkdir -p "$ac_dir"
12893   else
12894     as_dir="$ac_dir"
12895     as_dirs=
12896     while test ! -d "$as_dir"; do
12897       as_dirs="$as_dir $as_dirs"
12898       as_dir=`(dirname "$as_dir") 2>/dev/null ||
12899 $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
12900          X"$as_dir" : 'X\(//\)[^/]' \| \
12901          X"$as_dir" : 'X\(//\)$' \| \
12902          X"$as_dir" : 'X\(/\)' \| \
12903          .     : '\(.\)' 2>/dev/null ||
12904 echo X"$as_dir" |
12905     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{ s//\1/; q; }
12906           /^X\(\/\/\)[^/].*/{ s//\1/; q; }
12907           /^X\(\/\/\)$/{ s//\1/; q; }
12908           /^X\(\/\).*/{ s//\1/; q; }
12909           s/.*/./; q'`
12910     done
12911     test ! -n "$as_dirs" || mkdir $as_dirs
12912   fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5
12913 echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}
12914    { (exit 1); exit 1; }; }; }
12915
12916   ac_builddir=.
12917
12918 if test "$ac_dir" != .; then
12919   ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`
12920   # A "../" for each directory in $ac_dir_suffix.
12921   ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`
12922 else
12923   ac_dir_suffix= ac_top_builddir=
12924 fi
12925
12926 case $srcdir in
12927   .)  # No --srcdir option.  We are building in place.
12928     ac_srcdir=.
12929     if test -z "$ac_top_builddir"; then
12930        ac_top_srcdir=.
12931     else
12932        ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`
12933     fi ;;
12934   [\\/]* | ?:[\\/]* )  # Absolute path.
12935     ac_srcdir=$srcdir$ac_dir_suffix;
12936     ac_top_srcdir=$srcdir ;;
12937   *) # Relative path.
12938     ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix
12939     ac_top_srcdir=$ac_top_builddir$srcdir ;;
12940 esac
12941
12942 # Do not use `cd foo && pwd` to compute absolute paths, because
12943 # the directories may not exist.
12944 case `pwd` in
12945 .) ac_abs_builddir="$ac_dir";;
12946 *)
12947   case "$ac_dir" in
12948   .) ac_abs_builddir=`pwd`;;
12949   [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;
12950   *) ac_abs_builddir=`pwd`/"$ac_dir";;
12951   esac;;
12952 esac
12953 case $ac_abs_builddir in
12954 .) ac_abs_top_builddir=${ac_top_builddir}.;;
12955 *)
12956   case ${ac_top_builddir}. in
12957   .) ac_abs_top_builddir=$ac_abs_builddir;;
12958   [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;
12959   *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;
12960   esac;;
12961 esac
12962 case $ac_abs_builddir in
12963 .) ac_abs_srcdir=$ac_srcdir;;
12964 *)
12965   case $ac_srcdir in
12966   .) ac_abs_srcdir=$ac_abs_builddir;;
12967   [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;
12968   *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;
12969   esac;;
12970 esac
12971 case $ac_abs_builddir in
12972 .) ac_abs_top_srcdir=$ac_top_srcdir;;
12973 *)
12974   case $ac_top_srcdir in
12975   .) ac_abs_top_srcdir=$ac_abs_builddir;;
12976   [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;
12977   *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;
12978   esac;;
12979 esac
12980
12981
12982   case $INSTALL in
12983   [\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;
12984   *) ac_INSTALL=$ac_top_builddir$INSTALL ;;
12985   esac
12986
12987   if test x"$ac_file" != x-; then
12988     { echo "$as_me:$LINENO: creating $ac_file" >&5
12989 echo "$as_me: creating $ac_file" >&6;}
12990     rm -f "$ac_file"
12991   fi
12992   # Let's still pretend it is `configure' which instantiates (i.e., don't
12993   # use $as_me), people would be surprised to read:
12994   #    /* config.h.  Generated by config.status.  */
12995   if test x"$ac_file" = x-; then
12996     configure_input=
12997   else
12998     configure_input="$ac_file.  "
12999   fi
13000   configure_input=$configure_input"Generated from `echo $ac_file_in |
13001                                      sed 's,.*/,,'` by configure."
13002
13003   # First look for the input files in the build tree, otherwise in the
13004   # src tree.
13005   ac_file_inputs=`IFS=:
13006     for f in $ac_file_in; do
13007       case $f in
13008       -) echo $tmp/stdin ;;
13009       [\\/$]*)
13010          # Absolute (can't be DOS-style, as IFS=:)
13011          test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13012 echo "$as_me: error: cannot find input file: $f" >&2;}
13013    { (exit 1); exit 1; }; }
13014          echo "$f";;
13015       *) # Relative
13016          if test -f "$f"; then
13017            # Build tree
13018            echo "$f"
13019          elif test -f "$srcdir/$f"; then
13020            # Source tree
13021            echo "$srcdir/$f"
13022          else
13023            # /dev/null tree
13024            { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5
13025 echo "$as_me: error: cannot find input file: $f" >&2;}
13026    { (exit 1); exit 1; }; }
13027          fi;;
13028       esac
13029     done` || { (exit 1); exit 1; }
13030 _ACEOF
13031 cat >>$CONFIG_STATUS <<_ACEOF
13032   sed "$ac_vpsub
13033 $extrasub
13034 _ACEOF
13035 cat >>$CONFIG_STATUS <<\_ACEOF
13036 :t
13037 /@[a-zA-Z_][a-zA-Z_0-9]*@/!b
13038 s,@configure_input@,$configure_input,;t t
13039 s,@srcdir@,$ac_srcdir,;t t
13040 s,@abs_srcdir@,$ac_abs_srcdir,;t t
13041 s,@top_srcdir@,$ac_top_srcdir,;t t
13042 s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t
13043 s,@builddir@,$ac_builddir,;t t
13044 s,@abs_builddir@,$ac_abs_builddir,;t t
13045 s,@top_builddir@,$ac_top_builddir,;t t
13046 s,@abs_top_builddir@,$ac_abs_top_builddir,;t t
13047 s,@INSTALL@,$ac_INSTALL,;t t
13048 " $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out
13049   rm -f $tmp/stdin
13050   if test x"$ac_file" != x-; then
13051     mv $tmp/out $ac_file
13052   else
13053     cat $tmp/out
13054     rm -f $tmp/out
13055   fi
13056
13057 done
13058 _ACEOF
13059
13060 cat >>$CONFIG_STATUS <<\_ACEOF
13061
13062 { (exit 0); exit 0; }
13063 _ACEOF
13064 chmod +x $CONFIG_STATUS
13065 ac_clean_files=$ac_clean_files_save
13066
13067
13068 # configure is writing to config.log, and then calls config.status.
13069 # config.status does its own redirection, appending to config.log.
13070 # Unfortunately, on DOS this fails, as config.log is still kept open
13071 # by configure, so config.status won't be able to write to it; its
13072 # output is simply discarded.  So we exec the FD to /dev/null,
13073 # effectively closing config.log, so it can be properly (re)opened and
13074 # appended to by config.status.  When coming back to configure, we
13075 # need to make the FD available again.
13076 if test "$no_create" != yes; then
13077   ac_cs_success=:
13078   ac_config_status_args=
13079   test "$silent" = yes &&
13080     ac_config_status_args="$ac_config_status_args --quiet"
13081   exec 5>/dev/null
13082   $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
13083   exec 5>>config.log
13084   # Use ||, not &&, to avoid exiting from the if with $? = 1, which
13085   # would make configure fail if this is the last instruction.
13086   $ac_cs_success || { (exit 1); exit 1; }
13087 fi
13088