← Back to branch summary

~ubuntu-branches/ubuntu/karmic/insight/karmic

« back to all changes in this revision

Viewing changes to opcodes/configure

  • Committer: Bazaar Package Importer
  • Author(s): Masayuki Hatta (mhatta)
  • Date: 2007-12-04 22:37:09 UTC
  • mfrom: (1.2.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20071204223709-jxj396d1ox92s8ox
Tags: 6.7.1.dfsg.1-1
http://bugs.debian.org/314037
* New upstream release.
* This typo has been fixed in the upstream - closes: #314037.
* Removed non-free documents (GFDL'd with Invariant Sections, etc.).

Show diffs side-by-side

added added

removed removed

Lines of Context:
opcodes/configure
241
241
$as_unset CDPATH
242
242
 
243
243
 
 
244
 
 
245
# Check that we are running under the correct shell.
 
246
SHELL=${CONFIG_SHELL-/bin/sh}
 
247
 
 
248
case X$lt_ECHO in
 
249
X*--fallback-echo)
 
250
  # Remove one level of quotation (which was required for Make).
 
251
  ECHO=`echo "$lt_ECHO" | sed 's,\\\\\$\\$0,'$0','`
 
252
  ;;
 
253
esac
 
254
 
 
255
ECHO=${lt_ECHO-echo}
 
256
if test "X$1" = X--no-reexec; then
 
257
  # Discard the --no-reexec flag, and continue.
 
258
  shift
 
259
elif test "X$1" = X--fallback-echo; then
 
260
  # Avoid inline document here, it may be left over
 
261
  :
 
262
elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t' ; then
 
263
  # Yippee, $ECHO works!
 
264
  :
 
265
else
 
266
  # Restart under the correct shell.
 
267
  exec $SHELL "$0" --no-reexec ${1+"$@"}
 
268
fi
 
269
 
 
270
if test "X$1" = X--fallback-echo; then
 
271
  # used as fallback echo
 
272
  shift
 
273
  cat <<_LT_EOF
 
274
$*
 
275
_LT_EOF
 
276
  exit 0
 
277
fi
 
278
 
 
279
# The HP-UX ksh and POSIX shell print the target directory to stdout
 
280
# if CDPATH is set.
 
281
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
 
282
 
 
283
if test -z "$lt_ECHO"; then
 
284
  if test "X${echo_test_string+set}" != Xset; then
 
285
    # find a string as large as possible, as long as the shell can cope with it
 
286
    for cmd in 'sed 50q "$0"' 'sed 20q "$0"' 'sed 10q "$0"' 'sed 2q "$0"' 'echo test'; do
 
287
      # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...
 
288
      if { echo_test_string=`eval $cmd`; } 2>/dev/null &&
 
289
         { test "X$echo_test_string" = "X$echo_test_string"; } 2>/dev/null
 
290
      then
 
291
        break
 
292
      fi
 
293
    done
 
294
  fi
 
295
 
 
296
  if test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t' &&
 
297
     echo_testing_string=`{ $ECHO "$echo_test_string"; } 2>/dev/null` &&
 
298
     test "X$echo_testing_string" = "X$echo_test_string"; then
 
299
    :
 
300
  else
 
301
    # The Solaris, AIX, and Digital Unix default echo programs unquote
 
302
    # backslashes.  This makes it impossible to quote backslashes using
 
303
    #   echo "$something" | sed 's/\\/\\\\/g'
 
304
    #
 
305
    # So, first we look for a working echo in the user's PATH.
 
306
 
 
307
    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
 
308
    for dir in $PATH /usr/ucb; do
 
309
      IFS="$lt_save_ifs"
 
310
      if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&
 
311
         test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&
 
312
         echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&
 
313
         test "X$echo_testing_string" = "X$echo_test_string"; then
 
314
        ECHO="$dir/echo"
 
315
        break
 
316
      fi
 
317
    done
 
318
    IFS="$lt_save_ifs"
 
319
 
 
320
    if test "X$ECHO" = Xecho; then
 
321
      # We didn't find a better echo, so look for alternatives.
 
322
      if test "X`{ print -r '\t'; } 2>/dev/null`" = 'X\t' &&
 
323
         echo_testing_string=`{ print -r "$echo_test_string"; } 2>/dev/null` &&
 
324
         test "X$echo_testing_string" = "X$echo_test_string"; then
 
325
        # This shell has a builtin print -r that does the trick.
 
326
        ECHO='print -r'
 
327
      elif { test -f /bin/ksh || test -f /bin/ksh$ac_exeext; } &&
 
328
           test "X$CONFIG_SHELL" != X/bin/ksh; then
 
329
        # If we have ksh, try running configure again with it.
 
330
        ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
 
331
        export ORIGINAL_CONFIG_SHELL
 
332
        CONFIG_SHELL=/bin/ksh
 
333
        export CONFIG_SHELL
 
334
        exec $CONFIG_SHELL "$0" --no-reexec ${1+"$@"}
 
335
      else
 
336
        # Try using printf.
 
337
        ECHO='printf %s\n'
 
338
        if test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t' &&
 
339
           echo_testing_string=`{ $ECHO "$echo_test_string"; } 2>/dev/null` &&
 
340
           test "X$echo_testing_string" = "X$echo_test_string"; then
 
341
          # Cool, printf works
 
342
          :
 
343
        elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` &&
 
344
             test "X$echo_testing_string" = 'X\t' &&
 
345
             echo_testing_string=`($ORIGINAL_CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
 
346
             test "X$echo_testing_string" = "X$echo_test_string"; then
 
347
          CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL
 
348
          export CONFIG_SHELL
 
349
          SHELL="$CONFIG_SHELL"
 
350
          export SHELL
 
351
          ECHO="$CONFIG_SHELL $0 --fallback-echo"
 
352
        elif echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo '\t') 2>/dev/null` &&
 
353
             test "X$echo_testing_string" = 'X\t' &&
 
354
             echo_testing_string=`($CONFIG_SHELL "$0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
 
355
             test "X$echo_testing_string" = "X$echo_test_string"; then
 
356
          ECHO="$CONFIG_SHELL $0 --fallback-echo"
 
357
        else
 
358
          # maybe with a smaller string...
 
359
          prev=:
 
360
 
 
361
          for cmd in 'echo test' 'sed 2q "$0"' 'sed 10q "$0"' 'sed 20q "$0"' 'sed 50q "$0"'; do
 
362
            if { test "X$echo_test_string" = "X`eval $cmd`"; } 2>/dev/null
 
363
            then
 
364
              break
 
365
            fi
 
366
            prev="$cmd"
 
367
          done
 
368
 
 
369
          if test "$prev" != 'sed 50q "$0"'; then
 
370
            echo_test_string=`eval $prev`
 
371
            export echo_test_string
 
372
            exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "$0" ${1+"$@"}
 
373
          else
 
374
            # Oops.  We lost completely, so just stick with echo.
 
375
            ECHO=echo
 
376
          fi
 
377
        fi
 
378
      fi
 
379
    fi
 
380
  fi
 
381
fi
 
382
 
 
383
# Copy echo and quote the copy suitably for passing to libtool from
 
384
# the Makefile, instead of quoting the original, which is used later.
 
385
lt_ECHO=$ECHO
 
386
if test "X$lt_ECHO" = "X$CONFIG_SHELL $0 --fallback-echo"; then
 
387
   lt_ECHO="$CONFIG_SHELL \\\$\$0 --fallback-echo"
 
388
fi
 
389
 
 
390
 
 
391
 
 
392
 
244
393
# Name of the host.
245
394
# hostname on some systems (SVR3.2, Linux) returns a bogus exit status,
246
395
# so uname gets run too.
309
458
# include <unistd.h>
310
459
#endif"
311
460
 
312
 
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 host host_cpu host_vendor host_os target target_cpu target_vendor target_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE am__leading_dot AMTAR am__tar am__untar DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE am__fastdepCC_TRUE am__fastdepCC_FALSE AR ac_ct_AR RANLIB ac_ct_RANLIB LN_S LIBTOOL WARN_CFLAGS NO_WERROR MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT INSTALL_LIBBFD_TRUE INSTALL_LIBBFD_FALSE host_noncanonical target_noncanonical bfdlibdir bfdincludedir USE_NLS LIBINTL LIBINTL_DEP INCINTL XGETTEXT GMSGFMT POSUB CATALOGS DATADIRNAME INSTOBJEXT GENCAT CATOBJEXT MKINSTALLDIRS MSGFMT MSGMERGE CC_FOR_BUILD EXEEXT_FOR_BUILD HDEFINES CPP EGREP CGEN_MAINT_TRUE CGEN_MAINT_FALSE cgendir WIN32LDFLAGS WIN32LIBADD archdefs BFD_MACHINES LIBOBJS LTLIBOBJS'
 
461
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 host host_cpu host_vendor host_os target target_cpu target_vendor target_os CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE am__leading_dot AMTAR am__tar am__untar DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE am__fastdepCC_TRUE am__fastdepCC_FALSE AR ac_ct_AR RANLIB ac_ct_RANLIB LIBTOOL SED EGREP FGREP GREP LD DUMPBIN ac_ct_DUMPBIN NM LN_S lt_ECHO CPP WARN_CFLAGS NO_WERROR MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT INSTALL_LIBBFD_TRUE INSTALL_LIBBFD_FALSE host_noncanonical target_noncanonical bfdlibdir bfdincludedir USE_NLS LIBINTL LIBINTL_DEP INCINTL XGETTEXT GMSGFMT POSUB CATALOGS DATADIRNAME INSTOBJEXT GENCAT CATOBJEXT MKINSTALLDIRS MSGFMT MSGMERGE CC_FOR_BUILD EXEEXT_FOR_BUILD HDEFINES CGEN_MAINT_TRUE CGEN_MAINT_FALSE cgendir WIN32LDFLAGS WIN32LIBADD archdefs BFD_MACHINES LIBOBJS LTLIBOBJS'
313
462
ac_subst_files=''
314
463
 
315
464
# Initialize some variables set by options.
852
1001
  --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
853
1002
  --disable-dependency-tracking  speeds up one-time build
854
1003
  --enable-dependency-tracking   do not reject slow dependency extractors
855
 
  --enable-shared=PKGS  build shared libraries default=no
856
 
  --enable-static=PKGS  build static libraries default=yes
857
 
  --enable-fast-install=PKGS  optimize for fast installation default=yes
 
1004
  --enable-shared[=PKGS]
 
1005
                          build shared libraries [default=no]
 
1006
  --enable-static[=PKGS]
 
1007
                          build static libraries [default=yes]
 
1008
  --enable-fast-install[=PKGS]
 
1009
                          optimize for fast installation [default=yes]
858
1010
  --disable-libtool-lock  avoid locking (might break parallel builds)
859
1011
  --enable-targets        alternative target configurations
860
1012
  --enable-commonbfdlib   build shared BFD/opcodes/libiberty library
869
1021
Optional Packages:
870
1022
  --with-PACKAGE[=ARG]    use PACKAGE [ARG=yes]
871
1023
  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
872
 
  --with-gnu-ld           assume the C compiler uses GNU ld default=no
873
 
  --with-pic              try to use only PIC/non-PIC objects default=use both
 
1024
  --with-pic              try to use only PIC/non-PIC objects [default=use
 
1025
                          both]
 
1026
  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]
874
1027
 
875
1028
Some influential environment variables:
876
1029
  CC          C compiler command
3078
3231
 
3079
3232
 
3080
3233
 
 
3234
ac_ext=c
 
3235
ac_cpp='$CPP $CPPFLAGS'
 
3236
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3237
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3238
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
3239
if test -n "$ac_tool_prefix"; then
 
3240
  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
 
3241
set dummy ${ac_tool_prefix}gcc; ac_word=$2
 
3242
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
3243
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
3244
if test "${ac_cv_prog_CC+set}" = set; then
 
3245
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3246
else
 
3247
  if test -n "$CC"; then
 
3248
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
3249
else
 
3250
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3251
for as_dir in $PATH
 
3252
do
 
3253
  IFS=$as_save_IFS
 
3254
  test -z "$as_dir" && as_dir=.
 
3255
  for ac_exec_ext in '' $ac_executable_extensions; do
 
3256
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
3257
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
 
3258
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
3259
    break 2
 
3260
  fi
 
3261
done
 
3262
done
 
3263
 
 
3264
fi
 
3265
fi
 
3266
CC=$ac_cv_prog_CC
 
3267
if test -n "$CC"; then
 
3268
  echo "$as_me:$LINENO: result: $CC" >&5
 
3269
echo "${ECHO_T}$CC" >&6
 
3270
else
 
3271
  echo "$as_me:$LINENO: result: no" >&5
 
3272
echo "${ECHO_T}no" >&6
 
3273
fi
 
3274
 
 
3275
fi
 
3276
if test -z "$ac_cv_prog_CC"; then
 
3277
  ac_ct_CC=$CC
 
3278
  # Extract the first word of "gcc", so it can be a program name with args.
 
3279
set dummy gcc; ac_word=$2
 
3280
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
3281
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
3282
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
 
3283
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3284
else
 
3285
  if test -n "$ac_ct_CC"; then
 
3286
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 
3287
else
 
3288
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3289
for as_dir in $PATH
 
3290
do
 
3291
  IFS=$as_save_IFS
 
3292
  test -z "$as_dir" && as_dir=.
 
3293
  for ac_exec_ext in '' $ac_executable_extensions; do
 
3294
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
3295
    ac_cv_prog_ac_ct_CC="gcc"
 
3296
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
3297
    break 2
 
3298
  fi
 
3299
done
 
3300
done
 
3301
 
 
3302
fi
 
3303
fi
 
3304
ac_ct_CC=$ac_cv_prog_ac_ct_CC
 
3305
if test -n "$ac_ct_CC"; then
 
3306
  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
 
3307
echo "${ECHO_T}$ac_ct_CC" >&6
 
3308
else
 
3309
  echo "$as_me:$LINENO: result: no" >&5
 
3310
echo "${ECHO_T}no" >&6
 
3311
fi
 
3312
 
 
3313
  CC=$ac_ct_CC
 
3314
else
 
3315
  CC="$ac_cv_prog_CC"
 
3316
fi
 
3317
 
 
3318
if test -z "$CC"; then
 
3319
  if test -n "$ac_tool_prefix"; then
 
3320
  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
 
3321
set dummy ${ac_tool_prefix}cc; ac_word=$2
 
3322
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
3323
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
3324
if test "${ac_cv_prog_CC+set}" = set; then
 
3325
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3326
else
 
3327
  if test -n "$CC"; then
 
3328
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
3329
else
 
3330
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3331
for as_dir in $PATH
 
3332
do
 
3333
  IFS=$as_save_IFS
 
3334
  test -z "$as_dir" && as_dir=.
 
3335
  for ac_exec_ext in '' $ac_executable_extensions; do
 
3336
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
3337
    ac_cv_prog_CC="${ac_tool_prefix}cc"
 
3338
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
3339
    break 2
 
3340
  fi
 
3341
done
 
3342
done
 
3343
 
 
3344
fi
 
3345
fi
 
3346
CC=$ac_cv_prog_CC
 
3347
if test -n "$CC"; then
 
3348
  echo "$as_me:$LINENO: result: $CC" >&5
 
3349
echo "${ECHO_T}$CC" >&6
 
3350
else
 
3351
  echo "$as_me:$LINENO: result: no" >&5
 
3352
echo "${ECHO_T}no" >&6
 
3353
fi
 
3354
 
 
3355
fi
 
3356
if test -z "$ac_cv_prog_CC"; then
 
3357
  ac_ct_CC=$CC
 
3358
  # Extract the first word of "cc", so it can be a program name with args.
 
3359
set dummy cc; ac_word=$2
 
3360
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
3361
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
3362
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
 
3363
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3364
else
 
3365
  if test -n "$ac_ct_CC"; then
 
3366
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 
3367
else
 
3368
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3369
for as_dir in $PATH
 
3370
do
 
3371
  IFS=$as_save_IFS
 
3372
  test -z "$as_dir" && as_dir=.
 
3373
  for ac_exec_ext in '' $ac_executable_extensions; do
 
3374
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
3375
    ac_cv_prog_ac_ct_CC="cc"
 
3376
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
3377
    break 2
 
3378
  fi
 
3379
done
 
3380
done
 
3381
 
 
3382
fi
 
3383
fi
 
3384
ac_ct_CC=$ac_cv_prog_ac_ct_CC
 
3385
if test -n "$ac_ct_CC"; then
 
3386
  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
 
3387
echo "${ECHO_T}$ac_ct_CC" >&6
 
3388
else
 
3389
  echo "$as_me:$LINENO: result: no" >&5
 
3390
echo "${ECHO_T}no" >&6
 
3391
fi
 
3392
 
 
3393
  CC=$ac_ct_CC
 
3394
else
 
3395
  CC="$ac_cv_prog_CC"
 
3396
fi
 
3397
 
 
3398
fi
 
3399
if test -z "$CC"; then
 
3400
  # Extract the first word of "cc", so it can be a program name with args.
 
3401
set dummy cc; ac_word=$2
 
3402
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
3403
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
3404
if test "${ac_cv_prog_CC+set}" = set; then
 
3405
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3406
else
 
3407
  if test -n "$CC"; then
 
3408
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
3409
else
 
3410
  ac_prog_rejected=no
 
3411
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3412
for as_dir in $PATH
 
3413
do
 
3414
  IFS=$as_save_IFS
 
3415
  test -z "$as_dir" && as_dir=.
 
3416
  for ac_exec_ext in '' $ac_executable_extensions; do
 
3417
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
3418
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
 
3419
       ac_prog_rejected=yes
 
3420
       continue
 
3421
     fi
 
3422
    ac_cv_prog_CC="cc"
 
3423
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
3424
    break 2
 
3425
  fi
 
3426
done
 
3427
done
 
3428
 
 
3429
if test $ac_prog_rejected = yes; then
 
3430
  # We found a bogon in the path, so make sure we never use it.
 
3431
  set dummy $ac_cv_prog_CC
 
3432
  shift
 
3433
  if test $# != 0; then
 
3434
    # We chose a different compiler from the bogus one.
 
3435
    # However, it has the same basename, so the bogon will be chosen
 
3436
    # first if we set CC to just the basename; use the full file name.
 
3437
    shift
 
3438
    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
 
3439
  fi
 
3440
fi
 
3441
fi
 
3442
fi
 
3443
CC=$ac_cv_prog_CC
 
3444
if test -n "$CC"; then
 
3445
  echo "$as_me:$LINENO: result: $CC" >&5
 
3446
echo "${ECHO_T}$CC" >&6
 
3447
else
 
3448
  echo "$as_me:$LINENO: result: no" >&5
 
3449
echo "${ECHO_T}no" >&6
 
3450
fi
 
3451
 
 
3452
fi
 
3453
if test -z "$CC"; then
 
3454
  if test -n "$ac_tool_prefix"; then
 
3455
  for ac_prog in cl
 
3456
  do
 
3457
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
 
3458
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
 
3459
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
3460
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
3461
if test "${ac_cv_prog_CC+set}" = set; then
 
3462
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3463
else
 
3464
  if test -n "$CC"; then
 
3465
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
3466
else
 
3467
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3468
for as_dir in $PATH
 
3469
do
 
3470
  IFS=$as_save_IFS
 
3471
  test -z "$as_dir" && as_dir=.
 
3472
  for ac_exec_ext in '' $ac_executable_extensions; do
 
3473
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
3474
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
 
3475
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
3476
    break 2
 
3477
  fi
 
3478
done
 
3479
done
 
3480
 
 
3481
fi
 
3482
fi
 
3483
CC=$ac_cv_prog_CC
 
3484
if test -n "$CC"; then
 
3485
  echo "$as_me:$LINENO: result: $CC" >&5
 
3486
echo "${ECHO_T}$CC" >&6
 
3487
else
 
3488
  echo "$as_me:$LINENO: result: no" >&5
 
3489
echo "${ECHO_T}no" >&6
 
3490
fi
 
3491
 
 
3492
    test -n "$CC" && break
 
3493
  done
 
3494
fi
 
3495
if test -z "$CC"; then
 
3496
  ac_ct_CC=$CC
 
3497
  for ac_prog in cl
 
3498
do
 
3499
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
3500
set dummy $ac_prog; ac_word=$2
 
3501
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
3502
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
3503
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
 
3504
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3505
else
 
3506
  if test -n "$ac_ct_CC"; then
 
3507
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 
3508
else
 
3509
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
3510
for as_dir in $PATH
 
3511
do
 
3512
  IFS=$as_save_IFS
 
3513
  test -z "$as_dir" && as_dir=.
 
3514
  for ac_exec_ext in '' $ac_executable_extensions; do
 
3515
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
3516
    ac_cv_prog_ac_ct_CC="$ac_prog"
 
3517
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
3518
    break 2
 
3519
  fi
 
3520
done
 
3521
done
 
3522
 
 
3523
fi
 
3524
fi
 
3525
ac_ct_CC=$ac_cv_prog_ac_ct_CC
 
3526
if test -n "$ac_ct_CC"; then
 
3527
  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
 
3528
echo "${ECHO_T}$ac_ct_CC" >&6
 
3529
else
 
3530
  echo "$as_me:$LINENO: result: no" >&5
 
3531
echo "${ECHO_T}no" >&6
 
3532
fi
 
3533
 
 
3534
  test -n "$ac_ct_CC" && break
 
3535
done
 
3536
 
 
3537
  CC=$ac_ct_CC
 
3538
fi
 
3539
 
 
3540
fi
 
3541
 
 
3542
 
 
3543
test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
 
3544
See \`config.log' for more details." >&5
 
3545
echo "$as_me: error: no acceptable C compiler found in \$PATH
 
3546
See \`config.log' for more details." >&2;}
 
3547
   { (exit 1); exit 1; }; }
 
3548
 
 
3549
# Provide some information about the compiler.
 
3550
echo "$as_me:$LINENO:" \
 
3551
     "checking for C compiler version" >&5
 
3552
ac_compiler=`set X $ac_compile; echo $2`
 
3553
{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
 
3554
  (eval $ac_compiler --version </dev/null >&5) 2>&5
 
3555
  ac_status=$?
 
3556
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3557
  (exit $ac_status); }
 
3558
{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
 
3559
  (eval $ac_compiler -v </dev/null >&5) 2>&5
 
3560
  ac_status=$?
 
3561
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3562
  (exit $ac_status); }
 
3563
{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
 
3564
  (eval $ac_compiler -V </dev/null >&5) 2>&5
 
3565
  ac_status=$?
 
3566
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3567
  (exit $ac_status); }
 
3568
 
 
3569
echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
 
3570
echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
 
3571
if test "${ac_cv_c_compiler_gnu+set}" = set; then
 
3572
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3573
else
 
3574
  cat >conftest.$ac_ext <<_ACEOF
 
3575
/* confdefs.h.  */
 
3576
_ACEOF
 
3577
cat confdefs.h >>conftest.$ac_ext
 
3578
cat >>conftest.$ac_ext <<_ACEOF
 
3579
/* end confdefs.h.  */
 
3580
 
 
3581
int
 
3582
main ()
 
3583
{
 
3584
#ifndef __GNUC__
 
3585
       choke me
 
3586
#endif
 
3587
 
 
3588
  ;
 
3589
  return 0;
 
3590
}
 
3591
_ACEOF
 
3592
rm -f conftest.$ac_objext
 
3593
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
3594
  (eval $ac_compile) 2>conftest.er1
 
3595
  ac_status=$?
 
3596
  grep -v '^ *+' conftest.er1 >conftest.err
 
3597
  rm -f conftest.er1
 
3598
  cat conftest.err >&5
 
3599
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3600
  (exit $ac_status); } &&
 
3601
         { ac_try='test -z "$ac_c_werror_flag"
 
3602
                         || test ! -s conftest.err'
 
3603
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
3604
  (eval $ac_try) 2>&5
 
3605
  ac_status=$?
 
3606
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3607
  (exit $ac_status); }; } &&
 
3608
         { ac_try='test -s conftest.$ac_objext'
 
3609
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
3610
  (eval $ac_try) 2>&5
 
3611
  ac_status=$?
 
3612
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3613
  (exit $ac_status); }; }; then
 
3614
  ac_compiler_gnu=yes
 
3615
else
 
3616
  echo "$as_me: failed program was:" >&5
 
3617
sed 's/^/| /' conftest.$ac_ext >&5
 
3618
 
 
3619
ac_compiler_gnu=no
 
3620
fi
 
3621
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
 
3622
ac_cv_c_compiler_gnu=$ac_compiler_gnu
 
3623
 
 
3624
fi
 
3625
echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
 
3626
echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
 
3627
GCC=`test $ac_compiler_gnu = yes && echo yes`
 
3628
ac_test_CFLAGS=${CFLAGS+set}
 
3629
ac_save_CFLAGS=$CFLAGS
 
3630
CFLAGS="-g"
 
3631
echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
 
3632
echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
 
3633
if test "${ac_cv_prog_cc_g+set}" = set; then
 
3634
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3635
else
 
3636
  cat >conftest.$ac_ext <<_ACEOF
 
3637
/* confdefs.h.  */
 
3638
_ACEOF
 
3639
cat confdefs.h >>conftest.$ac_ext
 
3640
cat >>conftest.$ac_ext <<_ACEOF
 
3641
/* end confdefs.h.  */
 
3642
 
 
3643
int
 
3644
main ()
 
3645
{
 
3646
 
 
3647
  ;
 
3648
  return 0;
 
3649
}
 
3650
_ACEOF
 
3651
rm -f conftest.$ac_objext
 
3652
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
3653
  (eval $ac_compile) 2>conftest.er1
 
3654
  ac_status=$?
 
3655
  grep -v '^ *+' conftest.er1 >conftest.err
 
3656
  rm -f conftest.er1
 
3657
  cat conftest.err >&5
 
3658
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3659
  (exit $ac_status); } &&
 
3660
         { ac_try='test -z "$ac_c_werror_flag"
 
3661
                         || test ! -s conftest.err'
 
3662
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
3663
  (eval $ac_try) 2>&5
 
3664
  ac_status=$?
 
3665
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3666
  (exit $ac_status); }; } &&
 
3667
         { ac_try='test -s conftest.$ac_objext'
 
3668
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
3669
  (eval $ac_try) 2>&5
 
3670
  ac_status=$?
 
3671
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3672
  (exit $ac_status); }; }; then
 
3673
  ac_cv_prog_cc_g=yes
 
3674
else
 
3675
  echo "$as_me: failed program was:" >&5
 
3676
sed 's/^/| /' conftest.$ac_ext >&5
 
3677
 
 
3678
ac_cv_prog_cc_g=no
 
3679
fi
 
3680
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
 
3681
fi
 
3682
echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
 
3683
echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
 
3684
if test "$ac_test_CFLAGS" = set; then
 
3685
  CFLAGS=$ac_save_CFLAGS
 
3686
elif test $ac_cv_prog_cc_g = yes; then
 
3687
  if test "$GCC" = yes; then
 
3688
    CFLAGS="-g -O2"
 
3689
  else
 
3690
    CFLAGS="-g"
 
3691
  fi
 
3692
else
 
3693
  if test "$GCC" = yes; then
 
3694
    CFLAGS="-O2"
 
3695
  else
 
3696
    CFLAGS=
 
3697
  fi
 
3698
fi
 
3699
echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
 
3700
echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
 
3701
if test "${ac_cv_prog_cc_stdc+set}" = set; then
 
3702
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
3703
else
 
3704
  ac_cv_prog_cc_stdc=no
 
3705
ac_save_CC=$CC
 
3706
cat >conftest.$ac_ext <<_ACEOF
 
3707
/* confdefs.h.  */
 
3708
_ACEOF
 
3709
cat confdefs.h >>conftest.$ac_ext
 
3710
cat >>conftest.$ac_ext <<_ACEOF
 
3711
/* end confdefs.h.  */
 
3712
#include <stdarg.h>
 
3713
#include <stdio.h>
 
3714
#include <sys/types.h>
 
3715
#include <sys/stat.h>
 
3716
/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
 
3717
struct buf { int x; };
 
3718
FILE * (*rcsopen) (struct buf *, struct stat *, int);
 
3719
static char *e (p, i)
 
3720
     char **p;
 
3721
     int i;
 
3722
{
 
3723
  return p[i];
 
3724
}
 
3725
static char *f (char * (*g) (char **, int), char **p, ...)
 
3726
{
 
3727
  char *s;
 
3728
  va_list v;
 
3729
  va_start (v,p);
 
3730
  s = g (p, va_arg (v,int));
 
3731
  va_end (v);
 
3732
  return s;
 
3733
}
 
3734
 
 
3735
/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
 
3736
   function prototypes and stuff, but not '\xHH' hex character constants.
 
3737
   These don't provoke an error unfortunately, instead are silently treated
 
3738
   as 'x'.  The following induces an error, until -std1 is added to get
 
3739
   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
 
3740
   array size at least.  It's necessary to write '\x00'==0 to get something
 
3741
   that's true only with -std1.  */
 
3742
int osf4_cc_array ['\x00' == 0 ? 1 : -1];
 
3743
 
 
3744
int test (int i, double x);
 
3745
struct s1 {int (*f) (int a);};
 
3746
struct s2 {int (*f) (double a);};
 
3747
int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
 
3748
int argc;
 
3749
char **argv;
 
3750
int
 
3751
main ()
 
3752
{
 
3753
return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
 
3754
  ;
 
3755
  return 0;
 
3756
}
 
3757
_ACEOF
 
3758
# Don't try gcc -ansi; that turns off useful extensions and
 
3759
# breaks some systems' header files.
 
3760
# AIX                   -qlanglvl=ansi
 
3761
# Ultrix and OSF/1      -std1
 
3762
# HP-UX 10.20 and later -Ae
 
3763
# HP-UX older versions  -Aa -D_HPUX_SOURCE
 
3764
# SVR4                  -Xc -D__EXTENSIONS__
 
3765
for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
 
3766
do
 
3767
  CC="$ac_save_CC $ac_arg"
 
3768
  rm -f conftest.$ac_objext
 
3769
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
3770
  (eval $ac_compile) 2>conftest.er1
 
3771
  ac_status=$?
 
3772
  grep -v '^ *+' conftest.er1 >conftest.err
 
3773
  rm -f conftest.er1
 
3774
  cat conftest.err >&5
 
3775
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3776
  (exit $ac_status); } &&
 
3777
         { ac_try='test -z "$ac_c_werror_flag"
 
3778
                         || test ! -s conftest.err'
 
3779
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
3780
  (eval $ac_try) 2>&5
 
3781
  ac_status=$?
 
3782
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3783
  (exit $ac_status); }; } &&
 
3784
         { ac_try='test -s conftest.$ac_objext'
 
3785
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
3786
  (eval $ac_try) 2>&5
 
3787
  ac_status=$?
 
3788
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3789
  (exit $ac_status); }; }; then
 
3790
  ac_cv_prog_cc_stdc=$ac_arg
 
3791
break
 
3792
else
 
3793
  echo "$as_me: failed program was:" >&5
 
3794
sed 's/^/| /' conftest.$ac_ext >&5
 
3795
 
 
3796
fi
 
3797
rm -f conftest.err conftest.$ac_objext
 
3798
done
 
3799
rm -f conftest.$ac_ext conftest.$ac_objext
 
3800
CC=$ac_save_CC
 
3801
 
 
3802
fi
 
3803
 
 
3804
case "x$ac_cv_prog_cc_stdc" in
 
3805
  x|xno)
 
3806
    echo "$as_me:$LINENO: result: none needed" >&5
 
3807
echo "${ECHO_T}none needed" >&6 ;;
 
3808
  *)
 
3809
    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
 
3810
echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
 
3811
    CC="$CC $ac_cv_prog_cc_stdc" ;;
 
3812
esac
 
3813
 
 
3814
# Some people use a C++ compiler to compile C.  Since we use `exit',
 
3815
# in C++ we need to declare it.  In case someone uses the same compiler
 
3816
# for both compiling C and C++ we need to have the C++ compiler decide
 
3817
# the declaration of exit, since it's the most demanding environment.
 
3818
cat >conftest.$ac_ext <<_ACEOF
 
3819
#ifndef __cplusplus
 
3820
  choke me
 
3821
#endif
 
3822
_ACEOF
 
3823
rm -f conftest.$ac_objext
 
3824
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
3825
  (eval $ac_compile) 2>conftest.er1
 
3826
  ac_status=$?
 
3827
  grep -v '^ *+' conftest.er1 >conftest.err
 
3828
  rm -f conftest.er1
 
3829
  cat conftest.err >&5
 
3830
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3831
  (exit $ac_status); } &&
 
3832
         { ac_try='test -z "$ac_c_werror_flag"
 
3833
                         || test ! -s conftest.err'
 
3834
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
3835
  (eval $ac_try) 2>&5
 
3836
  ac_status=$?
 
3837
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3838
  (exit $ac_status); }; } &&
 
3839
         { ac_try='test -s conftest.$ac_objext'
 
3840
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
3841
  (eval $ac_try) 2>&5
 
3842
  ac_status=$?
 
3843
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3844
  (exit $ac_status); }; }; then
 
3845
  for ac_declaration in \
 
3846
   '' \
 
3847
   'extern "C" void std::exit (int) throw (); using std::exit;' \
 
3848
   'extern "C" void std::exit (int); using std::exit;' \
 
3849
   'extern "C" void exit (int) throw ();' \
 
3850
   'extern "C" void exit (int);' \
 
3851
   'void exit (int);'
 
3852
do
 
3853
  cat >conftest.$ac_ext <<_ACEOF
 
3854
/* confdefs.h.  */
 
3855
_ACEOF
 
3856
cat confdefs.h >>conftest.$ac_ext
 
3857
cat >>conftest.$ac_ext <<_ACEOF
 
3858
/* end confdefs.h.  */
 
3859
$ac_declaration
 
3860
#include <stdlib.h>
 
3861
int
 
3862
main ()
 
3863
{
 
3864
exit (42);
 
3865
  ;
 
3866
  return 0;
 
3867
}
 
3868
_ACEOF
 
3869
rm -f conftest.$ac_objext
 
3870
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
3871
  (eval $ac_compile) 2>conftest.er1
 
3872
  ac_status=$?
 
3873
  grep -v '^ *+' conftest.er1 >conftest.err
 
3874
  rm -f conftest.er1
 
3875
  cat conftest.err >&5
 
3876
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3877
  (exit $ac_status); } &&
 
3878
         { ac_try='test -z "$ac_c_werror_flag"
 
3879
                         || test ! -s conftest.err'
 
3880
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
3881
  (eval $ac_try) 2>&5
 
3882
  ac_status=$?
 
3883
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3884
  (exit $ac_status); }; } &&
 
3885
         { ac_try='test -s conftest.$ac_objext'
 
3886
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
3887
  (eval $ac_try) 2>&5
 
3888
  ac_status=$?
 
3889
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3890
  (exit $ac_status); }; }; then
 
3891
  :
 
3892
else
 
3893
  echo "$as_me: failed program was:" >&5
 
3894
sed 's/^/| /' conftest.$ac_ext >&5
 
3895
 
 
3896
continue
 
3897
fi
 
3898
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
 
3899
  cat >conftest.$ac_ext <<_ACEOF
 
3900
/* confdefs.h.  */
 
3901
_ACEOF
 
3902
cat confdefs.h >>conftest.$ac_ext
 
3903
cat >>conftest.$ac_ext <<_ACEOF
 
3904
/* end confdefs.h.  */
 
3905
$ac_declaration
 
3906
int
 
3907
main ()
 
3908
{
 
3909
exit (42);
 
3910
  ;
 
3911
  return 0;
 
3912
}
 
3913
_ACEOF
 
3914
rm -f conftest.$ac_objext
 
3915
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
3916
  (eval $ac_compile) 2>conftest.er1
 
3917
  ac_status=$?
 
3918
  grep -v '^ *+' conftest.er1 >conftest.err
 
3919
  rm -f conftest.er1
 
3920
  cat conftest.err >&5
 
3921
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3922
  (exit $ac_status); } &&
 
3923
         { ac_try='test -z "$ac_c_werror_flag"
 
3924
                         || test ! -s conftest.err'
 
3925
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
3926
  (eval $ac_try) 2>&5
 
3927
  ac_status=$?
 
3928
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3929
  (exit $ac_status); }; } &&
 
3930
         { ac_try='test -s conftest.$ac_objext'
 
3931
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
3932
  (eval $ac_try) 2>&5
 
3933
  ac_status=$?
 
3934
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
3935
  (exit $ac_status); }; }; then
 
3936
  break
 
3937
else
 
3938
  echo "$as_me: failed program was:" >&5
 
3939
sed 's/^/| /' conftest.$ac_ext >&5
 
3940
 
 
3941
fi
 
3942
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
 
3943
done
 
3944
rm -f conftest*
 
3945
if test -n "$ac_declaration"; then
 
3946
  echo '#ifdef __cplusplus' >>confdefs.h
 
3947
  echo $ac_declaration      >>confdefs.h
 
3948
  echo '#endif'             >>confdefs.h
 
3949
fi
 
3950
 
 
3951
else
 
3952
  echo "$as_me: failed program was:" >&5
 
3953
sed 's/^/| /' conftest.$ac_ext >&5
 
3954
 
 
3955
fi
 
3956
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
 
3957
ac_ext=c
 
3958
ac_cpp='$CPP $CPPFLAGS'
 
3959
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
3960
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
3961
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
3962
 
 
3963
 
 
3964
cat >>confdefs.h <<\_ACEOF
 
3965
#define _GNU_SOURCE 1
 
3966
_ACEOF
 
3967
 
 
3968
 
 
3969
 
3081
3970
if test -n "$ac_tool_prefix"; then
3082
3971
  # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
3083
3972
set dummy ${ac_tool_prefix}ar; ac_word=$2
3242
4131
if test "${enable_shared+set}" = set; then
3243
4132
  enableval="$enable_shared"
3244
4133
  p=${PACKAGE-default}
3245
 
case $enableval in
3246
 
yes) enable_shared=yes ;;
3247
 
no) enable_shared=no ;;
3248
 
*)
3249
 
  enable_shared=no
3250
 
  # Look at the argument we got.  We use all the common list separators.
3251
 
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3252
 
  for pkg in $enableval; do
3253
 
    if test "X$pkg" = "X$p"; then
3254
 
      enable_shared=yes
3255
 
    fi
3256
 
  done
3257
 
  IFS="$ac_save_ifs"
3258
 
  ;;
3259
 
esac
 
4134
    case $enableval in
 
4135
    yes) enable_shared=yes ;;
 
4136
    no) enable_shared=no ;;
 
4137
    *)
 
4138
      enable_shared=no
 
4139
      # Look at the argument we got.  We use all the common list separators.
 
4140
      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
 
4141
      for pkg in $enableval; do
 
4142
        IFS="$lt_save_ifs"
 
4143
        if test "X$pkg" = "X$p"; then
 
4144
          enable_shared=yes
 
4145
        fi
 
4146
      done
 
4147
      IFS="$lt_save_ifs"
 
4148
      ;;
 
4149
    esac
3260
4150
else
3261
4151
  enable_shared=no
3262
4152
fi;
3263
4153
 
 
4154
 
 
4155
 
 
4156
 
 
4157
 
 
4158
 
 
4159
 
 
4160
 
 
4161
 
 
4162
 
 
4163
 
 
4164
macro_version='2.1a'
 
4165
macro_revision='1.2435'
 
4166
 
 
4167
 
 
4168
 
 
4169
 
 
4170
 
 
4171
 
 
4172
 
 
4173
 
 
4174
 
 
4175
 
 
4176
 
 
4177
 
 
4178
ltmain="$ac_aux_dir/ltmain.sh"
 
4179
 
 
4180
# Set options
 
4181
 
 
4182
enable_dlopen=no
 
4183
 
 
4184
 
 
4185
enable_win32_dll=no
 
4186
 
 
4187
 
 
4188
 
3264
4189
# Check whether --enable-static or --disable-static was given.
3265
4190
if test "${enable_static+set}" = set; then
3266
4191
  enableval="$enable_static"
3267
4192
  p=${PACKAGE-default}
3268
 
case $enableval in
3269
 
yes) enable_static=yes ;;
3270
 
no) enable_static=no ;;
3271
 
*)
3272
 
  enable_static=no
3273
 
  # Look at the argument we got.  We use all the common list separators.
3274
 
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3275
 
  for pkg in $enableval; do
3276
 
    if test "X$pkg" = "X$p"; then
3277
 
      enable_static=yes
3278
 
    fi
3279
 
  done
3280
 
  IFS="$ac_save_ifs"
3281
 
  ;;
3282
 
esac
 
4193
    case $enableval in
 
4194
    yes) enable_static=yes ;;
 
4195
    no) enable_static=no ;;
 
4196
    *)
 
4197
     enable_static=no
 
4198
      # Look at the argument we got.  We use all the common list separators.
 
4199
      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
 
4200
      for pkg in $enableval; do
 
4201
        IFS="$lt_save_ifs"
 
4202
        if test "X$pkg" = "X$p"; then
 
4203
          enable_static=yes
 
4204
        fi
 
4205
      done
 
4206
      IFS="$lt_save_ifs"
 
4207
      ;;
 
4208
    esac
3283
4209
else
3284
4210
  enable_static=yes
3285
4211
fi;
 
4212
 
 
4213
 
 
4214
 
 
4215
 
 
4216
 
 
4217
 
 
4218
 
 
4219
 
 
4220
 
 
4221
# Check whether --with-pic or --without-pic was given.
 
4222
if test "${with_pic+set}" = set; then
 
4223
  withval="$with_pic"
 
4224
  pic_mode="$withval"
 
4225
else
 
4226
  pic_mode=default
 
4227
fi;
 
4228
 
 
4229
test -z "$pic_mode" && pic_mode=default
 
4230
 
 
4231
 
 
4232
 
 
4233
 
 
4234
 
 
4235
 
 
4236
 
3286
4237
# Check whether --enable-fast-install or --disable-fast-install was given.
3287
4238
if test "${enable_fast_install+set}" = set; then
3288
4239
  enableval="$enable_fast_install"
3289
4240
  p=${PACKAGE-default}
3290
 
case $enableval in
3291
 
yes) enable_fast_install=yes ;;
3292
 
no) enable_fast_install=no ;;
3293
 
*)
3294
 
  enable_fast_install=no
3295
 
  # Look at the argument we got.  We use all the common list separators.
3296
 
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}:,"
3297
 
  for pkg in $enableval; do
3298
 
    if test "X$pkg" = "X$p"; then
3299
 
      enable_fast_install=yes
3300
 
    fi
3301
 
  done
3302
 
  IFS="$ac_save_ifs"
3303
 
  ;;
3304
 
esac
 
4241
    case $enableval in
 
4242
    yes) enable_fast_install=yes ;;
 
4243
    no) enable_fast_install=no ;;
 
4244
    *)
 
4245
      enable_fast_install=no
 
4246
      # Look at the argument we got.  We use all the common list separators.
 
4247
      lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
 
4248
      for pkg in $enableval; do
 
4249
        IFS="$lt_save_ifs"
 
4250
        if test "X$pkg" = "X$p"; then
 
4251
          enable_fast_install=yes
 
4252
        fi
 
4253
      done
 
4254
      IFS="$lt_save_ifs"
 
4255
      ;;
 
4256
    esac
3305
4257
else
3306
4258
  enable_fast_install=yes
3307
4259
fi;
3308
4260
 
 
4261
 
 
4262
 
 
4263
 
 
4264
 
 
4265
 
 
4266
 
 
4267
 
 
4268
echo "$as_me:$LINENO: checking for a sed that does not truncate output" >&5
 
4269
echo $ECHO_N "checking for a sed that does not truncate output... $ECHO_C" >&6
 
4270
if test "${lt_cv_path_SED+set}" = set; then
 
4271
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4272
else
 
4273
  # Loop through the user's path and test for sed and gsed.
 
4274
# Then use that list of sed's as ones to test for truncation.
 
4275
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4276
for as_dir in $PATH
 
4277
do
 
4278
  IFS=$as_save_IFS
 
4279
  test -z "$as_dir" && as_dir=.
 
4280
  for lt_ac_prog in sed gsed; do
 
4281
    for ac_exec_ext in '' $ac_executable_extensions; do
 
4282
      if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then
 
4283
        lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext"
 
4284
      fi
 
4285
    done
 
4286
  done
 
4287
done
 
4288
IFS=$as_save_IFS
 
4289
lt_ac_max=0
 
4290
lt_ac_count=0
 
4291
# Add /usr/xpg4/bin/sed as it is typically found on Solaris
 
4292
# along with /bin/sed that truncates output.
 
4293
for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do
 
4294
  test ! -f $lt_ac_sed && continue
 
4295
  cat /dev/null > conftest.in
 
4296
  lt_ac_count=0
 
4297
  echo $ECHO_N "0123456789$ECHO_C" >conftest.in
 
4298
  # Check for GNU sed and select it if it is found.
 
4299
  if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then
 
4300
    lt_cv_path_SED=$lt_ac_sed
 
4301
    break
 
4302
  fi
 
4303
  while true; do
 
4304
    cat conftest.in conftest.in >conftest.tmp
 
4305
    mv conftest.tmp conftest.in
 
4306
    cp conftest.in conftest.nl
 
4307
    echo >>conftest.nl
 
4308
    $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break
 
4309
    cmp -s conftest.out conftest.nl || break
 
4310
    # 10000 chars as input seems more than enough
 
4311
    test $lt_ac_count -gt 10 && break
 
4312
    lt_ac_count=`expr $lt_ac_count + 1`
 
4313
    if test $lt_ac_count -gt $lt_ac_max; then
 
4314
      lt_ac_max=$lt_ac_count
 
4315
      lt_cv_path_SED=$lt_ac_sed
 
4316
    fi
 
4317
  done
 
4318
done
 
4319
 
 
4320
fi
 
4321
 
 
4322
SED=$lt_cv_path_SED
 
4323
 
 
4324
echo "$as_me:$LINENO: result: $SED" >&5
 
4325
echo "${ECHO_T}$SED" >&6
 
4326
 
 
4327
test -z "$SED" && SED=sed
 
4328
Xsed="$SED -e 1s/^X//"
 
4329
 
 
4330
 
 
4331
 
 
4332
 
 
4333
 
 
4334
 
 
4335
 
 
4336
 
 
4337
 
 
4338
 
 
4339
 
 
4340
echo "$as_me:$LINENO: checking for egrep" >&5
 
4341
echo $ECHO_N "checking for egrep... $ECHO_C" >&6
 
4342
if test "${ac_cv_prog_egrep+set}" = set; then
 
4343
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4344
else
 
4345
  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
 
4346
    then ac_cv_prog_egrep='grep -E'
 
4347
    else ac_cv_prog_egrep='egrep'
 
4348
    fi
 
4349
fi
 
4350
echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
 
4351
echo "${ECHO_T}$ac_cv_prog_egrep" >&6
 
4352
 EGREP=$ac_cv_prog_egrep
 
4353
 
 
4354
 
 
4355
echo "$as_me:$LINENO: checking for fgrep" >&5
 
4356
echo $ECHO_N "checking for fgrep... $ECHO_C" >&6
 
4357
if test "${ac_cv_prog_fgrep+set}" = set; then
 
4358
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4359
else
 
4360
  if echo 'ab*c' | (grep -F 'ab*c') >/dev/null 2>&1
 
4361
    then ac_cv_prog_fgrep='grep -F'
 
4362
    else ac_cv_prog_fgrep='fgrep'
 
4363
    fi
 
4364
fi
 
4365
echo "$as_me:$LINENO: result: $ac_cv_prog_fgrep" >&5
 
4366
echo "${ECHO_T}$ac_cv_prog_fgrep" >&6
 
4367
 FGREP=$ac_cv_prog_fgrep
 
4368
 
 
4369
 
 
4370
test -z "$GREP" && GREP=grep
 
4371
 
 
4372
 
 
4373
 
 
4374
 
 
4375
 
 
4376
 
 
4377
 
 
4378
 
 
4379
 
 
4380
 
 
4381
 
 
4382
 
 
4383
 
 
4384
 
 
4385
 
 
4386
 
 
4387
 
 
4388
 
 
4389
 
3309
4390
# Check whether --with-gnu-ld or --without-gnu-ld was given.
3310
4391
if test "${with_gnu_ld+set}" = set; then
3311
4392
  withval="$with_gnu_ld"
3316
4397
ac_prog=ld
3317
4398
if test "$GCC" = yes; then
3318
4399
  # Check if gcc -print-prog-name=ld gives a path.
3319
 
  echo "$as_me:$LINENO: checking for ld used by GCC" >&5
3320
 
echo $ECHO_N "checking for ld used by GCC... $ECHO_C" >&6
 
4400
  echo "$as_me:$LINENO: checking for ld used by $CC" >&5
 
4401
echo $ECHO_N "checking for ld used by $CC... $ECHO_C" >&6
3321
4402
  case $host in
3322
4403
  *-*-mingw*)
3323
4404
    # gcc leaves a trailing carriage return which upsets mingw
3327
4408
  esac
3328
4409
  case $ac_prog in
3329
4410
    # Accept absolute paths.
3330
 
    [\\/]* | [A-Za-z]:[\\/]*)
 
4411
    [\\/]* | ?:[\\/]*)
3331
4412
      re_direlt='/[^/][^/]*/\.\./'
3332
 
      # Canonicalize the path of ld
3333
 
      ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
3334
 
      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
3335
 
        ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
 
4413
      # Canonicalize the pathname of ld
 
4414
      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
 
4415
      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
 
4416
        ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
3336
4417
      done
3337
4418
      test -z "$LD" && LD="$ac_prog"
3338
4419
      ;;
3356
4437
  echo $ECHO_N "(cached) $ECHO_C" >&6
3357
4438
else
3358
4439
  if test -z "$LD"; then
3359
 
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
 
4440
  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
3360
4441
  for ac_dir in $PATH; do
 
4442
    IFS="$lt_save_ifs"
3361
4443
    test -z "$ac_dir" && ac_dir=.
3362
4444
    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
3363
4445
      lt_cv_path_LD="$ac_dir/$ac_prog"
3364
4446
      # Check to see if the program is GNU ld.  I'd rather use --version,
3365
 
      # but apparently some GNU ld's only accept -v.
 
4447
      # but apparently some variants of GNU ld only accept -v.
3366
4448
      # Break only if it was the GNU/non-GNU ld that we prefer.
3367
 
      if "$lt_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
 
4449
      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
 
4450
      *GNU* | *'with BFD'*)
3368
4451
        test "$with_gnu_ld" != no && break
3369
 
      else
 
4452
        ;;
 
4453
      *)
3370
4454
        test "$with_gnu_ld" != yes && break
3371
 
      fi
 
4455
        ;;
 
4456
      esac
3372
4457
    fi
3373
4458
  done
3374
 
  IFS="$ac_save_ifs"
 
4459
  IFS="$lt_save_ifs"
3375
4460
else
3376
4461
  lt_cv_path_LD="$LD" # Let the user override the test with a path.
3377
4462
fi
3393
4478
if test "${lt_cv_prog_gnu_ld+set}" = set; then
3394
4479
  echo $ECHO_N "(cached) $ECHO_C" >&6
3395
4480
else
3396
 
  # I'd rather use --version here, but apparently some GNU ld's only accept -v.
3397
 
if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
 
4481
  # I'd rather use --version here, but apparently some GNU lds only accept -v.
 
4482
case `$LD -v 2>&1 </dev/null` in
 
4483
*GNU* | *'with BFD'*)
3398
4484
  lt_cv_prog_gnu_ld=yes
3399
 
else
 
4485
  ;;
 
4486
*)
3400
4487
  lt_cv_prog_gnu_ld=no
3401
 
fi
 
4488
  ;;
 
4489
esac
3402
4490
fi
3403
4491
echo "$as_me:$LINENO: result: $lt_cv_prog_gnu_ld" >&5
3404
4492
echo "${ECHO_T}$lt_cv_prog_gnu_ld" >&6
3405
4493
with_gnu_ld=$lt_cv_prog_gnu_ld
3406
4494
 
3407
4495
 
3408
 
echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
3409
 
echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
3410
 
if test "${lt_cv_ld_reload_flag+set}" = set; then
3411
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
3412
 
else
3413
 
  lt_cv_ld_reload_flag='-r'
3414
 
fi
3415
 
echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
3416
 
echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
3417
 
reload_flag=$lt_cv_ld_reload_flag
3418
 
test -n "$reload_flag" && reload_flag=" $reload_flag"
3419
 
 
3420
 
echo "$as_me:$LINENO: checking for BSD-compatible nm" >&5
3421
 
echo $ECHO_N "checking for BSD-compatible nm... $ECHO_C" >&6
 
4496
 
 
4497
 
 
4498
 
 
4499
 
 
4500
 
 
4501
 
 
4502
 
 
4503
 
 
4504
echo "$as_me:$LINENO: checking for BSD- or MS-compatible name lister (nm)" >&5
 
4505
echo $ECHO_N "checking for BSD- or MS-compatible name lister (nm)... $ECHO_C" >&6
3422
4506
if test "${lt_cv_path_NM+set}" = set; then
3423
4507
  echo $ECHO_N "(cached) $ECHO_C" >&6
3424
4508
else
3426
4510
  # Let the user override the test.
3427
4511
  lt_cv_path_NM="$NM"
3428
4512
else
3429
 
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
3430
 
  for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
3431
 
    test -z "$ac_dir" && ac_dir=.
3432
 
    tmp_nm=$ac_dir/${ac_tool_prefix}nm
3433
 
    if test -f $tmp_nm || test -f $tmp_nm$ac_exeext ; then
3434
 
      # Check to see if the nm accepts a BSD-compat flag.
3435
 
      # Adding the `sed 1q' prevents false positives on HP-UX, which says:
3436
 
      #   nm: unknown option "B" ignored
3437
 
      # Tru64's nm complains that /dev/null is an invalid object file
3438
 
      if ($tmp_nm -B /dev/null 2>&1 | sed '1q'; exit 0) | egrep '(/dev/null|Invalid file or object type)' >/dev/null; then
3439
 
        lt_cv_path_NM="$tmp_nm -B"
3440
 
        break
3441
 
      elif ($tmp_nm -p /dev/null 2>&1 | sed '1q'; exit 0) | egrep /dev/null >/dev/null; then
3442
 
        lt_cv_path_NM="$tmp_nm -p"
3443
 
        break
3444
 
      else
3445
 
        lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
3446
 
        continue # so that we can try to find one that supports BSD flags
 
4513
  lt_nm_to_check="${ac_tool_prefix}nm"
 
4514
  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
 
4515
    lt_nm_to_check="$lt_nm_to_check nm"
 
4516
  fi
 
4517
  for lt_tmp_nm in $lt_nm_to_check; do
 
4518
    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
 
4519
    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
 
4520
      IFS="$lt_save_ifs"
 
4521
      test -z "$ac_dir" && ac_dir=.
 
4522
      tmp_nm="$ac_dir/$lt_tmp_nm"
 
4523
      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
 
4524
        # Check to see if the nm accepts a BSD-compat flag.
 
4525
        # Adding the `sed 1q' prevents false positives on HP-UX, which says:
 
4526
        #   nm: unknown option "B" ignored
 
4527
        # Tru64's nm complains that /dev/null is an invalid object file
 
4528
        case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
 
4529
        */dev/null* | *'Invalid file or object type'*)
 
4530
          lt_cv_path_NM="$tmp_nm -B"
 
4531
          break
 
4532
          ;;
 
4533
        *)
 
4534
          case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
 
4535
          */dev/null*)
 
4536
            lt_cv_path_NM="$tmp_nm -p"
 
4537
            break
 
4538
            ;;
 
4539
          *)
 
4540
            lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
 
4541
            continue # so that we can try to find one that supports BSD flags
 
4542
            ;;
 
4543
          esac
 
4544
          ;;
 
4545
        esac
3447
4546
      fi
3448
 
    fi
3449
 
  done
3450
 
  IFS="$ac_save_ifs"
3451
 
  test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm
3452
 
fi
3453
 
fi
3454
 
 
3455
 
NM="$lt_cv_path_NM"
3456
 
echo "$as_me:$LINENO: result: $NM" >&5
3457
 
echo "${ECHO_T}$NM" >&6
 
4547
    done
 
4548
    IFS="$lt_save_ifs"
 
4549
  done
 
4550
  : ${lt_cv_path_NM=no}
 
4551
fi
 
4552
fi
 
4553
echo "$as_me:$LINENO: result: $lt_cv_path_NM" >&5
 
4554
echo "${ECHO_T}$lt_cv_path_NM" >&6
 
4555
if test "$lt_cv_path_NM" != "no"; then
 
4556
  NM="$lt_cv_path_NM"
 
4557
else
 
4558
  # Didn't find any BSD compatible name lister, look for dumpbin.
 
4559
  if test -n "$ac_tool_prefix"; then
 
4560
  for ac_prog in "dumpbin -symbols" "link -dump -symbols"
 
4561
  do
 
4562
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
 
4563
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
 
4564
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
4565
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
4566
if test "${ac_cv_prog_DUMPBIN+set}" = set; then
 
4567
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4568
else
 
4569
  if test -n "$DUMPBIN"; then
 
4570
  ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
 
4571
else
 
4572
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4573
for as_dir in $PATH
 
4574
do
 
4575
  IFS=$as_save_IFS
 
4576
  test -z "$as_dir" && as_dir=.
 
4577
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4578
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
4579
    ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog"
 
4580
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4581
    break 2
 
4582
  fi
 
4583
done
 
4584
done
 
4585
 
 
4586
fi
 
4587
fi
 
4588
DUMPBIN=$ac_cv_prog_DUMPBIN
 
4589
if test -n "$DUMPBIN"; then
 
4590
  echo "$as_me:$LINENO: result: $DUMPBIN" >&5
 
4591
echo "${ECHO_T}$DUMPBIN" >&6
 
4592
else
 
4593
  echo "$as_me:$LINENO: result: no" >&5
 
4594
echo "${ECHO_T}no" >&6
 
4595
fi
 
4596
 
 
4597
    test -n "$DUMPBIN" && break
 
4598
  done
 
4599
fi
 
4600
if test -z "$DUMPBIN"; then
 
4601
  ac_ct_DUMPBIN=$DUMPBIN
 
4602
  for ac_prog in "dumpbin -symbols" "link -dump -symbols"
 
4603
do
 
4604
  # Extract the first word of "$ac_prog", so it can be a program name with args.
 
4605
set dummy $ac_prog; ac_word=$2
 
4606
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
4607
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
4608
if test "${ac_cv_prog_ac_ct_DUMPBIN+set}" = set; then
 
4609
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4610
else
 
4611
  if test -n "$ac_ct_DUMPBIN"; then
 
4612
  ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test.
 
4613
else
 
4614
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
4615
for as_dir in $PATH
 
4616
do
 
4617
  IFS=$as_save_IFS
 
4618
  test -z "$as_dir" && as_dir=.
 
4619
  for ac_exec_ext in '' $ac_executable_extensions; do
 
4620
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
4621
    ac_cv_prog_ac_ct_DUMPBIN="$ac_prog"
 
4622
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
4623
    break 2
 
4624
  fi
 
4625
done
 
4626
done
 
4627
 
 
4628
fi
 
4629
fi
 
4630
ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN
 
4631
if test -n "$ac_ct_DUMPBIN"; then
 
4632
  echo "$as_me:$LINENO: result: $ac_ct_DUMPBIN" >&5
 
4633
echo "${ECHO_T}$ac_ct_DUMPBIN" >&6
 
4634
else
 
4635
  echo "$as_me:$LINENO: result: no" >&5
 
4636
echo "${ECHO_T}no" >&6
 
4637
fi
 
4638
 
 
4639
  test -n "$ac_ct_DUMPBIN" && break
 
4640
done
 
4641
test -n "$ac_ct_DUMPBIN" || ac_ct_DUMPBIN=":"
 
4642
 
 
4643
  DUMPBIN=$ac_ct_DUMPBIN
 
4644
fi
 
4645
 
 
4646
 
 
4647
  if test "$DUMPBIN" != ":"; then
 
4648
    NM="$DUMPBIN"
 
4649
  fi
 
4650
fi
 
4651
test -z "$NM" && NM=nm
 
4652
 
 
4653
 
 
4654
 
 
4655
 
 
4656
 
 
4657
 
 
4658
echo "$as_me:$LINENO: checking the name lister ($NM) interface" >&5
 
4659
echo $ECHO_N "checking the name lister ($NM) interface... $ECHO_C" >&6
 
4660
if test "${lt_cv_nm_interface+set}" = set; then
 
4661
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4662
else
 
4663
  lt_cv_nm_interface="BSD nm"
 
4664
  echo "int some_variable = 0;" > conftest.$ac_ext
 
4665
  (eval echo "\"\$as_me:4665: $ac_compile\"" >&5)
 
4666
  (eval "$ac_compile" 2>conftest.err)
 
4667
  cat conftest.err >&5
 
4668
  (eval echo "\"\$as_me:4668: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
 
4669
  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
 
4670
  cat conftest.err >&5
 
4671
  (eval echo "\"\$as_me:4671: output\"" >&5)
 
4672
  cat conftest.out >&5
 
4673
  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
 
4674
    lt_cv_nm_interface="MS dumpbin"
 
4675
  fi
 
4676
  rm -f conftest*
 
4677
fi
 
4678
echo "$as_me:$LINENO: result: $lt_cv_nm_interface" >&5
 
4679
echo "${ECHO_T}$lt_cv_nm_interface" >&6
3458
4680
 
3459
4681
echo "$as_me:$LINENO: checking whether ln -s works" >&5
3460
4682
echo $ECHO_N "checking whether ln -s works... $ECHO_C" >&6
3467
4689
echo "${ECHO_T}no, using $LN_S" >&6
3468
4690
fi
3469
4691
 
3470
 
echo "$as_me:$LINENO: checking how to recognise dependant libraries" >&5
3471
 
echo $ECHO_N "checking how to recognise dependant libraries... $ECHO_C" >&6
3472
 
if test "${lt_cv_deplibs_check_method+set}" = set; then
3473
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
3474
 
else
3475
 
  lt_cv_file_magic_cmd='$MAGIC_CMD'
3476
 
lt_cv_file_magic_test_file=
3477
 
lt_cv_deplibs_check_method='unknown'
3478
 
# Need to set the preceding variable on all platforms that support
3479
 
# interlibrary dependencies.
3480
 
# 'none' -- dependencies not supported.
3481
 
# `unknown' -- same as none, but documents that we really don't know.
3482
 
# 'pass_all' -- all dependencies passed with no checks.
3483
 
# 'test_compile' -- check by making test program.
3484
 
# 'file_magic [regex]' -- check by looking for files in library path
3485
 
# which responds to the $file_magic_cmd with a given egrep regex.
3486
 
# If you have `file' or equivalent on your system and you're not sure
3487
 
# whether `pass_all' will *always* work, you probably want this one.
3488
 
 
3489
 
case $host_os in
3490
 
aix*)
3491
 
  lt_cv_deplibs_check_method=pass_all
3492
 
  ;;
3493
 
 
3494
 
beos*)
3495
 
  lt_cv_deplibs_check_method=pass_all
3496
 
  ;;
3497
 
 
3498
 
bsdi4*)
3499
 
  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
3500
 
  lt_cv_file_magic_cmd='/usr/bin/file -L'
3501
 
  lt_cv_file_magic_test_file=/shlib/libc.so
3502
 
  ;;
3503
 
 
3504
 
cygwin* | mingw* |pw32*)
3505
 
  lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
3506
 
  lt_cv_file_magic_cmd='$OBJDUMP -f'
3507
 
  ;;
3508
 
 
3509
 
darwin* | rhapsody*)
3510
 
  # this will be overwritten by pass_all, but leave it in just in case
3511
 
  lt_cv_deplibs_check_method='file_magic Mach-O dynamically linked shared library'
3512
 
  lt_cv_file_magic_cmd='/usr/bin/file -L'
3513
 
  case "$host_os" in
3514
 
  rhapsody* | darwin1.012)
3515
 
    lt_cv_file_magic_test_file='/System/Library/Frameworks/System.framework/System'
3516
 
    ;;
3517
 
  *) # Darwin 1.3 on
3518
 
    lt_cv_file_magic_test_file='/usr/lib/libSystem.dylib'
3519
 
    ;;
3520
 
  esac
3521
 
  lt_cv_deplibs_check_method=pass_all
3522
 
  ;;
3523
 
 
3524
 
freebsd* | kfreebsd*-gnu)
3525
 
  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3526
 
    case $host_cpu in
3527
 
    i*86 )
3528
 
      # Not sure whether the presence of OpenBSD here was a mistake.
3529
 
      # Let's accept both of them until this is cleared up.
3530
 
      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[3-9]86 (compact )?demand paged shared library'
3531
 
      lt_cv_file_magic_cmd=/usr/bin/file
3532
 
      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
3533
 
      ;;
3534
 
    esac
3535
 
  else
3536
 
    lt_cv_deplibs_check_method=pass_all
3537
 
  fi
3538
 
  ;;
3539
 
 
3540
 
gnu*)
3541
 
  lt_cv_deplibs_check_method=pass_all
3542
 
  ;;
3543
 
 
3544
 
hpux10.20*|hpux11*)
3545
 
  case $host_cpu in
3546
 
  hppa*)
3547
 
    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'
3548
 
    lt_cv_file_magic_cmd=/usr/bin/file
3549
 
    lt_cv_file_magic_test_file=/usr/lib/libc.sl
3550
 
    ;;
3551
 
  ia64*)
3552
 
    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
3553
 
    lt_cv_file_magic_cmd=/usr/bin/file
3554
 
    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
3555
 
    ;;
3556
 
  esac
3557
 
  ;;
3558
 
 
3559
 
irix5* | irix6*)
3560
 
  case $host_os in
3561
 
  irix5*)
3562
 
    # this will be overridden with pass_all, but let us keep it just in case
3563
 
    lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
3564
 
    ;;
3565
 
  *)
3566
 
    case $LD in
3567
 
    *-32|*"-32 ") libmagic=32-bit;;
3568
 
    *-n32|*"-n32 ") libmagic=N32;;
3569
 
    *-64|*"-64 ") libmagic=64-bit;;
3570
 
    *) libmagic=never-match;;
3571
 
    esac
3572
 
    # this will be overridden with pass_all, but let us keep it just in case
3573
 
    lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[1234] dynamic lib MIPS - version 1"
3574
 
    ;;
3575
 
  esac
3576
 
  lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
3577
 
  lt_cv_deplibs_check_method=pass_all
3578
 
  ;;
3579
 
 
3580
 
# This must be Linux ELF.
3581
 
linux-gnu*)
3582
 
  lt_cv_deplibs_check_method=pass_all
3583
 
  ;;
3584
 
 
3585
 
netbsd* | knetbsd*-gnu)
3586
 
  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3587
 
    lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so\.[0-9]+\.[0-9]+$'
3588
 
  else
3589
 
    lt_cv_deplibs_check_method='match_pattern /lib[^/\.]+\.so$'
3590
 
  fi
3591
 
  ;;
3592
 
 
3593
 
newsos6)
3594
 
  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
3595
 
  lt_cv_file_magic_cmd=/usr/bin/file
3596
 
  lt_cv_file_magic_test_file=/usr/lib/libnls.so
3597
 
  ;;
3598
 
 
3599
 
osf3* | osf4* | osf5*)
3600
 
  # this will be overridden with pass_all, but let us keep it just in case
3601
 
  lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
3602
 
  lt_cv_file_magic_test_file=/shlib/libc.so
3603
 
  lt_cv_deplibs_check_method=pass_all
3604
 
  ;;
3605
 
 
3606
 
sco3.2v5*)
3607
 
  lt_cv_deplibs_check_method=pass_all
3608
 
  ;;
3609
 
 
3610
 
solaris*)
3611
 
  lt_cv_deplibs_check_method=pass_all
3612
 
  lt_cv_file_magic_test_file=/lib/libc.so
3613
 
  ;;
3614
 
 
3615
 
sysv5uw[78]* | sysv4*uw2*)
3616
 
  lt_cv_deplibs_check_method=pass_all
3617
 
  ;;
3618
 
 
3619
 
sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
3620
 
  case $host_vendor in
3621
 
  ncr)
3622
 
    lt_cv_deplibs_check_method=pass_all
3623
 
    ;;
3624
 
  motorola)
3625
 
    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
3626
 
    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
3627
 
    ;;
3628
 
  esac
3629
 
  ;;
3630
 
esac
3631
 
 
3632
 
fi
3633
 
echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
3634
 
echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
3635
 
file_magic_cmd=$lt_cv_file_magic_cmd
3636
 
deplibs_check_method=$lt_cv_deplibs_check_method
3637
 
 
3638
 
 
3639
 
 
3640
 
 
3641
 
# Autoconf 2.13's AC_OBJEXT and AC_EXEEXT macros only works for C compilers!
3642
 
 
3643
4692
# find the maximum length of command line arguments
3644
4693
echo "$as_me:$LINENO: checking the maximum length of command line arguments" >&5
3645
4694
echo $ECHO_N "checking the maximum length of command line arguments... $ECHO_C" >&6
3658
4707
    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
3659
4708
    ;;
3660
4709
 
 
4710
  gnu*)
 
4711
    # Under GNU Hurd, this test is not required because there is
 
4712
    # no limit to the length of command line arguments.
 
4713
    # Libtool will interpret -1 as no limit whatsoever
 
4714
    lt_cv_sys_max_cmd_len=-1;
 
4715
    ;;
 
4716
 
3661
4717
  cygwin* | mingw*)
3662
4718
    # On Win9x/ME, this test blows up -- it succeeds, but takes
3663
4719
    # about 5 minutes as the teststring grows exponentially.
3682
4738
    elif test -x /usr/sbin/sysctl; then
3683
4739
      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
3684
4740
    else
3685
 
      lt_cv_sys_max_cmd_len=65536 # usable default for *BSD
 
4741
      lt_cv_sys_max_cmd_len=65536       # usable default for all BSDs
3686
4742
    fi
3687
4743
    # And add a safety zone
3688
4744
    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
3689
4745
    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
3690
4746
    ;;
 
4747
 
 
4748
  interix*)
 
4749
    # We know the value 262144 and hardcode it with a safety zone (like BSD)
 
4750
    lt_cv_sys_max_cmd_len=196608
 
4751
    ;;
 
4752
 
 
4753
  osf*)
 
4754
    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
 
4755
    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
 
4756
    # nice to cause kernel panics so lets avoid the loop below.
 
4757
    # First set a reasonable default.
 
4758
    lt_cv_sys_max_cmd_len=16384
 
4759
    #
 
4760
    if test -x /sbin/sysconfig; then
 
4761
      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
 
4762
        *1*) lt_cv_sys_max_cmd_len=-1 ;;
 
4763
      esac
 
4764
    fi
 
4765
    ;;
 
4766
  sco3.2v5*)
 
4767
    lt_cv_sys_max_cmd_len=102400
 
4768
    ;;
 
4769
  sysv5* | sco5v6* | sysv4.2uw2*)
 
4770
    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
 
4771
    if test -n "$kargmax"; then
 
4772
      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[  ]//'`
 
4773
    else
 
4774
      lt_cv_sys_max_cmd_len=32768
 
4775
    fi
 
4776
    ;;
 
4777
  *)
 
4778
    lt_cv_sys_max_cmd_len=`getconf ARG_MAX 2> /dev/null`
 
4779
    if test -n $lt_cv_sys_max_cmd_len; then
 
4780
      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
 
4781
      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
 
4782
    else
 
4783
      # Make teststring a little bigger before we do anything with it.
 
4784
      # a 1K string should be a reasonable start.
 
4785
      for i in 1 2 3 4 5 6 7 8 ; do
 
4786
        teststring=$teststring$teststring
 
4787
      done
 
4788
      SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
 
4789
      # If test is not a shell built-in, we'll probably end up computing a
 
4790
      # maximum length that is only half of the actual maximum length, but
 
4791
      # we can't tell.
 
4792
      while { test "X"`$SHELL $0 --fallback-echo "X$teststring$teststring" 2>/dev/null` \
 
4793
                 = "XX$teststring$teststring"; } >/dev/null 2>&1 &&
 
4794
              test $i != 17 # 1/2 MB should be enough
 
4795
      do
 
4796
        i=`expr $i + 1`
 
4797
        teststring=$teststring$teststring
 
4798
      done
 
4799
      # Only check the string length outside the loop.
 
4800
      lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
 
4801
      teststring=
 
4802
      # Add a significant safety factor because C++ compilers can tack on
 
4803
      # massive amounts of additional arguments before passing them to the
 
4804
      # linker.  It appears as though 1/2 is a usable value.
 
4805
      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
 
4806
    fi
 
4807
    ;;
3691
4808
  esac
3692
4809
 
3693
4810
fi
3694
4811
 
3695
 
if test -n "$lt_cv_sys_max_cmd_len" ; then
 
4812
if test -n $lt_cv_sys_max_cmd_len ; then
3696
4813
  echo "$as_me:$LINENO: result: $lt_cv_sys_max_cmd_len" >&5
3697
4814
echo "${ECHO_T}$lt_cv_sys_max_cmd_len" >&6
3698
4815
else
3699
4816
  echo "$as_me:$LINENO: result: none" >&5
3700
4817
echo "${ECHO_T}none" >&6
3701
4818
fi
3702
 
 
3703
 
 
3704
 
# Only perform the check for file, if the check method requires it
3705
 
case $deplibs_check_method in
3706
 
file_magic*)
3707
 
  if test "$file_magic_cmd" = '$MAGIC_CMD'; then
3708
 
    echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
3709
 
echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
3710
 
if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
3711
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
3712
 
else
3713
 
  case $MAGIC_CMD in
3714
 
  /*)
3715
 
  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
3716
 
  ;;
3717
 
  ?:/*)
3718
 
  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
3719
 
  ;;
3720
 
  *)
3721
 
  ac_save_MAGIC_CMD="$MAGIC_CMD"
3722
 
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3723
 
  ac_dummy="/usr/bin:$PATH"
3724
 
  for ac_dir in $ac_dummy; do
3725
 
    test -z "$ac_dir" && ac_dir=.
3726
 
    if test -f $ac_dir/${ac_tool_prefix}file; then
3727
 
      lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
3728
 
      if test -n "$file_magic_test_file"; then
3729
 
        case $deplibs_check_method in
3730
 
        "file_magic "*)
3731
 
          file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
3732
 
          MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3733
 
          if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
3734
 
            egrep "$file_magic_regex" > /dev/null; then
3735
 
            :
3736
 
          else
3737
 
            cat <<EOF 1>&2
3738
 
 
3739
 
*** Warning: the command libtool uses to detect shared libraries,
3740
 
*** $file_magic_cmd, produces output that libtool cannot recognize.
3741
 
*** The result is that libtool may fail to recognize shared libraries
3742
 
*** as such.  This will affect the creation of libtool libraries that
3743
 
*** depend on shared libraries, but programs linked with such libtool
3744
 
*** libraries will work regardless of this problem.  Nevertheless, you
3745
 
*** may want to report the problem to your system manager and/or to
3746
 
*** bug-libtool@gnu.org
3747
 
 
3748
 
EOF
3749
 
          fi ;;
3750
 
        esac
3751
 
      fi
3752
 
      break
3753
 
    fi
3754
 
  done
3755
 
  IFS="$ac_save_ifs"
3756
 
  MAGIC_CMD="$ac_save_MAGIC_CMD"
3757
 
  ;;
3758
 
esac
3759
 
fi
3760
 
 
3761
 
MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3762
 
if test -n "$MAGIC_CMD"; then
3763
 
  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
3764
 
echo "${ECHO_T}$MAGIC_CMD" >&6
3765
 
else
3766
 
  echo "$as_me:$LINENO: result: no" >&5
3767
 
echo "${ECHO_T}no" >&6
3768
 
fi
3769
 
 
3770
 
if test -z "$lt_cv_path_MAGIC_CMD"; then
3771
 
  if test -n "$ac_tool_prefix"; then
3772
 
    echo "$as_me:$LINENO: checking for file" >&5
3773
 
echo $ECHO_N "checking for file... $ECHO_C" >&6
3774
 
if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
3775
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
3776
 
else
3777
 
  case $MAGIC_CMD in
3778
 
  /*)
3779
 
  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
3780
 
  ;;
3781
 
  ?:/*)
3782
 
  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a dos path.
3783
 
  ;;
3784
 
  *)
3785
 
  ac_save_MAGIC_CMD="$MAGIC_CMD"
3786
 
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS=":"
3787
 
  ac_dummy="/usr/bin:$PATH"
3788
 
  for ac_dir in $ac_dummy; do
3789
 
    test -z "$ac_dir" && ac_dir=.
3790
 
    if test -f $ac_dir/file; then
3791
 
      lt_cv_path_MAGIC_CMD="$ac_dir/file"
3792
 
      if test -n "$file_magic_test_file"; then
3793
 
        case $deplibs_check_method in
3794
 
        "file_magic "*)
3795
 
          file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
3796
 
          MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3797
 
          if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
3798
 
            egrep "$file_magic_regex" > /dev/null; then
3799
 
            :
3800
 
          else
3801
 
            cat <<EOF 1>&2
3802
 
 
3803
 
*** Warning: the command libtool uses to detect shared libraries,
3804
 
*** $file_magic_cmd, produces output that libtool cannot recognize.
3805
 
*** The result is that libtool may fail to recognize shared libraries
3806
 
*** as such.  This will affect the creation of libtool libraries that
3807
 
*** depend on shared libraries, but programs linked with such libtool
3808
 
*** libraries will work regardless of this problem.  Nevertheless, you
3809
 
*** may want to report the problem to your system manager and/or to
3810
 
*** bug-libtool@gnu.org
3811
 
 
3812
 
EOF
3813
 
          fi ;;
3814
 
        esac
3815
 
      fi
3816
 
      break
3817
 
    fi
3818
 
  done
3819
 
  IFS="$ac_save_ifs"
3820
 
  MAGIC_CMD="$ac_save_MAGIC_CMD"
3821
 
  ;;
3822
 
esac
3823
 
fi
3824
 
 
3825
 
MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
3826
 
if test -n "$MAGIC_CMD"; then
3827
 
  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
3828
 
echo "${ECHO_T}$MAGIC_CMD" >&6
3829
 
else
3830
 
  echo "$as_me:$LINENO: result: no" >&5
3831
 
echo "${ECHO_T}no" >&6
3832
 
fi
3833
 
 
3834
 
  else
3835
 
    MAGIC_CMD=:
3836
 
  fi
3837
 
fi
3838
 
 
3839
 
  fi
3840
 
  ;;
3841
 
esac
 
4819
max_cmd_len=$lt_cv_sys_max_cmd_len
 
4820
 
 
4821
 
 
4822
 
 
4823
 
 
4824
 
 
4825
 
 
4826
 
 
4827
: ${CP="cp -f"}
 
4828
: ${MV="mv -f"}
 
4829
: ${RM="rm -f"}
 
4830
 
 
4831
echo "$as_me:$LINENO: checking whether the shell understands some XSI constructs" >&5
 
4832
echo $ECHO_N "checking whether the shell understands some XSI constructs... $ECHO_C" >&6
 
4833
# Try some XSI features
 
4834
xsi_shell=no
 
4835
( _lt_dummy="a/b/c"
 
4836
  test "${_lt_dummy##*/},${_lt_dummy%/*},"${_lt_dummy%"$_lt_dummy"}, \
 
4837
      = c,a/b,, ) >/dev/null 2>&1 \
 
4838
  && xsi_shell=yes
 
4839
echo "$as_me:$LINENO: result: $xsi_shell" >&5
 
4840
echo "${ECHO_T}$xsi_shell" >&6
 
4841
 
 
4842
 
 
4843
echo "$as_me:$LINENO: checking whether the shell understands \"+=\"" >&5
 
4844
echo $ECHO_N "checking whether the shell understands \"+=\"... $ECHO_C" >&6
 
4845
lt_shell_append=no
 
4846
( foo=bar; set foo baz; eval "$1+=\$2" && test "$foo" = barbaz ) \
 
4847
    >/dev/null 2>&1 \
 
4848
  && lt_shell_append=yes
 
4849
echo "$as_me:$LINENO: result: $lt_shell_append" >&5
 
4850
echo "${ECHO_T}$lt_shell_append" >&6
 
4851
 
 
4852
 
 
4853
if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
 
4854
  lt_unset=unset
 
4855
else
 
4856
  lt_unset=false
 
4857
fi
 
4858
 
 
4859
 
 
4860
 
 
4861
 
 
4862
 
 
4863
# test EBCDIC or ASCII
 
4864
case `echo X|tr X '\101'` in
 
4865
 A) # ASCII based system
 
4866
    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
 
4867
  lt_SP2NL='tr \040 \012'
 
4868
  lt_NL2SP='tr \015\012 \040\040'
 
4869
  ;;
 
4870
 *) # EBCDIC based system
 
4871
  lt_SP2NL='tr \100 \n'
 
4872
  lt_NL2SP='tr \r\n \100\100'
 
4873
  ;;
 
4874
esac
 
4875
 
 
4876
 
 
4877
 
 
4878
 
 
4879
 
 
4880
 
 
4881
 
 
4882
 
 
4883
 
 
4884
echo "$as_me:$LINENO: checking for $LD option to reload object files" >&5
 
4885
echo $ECHO_N "checking for $LD option to reload object files... $ECHO_C" >&6
 
4886
if test "${lt_cv_ld_reload_flag+set}" = set; then
 
4887
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4888
else
 
4889
  lt_cv_ld_reload_flag='-r'
 
4890
fi
 
4891
echo "$as_me:$LINENO: result: $lt_cv_ld_reload_flag" >&5
 
4892
echo "${ECHO_T}$lt_cv_ld_reload_flag" >&6
 
4893
reload_flag=$lt_cv_ld_reload_flag
 
4894
case $reload_flag in
 
4895
"" | " "*) ;;
 
4896
*) reload_flag=" $reload_flag" ;;
 
4897
esac
 
4898
reload_cmds='$LD$reload_flag -o $output$reload_objs'
 
4899
case $host_os in
 
4900
  darwin*)
 
4901
    if test "$GCC" = yes; then
 
4902
      reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'
 
4903
    else
 
4904
      reload_cmds='$LD$reload_flag -o $output$reload_objs'
 
4905
    fi
 
4906
    ;;
 
4907
esac
 
4908
 
 
4909
 
 
4910
 
 
4911
 
 
4912
 
 
4913
 
 
4914
 
 
4915
 
 
4916
 
 
4917
 
 
4918
echo "$as_me:$LINENO: checking how to recognize dependent libraries" >&5
 
4919
echo $ECHO_N "checking how to recognize dependent libraries... $ECHO_C" >&6
 
4920
if test "${lt_cv_deplibs_check_method+set}" = set; then
 
4921
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
4922
else
 
4923
  lt_cv_file_magic_cmd='$MAGIC_CMD'
 
4924
lt_cv_file_magic_test_file=
 
4925
lt_cv_deplibs_check_method='unknown'
 
4926
# Need to set the preceding variable on all platforms that support
 
4927
# interlibrary dependencies.
 
4928
# 'none' -- dependencies not supported.
 
4929
# `unknown' -- same as none, but documents that we really don't know.
 
4930
# 'pass_all' -- all dependencies passed with no checks.
 
4931
# 'test_compile' -- check by making test program.
 
4932
# 'file_magic [[regex]]' -- check by looking for files in library path
 
4933
# which responds to the $file_magic_cmd with a given extended regex.
 
4934
# If you have `file' or equivalent on your system and you're not sure
 
4935
# whether `pass_all' will *always* work, you probably want this one.
 
4936
 
 
4937
case $host_os in
 
4938
aix4* | aix5*)
 
4939
  lt_cv_deplibs_check_method=pass_all
 
4940
  ;;
 
4941
 
 
4942
beos*)
 
4943
  lt_cv_deplibs_check_method=pass_all
 
4944
  ;;
 
4945
 
 
4946
bsdi[45]*)
 
4947
  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib)'
 
4948
  lt_cv_file_magic_cmd='/usr/bin/file -L'
 
4949
  lt_cv_file_magic_test_file=/shlib/libc.so
 
4950
  ;;
 
4951
 
 
4952
cygwin*)
 
4953
  # func_win32_libid is a shell function defined in ltmain.sh
 
4954
  lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
 
4955
  lt_cv_file_magic_cmd='func_win32_libid'
 
4956
  ;;
 
4957
 
 
4958
mingw* | pw32*)
 
4959
  # Base MSYS/MinGW do not provide the 'file' command needed by
 
4960
  # func_win32_libid shell function, so use a weaker test based on 'objdump',
 
4961
  # unless we find 'file', for example because we are cross-compiling.
 
4962
  if ( file / ) >/dev/null 2>&1; then
 
4963
    lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
 
4964
    lt_cv_file_magic_cmd='func_win32_libid'
 
4965
  else
 
4966
    lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
 
4967
    lt_cv_file_magic_cmd='$OBJDUMP -f'
 
4968
  fi
 
4969
  ;;
 
4970
 
 
4971
darwin* | rhapsody*)
 
4972
  lt_cv_deplibs_check_method=pass_all
 
4973
  ;;
 
4974
 
 
4975
freebsd* | dragonfly*)
 
4976
  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
 
4977
    case $host_cpu in
 
4978
    i*86 )
 
4979
      # Not sure whether the presence of OpenBSD here was a mistake.
 
4980
      # Let's accept both of them until this is cleared up.
 
4981
      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[3-9]86 (compact )?demand paged shared library'
 
4982
      lt_cv_file_magic_cmd=/usr/bin/file
 
4983
      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
 
4984
      ;;
 
4985
    esac
 
4986
  else
 
4987
    lt_cv_deplibs_check_method=pass_all
 
4988
  fi
 
4989
  ;;
 
4990
 
 
4991
gnu*)
 
4992
  lt_cv_deplibs_check_method=pass_all
 
4993
  ;;
 
4994
 
 
4995
hpux10.20* | hpux11*)
 
4996
  lt_cv_file_magic_cmd=/usr/bin/file
 
4997
  case $host_cpu in
 
4998
  ia64*)
 
4999
    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - IA64'
 
5000
    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
 
5001
    ;;
 
5002
  hppa*64*)
 
5003
    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - PA-RISC [0-9].[0-9]'
 
5004
    lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
 
5005
    ;;
 
5006
  *)
 
5007
    lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|PA-RISC[0-9].[0-9]) shared library'
 
5008
    lt_cv_file_magic_test_file=/usr/lib/libc.sl
 
5009
    ;;
 
5010
  esac
 
5011
  ;;
 
5012
 
 
5013
interix[3-9]*)
 
5014
  # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
 
5015
  lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|\.a)$'
 
5016
  ;;
 
5017
 
 
5018
irix5* | irix6* | nonstopux*)
 
5019
  case $LD in
 
5020
  *-32|*"-32 ") libmagic=32-bit;;
 
5021
  *-n32|*"-n32 ") libmagic=N32;;
 
5022
  *-64|*"-64 ") libmagic=64-bit;;
 
5023
  *) libmagic=never-match;;
 
5024
  esac
 
5025
  lt_cv_deplibs_check_method=pass_all
 
5026
  ;;
 
5027
 
 
5028
# This must be Linux ELF.
 
5029
linux* | k*bsd*-gnu)
 
5030
  lt_cv_deplibs_check_method=pass_all
 
5031
  ;;
 
5032
 
 
5033
netbsd*)
 
5034
  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
 
5035
    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
 
5036
  else
 
5037
    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so|_pic\.a)$'
 
5038
  fi
 
5039
  ;;
 
5040
 
 
5041
newos6*)
 
5042
  lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (executable|dynamic lib)'
 
5043
  lt_cv_file_magic_cmd=/usr/bin/file
 
5044
  lt_cv_file_magic_test_file=/usr/lib/libnls.so
 
5045
  ;;
 
5046
 
 
5047
*nto* | *qnx*)
 
5048
  lt_cv_deplibs_check_method=pass_all
 
5049
  ;;
 
5050
 
 
5051
openbsd*)
 
5052
  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
 
5053
    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|\.so|_pic\.a)$'
 
5054
  else
 
5055
    lt_cv_deplibs_check_method='match_pattern /lib[^/]+(\.so\.[0-9]+\.[0-9]+|_pic\.a)$'
 
5056
  fi
 
5057
  ;;
 
5058
 
 
5059
osf3* | osf4* | osf5*)
 
5060
  lt_cv_deplibs_check_method=pass_all
 
5061
  ;;
 
5062
 
 
5063
rdos*)
 
5064
  lt_cv_deplibs_check_method=pass_all
 
5065
  ;;
 
5066
 
 
5067
solaris*)
 
5068
  lt_cv_deplibs_check_method=pass_all
 
5069
  ;;
 
5070
 
 
5071
sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
 
5072
  lt_cv_deplibs_check_method=pass_all
 
5073
  ;;
 
5074
 
 
5075
sysv4 | sysv4.3*)
 
5076
  case $host_vendor in
 
5077
  motorola)
 
5078
    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [ML]SB (shared object|dynamic lib) M[0-9][0-9]* Version [0-9]'
 
5079
    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
 
5080
    ;;
 
5081
  ncr)
 
5082
    lt_cv_deplibs_check_method=pass_all
 
5083
    ;;
 
5084
  sequent)
 
5085
    lt_cv_file_magic_cmd='/bin/file'
 
5086
    lt_cv_deplibs_check_method='file_magic ELF [0-9][0-9]*-bit [LM]SB (shared object|dynamic lib )'
 
5087
    ;;
 
5088
  sni)
 
5089
    lt_cv_file_magic_cmd='/bin/file'
 
5090
    lt_cv_deplibs_check_method="file_magic ELF [0-9][0-9]*-bit [LM]SB dynamic lib"
 
5091
    lt_cv_file_magic_test_file=/lib/libc.so
 
5092
    ;;
 
5093
  siemens)
 
5094
    lt_cv_deplibs_check_method=pass_all
 
5095
    ;;
 
5096
  pc)
 
5097
    lt_cv_deplibs_check_method=pass_all
 
5098
    ;;
 
5099
  esac
 
5100
  ;;
 
5101
 
 
5102
tpf*)
 
5103
  lt_cv_deplibs_check_method=pass_all
 
5104
  ;;
 
5105
esac
 
5106
 
 
5107
fi
 
5108
echo "$as_me:$LINENO: result: $lt_cv_deplibs_check_method" >&5
 
5109
echo "${ECHO_T}$lt_cv_deplibs_check_method" >&6
 
5110
file_magic_cmd=$lt_cv_file_magic_cmd
 
5111
deplibs_check_method=$lt_cv_deplibs_check_method
 
5112
test -z "$deplibs_check_method" && deplibs_check_method=unknown
 
5113
 
 
5114
 
 
5115
 
 
5116
 
 
5117
 
 
5118
 
 
5119
 
 
5120
 
 
5121
 
 
5122
 
 
5123
 
3842
5124
 
3843
5125
if test -n "$ac_tool_prefix"; then
3844
 
  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
3845
 
set dummy ${ac_tool_prefix}ranlib; ac_word=$2
3846
 
echo "$as_me:$LINENO: checking for $ac_word" >&5
3847
 
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3848
 
if test "${ac_cv_prog_RANLIB+set}" = set; then
3849
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
3850
 
else
3851
 
  if test -n "$RANLIB"; then
3852
 
  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
3853
 
else
3854
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3855
 
for as_dir in $PATH
3856
 
do
3857
 
  IFS=$as_save_IFS
3858
 
  test -z "$as_dir" && as_dir=.
3859
 
  for ac_exec_ext in '' $ac_executable_extensions; do
3860
 
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3861
 
    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
3862
 
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3863
 
    break 2
3864
 
  fi
3865
 
done
3866
 
done
3867
 
 
3868
 
fi
3869
 
fi
3870
 
RANLIB=$ac_cv_prog_RANLIB
3871
 
if test -n "$RANLIB"; then
3872
 
  echo "$as_me:$LINENO: result: $RANLIB" >&5
3873
 
echo "${ECHO_T}$RANLIB" >&6
3874
 
else
3875
 
  echo "$as_me:$LINENO: result: no" >&5
3876
 
echo "${ECHO_T}no" >&6
3877
 
fi
3878
 
 
3879
 
fi
3880
 
if test -z "$ac_cv_prog_RANLIB"; then
3881
 
  ac_ct_RANLIB=$RANLIB
3882
 
  # Extract the first word of "ranlib", so it can be a program name with args.
3883
 
set dummy ranlib; ac_word=$2
3884
 
echo "$as_me:$LINENO: checking for $ac_word" >&5
3885
 
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
3886
 
if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
3887
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
3888
 
else
3889
 
  if test -n "$ac_ct_RANLIB"; then
3890
 
  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
3891
 
else
3892
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3893
 
for as_dir in $PATH
3894
 
do
3895
 
  IFS=$as_save_IFS
3896
 
  test -z "$as_dir" && as_dir=.
3897
 
  for ac_exec_ext in '' $ac_executable_extensions; do
3898
 
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
3899
 
    ac_cv_prog_ac_ct_RANLIB="ranlib"
3900
 
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3901
 
    break 2
3902
 
  fi
3903
 
done
3904
 
done
3905
 
 
3906
 
  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
3907
 
fi
3908
 
fi
3909
 
ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
3910
 
if test -n "$ac_ct_RANLIB"; then
3911
 
  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
3912
 
echo "${ECHO_T}$ac_ct_RANLIB" >&6
3913
 
else
3914
 
  echo "$as_me:$LINENO: result: no" >&5
3915
 
echo "${ECHO_T}no" >&6
3916
 
fi
3917
 
 
3918
 
  RANLIB=$ac_ct_RANLIB
3919
 
else
3920
 
  RANLIB="$ac_cv_prog_RANLIB"
3921
 
fi
 
5126
  # Extract the first word of "${ac_tool_prefix}ar", so it can be a program name with args.
 
5127
set dummy ${ac_tool_prefix}ar; ac_word=$2
 
5128
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
5129
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
5130
if test "${ac_cv_prog_AR+set}" = set; then
 
5131
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5132
else
 
5133
  if test -n "$AR"; then
 
5134
  ac_cv_prog_AR="$AR" # Let the user override the test.
 
5135
else
 
5136
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
5137
for as_dir in $PATH
 
5138
do
 
5139
  IFS=$as_save_IFS
 
5140
  test -z "$as_dir" && as_dir=.
 
5141
  for ac_exec_ext in '' $ac_executable_extensions; do
 
5142
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
5143
    ac_cv_prog_AR="${ac_tool_prefix}ar"
 
5144
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
5145
    break 2
 
5146
  fi
 
5147
done
 
5148
done
 
5149
 
 
5150
fi
 
5151
fi
 
5152
AR=$ac_cv_prog_AR
 
5153
if test -n "$AR"; then
 
5154
  echo "$as_me:$LINENO: result: $AR" >&5
 
5155
echo "${ECHO_T}$AR" >&6
 
5156
else
 
5157
  echo "$as_me:$LINENO: result: no" >&5
 
5158
echo "${ECHO_T}no" >&6
 
5159
fi
 
5160
 
 
5161
fi
 
5162
if test -z "$ac_cv_prog_AR"; then
 
5163
  ac_ct_AR=$AR
 
5164
  # Extract the first word of "ar", so it can be a program name with args.
 
5165
set dummy ar; ac_word=$2
 
5166
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
5167
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
5168
if test "${ac_cv_prog_ac_ct_AR+set}" = set; then
 
5169
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5170
else
 
5171
  if test -n "$ac_ct_AR"; then
 
5172
  ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
 
5173
else
 
5174
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
5175
for as_dir in $PATH
 
5176
do
 
5177
  IFS=$as_save_IFS
 
5178
  test -z "$as_dir" && as_dir=.
 
5179
  for ac_exec_ext in '' $ac_executable_extensions; do
 
5180
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
5181
    ac_cv_prog_ac_ct_AR="ar"
 
5182
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
5183
    break 2
 
5184
  fi
 
5185
done
 
5186
done
 
5187
 
 
5188
  test -z "$ac_cv_prog_ac_ct_AR" && ac_cv_prog_ac_ct_AR="false"
 
5189
fi
 
5190
fi
 
5191
ac_ct_AR=$ac_cv_prog_ac_ct_AR
 
5192
if test -n "$ac_ct_AR"; then
 
5193
  echo "$as_me:$LINENO: result: $ac_ct_AR" >&5
 
5194
echo "${ECHO_T}$ac_ct_AR" >&6
 
5195
else
 
5196
  echo "$as_me:$LINENO: result: no" >&5
 
5197
echo "${ECHO_T}no" >&6
 
5198
fi
 
5199
 
 
5200
  AR=$ac_ct_AR
 
5201
else
 
5202
  AR="$ac_cv_prog_AR"
 
5203
fi
 
5204
 
 
5205
test -z "$AR" && AR=ar
 
5206
test -z "$AR_FLAGS" && AR_FLAGS=cru
 
5207
 
 
5208
 
 
5209
 
 
5210
 
 
5211
 
 
5212
 
 
5213
 
 
5214
 
 
5215
 
 
5216
 
3922
5217
 
3923
5218
if test -n "$ac_tool_prefix"; then
3924
5219
  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
4000
5295
  STRIP="$ac_cv_prog_STRIP"
4001
5296
fi
4002
5297
 
4003
 
 
4004
 
# Check for any special flags to pass to ltconfig.
4005
 
libtool_flags="--cache-file=$cache_file"
4006
 
test "$enable_shared" = no && libtool_flags="$libtool_flags --disable-shared"
4007
 
test "$enable_static" = no && libtool_flags="$libtool_flags --disable-static"
4008
 
test "$enable_fast_install" = no && libtool_flags="$libtool_flags --disable-fast-install"
4009
 
test "$GCC" = yes && libtool_flags="$libtool_flags --with-gcc"
4010
 
test "$lt_cv_prog_gnu_ld" = yes && libtool_flags="$libtool_flags --with-gnu-ld"
 
5298
test -z "$STRIP" && STRIP=:
 
5299
 
 
5300
 
 
5301
 
 
5302
 
 
5303
 
 
5304
 
 
5305
if test -n "$ac_tool_prefix"; then
 
5306
  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
 
5307
set dummy ${ac_tool_prefix}ranlib; ac_word=$2
 
5308
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
5309
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
5310
if test "${ac_cv_prog_RANLIB+set}" = set; then
 
5311
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5312
else
 
5313
  if test -n "$RANLIB"; then
 
5314
  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
 
5315
else
 
5316
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
5317
for as_dir in $PATH
 
5318
do
 
5319
  IFS=$as_save_IFS
 
5320
  test -z "$as_dir" && as_dir=.
 
5321
  for ac_exec_ext in '' $ac_executable_extensions; do
 
5322
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
5323
    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
 
5324
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
5325
    break 2
 
5326
  fi
 
5327
done
 
5328
done
 
5329
 
 
5330
fi
 
5331
fi
 
5332
RANLIB=$ac_cv_prog_RANLIB
 
5333
if test -n "$RANLIB"; then
 
5334
  echo "$as_me:$LINENO: result: $RANLIB" >&5
 
5335
echo "${ECHO_T}$RANLIB" >&6
 
5336
else
 
5337
  echo "$as_me:$LINENO: result: no" >&5
 
5338
echo "${ECHO_T}no" >&6
 
5339
fi
 
5340
 
 
5341
fi
 
5342
if test -z "$ac_cv_prog_RANLIB"; then
 
5343
  ac_ct_RANLIB=$RANLIB
 
5344
  # Extract the first word of "ranlib", so it can be a program name with args.
 
5345
set dummy ranlib; ac_word=$2
 
5346
echo "$as_me:$LINENO: checking for $ac_word" >&5
 
5347
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
 
5348
if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then
 
5349
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5350
else
 
5351
  if test -n "$ac_ct_RANLIB"; then
 
5352
  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
 
5353
else
 
5354
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
5355
for as_dir in $PATH
 
5356
do
 
5357
  IFS=$as_save_IFS
 
5358
  test -z "$as_dir" && as_dir=.
 
5359
  for ac_exec_ext in '' $ac_executable_extensions; do
 
5360
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
 
5361
    ac_cv_prog_ac_ct_RANLIB="ranlib"
 
5362
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
5363
    break 2
 
5364
  fi
 
5365
done
 
5366
done
 
5367
 
 
5368
  test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"
 
5369
fi
 
5370
fi
 
5371
ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
 
5372
if test -n "$ac_ct_RANLIB"; then
 
5373
  echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5
 
5374
echo "${ECHO_T}$ac_ct_RANLIB" >&6
 
5375
else
 
5376
  echo "$as_me:$LINENO: result: no" >&5
 
5377
echo "${ECHO_T}no" >&6
 
5378
fi
 
5379
 
 
5380
  RANLIB=$ac_ct_RANLIB
 
5381
else
 
5382
  RANLIB="$ac_cv_prog_RANLIB"
 
5383
fi
 
5384
 
 
5385
test -z "$RANLIB" && RANLIB=:
 
5386
 
 
5387
 
 
5388
 
 
5389
 
 
5390
 
 
5391
 
 
5392
# Determine commands to create old-style static archives.
 
5393
old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs'
 
5394
old_postinstall_cmds='chmod 644 $oldlib'
 
5395
old_postuninstall_cmds=
 
5396
 
 
5397
if test -n "$RANLIB"; then
 
5398
  case $host_os in
 
5399
  openbsd*)
 
5400
    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$oldlib"
 
5401
    ;;
 
5402
  *)
 
5403
    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$oldlib"
 
5404
    ;;
 
5405
  esac
 
5406
  old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"
 
5407
fi
 
5408
 
 
5409
 
 
5410
 
 
5411
 
 
5412
 
 
5413
 
 
5414
 
 
5415
 
 
5416
 
 
5417
 
 
5418
 
 
5419
 
 
5420
 
 
5421
 
 
5422
 
 
5423
 
 
5424
 
 
5425
 
 
5426
 
 
5427
 
 
5428
 
 
5429
 
 
5430
 
 
5431
 
 
5432
 
 
5433
 
 
5434
 
 
5435
 
 
5436
 
 
5437
 
 
5438
 
 
5439
 
 
5440
 
 
5441
 
 
5442
# If no C compiler was specified, use CC.
 
5443
LTCC=${LTCC-"$CC"}
 
5444
 
 
5445
# If no C compiler flags were specified, use CFLAGS.
 
5446
LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
 
5447
 
 
5448
# Allow CC to be a program name with arguments.
 
5449
compiler=$CC
 
5450
 
 
5451
 
 
5452
# Check for command to grab the raw symbol name followed by C symbol from nm.
 
5453
echo "$as_me:$LINENO: checking command to parse $NM output from $compiler object" >&5
 
5454
echo $ECHO_N "checking command to parse $NM output from $compiler object... $ECHO_C" >&6
 
5455
if test "${lt_cv_sys_global_symbol_pipe+set}" = set; then
 
5456
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5457
else
 
5458
 
 
5459
# These are sane defaults that work on at least a few old systems.
 
5460
# [They come from Ultrix.  What could be older than Ultrix?!! ;)]
 
5461
 
 
5462
# Character class describing NM global symbol codes.
 
5463
symcode='[BCDEGRST]'
 
5464
 
 
5465
# Regexp to match symbols that can be accessed directly from C.
 
5466
sympat='\([_A-Za-z][_A-Za-z0-9]*\)'
 
5467
 
 
5468
# Define system-specific variables.
 
5469
case $host_os in
 
5470
aix*)
 
5471
  symcode='[BCDT]'
 
5472
  ;;
 
5473
cygwin* | mingw* | pw32*)
 
5474
  symcode='[ABCDGISTW]'
 
5475
  ;;
 
5476
hpux*)
 
5477
  if test "$host_cpu" = ia64; then
 
5478
    symcode='[ABCDEGRST]'
 
5479
  fi
 
5480
  ;;
 
5481
irix* | nonstopux*)
 
5482
  symcode='[BCDEGRST]'
 
5483
  ;;
 
5484
osf*)
 
5485
  symcode='[BCDEGQRST]'
 
5486
  ;;
 
5487
solaris*)
 
5488
  symcode='[BDRT]'
 
5489
  ;;
 
5490
sco3.2v5*)
 
5491
  symcode='[DT]'
 
5492
  ;;
 
5493
sysv4.2uw2*)
 
5494
  symcode='[DT]'
 
5495
  ;;
 
5496
sysv5* | sco5v6* | unixware* | OpenUNIX*)
 
5497
  symcode='[ABDT]'
 
5498
  ;;
 
5499
sysv4)
 
5500
  symcode='[DFNSTU]'
 
5501
  ;;
 
5502
esac
 
5503
 
 
5504
# If we're using GNU nm, then use its standard symbol codes.
 
5505
case `$NM -V 2>&1` in
 
5506
*GNU* | *'with BFD'*)
 
5507
  symcode='[ABCDGIRSTW]' ;;
 
5508
esac
 
5509
 
 
5510
# Transform an extracted symbol line into a proper C declaration.
 
5511
# Some systems (esp. on ia64) link data and code symbols differently,
 
5512
# so use this general approach.
 
5513
lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
 
5514
 
 
5515
# Transform an extracted symbol line into symbol name and symbol address
 
5516
lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([^ ]*\) $/  {\\\"\1\\\", (void *) 0},/p' -e 's/^$symcode* \([^ ]*\) \([^ ]*\)$/  {\"\2\", (void *) \&\2},/p'"
 
5517
 
 
5518
# Handle CRLF in mingw tool chain
 
5519
opt_cr=
 
5520
case $build_os in
 
5521
mingw*)
 
5522
  opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp
 
5523
  ;;
 
5524
esac
 
5525
 
 
5526
# Try without a prefix underscore, then with it.
 
5527
for ac_symprfx in "" "_"; do
 
5528
 
 
5529
  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
 
5530
  symxfrm="\\1 $ac_symprfx\\2 \\2"
 
5531
 
 
5532
  # Write the raw and C identifiers.
 
5533
  if test "$lt_cv_nm_interface" = "MS dumpbin"; then
 
5534
    # Fake it for dumpbin and say T for any non-static function
 
5535
    # and D for any global variable.
 
5536
    # Also find C++ and __fastcall symbols from MSVC++,
 
5537
    # which start with @ or ?.
 
5538
    lt_cv_sys_global_symbol_pipe="$AWK '"\
 
5539
"     {last_section=section; section=\$ 3};"\
 
5540
"     /Section length .*#relocs.*(pick any)/{hide[last_section]=1};"\
 
5541
"     \$ 0!~/External *\|/{next};"\
 
5542
"     / 0+ UNDEF /{next}; / UNDEF \([^|]\)*()/{next};"\
 
5543
"     {if(hide[section]) next};"\
 
5544
"     {f=0}; \$ 0~/\(\).*\|/{f=1}; {printf f ? \"T \" : \"D \"};"\
 
5545
"     {split(\$ 0, a, /\||\r/); split(a[2], s)};"\
 
5546
"     s[1]~/^[@?]/{print s[1], s[1]; next};"\
 
5547
"     s[1]~prfx {split(s[1],t,\"@\"); print t[1], substr(t[1],length(prfx))}"\
 
5548
"     ' prfx=^$ac_symprfx"
 
5549
  else
 
5550
    lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[      ]\($symcode$symcode*\)[         ][      ]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
 
5551
  fi
 
5552
 
 
5553
  # Check to see that the pipe works correctly.
 
5554
  pipe_works=no
 
5555
 
 
5556
  rm -f conftest*
 
5557
  cat > conftest.$ac_ext <<_LT_EOF
 
5558
#ifdef __cplusplus
 
5559
extern "C" {
 
5560
#endif
 
5561
char nm_test_var;
 
5562
void nm_test_func(void);
 
5563
void nm_test_func(void){}
 
5564
#ifdef __cplusplus
 
5565
}
 
5566
#endif
 
5567
int main(){nm_test_var='a';nm_test_func();return(0);}
 
5568
_LT_EOF
 
5569
 
 
5570
  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
5571
  (eval $ac_compile) 2>&5
 
5572
  ac_status=$?
 
5573
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5574
  (exit $ac_status); }; then
 
5575
    # Now try to grab the symbols.
 
5576
    nlist=conftest.nm
 
5577
    if { (eval echo "$as_me:$LINENO: \"$NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist\"") >&5
 
5578
  (eval $NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) 2>&5
 
5579
  ac_status=$?
 
5580
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5581
  (exit $ac_status); } && test -s "$nlist"; then
 
5582
      # Try sorting and uniquifying the output.
 
5583
      if sort "$nlist" | uniq > "$nlist"T; then
 
5584
        mv -f "$nlist"T "$nlist"
 
5585
      else
 
5586
        rm -f "$nlist"T
 
5587
      fi
 
5588
 
 
5589
      # Make sure that we snagged all the symbols we need.
 
5590
      if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
 
5591
        if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
 
5592
          cat <<_LT_EOF > conftest.$ac_ext
 
5593
#ifdef __cplusplus
 
5594
extern "C" {
 
5595
#endif
 
5596
 
 
5597
_LT_EOF
 
5598
          # Now generate the symbol file.
 
5599
          eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'
 
5600
 
 
5601
          cat <<_LT_EOF >> conftest.$ac_ext
 
5602
 
 
5603
/* The mapping between symbol names and symbols.  */
 
5604
const struct {
 
5605
  const char *name;
 
5606
  void       *address;
 
5607
}
 
5608
lt__PROGRAM__LTX_preloaded_symbols[] =
 
5609
{
 
5610
  { "@PROGRAM@", (void *) 0 },
 
5611
_LT_EOF
 
5612
          $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/  {\"\2\", (void *) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
 
5613
          cat <<\_LT_EOF >> conftest.$ac_ext
 
5614
  {0, (void *) 0}
 
5615
};
 
5616
 
 
5617
/* This works around a problem in FreeBSD linker */
 
5618
#ifdef FREEBSD_WORKAROUND
 
5619
static const void *lt_preloaded_setup() {
 
5620
  return lt__PROGRAM__LTX_preloaded_symbols;
 
5621
}
 
5622
#endif
 
5623
 
 
5624
#ifdef __cplusplus
 
5625
}
 
5626
#endif
 
5627
_LT_EOF
 
5628
          # Now try linking the two files.
 
5629
          mv conftest.$ac_objext conftstm.$ac_objext
 
5630
          lt_save_LIBS="$LIBS"
 
5631
          lt_save_CFLAGS="$CFLAGS"
 
5632
          LIBS="conftstm.$ac_objext"
 
5633
          CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag"
 
5634
          if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
5635
  (eval $ac_link) 2>&5
 
5636
  ac_status=$?
 
5637
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5638
  (exit $ac_status); } && test -s conftest${ac_exeext}; then
 
5639
            pipe_works=yes
 
5640
          fi
 
5641
          LIBS="$lt_save_LIBS"
 
5642
          CFLAGS="$lt_save_CFLAGS"
 
5643
        else
 
5644
          echo "cannot find nm_test_func in $nlist" >&5
 
5645
        fi
 
5646
      else
 
5647
        echo "cannot find nm_test_var in $nlist" >&5
 
5648
      fi
 
5649
    else
 
5650
      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5
 
5651
    fi
 
5652
  else
 
5653
    echo "$progname: failed program was:" >&5
 
5654
    cat conftest.$ac_ext >&5
 
5655
  fi
 
5656
  rm -f conftest* conftst*
 
5657
 
 
5658
  # Do not use the global_symbol_pipe unless it works.
 
5659
  if test "$pipe_works" = yes; then
 
5660
    break
 
5661
  else
 
5662
    lt_cv_sys_global_symbol_pipe=
 
5663
  fi
 
5664
done
 
5665
 
 
5666
fi
 
5667
 
 
5668
if test -z "$lt_cv_sys_global_symbol_pipe"; then
 
5669
  lt_cv_sys_global_symbol_to_cdecl=
 
5670
fi
 
5671
if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
 
5672
  echo "$as_me:$LINENO: result: failed" >&5
 
5673
echo "${ECHO_T}failed" >&6
 
5674
else
 
5675
  echo "$as_me:$LINENO: result: ok" >&5
 
5676
echo "${ECHO_T}ok" >&6
 
5677
fi
 
5678
 
 
5679
 
 
5680
 
 
5681
 
 
5682
 
 
5683
 
 
5684
 
 
5685
 
 
5686
 
 
5687
 
 
5688
 
 
5689
 
 
5690
 
 
5691
 
 
5692
 
4011
5693
 
4012
5694
 
4013
5695
# Check whether --enable-libtool-lock or --disable-libtool-lock was given.
4015
5697
  enableval="$enable_libtool_lock"
4016
5698
 
4017
5699
fi;
4018
 
test "x$enable_libtool_lock" = xno && libtool_flags="$libtool_flags --disable-lock"
4019
 
test x"$silent" = xyes && libtool_flags="$libtool_flags --silent"
4020
 
 
4021
 
 
4022
 
# Check whether --with-pic or --without-pic was given.
4023
 
if test "${with_pic+set}" = set; then
4024
 
  withval="$with_pic"
4025
 
  pic_mode="$withval"
4026
 
else
4027
 
  pic_mode=default
4028
 
fi;
4029
 
test x"$pic_mode" = xyes && libtool_flags="$libtool_flags --prefer-pic"
4030
 
test x"$pic_mode" = xno && libtool_flags="$libtool_flags --prefer-non-pic"
 
5700
test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
4031
5701
 
4032
5702
# Some flags need to be propagated to the compiler or linker for good
4033
5703
# libtool support.
4034
5704
case $host in
 
5705
ia64-*-hpux*)
 
5706
  # Find out which ABI we are using.
 
5707
  echo 'int i;' > conftest.$ac_ext
 
5708
  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
5709
  (eval $ac_compile) 2>&5
 
5710
  ac_status=$?
 
5711
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5712
  (exit $ac_status); }; then
 
5713
    case `/usr/bin/file conftest.$ac_objext` in
 
5714
      *ELF-32*)
 
5715
        HPUX_IA64_MODE="32"
 
5716
        ;;
 
5717
      *ELF-64*)
 
5718
        HPUX_IA64_MODE="64"
 
5719
        ;;
 
5720
    esac
 
5721
  fi
 
5722
  rm -rf conftest*
 
5723
  ;;
4035
5724
*-*-irix6*)
4036
5725
  # Find out which ABI we are using.
4037
 
  echo '#line 4037 "configure"' > conftest.$ac_ext
4038
 
  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4039
 
  (eval $ac_compile) 2>&5
4040
 
  ac_status=$?
4041
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4042
 
  (exit $ac_status); }; then
4043
 
   if test "$lt_cv_prog_gnu_ld" = yes; then
4044
 
    case `/usr/bin/file conftest.$ac_objext` in
4045
 
    *32-bit*)
4046
 
      LD="${LD-ld} -melf32bsmip"
4047
 
      ;;
4048
 
    *N32*)
4049
 
      LD="${LD-ld} -melf32bmipn32"
4050
 
      ;;
4051
 
    *64-bit*)
4052
 
      LD="${LD-ld} -melf64bmip"
4053
 
      ;;
4054
 
    esac
4055
 
   else
4056
 
    case `/usr/bin/file conftest.$ac_objext` in
4057
 
    *32-bit*)
4058
 
      LD="${LD-ld} -32"
4059
 
      ;;
4060
 
    *N32*)
4061
 
      LD="${LD-ld} -n32"
4062
 
      ;;
4063
 
    *64-bit*)
4064
 
      LD="${LD-ld} -64"
4065
 
      ;;
4066
 
    esac
4067
 
   fi
4068
 
  fi
4069
 
  rm -rf conftest*
4070
 
  ;;
4071
 
 
4072
 
ia64-*-hpux*)
4073
 
  # Find out which ABI we are using.
4074
 
  echo 'int i;' > conftest.$ac_ext
4075
 
  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4076
 
  (eval $ac_compile) 2>&5
4077
 
  ac_status=$?
4078
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4079
 
  (exit $ac_status); }; then
4080
 
    case "`/usr/bin/file conftest.o`" in
4081
 
    *ELF-32*)
4082
 
      HPUX_IA64_MODE="32"
4083
 
      ;;
4084
 
    *ELF-64*)
4085
 
      HPUX_IA64_MODE="64"
4086
 
      ;;
4087
 
    esac
4088
 
  fi
4089
 
  rm -rf conftest*
4090
 
  ;;
4091
 
 
4092
 
x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
4093
 
  # Find out which ABI we are using.
4094
 
  echo 'int i;' > conftest.$ac_ext
4095
 
  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4096
 
  (eval $ac_compile) 2>&5
4097
 
  ac_status=$?
4098
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4099
 
  (exit $ac_status); }; then
4100
 
    case "`/usr/bin/file conftest.o`" in
4101
 
    *32-bit*)
4102
 
      case $host in
4103
 
        x86_64-*linux*)
4104
 
          LD="${LD-ld} -m elf_i386"
4105
 
          ;;
4106
 
        ppc64-*linux*|powerpc64-*linux*)
4107
 
          LD="${LD-ld} -m elf32ppclinux"
4108
 
          ;;
4109
 
        s390x-*linux*)
4110
 
          LD="${LD-ld} -m elf_s390"
4111
 
          ;;
4112
 
        sparc64-*linux*)
4113
 
          LD="${LD-ld} -m elf32_sparc"
4114
 
          ;;
4115
 
      esac
4116
 
      ;;
4117
 
    *64-bit*)
4118
 
      case $host in
4119
 
        x86_64-*linux*)
4120
 
          LD="${LD-ld} -m elf_x86_64"
4121
 
          ;;
4122
 
        ppc*-*linux*|powerpc*-*linux*)
4123
 
          LD="${LD-ld} -m elf64ppc"
4124
 
          ;;
4125
 
        s390*-*linux*)
4126
 
          LD="${LD-ld} -m elf64_s390"
4127
 
          ;;
4128
 
        sparc*-*linux*)
4129
 
          LD="${LD-ld} -m elf64_sparc"
4130
 
          ;;
4131
 
      esac
4132
 
      ;;
 
5726
  echo '#line 5726 "configure"' > conftest.$ac_ext
 
5727
  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
5728
  (eval $ac_compile) 2>&5
 
5729
  ac_status=$?
 
5730
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5731
  (exit $ac_status); }; then
 
5732
    if test "$lt_cv_prog_gnu_ld" = yes; then
 
5733
      case `/usr/bin/file conftest.$ac_objext` in
 
5734
        *32-bit*)
 
5735
          LD="${LD-ld} -melf32bsmip"
 
5736
          ;;
 
5737
        *N32*)
 
5738
          LD="${LD-ld} -melf32bmipn32"
 
5739
          ;;
 
5740
        *64-bit*)
 
5741
          LD="${LD-ld} -melf64bmip"
 
5742
        ;;
 
5743
      esac
 
5744
    else
 
5745
      case `/usr/bin/file conftest.$ac_objext` in
 
5746
        *32-bit*)
 
5747
          LD="${LD-ld} -32"
 
5748
          ;;
 
5749
        *N32*)
 
5750
          LD="${LD-ld} -n32"
 
5751
          ;;
 
5752
        *64-bit*)
 
5753
          LD="${LD-ld} -64"
 
5754
          ;;
 
5755
      esac
 
5756
    fi
 
5757
  fi
 
5758
  rm -rf conftest*
 
5759
  ;;
 
5760
 
 
5761
x86_64-*kfreebsd*-gnu|x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*| \
 
5762
s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
 
5763
  # Find out which ABI we are using.
 
5764
  echo 'int i;' > conftest.$ac_ext
 
5765
  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
5766
  (eval $ac_compile) 2>&5
 
5767
  ac_status=$?
 
5768
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5769
  (exit $ac_status); }; then
 
5770
    case `/usr/bin/file conftest.o` in
 
5771
      *32-bit*)
 
5772
        case $host in
 
5773
          x86_64-*kfreebsd*-gnu)
 
5774
            LD="${LD-ld} -m elf_i386_fbsd"
 
5775
            ;;
 
5776
          x86_64-*linux*)
 
5777
            LD="${LD-ld} -m elf_i386"
 
5778
            ;;
 
5779
          ppc64-*linux*|powerpc64-*linux*)
 
5780
            LD="${LD-ld} -m elf32ppclinux"
 
5781
            ;;
 
5782
          s390x-*linux*)
 
5783
            LD="${LD-ld} -m elf_s390"
 
5784
            ;;
 
5785
          sparc64-*linux*)
 
5786
            LD="${LD-ld} -m elf32_sparc"
 
5787
            ;;
 
5788
        esac
 
5789
        ;;
 
5790
      *64-bit*)
 
5791
        case $host in
 
5792
          x86_64-*kfreebsd*-gnu)
 
5793
            LD="${LD-ld} -m elf_x86_64_fbsd"
 
5794
            ;;
 
5795
          x86_64-*linux*)
 
5796
            LD="${LD-ld} -m elf_x86_64"
 
5797
            ;;
 
5798
          ppc*-*linux*|powerpc*-*linux*)
 
5799
            LD="${LD-ld} -m elf64ppc"
 
5800
            ;;
 
5801
          s390*-*linux*|s390*-*tpf*)
 
5802
            LD="${LD-ld} -m elf64_s390"
 
5803
            ;;
 
5804
          sparc*-*linux*)
 
5805
            LD="${LD-ld} -m elf64_sparc"
 
5806
            ;;
 
5807
        esac
 
5808
        ;;
4133
5809
    esac
4134
5810
  fi
4135
5811
  rm -rf conftest*
4144
5820
if test "${lt_cv_cc_needs_belf+set}" = set; then
4145
5821
  echo $ECHO_N "(cached) $ECHO_C" >&6
4146
5822
else
4147
 
 
4148
 
 
4149
 
     ac_ext=c
 
5823
  ac_ext=c
4150
5824
ac_cpp='$CPP $CPPFLAGS'
4151
5825
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4152
5826
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4212
5886
    CFLAGS="$SAVE_CFLAGS"
4213
5887
  fi
4214
5888
  ;;
4215
 
 
4216
 
 
 
5889
sparc*-*solaris*)
 
5890
  # Find out which ABI we are using.
 
5891
  echo 'int i;' > conftest.$ac_ext
 
5892
  if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
5893
  (eval $ac_compile) 2>&5
 
5894
  ac_status=$?
 
5895
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5896
  (exit $ac_status); }; then
 
5897
    case `/usr/bin/file conftest.o` in
 
5898
    *64-bit*)
 
5899
      case $lt_cv_prog_gnu_ld in
 
5900
      yes*) LD="${LD-ld} -m elf64_sparc" ;;
 
5901
      *)    LD="${LD-ld} -64" ;;
 
5902
      esac
 
5903
      ;;
 
5904
    esac
 
5905
  fi
 
5906
  rm -rf conftest*
 
5907
  ;;
4217
5908
esac
4218
5909
 
4219
 
 
4220
 
# Save cache, so that ltconfig can load it
4221
 
cat >confcache <<\_ACEOF
4222
 
# This file is a shell script that caches the results of configure
4223
 
# tests run on this system so they can be shared between configure
4224
 
# scripts and configure runs, see configure's option --config-cache.
4225
 
# It is not useful on other systems.  If it contains results you don't
4226
 
# want to keep, you may remove or edit it.
4227
 
#
4228
 
# config.status only pays attention to the cache file if you give it
4229
 
# the --recheck option to rerun configure.
4230
 
#
4231
 
# `ac_cv_env_foo' variables (set or unset) will be overridden when
4232
 
# loading this file, other *unset* `ac_cv_foo' will be assigned the
4233
 
# following values.
4234
 
 
4235
 
_ACEOF
4236
 
 
4237
 
# The following way of writing the cache mishandles newlines in values,
4238
 
# but we know of no workaround that is simple, portable, and efficient.
4239
 
# So, don't put newlines in cache variables' values.
4240
 
# Ultrix sh set writes to stderr and can't be redirected directly,
4241
 
# and sets the high bit in the cache file unless we assign to the vars.
4242
 
{
4243
 
  (set) 2>&1 |
4244
 
    case `(ac_space=' '; set | grep ac_space) 2>&1` in
4245
 
    *ac_space=\ *)
4246
 
      # `set' does not quote correctly, so add quotes (double-quote
4247
 
      # substitution turns \\\\ into \\, and sed turns \\ into \).
4248
 
      sed -n \
4249
 
        "s/'/'\\\\''/g;
4250
 
          s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
4251
 
      ;;
4252
 
    *)
4253
 
      # `set' quotes correctly as required by POSIX, so do not add quotes.
4254
 
      sed -n \
4255
 
        "s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1=\\2/p"
4256
 
      ;;
4257
 
    esac;
4258
 
} |
4259
 
  sed '
4260
 
     t clear
4261
 
     : clear
4262
 
     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
4263
 
     t end
4264
 
     /^ac_cv_env/!s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
4265
 
     : end' >>confcache
4266
 
if diff $cache_file confcache >/dev/null 2>&1; then :; else
4267
 
  if test -w $cache_file; then
4268
 
    test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"
4269
 
    cat confcache >$cache_file
4270
 
  else
4271
 
    echo "not updating unwritable cache $cache_file"
4272
 
  fi
4273
 
fi
4274
 
rm -f confcache
4275
 
 
4276
 
# Actually configure libtool.  ac_aux_dir is where install-sh is found.
4277
 
AR="$AR" LTCC="$CC" CC="$CC" CFLAGS="$CFLAGS" CPPFLAGS="$CPPFLAGS" \
4278
 
MAGIC_CMD="$MAGIC_CMD" LD="$LD" LDFLAGS="$LDFLAGS" LIBS="$LIBS" \
4279
 
LN_S="$LN_S" NM="$NM" RANLIB="$RANLIB" STRIP="$STRIP" \
4280
 
AS="$AS" DLLTOOL="$DLLTOOL" OBJDUMP="$OBJDUMP" \
4281
 
objext="$OBJEXT" exeext="$EXEEXT" reload_flag="$reload_flag" \
4282
 
deplibs_check_method="$deplibs_check_method" file_magic_cmd="$file_magic_cmd" \
4283
 
${CONFIG_SHELL-/bin/sh} $ac_aux_dir/ltconfig --no-reexec \
4284
 
$libtool_flags --no-verify --build="$build" $ac_aux_dir/ltmain.sh $host \
4285
 
|| { { echo "$as_me:$LINENO: error: libtool configure failed" >&5
4286
 
echo "$as_me: error: libtool configure failed" >&2;}
 
5910
need_locks="$enable_libtool_lock"
 
5911
 
 
5912
ac_ext=c
 
5913
ac_cpp='$CPP $CPPFLAGS'
 
5914
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
5915
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
5916
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
5917
echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
 
5918
echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
 
5919
# On Suns, sometimes $CPP names a directory.
 
5920
if test -n "$CPP" && test -d "$CPP"; then
 
5921
  CPP=
 
5922
fi
 
5923
if test -z "$CPP"; then
 
5924
  if test "${ac_cv_prog_CPP+set}" = set; then
 
5925
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
5926
else
 
5927
      # Double quotes because CPP needs to be expanded
 
5928
    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
 
5929
    do
 
5930
      ac_preproc_ok=false
 
5931
for ac_c_preproc_warn_flag in '' yes
 
5932
do
 
5933
  # Use a header file that comes with gcc, so configuring glibc
 
5934
  # with a fresh cross-compiler works.
 
5935
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
 
5936
  # <limits.h> exists even on freestanding compilers.
 
5937
  # On the NeXT, cc -E runs the code through the compiler's parser,
 
5938
  # not just through cpp. "Syntax error" is here to catch this case.
 
5939
  cat >conftest.$ac_ext <<_ACEOF
 
5940
/* confdefs.h.  */
 
5941
_ACEOF
 
5942
cat confdefs.h >>conftest.$ac_ext
 
5943
cat >>conftest.$ac_ext <<_ACEOF
 
5944
/* end confdefs.h.  */
 
5945
#ifdef __STDC__
 
5946
# include <limits.h>
 
5947
#else
 
5948
# include <assert.h>
 
5949
#endif
 
5950
                     Syntax error
 
5951
_ACEOF
 
5952
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
5953
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
5954
  ac_status=$?
 
5955
  grep -v '^ *+' conftest.er1 >conftest.err
 
5956
  rm -f conftest.er1
 
5957
  cat conftest.err >&5
 
5958
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5959
  (exit $ac_status); } >/dev/null; then
 
5960
  if test -s conftest.err; then
 
5961
    ac_cpp_err=$ac_c_preproc_warn_flag
 
5962
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
 
5963
  else
 
5964
    ac_cpp_err=
 
5965
  fi
 
5966
else
 
5967
  ac_cpp_err=yes
 
5968
fi
 
5969
if test -z "$ac_cpp_err"; then
 
5970
  :
 
5971
else
 
5972
  echo "$as_me: failed program was:" >&5
 
5973
sed 's/^/| /' conftest.$ac_ext >&5
 
5974
 
 
5975
  # Broken: fails on valid input.
 
5976
continue
 
5977
fi
 
5978
rm -f conftest.err conftest.$ac_ext
 
5979
 
 
5980
  # OK, works on sane cases.  Now check whether non-existent headers
 
5981
  # can be detected and how.
 
5982
  cat >conftest.$ac_ext <<_ACEOF
 
5983
/* confdefs.h.  */
 
5984
_ACEOF
 
5985
cat confdefs.h >>conftest.$ac_ext
 
5986
cat >>conftest.$ac_ext <<_ACEOF
 
5987
/* end confdefs.h.  */
 
5988
#include <ac_nonexistent.h>
 
5989
_ACEOF
 
5990
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
5991
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
5992
  ac_status=$?
 
5993
  grep -v '^ *+' conftest.er1 >conftest.err
 
5994
  rm -f conftest.er1
 
5995
  cat conftest.err >&5
 
5996
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
5997
  (exit $ac_status); } >/dev/null; then
 
5998
  if test -s conftest.err; then
 
5999
    ac_cpp_err=$ac_c_preproc_warn_flag
 
6000
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
 
6001
  else
 
6002
    ac_cpp_err=
 
6003
  fi
 
6004
else
 
6005
  ac_cpp_err=yes
 
6006
fi
 
6007
if test -z "$ac_cpp_err"; then
 
6008
  # Broken: success on invalid input.
 
6009
continue
 
6010
else
 
6011
  echo "$as_me: failed program was:" >&5
 
6012
sed 's/^/| /' conftest.$ac_ext >&5
 
6013
 
 
6014
  # Passes both tests.
 
6015
ac_preproc_ok=:
 
6016
break
 
6017
fi
 
6018
rm -f conftest.err conftest.$ac_ext
 
6019
 
 
6020
done
 
6021
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
 
6022
rm -f conftest.err conftest.$ac_ext
 
6023
if $ac_preproc_ok; then
 
6024
  break
 
6025
fi
 
6026
 
 
6027
    done
 
6028
    ac_cv_prog_CPP=$CPP
 
6029
 
 
6030
fi
 
6031
  CPP=$ac_cv_prog_CPP
 
6032
else
 
6033
  ac_cv_prog_CPP=$CPP
 
6034
fi
 
6035
echo "$as_me:$LINENO: result: $CPP" >&5
 
6036
echo "${ECHO_T}$CPP" >&6
 
6037
ac_preproc_ok=false
 
6038
for ac_c_preproc_warn_flag in '' yes
 
6039
do
 
6040
  # Use a header file that comes with gcc, so configuring glibc
 
6041
  # with a fresh cross-compiler works.
 
6042
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
 
6043
  # <limits.h> exists even on freestanding compilers.
 
6044
  # On the NeXT, cc -E runs the code through the compiler's parser,
 
6045
  # not just through cpp. "Syntax error" is here to catch this case.
 
6046
  cat >conftest.$ac_ext <<_ACEOF
 
6047
/* confdefs.h.  */
 
6048
_ACEOF
 
6049
cat confdefs.h >>conftest.$ac_ext
 
6050
cat >>conftest.$ac_ext <<_ACEOF
 
6051
/* end confdefs.h.  */
 
6052
#ifdef __STDC__
 
6053
# include <limits.h>
 
6054
#else
 
6055
# include <assert.h>
 
6056
#endif
 
6057
                     Syntax error
 
6058
_ACEOF
 
6059
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
6060
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
6061
  ac_status=$?
 
6062
  grep -v '^ *+' conftest.er1 >conftest.err
 
6063
  rm -f conftest.er1
 
6064
  cat conftest.err >&5
 
6065
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6066
  (exit $ac_status); } >/dev/null; then
 
6067
  if test -s conftest.err; then
 
6068
    ac_cpp_err=$ac_c_preproc_warn_flag
 
6069
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
 
6070
  else
 
6071
    ac_cpp_err=
 
6072
  fi
 
6073
else
 
6074
  ac_cpp_err=yes
 
6075
fi
 
6076
if test -z "$ac_cpp_err"; then
 
6077
  :
 
6078
else
 
6079
  echo "$as_me: failed program was:" >&5
 
6080
sed 's/^/| /' conftest.$ac_ext >&5
 
6081
 
 
6082
  # Broken: fails on valid input.
 
6083
continue
 
6084
fi
 
6085
rm -f conftest.err conftest.$ac_ext
 
6086
 
 
6087
  # OK, works on sane cases.  Now check whether non-existent headers
 
6088
  # can be detected and how.
 
6089
  cat >conftest.$ac_ext <<_ACEOF
 
6090
/* confdefs.h.  */
 
6091
_ACEOF
 
6092
cat confdefs.h >>conftest.$ac_ext
 
6093
cat >>conftest.$ac_ext <<_ACEOF
 
6094
/* end confdefs.h.  */
 
6095
#include <ac_nonexistent.h>
 
6096
_ACEOF
 
6097
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
 
6098
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
 
6099
  ac_status=$?
 
6100
  grep -v '^ *+' conftest.er1 >conftest.err
 
6101
  rm -f conftest.er1
 
6102
  cat conftest.err >&5
 
6103
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6104
  (exit $ac_status); } >/dev/null; then
 
6105
  if test -s conftest.err; then
 
6106
    ac_cpp_err=$ac_c_preproc_warn_flag
 
6107
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
 
6108
  else
 
6109
    ac_cpp_err=
 
6110
  fi
 
6111
else
 
6112
  ac_cpp_err=yes
 
6113
fi
 
6114
if test -z "$ac_cpp_err"; then
 
6115
  # Broken: success on invalid input.
 
6116
continue
 
6117
else
 
6118
  echo "$as_me: failed program was:" >&5
 
6119
sed 's/^/| /' conftest.$ac_ext >&5
 
6120
 
 
6121
  # Passes both tests.
 
6122
ac_preproc_ok=:
 
6123
break
 
6124
fi
 
6125
rm -f conftest.err conftest.$ac_ext
 
6126
 
 
6127
done
 
6128
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
 
6129
rm -f conftest.err conftest.$ac_ext
 
6130
if $ac_preproc_ok; then
 
6131
  :
 
6132
else
 
6133
  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
 
6134
See \`config.log' for more details." >&5
 
6135
echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
 
6136
See \`config.log' for more details." >&2;}
4287
6137
   { (exit 1); exit 1; }; }
4288
 
 
4289
 
# Reload cache, that may have been modified by ltconfig
4290
 
if test -r "$cache_file"; then
4291
 
  # Some versions of bash will fail to source /dev/null (special
4292
 
  # files actually), so we avoid doing that.
4293
 
  if test -f "$cache_file"; then
4294
 
    { echo "$as_me:$LINENO: loading cache $cache_file" >&5
4295
 
echo "$as_me: loading cache $cache_file" >&6;}
4296
 
    case $cache_file in
4297
 
      [\\/]* | ?:[\\/]* ) . $cache_file;;
4298
 
      *)                      . ./$cache_file;;
4299
 
    esac
4300
 
  fi
4301
 
else
4302
 
  { echo "$as_me:$LINENO: creating cache $cache_file" >&5
4303
 
echo "$as_me: creating cache $cache_file" >&6;}
4304
 
  >$cache_file
4305
 
fi
 
6138
fi
 
6139
 
 
6140
ac_ext=c
 
6141
ac_cpp='$CPP $CPPFLAGS'
 
6142
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
6143
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
6144
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
6145
 
 
6146
 
 
6147
echo "$as_me:$LINENO: checking for ANSI C header files" >&5
 
6148
echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
 
6149
if test "${ac_cv_header_stdc+set}" = set; then
 
6150
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6151
else
 
6152
  cat >conftest.$ac_ext <<_ACEOF
 
6153
/* confdefs.h.  */
 
6154
_ACEOF
 
6155
cat confdefs.h >>conftest.$ac_ext
 
6156
cat >>conftest.$ac_ext <<_ACEOF
 
6157
/* end confdefs.h.  */
 
6158
#include <stdlib.h>
 
6159
#include <stdarg.h>
 
6160
#include <string.h>
 
6161
#include <float.h>
 
6162
 
 
6163
int
 
6164
main ()
 
6165
{
 
6166
 
 
6167
  ;
 
6168
  return 0;
 
6169
}
 
6170
_ACEOF
 
6171
rm -f conftest.$ac_objext
 
6172
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
6173
  (eval $ac_compile) 2>conftest.er1
 
6174
  ac_status=$?
 
6175
  grep -v '^ *+' conftest.er1 >conftest.err
 
6176
  rm -f conftest.er1
 
6177
  cat conftest.err >&5
 
6178
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6179
  (exit $ac_status); } &&
 
6180
         { ac_try='test -z "$ac_c_werror_flag"
 
6181
                         || test ! -s conftest.err'
 
6182
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6183
  (eval $ac_try) 2>&5
 
6184
  ac_status=$?
 
6185
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6186
  (exit $ac_status); }; } &&
 
6187
         { ac_try='test -s conftest.$ac_objext'
 
6188
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6189
  (eval $ac_try) 2>&5
 
6190
  ac_status=$?
 
6191
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6192
  (exit $ac_status); }; }; then
 
6193
  ac_cv_header_stdc=yes
 
6194
else
 
6195
  echo "$as_me: failed program was:" >&5
 
6196
sed 's/^/| /' conftest.$ac_ext >&5
 
6197
 
 
6198
ac_cv_header_stdc=no
 
6199
fi
 
6200
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
 
6201
 
 
6202
if test $ac_cv_header_stdc = yes; then
 
6203
  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
 
6204
  cat >conftest.$ac_ext <<_ACEOF
 
6205
/* confdefs.h.  */
 
6206
_ACEOF
 
6207
cat confdefs.h >>conftest.$ac_ext
 
6208
cat >>conftest.$ac_ext <<_ACEOF
 
6209
/* end confdefs.h.  */
 
6210
#include <string.h>
 
6211
 
 
6212
_ACEOF
 
6213
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
 
6214
  $EGREP "memchr" >/dev/null 2>&1; then
 
6215
  :
 
6216
else
 
6217
  ac_cv_header_stdc=no
 
6218
fi
 
6219
rm -f conftest*
 
6220
 
 
6221
fi
 
6222
 
 
6223
if test $ac_cv_header_stdc = yes; then
 
6224
  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
 
6225
  cat >conftest.$ac_ext <<_ACEOF
 
6226
/* confdefs.h.  */
 
6227
_ACEOF
 
6228
cat confdefs.h >>conftest.$ac_ext
 
6229
cat >>conftest.$ac_ext <<_ACEOF
 
6230
/* end confdefs.h.  */
 
6231
#include <stdlib.h>
 
6232
 
 
6233
_ACEOF
 
6234
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
 
6235
  $EGREP "free" >/dev/null 2>&1; then
 
6236
  :
 
6237
else
 
6238
  ac_cv_header_stdc=no
 
6239
fi
 
6240
rm -f conftest*
 
6241
 
 
6242
fi
 
6243
 
 
6244
if test $ac_cv_header_stdc = yes; then
 
6245
  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
 
6246
  if test "$cross_compiling" = yes; then
 
6247
  :
 
6248
else
 
6249
  cat >conftest.$ac_ext <<_ACEOF
 
6250
/* confdefs.h.  */
 
6251
_ACEOF
 
6252
cat confdefs.h >>conftest.$ac_ext
 
6253
cat >>conftest.$ac_ext <<_ACEOF
 
6254
/* end confdefs.h.  */
 
6255
#include <ctype.h>
 
6256
#if ((' ' & 0x0FF) == 0x020)
 
6257
# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
 
6258
# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
 
6259
#else
 
6260
# define ISLOWER(c) \
 
6261
                   (('a' <= (c) && (c) <= 'i') \
 
6262
                     || ('j' <= (c) && (c) <= 'r') \
 
6263
                     || ('s' <= (c) && (c) <= 'z'))
 
6264
# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
 
6265
#endif
 
6266
 
 
6267
#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
 
6268
int
 
6269
main ()
 
6270
{
 
6271
  int i;
 
6272
  for (i = 0; i < 256; i++)
 
6273
    if (XOR (islower (i), ISLOWER (i))
 
6274
        || toupper (i) != TOUPPER (i))
 
6275
      exit(2);
 
6276
  exit (0);
 
6277
}
 
6278
_ACEOF
 
6279
rm -f conftest$ac_exeext
 
6280
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
6281
  (eval $ac_link) 2>&5
 
6282
  ac_status=$?
 
6283
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6284
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
 
6285
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6286
  (eval $ac_try) 2>&5
 
6287
  ac_status=$?
 
6288
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6289
  (exit $ac_status); }; }; then
 
6290
  :
 
6291
else
 
6292
  echo "$as_me: program exited with status $ac_status" >&5
 
6293
echo "$as_me: failed program was:" >&5
 
6294
sed 's/^/| /' conftest.$ac_ext >&5
 
6295
 
 
6296
( exit $ac_status )
 
6297
ac_cv_header_stdc=no
 
6298
fi
 
6299
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
 
6300
fi
 
6301
fi
 
6302
fi
 
6303
echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
 
6304
echo "${ECHO_T}$ac_cv_header_stdc" >&6
 
6305
if test $ac_cv_header_stdc = yes; then
 
6306
 
 
6307
cat >>confdefs.h <<\_ACEOF
 
6308
#define STDC_HEADERS 1
 
6309
_ACEOF
 
6310
 
 
6311
fi
 
6312
 
 
6313
# On IRIX 5.3, sys/types and inttypes.h are conflicting.
 
6314
 
 
6315
 
 
6316
 
 
6317
 
 
6318
 
 
6319
 
 
6320
 
 
6321
 
 
6322
 
 
6323
for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
 
6324
                  inttypes.h stdint.h unistd.h
 
6325
do
 
6326
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
6327
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
6328
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
6329
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
6330
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6331
else
 
6332
  cat >conftest.$ac_ext <<_ACEOF
 
6333
/* confdefs.h.  */
 
6334
_ACEOF
 
6335
cat confdefs.h >>conftest.$ac_ext
 
6336
cat >>conftest.$ac_ext <<_ACEOF
 
6337
/* end confdefs.h.  */
 
6338
$ac_includes_default
 
6339
 
 
6340
#include <$ac_header>
 
6341
_ACEOF
 
6342
rm -f conftest.$ac_objext
 
6343
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
6344
  (eval $ac_compile) 2>conftest.er1
 
6345
  ac_status=$?
 
6346
  grep -v '^ *+' conftest.er1 >conftest.err
 
6347
  rm -f conftest.er1
 
6348
  cat conftest.err >&5
 
6349
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6350
  (exit $ac_status); } &&
 
6351
         { ac_try='test -z "$ac_c_werror_flag"
 
6352
                         || test ! -s conftest.err'
 
6353
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6354
  (eval $ac_try) 2>&5
 
6355
  ac_status=$?
 
6356
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6357
  (exit $ac_status); }; } &&
 
6358
         { ac_try='test -s conftest.$ac_objext'
 
6359
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6360
  (eval $ac_try) 2>&5
 
6361
  ac_status=$?
 
6362
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6363
  (exit $ac_status); }; }; then
 
6364
  eval "$as_ac_Header=yes"
 
6365
else
 
6366
  echo "$as_me: failed program was:" >&5
 
6367
sed 's/^/| /' conftest.$ac_ext >&5
 
6368
 
 
6369
eval "$as_ac_Header=no"
 
6370
fi
 
6371
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
 
6372
fi
 
6373
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
6374
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
6375
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
6376
  cat >>confdefs.h <<_ACEOF
 
6377
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
6378
_ACEOF
 
6379
 
 
6380
fi
 
6381
 
 
6382
done
 
6383
 
 
6384
 
 
6385
 
 
6386
for ac_header in dlfcn.h
 
6387
do
 
6388
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
 
6389
echo "$as_me:$LINENO: checking for $ac_header" >&5
 
6390
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
 
6391
if eval "test \"\${$as_ac_Header+set}\" = set"; then
 
6392
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6393
else
 
6394
  cat >conftest.$ac_ext <<_ACEOF
 
6395
/* confdefs.h.  */
 
6396
_ACEOF
 
6397
cat confdefs.h >>conftest.$ac_ext
 
6398
cat >>conftest.$ac_ext <<_ACEOF
 
6399
/* end confdefs.h.  */
 
6400
$ac_includes_default
 
6401
 
 
6402
#include <$ac_header>
 
6403
_ACEOF
 
6404
rm -f conftest.$ac_objext
 
6405
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
6406
  (eval $ac_compile) 2>conftest.er1
 
6407
  ac_status=$?
 
6408
  grep -v '^ *+' conftest.er1 >conftest.err
 
6409
  rm -f conftest.er1
 
6410
  cat conftest.err >&5
 
6411
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6412
  (exit $ac_status); } &&
 
6413
         { ac_try='test -z "$ac_c_werror_flag"
 
6414
                         || test ! -s conftest.err'
 
6415
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6416
  (eval $ac_try) 2>&5
 
6417
  ac_status=$?
 
6418
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6419
  (exit $ac_status); }; } &&
 
6420
         { ac_try='test -s conftest.$ac_objext'
 
6421
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
6422
  (eval $ac_try) 2>&5
 
6423
  ac_status=$?
 
6424
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
6425
  (exit $ac_status); }; }; then
 
6426
  eval "$as_ac_Header=yes"
 
6427
else
 
6428
  echo "$as_me: failed program was:" >&5
 
6429
sed 's/^/| /' conftest.$ac_ext >&5
 
6430
 
 
6431
eval "$as_ac_Header=no"
 
6432
fi
 
6433
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
 
6434
fi
 
6435
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
 
6436
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
 
6437
if test `eval echo '${'$as_ac_Header'}'` = yes; then
 
6438
  cat >>confdefs.h <<_ACEOF
 
6439
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
 
6440
_ACEOF
 
6441
 
 
6442
fi
 
6443
 
 
6444
done
 
6445
 
4306
6446
 
4307
6447
 
4308
6448
# This can be used to rebuild libtool when needed
4309
 
LIBTOOL_DEPS="$ac_aux_dir/ltconfig $ac_aux_dir/ltmain.sh $ac_aux_dir/ltcf-c.sh"
 
6449
LIBTOOL_DEPS="$ltmain"
4310
6450
 
4311
6451
# Always use our own libtool.
4312
6452
LIBTOOL='$(SHELL) $(top_builddir)/libtool'
4313
6453
 
4314
 
# Redirect the config.log output again, so that the ltconfig log is not
4315
 
# clobbered by the next message.
4316
 
exec 5>>./config.log
4317
 
 
4318
 
 
4319
 
 
4320
 
 
 
6454
 
 
6455
 
 
6456
 
 
6457
 
 
6458
 
 
6459
 
 
6460
 
 
6461
 
 
6462
 
 
6463
 
 
6464
 
 
6465
 
 
6466
 
 
6467
 
 
6468
 
 
6469
 
 
6470
 
 
6471
 
 
6472
 
 
6473
 
 
6474
 
 
6475
 
 
6476
 
 
6477
 
 
6478
test -z "$LN_S" && LN_S="ln -s"
 
6479
 
 
6480
 
 
6481
 
 
6482
 
 
6483
 
 
6484
 
 
6485
 
 
6486
 
 
6487
 
 
6488
 
 
6489
 
 
6490
 
 
6491
 
 
6492
 
 
6493
if test -n "${ZSH_VERSION+set}" ; then
 
6494
   setopt NO_GLOB_SUBST
 
6495
fi
 
6496
 
 
6497
echo "$as_me:$LINENO: checking for objdir" >&5
 
6498
echo $ECHO_N "checking for objdir... $ECHO_C" >&6
 
6499
if test "${lt_cv_objdir+set}" = set; then
 
6500
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6501
else
 
6502
  rm -f .libs 2>/dev/null
 
6503
mkdir .libs 2>/dev/null
 
6504
if test -d .libs; then
 
6505
  lt_cv_objdir=.libs
 
6506
else
 
6507
  # MS-DOS does not allow filenames that begin with a dot.
 
6508
  lt_cv_objdir=_libs
 
6509
fi
 
6510
rmdir .libs 2>/dev/null
 
6511
fi
 
6512
echo "$as_me:$LINENO: result: $lt_cv_objdir" >&5
 
6513
echo "${ECHO_T}$lt_cv_objdir" >&6
 
6514
objdir=$lt_cv_objdir
 
6515
 
 
6516
 
 
6517
 
 
6518
 
 
6519
 
 
6520
cat >>confdefs.h <<_ACEOF
 
6521
#define LT_OBJDIR "$lt_cv_objdir/"
 
6522
_ACEOF
 
6523
 
 
6524
 
 
6525
 
 
6526
 
 
6527
 
 
6528
 
 
6529
 
 
6530
 
 
6531
 
 
6532
 
 
6533
 
 
6534
 
 
6535
 
 
6536
 
 
6537
 
 
6538
 
 
6539
 
 
6540
case $host_os in
 
6541
aix3*)
 
6542
  # AIX sometimes has problems with the GCC collect2 program.  For some
 
6543
  # reason, if we set the COLLECT_NAMES environment variable, the problems
 
6544
  # vanish in a puff of smoke.
 
6545
  if test "X${COLLECT_NAMES+set}" != Xset; then
 
6546
    COLLECT_NAMES=
 
6547
    export COLLECT_NAMES
 
6548
  fi
 
6549
  ;;
 
6550
esac
 
6551
 
 
6552
# Sed substitution that helps us do robust quoting.  It backslashifies
 
6553
# metacharacters that are still active within double-quoted strings.
 
6554
sed_quote_subst='s/\(["`$\\]\)/\\\1/g'
 
6555
 
 
6556
# Same as above, but do not quote variable references.
 
6557
double_quote_subst='s/\(["`\\]\)/\\\1/g'
 
6558
 
 
6559
# Sed substitution to delay expansion of an escaped shell variable in a
 
6560
# double_quote_subst'ed string.
 
6561
delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
 
6562
 
 
6563
# Sed substitution to delay expansion of an escaped single quote.
 
6564
delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
 
6565
 
 
6566
# Sed substitution to avoid accidental globbing in evaled expressions
 
6567
no_glob_subst='s/\*/\\\*/g'
 
6568
 
 
6569
# Global variables:
 
6570
ofile=libtool
 
6571
can_build_shared=yes
 
6572
 
 
6573
# All known linkers require a `.a' archive for static linking (except MSVC,
 
6574
# which needs '.lib').
 
6575
libext=a
 
6576
 
 
6577
with_gnu_ld="$lt_cv_prog_gnu_ld"
 
6578
 
 
6579
old_CC="$CC"
 
6580
old_CFLAGS="$CFLAGS"
 
6581
 
 
6582
# Set sane defaults for various variables
 
6583
test -z "$CC" && CC=cc
 
6584
test -z "$LTCC" && LTCC=$CC
 
6585
test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
 
6586
test -z "$LD" && LD=ld
 
6587
test -z "$ac_objext" && ac_objext=o
 
6588
 
 
6589
for cc_temp in $compiler""; do
 
6590
  case $cc_temp in
 
6591
    compile | *[\\/]compile | ccache | *[\\/]ccache ) ;;
 
6592
    distcc | *[\\/]distcc | purify | *[\\/]purify ) ;;
 
6593
    \-*) ;;
 
6594
    *) break;;
 
6595
  esac
 
6596
done
 
6597
cc_basename=`$ECHO "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
 
6598
 
 
6599
 
 
6600
# Only perform the check for file, if the check method requires it
 
6601
test -z "$MAGIC_CMD" && MAGIC_CMD=file
 
6602
case $deplibs_check_method in
 
6603
file_magic*)
 
6604
  if test "$file_magic_cmd" = '$MAGIC_CMD'; then
 
6605
    echo "$as_me:$LINENO: checking for ${ac_tool_prefix}file" >&5
 
6606
echo $ECHO_N "checking for ${ac_tool_prefix}file... $ECHO_C" >&6
 
6607
if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
 
6608
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6609
else
 
6610
  case $MAGIC_CMD in
 
6611
[\\/*] |  ?:[\\/]*)
 
6612
  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
 
6613
  ;;
 
6614
*)
 
6615
  lt_save_MAGIC_CMD="$MAGIC_CMD"
 
6616
  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
 
6617
  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
 
6618
  for ac_dir in $ac_dummy; do
 
6619
    IFS="$lt_save_ifs"
 
6620
    test -z "$ac_dir" && ac_dir=.
 
6621
    if test -f $ac_dir/${ac_tool_prefix}file; then
 
6622
      lt_cv_path_MAGIC_CMD="$ac_dir/${ac_tool_prefix}file"
 
6623
      if test -n "$file_magic_test_file"; then
 
6624
        case $deplibs_check_method in
 
6625
        "file_magic "*)
 
6626
          file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
 
6627
          MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
 
6628
          if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
 
6629
            $EGREP "$file_magic_regex" > /dev/null; then
 
6630
            :
 
6631
          else
 
6632
            cat <<_LT_EOF 1>&2
 
6633
 
 
6634
*** Warning: the command libtool uses to detect shared libraries,
 
6635
*** $file_magic_cmd, produces output that libtool cannot recognize.
 
6636
*** The result is that libtool may fail to recognize shared libraries
 
6637
*** as such.  This will affect the creation of libtool libraries that
 
6638
*** depend on shared libraries, but programs linked with such libtool
 
6639
*** libraries will work regardless of this problem.  Nevertheless, you
 
6640
*** may want to report the problem to your system manager and/or to
 
6641
*** bug-libtool@gnu.org
 
6642
 
 
6643
_LT_EOF
 
6644
          fi ;;
 
6645
        esac
 
6646
      fi
 
6647
      break
 
6648
    fi
 
6649
  done
 
6650
  IFS="$lt_save_ifs"
 
6651
  MAGIC_CMD="$lt_save_MAGIC_CMD"
 
6652
  ;;
 
6653
esac
 
6654
fi
 
6655
 
 
6656
MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
 
6657
if test -n "$MAGIC_CMD"; then
 
6658
  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
 
6659
echo "${ECHO_T}$MAGIC_CMD" >&6
 
6660
else
 
6661
  echo "$as_me:$LINENO: result: no" >&5
 
6662
echo "${ECHO_T}no" >&6
 
6663
fi
 
6664
 
 
6665
 
 
6666
 
 
6667
 
 
6668
 
 
6669
if test -z "$lt_cv_path_MAGIC_CMD"; then
 
6670
  if test -n "$ac_tool_prefix"; then
 
6671
    echo "$as_me:$LINENO: checking for file" >&5
 
6672
echo $ECHO_N "checking for file... $ECHO_C" >&6
 
6673
if test "${lt_cv_path_MAGIC_CMD+set}" = set; then
 
6674
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6675
else
 
6676
  case $MAGIC_CMD in
 
6677
[\\/*] |  ?:[\\/]*)
 
6678
  lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
 
6679
  ;;
 
6680
*)
 
6681
  lt_save_MAGIC_CMD="$MAGIC_CMD"
 
6682
  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
 
6683
  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
 
6684
  for ac_dir in $ac_dummy; do
 
6685
    IFS="$lt_save_ifs"
 
6686
    test -z "$ac_dir" && ac_dir=.
 
6687
    if test -f $ac_dir/file; then
 
6688
      lt_cv_path_MAGIC_CMD="$ac_dir/file"
 
6689
      if test -n "$file_magic_test_file"; then
 
6690
        case $deplibs_check_method in
 
6691
        "file_magic "*)
 
6692
          file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
 
6693
          MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
 
6694
          if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
 
6695
            $EGREP "$file_magic_regex" > /dev/null; then
 
6696
            :
 
6697
          else
 
6698
            cat <<_LT_EOF 1>&2
 
6699
 
 
6700
*** Warning: the command libtool uses to detect shared libraries,
 
6701
*** $file_magic_cmd, produces output that libtool cannot recognize.
 
6702
*** The result is that libtool may fail to recognize shared libraries
 
6703
*** as such.  This will affect the creation of libtool libraries that
 
6704
*** depend on shared libraries, but programs linked with such libtool
 
6705
*** libraries will work regardless of this problem.  Nevertheless, you
 
6706
*** may want to report the problem to your system manager and/or to
 
6707
*** bug-libtool@gnu.org
 
6708
 
 
6709
_LT_EOF
 
6710
          fi ;;
 
6711
        esac
 
6712
      fi
 
6713
      break
 
6714
    fi
 
6715
  done
 
6716
  IFS="$lt_save_ifs"
 
6717
  MAGIC_CMD="$lt_save_MAGIC_CMD"
 
6718
  ;;
 
6719
esac
 
6720
fi
 
6721
 
 
6722
MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
 
6723
if test -n "$MAGIC_CMD"; then
 
6724
  echo "$as_me:$LINENO: result: $MAGIC_CMD" >&5
 
6725
echo "${ECHO_T}$MAGIC_CMD" >&6
 
6726
else
 
6727
  echo "$as_me:$LINENO: result: no" >&5
 
6728
echo "${ECHO_T}no" >&6
 
6729
fi
 
6730
 
 
6731
 
 
6732
  else
 
6733
    MAGIC_CMD=:
 
6734
  fi
 
6735
fi
 
6736
 
 
6737
  fi
 
6738
  ;;
 
6739
esac
 
6740
 
 
6741
# Use C for the default configuration in the libtool script
 
6742
 
 
6743
lt_save_CC="$CC"
 
6744
ac_ext=c
 
6745
ac_cpp='$CPP $CPPFLAGS'
 
6746
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
6747
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
6748
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
6749
 
 
6750
 
 
6751
# Source file extension for C test sources.
 
6752
ac_ext=c
 
6753
 
 
6754
# Object file extension for compiled C test sources.
 
6755
objext=o
 
6756
objext=$objext
 
6757
 
 
6758
# Code to be used in simple compile tests
 
6759
lt_simple_compile_test_code="int some_variable = 0;"
 
6760
 
 
6761
# Code to be used in simple link tests
 
6762
lt_simple_link_test_code='int main(){return(0);}'
 
6763
 
 
6764
 
 
6765
 
 
6766
 
 
6767
 
 
6768
 
 
6769
 
 
6770
# If no C compiler was specified, use CC.
 
6771
LTCC=${LTCC-"$CC"}
 
6772
 
 
6773
# If no C compiler flags were specified, use CFLAGS.
 
6774
LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
 
6775
 
 
6776
# Allow CC to be a program name with arguments.
 
6777
compiler=$CC
 
6778
 
 
6779
# Save the default compiler, since it gets overwritten when the other
 
6780
# tags are being tested, and _LT_TAGVAR(compiler, []) is a NOP.
 
6781
compiler_DEFAULT=$CC
 
6782
 
 
6783
# save warnings/boilerplate of simple test code
 
6784
ac_outfile=conftest.$ac_objext
 
6785
echo "$lt_simple_compile_test_code" >conftest.$ac_ext
 
6786
eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
 
6787
_lt_compiler_boilerplate=`cat conftest.err`
 
6788
$RM conftest*
 
6789
 
 
6790
ac_outfile=conftest.$ac_objext
 
6791
echo "$lt_simple_link_test_code" >conftest.$ac_ext
 
6792
eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
 
6793
_lt_linker_boilerplate=`cat conftest.err`
 
6794
$RM conftest*
 
6795
 
 
6796
 
 
6797
## CAVEAT EMPTOR:
 
6798
## There is no encapsulation within the following macros, do not change
 
6799
## the running order or otherwise move them around unless you know exactly
 
6800
## what you are doing...
 
6801
if test -n "$compiler"; then
 
6802
 
 
6803
lt_prog_compiler_no_builtin_flag=
 
6804
 
 
6805
if test "$GCC" = yes; then
 
6806
  lt_prog_compiler_no_builtin_flag=' -fno-builtin'
 
6807
 
 
6808
  echo "$as_me:$LINENO: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
 
6809
echo $ECHO_N "checking if $compiler supports -fno-rtti -fno-exceptions... $ECHO_C" >&6
 
6810
if test "${lt_cv_prog_compiler_rtti_exceptions+set}" = set; then
 
6811
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
6812
else
 
6813
  lt_cv_prog_compiler_rtti_exceptions=no
 
6814
   ac_outfile=conftest.$ac_objext
 
6815
   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
 
6816
   lt_compiler_flag="-fno-rtti -fno-exceptions"
 
6817
   # Insert the option either (1) after the last *FLAGS variable, or
 
6818
   # (2) before a word containing "conftest.", or (3) at the end.
 
6819
   # Note that $ac_compile itself does not contain backslashes and begins
 
6820
   # with a dollar sign (not a hyphen), so the echo should work correctly.
 
6821
   # The option is referenced via a variable to avoid confusing sed.
 
6822
   lt_compile=`echo "$ac_compile" | $SED \
 
6823
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
 
6824
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
 
6825
   -e 's:$: $lt_compiler_flag:'`
 
6826
   (eval echo "\"\$as_me:6826: $lt_compile\"" >&5)
 
6827
   (eval "$lt_compile" 2>conftest.err)
 
6828
   ac_status=$?
 
6829
   cat conftest.err >&5
 
6830
   echo "$as_me:6830: \$? = $ac_status" >&5
 
6831
   if (exit $ac_status) && test -s "$ac_outfile"; then
 
6832
     # The compiler can only warn and ignore the option if not recognized
 
6833
     # So say no if there are warnings other than the usual output.
 
6834
     $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
 
6835
     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
 
6836
     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
 
6837
       lt_cv_prog_compiler_rtti_exceptions=yes
 
6838
     fi
 
6839
   fi
 
6840
   $RM conftest*
 
6841
 
 
6842
fi
 
6843
echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
 
6844
echo "${ECHO_T}$lt_cv_prog_compiler_rtti_exceptions" >&6
 
6845
 
 
6846
if test x"$lt_cv_prog_compiler_rtti_exceptions" = xyes; then
 
6847
    lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions"
 
6848
else
 
6849
    :
 
6850
fi
 
6851
 
 
6852
fi
 
6853
 
 
6854
 
 
6855
 
 
6856
 
 
6857
 
 
6858
 
 
6859
  lt_prog_compiler_wl=
 
6860
lt_prog_compiler_pic=
 
6861
lt_prog_compiler_static=
 
6862
 
 
6863
echo "$as_me:$LINENO: checking for $compiler option to produce PIC" >&5
 
6864
echo $ECHO_N "checking for $compiler option to produce PIC... $ECHO_C" >&6
 
6865
 
 
6866
  if test "$GCC" = yes; then
 
6867
    lt_prog_compiler_wl='-Wl,'
 
6868
    lt_prog_compiler_static='-static'
 
6869
 
 
6870
    case $host_os in
 
6871
      aix*)
 
6872
      # All AIX code is PIC.
 
6873
      if test "$host_cpu" = ia64; then
 
6874
        # AIX 5 now supports IA64 processor
 
6875
        lt_prog_compiler_static='-Bstatic'
 
6876
      fi
 
6877
      ;;
 
6878
 
 
6879
    amigaos*)
 
6880
      if test "$host_cpu" = m68k; then
 
6881
        # FIXME: we need at least 68020 code to build shared libraries, but
 
6882
        # adding the `-m68020' flag to GCC prevents building anything better,
 
6883
        # like `-m68040'.
 
6884
        lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4'
 
6885
      fi
 
6886
      ;;
 
6887
 
 
6888
    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
 
6889
      # PIC is the default for these OSes.
 
6890
      ;;
 
6891
 
 
6892
    mingw* | cygwin* | pw32* | os2*)
 
6893
      # This hack is so that the source file can tell whether it is being
 
6894
      # built for inclusion in a dll (and should export symbols for example).
 
6895
      # Although the cygwin gcc ignores -fPIC, still need this for old-style
 
6896
      # (--disable-auto-import) libraries
 
6897
      lt_prog_compiler_pic='-DDLL_EXPORT'
 
6898
      ;;
 
6899
 
 
6900
    darwin* | rhapsody*)
 
6901
      # PIC is the default on this platform
 
6902
      # Common symbols not allowed in MH_DYLIB files
 
6903
      lt_prog_compiler_pic='-fno-common'
 
6904
      ;;
 
6905
 
 
6906
    hpux*)
 
6907
      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
 
6908
      # not for PA HP-UX.
 
6909
      case $host_cpu in
 
6910
      hppa*64*|ia64*)
 
6911
        # +Z the default
 
6912
        ;;
 
6913
      *)
 
6914
        lt_prog_compiler_pic='-fPIC'
 
6915
        ;;
 
6916
      esac
 
6917
      ;;
 
6918
 
 
6919
    interix[3-9]*)
 
6920
      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
 
6921
      # Instead, we relocate shared libraries at runtime.
 
6922
      ;;
 
6923
 
 
6924
    msdosdjgpp*)
 
6925
      # Just because we use GCC doesn't mean we suddenly get shared libraries
 
6926
      # on systems that don't support them.
 
6927
      lt_prog_compiler_can_build_shared=no
 
6928
      enable_shared=no
 
6929
      ;;
 
6930
 
 
6931
    *nto* | *qnx*)
 
6932
      # QNX uses GNU C++, but need to define -shared option too, otherwise
 
6933
      # it will coredump.
 
6934
      lt_prog_compiler_pic='-fPIC -shared'
 
6935
      ;;
 
6936
 
 
6937
    sysv4*MP*)
 
6938
      if test -d /usr/nec; then
 
6939
        lt_prog_compiler_pic=-Kconform_pic
 
6940
      fi
 
6941
      ;;
 
6942
 
 
6943
    *)
 
6944
      lt_prog_compiler_pic='-fPIC'
 
6945
      ;;
 
6946
    esac
 
6947
  else
 
6948
    # PORTME Check for flag to pass linker flags through the system compiler.
 
6949
    case $host_os in
 
6950
    aix*)
 
6951
      lt_prog_compiler_wl='-Wl,'
 
6952
      if test "$host_cpu" = ia64; then
 
6953
        # AIX 5 now supports IA64 processor
 
6954
        lt_prog_compiler_static='-Bstatic'
 
6955
      else
 
6956
        lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp'
 
6957
      fi
 
6958
      ;;
 
6959
    darwin*)
 
6960
      # PIC is the default on this platform
 
6961
      # Common symbols not allowed in MH_DYLIB files
 
6962
      case $cc_basename in
 
6963
      xlc*)
 
6964
        lt_prog_compiler_pic='-qnocommon'
 
6965
        lt_prog_compiler_wl='-Wl,'
 
6966
        ;;
 
6967
      esac
 
6968
      ;;
 
6969
 
 
6970
    mingw* | cygwin* | pw32* | os2*)
 
6971
      # This hack is so that the source file can tell whether it is being
 
6972
      # built for inclusion in a dll (and should export symbols for example).
 
6973
      lt_prog_compiler_pic='-DDLL_EXPORT'
 
6974
      ;;
 
6975
 
 
6976
    hpux9* | hpux10* | hpux11*)
 
6977
      lt_prog_compiler_wl='-Wl,'
 
6978
      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
 
6979
      # not for PA HP-UX.
 
6980
      case $host_cpu in
 
6981
      hppa*64*|ia64*)
 
6982
        # +Z the default
 
6983
        ;;
 
6984
      *)
 
6985
        lt_prog_compiler_pic='+Z'
 
6986
        ;;
 
6987
      esac
 
6988
      # Is there a better lt_prog_compiler_static that works with the bundled CC?
 
6989
      lt_prog_compiler_static='${wl}-a ${wl}archive'
 
6990
      ;;
 
6991
 
 
6992
    irix5* | irix6* | nonstopux*)
 
6993
      lt_prog_compiler_wl='-Wl,'
 
6994
      # PIC (with -KPIC) is the default.
 
6995
      lt_prog_compiler_static='-non_shared'
 
6996
      ;;
 
6997
 
 
6998
    linux* | k*bsd*-gnu)
 
6999
      case $cc_basename in
 
7000
      icc* | ecc*)
 
7001
        lt_prog_compiler_wl='-Wl,'
 
7002
        lt_prog_compiler_pic='-KPIC'
 
7003
        lt_prog_compiler_static='-static'
 
7004
        ;;
 
7005
      pgcc* | pgf77* | pgf90* | pgf95*)
 
7006
        # Portland Group compilers (*not* the Pentium gcc compiler,
 
7007
        # which looks to be a dead project)
 
7008
        lt_prog_compiler_wl='-Wl,'
 
7009
        lt_prog_compiler_pic='-fpic'
 
7010
        lt_prog_compiler_static='-Bstatic'
 
7011
        ;;
 
7012
      ccc*)
 
7013
        lt_prog_compiler_wl='-Wl,'
 
7014
        # All Alpha code is PIC.
 
7015
        lt_prog_compiler_static='-non_shared'
 
7016
        ;;
 
7017
      *)
 
7018
        case `$CC -V 2>&1 | sed 5q` in
 
7019
        *Sun\ C*)
 
7020
          # Sun C 5.9
 
7021
          lt_prog_compiler_pic='-KPIC'
 
7022
          lt_prog_compiler_static='-Bstatic'
 
7023
          lt_prog_compiler_wl='-Wl,'
 
7024
          ;;
 
7025
        *Sun\ F*)
 
7026
          # Sun Fortran 8.3 passes all unrecognized flags to the linker
 
7027
          lt_prog_compiler_pic='-KPIC'
 
7028
          lt_prog_compiler_static='-Bstatic'
 
7029
          lt_prog_compiler_wl=''
 
7030
          ;;
 
7031
        esac
 
7032
        ;;
 
7033
      esac
 
7034
      ;;
 
7035
 
 
7036
    newsos6)
 
7037
      lt_prog_compiler_pic='-KPIC'
 
7038
      lt_prog_compiler_static='-Bstatic'
 
7039
      ;;
 
7040
 
 
7041
    *nto* | *qnx*)
 
7042
      # QNX uses GNU C++, but need to define -shared option too, otherwise
 
7043
      # it will coredump.
 
7044
      lt_prog_compiler_pic='-fPIC -shared'
 
7045
      ;;
 
7046
 
 
7047
    osf3* | osf4* | osf5*)
 
7048
      lt_prog_compiler_wl='-Wl,'
 
7049
      # All OSF/1 code is PIC.
 
7050
      lt_prog_compiler_static='-non_shared'
 
7051
      ;;
 
7052
 
 
7053
    rdos*)
 
7054
      lt_prog_compiler_static='-non_shared'
 
7055
      ;;
 
7056
 
 
7057
    solaris*)
 
7058
      lt_prog_compiler_pic='-KPIC'
 
7059
      lt_prog_compiler_static='-Bstatic'
 
7060
      case $cc_basename in
 
7061
      f77* | f90* | f95*)
 
7062
        lt_prog_compiler_wl='-Qoption ld ';;
 
7063
      *)
 
7064
        lt_prog_compiler_wl='-Wl,';;
 
7065
      esac
 
7066
      ;;
 
7067
 
 
7068
    sunos4*)
 
7069
      lt_prog_compiler_wl='-Qoption ld '
 
7070
      lt_prog_compiler_pic='-PIC'
 
7071
      lt_prog_compiler_static='-Bstatic'
 
7072
      ;;
 
7073
 
 
7074
    sysv4 | sysv4.2uw2* | sysv4.3*)
 
7075
      lt_prog_compiler_wl='-Wl,'
 
7076
      lt_prog_compiler_pic='-KPIC'
 
7077
      lt_prog_compiler_static='-Bstatic'
 
7078
      ;;
 
7079
 
 
7080
    sysv4*MP*)
 
7081
      if test -d /usr/nec ;then
 
7082
        lt_prog_compiler_pic='-Kconform_pic'
 
7083
        lt_prog_compiler_static='-Bstatic'
 
7084
      fi
 
7085
      ;;
 
7086
 
 
7087
    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
 
7088
      lt_prog_compiler_wl='-Wl,'
 
7089
      lt_prog_compiler_pic='-KPIC'
 
7090
      lt_prog_compiler_static='-Bstatic'
 
7091
      ;;
 
7092
 
 
7093
    unicos*)
 
7094
      lt_prog_compiler_wl='-Wl,'
 
7095
      lt_prog_compiler_can_build_shared=no
 
7096
      ;;
 
7097
 
 
7098
    uts4*)
 
7099
      lt_prog_compiler_pic='-pic'
 
7100
      lt_prog_compiler_static='-Bstatic'
 
7101
      ;;
 
7102
 
 
7103
    *)
 
7104
      lt_prog_compiler_can_build_shared=no
 
7105
      ;;
 
7106
    esac
 
7107
  fi
 
7108
 
 
7109
case $host_os in
 
7110
  # For platforms which do not support PIC, -DPIC is meaningless:
 
7111
  *djgpp*)
 
7112
    lt_prog_compiler_pic=
 
7113
    ;;
 
7114
  *)
 
7115
    lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC"
 
7116
    ;;
 
7117
esac
 
7118
echo "$as_me:$LINENO: result: $lt_prog_compiler_pic" >&5
 
7119
echo "${ECHO_T}$lt_prog_compiler_pic" >&6
 
7120
 
 
7121
 
 
7122
 
 
7123
 
 
7124
 
 
7125
 
 
7126
#
 
7127
# Check to make sure the PIC flag actually works.
 
7128
#
 
7129
if test -n "$lt_prog_compiler_pic"; then
 
7130
  echo "$as_me:$LINENO: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
 
7131
echo $ECHO_N "checking if $compiler PIC flag $lt_prog_compiler_pic works... $ECHO_C" >&6
 
7132
if test "${lt_prog_compiler_pic_works+set}" = set; then
 
7133
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7134
else
 
7135
  lt_prog_compiler_pic_works=no
 
7136
   ac_outfile=conftest.$ac_objext
 
7137
   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
 
7138
   lt_compiler_flag="$lt_prog_compiler_pic -DPIC"
 
7139
   # Insert the option either (1) after the last *FLAGS variable, or
 
7140
   # (2) before a word containing "conftest.", or (3) at the end.
 
7141
   # Note that $ac_compile itself does not contain backslashes and begins
 
7142
   # with a dollar sign (not a hyphen), so the echo should work correctly.
 
7143
   # The option is referenced via a variable to avoid confusing sed.
 
7144
   lt_compile=`echo "$ac_compile" | $SED \
 
7145
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
 
7146
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
 
7147
   -e 's:$: $lt_compiler_flag:'`
 
7148
   (eval echo "\"\$as_me:7148: $lt_compile\"" >&5)
 
7149
   (eval "$lt_compile" 2>conftest.err)
 
7150
   ac_status=$?
 
7151
   cat conftest.err >&5
 
7152
   echo "$as_me:7152: \$? = $ac_status" >&5
 
7153
   if (exit $ac_status) && test -s "$ac_outfile"; then
 
7154
     # The compiler can only warn and ignore the option if not recognized
 
7155
     # So say no if there are warnings other than the usual output.
 
7156
     $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
 
7157
     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
 
7158
     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
 
7159
       lt_prog_compiler_pic_works=yes
 
7160
     fi
 
7161
   fi
 
7162
   $RM conftest*
 
7163
 
 
7164
fi
 
7165
echo "$as_me:$LINENO: result: $lt_prog_compiler_pic_works" >&5
 
7166
echo "${ECHO_T}$lt_prog_compiler_pic_works" >&6
 
7167
 
 
7168
if test x"$lt_prog_compiler_pic_works" = xyes; then
 
7169
    case $lt_prog_compiler_pic in
 
7170
     "" | " "*) ;;
 
7171
     *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;;
 
7172
     esac
 
7173
else
 
7174
    lt_prog_compiler_pic=
 
7175
     lt_prog_compiler_can_build_shared=no
 
7176
fi
 
7177
 
 
7178
fi
 
7179
 
 
7180
 
 
7181
 
 
7182
 
 
7183
 
 
7184
 
 
7185
#
 
7186
# Check to make sure the static flag actually works.
 
7187
#
 
7188
wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\"
 
7189
echo "$as_me:$LINENO: checking if $compiler static flag $lt_tmp_static_flag works" >&5
 
7190
echo $ECHO_N "checking if $compiler static flag $lt_tmp_static_flag works... $ECHO_C" >&6
 
7191
if test "${lt_prog_compiler_static_works+set}" = set; then
 
7192
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7193
else
 
7194
  lt_prog_compiler_static_works=no
 
7195
   save_LDFLAGS="$LDFLAGS"
 
7196
   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
 
7197
   echo "$lt_simple_link_test_code" > conftest.$ac_ext
 
7198
   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
 
7199
     # The linker can only warn and ignore the option if not recognized
 
7200
     # So say no if there are warnings
 
7201
     if test -s conftest.err; then
 
7202
       # Append any errors to the config.log.
 
7203
       cat conftest.err 1>&5
 
7204
       $ECHO "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp
 
7205
       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
 
7206
       if diff conftest.exp conftest.er2 >/dev/null; then
 
7207
         lt_prog_compiler_static_works=yes
 
7208
       fi
 
7209
     else
 
7210
       lt_prog_compiler_static_works=yes
 
7211
     fi
 
7212
   fi
 
7213
   $RM conftest*
 
7214
   LDFLAGS="$save_LDFLAGS"
 
7215
 
 
7216
fi
 
7217
echo "$as_me:$LINENO: result: $lt_prog_compiler_static_works" >&5
 
7218
echo "${ECHO_T}$lt_prog_compiler_static_works" >&6
 
7219
 
 
7220
if test x"$lt_prog_compiler_static_works" = xyes; then
 
7221
    :
 
7222
else
 
7223
    lt_prog_compiler_static=
 
7224
fi
 
7225
 
 
7226
 
 
7227
 
 
7228
 
 
7229
 
 
7230
 
 
7231
 
 
7232
  echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5
 
7233
echo $ECHO_N "checking if $compiler supports -c -o file.$ac_objext... $ECHO_C" >&6
 
7234
if test "${lt_cv_prog_compiler_c_o+set}" = set; then
 
7235
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7236
else
 
7237
  lt_cv_prog_compiler_c_o=no
 
7238
   $RM -r conftest 2>/dev/null
 
7239
   mkdir conftest
 
7240
   cd conftest
 
7241
   mkdir out
 
7242
   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
 
7243
 
 
7244
   lt_compiler_flag="-o out/conftest2.$ac_objext"
 
7245
   # Insert the option either (1) after the last *FLAGS variable, or
 
7246
   # (2) before a word containing "conftest.", or (3) at the end.
 
7247
   # Note that $ac_compile itself does not contain backslashes and begins
 
7248
   # with a dollar sign (not a hyphen), so the echo should work correctly.
 
7249
   lt_compile=`echo "$ac_compile" | $SED \
 
7250
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
 
7251
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
 
7252
   -e 's:$: $lt_compiler_flag:'`
 
7253
   (eval echo "\"\$as_me:7253: $lt_compile\"" >&5)
 
7254
   (eval "$lt_compile" 2>out/conftest.err)
 
7255
   ac_status=$?
 
7256
   cat out/conftest.err >&5
 
7257
   echo "$as_me:7257: \$? = $ac_status" >&5
 
7258
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
 
7259
   then
 
7260
     # The compiler can only warn and ignore the option if not recognized
 
7261
     # So say no if there are warnings
 
7262
     $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp
 
7263
     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
 
7264
     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
 
7265
       lt_cv_prog_compiler_c_o=yes
 
7266
     fi
 
7267
   fi
 
7268
   chmod u+w . 2>&5
 
7269
   $RM conftest*
 
7270
   # SGI C++ compiler will create directory out/ii_files/ for
 
7271
   # template instantiation
 
7272
   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
 
7273
   $RM out/* && rmdir out
 
7274
   cd ..
 
7275
   $RM -r conftest
 
7276
   $RM conftest*
 
7277
 
 
7278
fi
 
7279
echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_c_o" >&5
 
7280
echo "${ECHO_T}$lt_cv_prog_compiler_c_o" >&6
 
7281
 
 
7282
 
 
7283
 
 
7284
 
 
7285
 
 
7286
 
 
7287
  echo "$as_me:$LINENO: checking if $compiler supports -c -o file.$ac_objext" >&5
 
7288
echo $ECHO_N "checking if $compiler supports -c -o file.$ac_objext... $ECHO_C" >&6
 
7289
if test "${lt_cv_prog_compiler_c_o+set}" = set; then
 
7290
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7291
else
 
7292
  lt_cv_prog_compiler_c_o=no
 
7293
   $RM -r conftest 2>/dev/null
 
7294
   mkdir conftest
 
7295
   cd conftest
 
7296
   mkdir out
 
7297
   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
 
7298
 
 
7299
   lt_compiler_flag="-o out/conftest2.$ac_objext"
 
7300
   # Insert the option either (1) after the last *FLAGS variable, or
 
7301
   # (2) before a word containing "conftest.", or (3) at the end.
 
7302
   # Note that $ac_compile itself does not contain backslashes and begins
 
7303
   # with a dollar sign (not a hyphen), so the echo should work correctly.
 
7304
   lt_compile=`echo "$ac_compile" | $SED \
 
7305
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
 
7306
   -e 's: [^ ]*conftest\.: $lt_compiler_flag&:; t' \
 
7307
   -e 's:$: $lt_compiler_flag:'`
 
7308
   (eval echo "\"\$as_me:7308: $lt_compile\"" >&5)
 
7309
   (eval "$lt_compile" 2>out/conftest.err)
 
7310
   ac_status=$?
 
7311
   cat out/conftest.err >&5
 
7312
   echo "$as_me:7312: \$? = $ac_status" >&5
 
7313
   if (exit $ac_status) && test -s out/conftest2.$ac_objext
 
7314
   then
 
7315
     # The compiler can only warn and ignore the option if not recognized
 
7316
     # So say no if there are warnings
 
7317
     $ECHO "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp
 
7318
     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
 
7319
     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
 
7320
       lt_cv_prog_compiler_c_o=yes
 
7321
     fi
 
7322
   fi
 
7323
   chmod u+w . 2>&5
 
7324
   $RM conftest*
 
7325
   # SGI C++ compiler will create directory out/ii_files/ for
 
7326
   # template instantiation
 
7327
   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
 
7328
   $RM out/* && rmdir out
 
7329
   cd ..
 
7330
   $RM -r conftest
 
7331
   $RM conftest*
 
7332
 
 
7333
fi
 
7334
echo "$as_me:$LINENO: result: $lt_cv_prog_compiler_c_o" >&5
 
7335
echo "${ECHO_T}$lt_cv_prog_compiler_c_o" >&6
 
7336
 
 
7337
 
 
7338
 
 
7339
 
 
7340
hard_links="nottested"
 
7341
if test "$lt_cv_prog_compiler_c_o" = no && test "$need_locks" != no; then
 
7342
  # do not overwrite the value of need_locks provided by the user
 
7343
  echo "$as_me:$LINENO: checking if we can lock with hard links" >&5
 
7344
echo $ECHO_N "checking if we can lock with hard links... $ECHO_C" >&6
 
7345
  hard_links=yes
 
7346
  $RM conftest*
 
7347
  ln conftest.a conftest.b 2>/dev/null && hard_links=no
 
7348
  touch conftest.a
 
7349
  ln conftest.a conftest.b 2>&5 || hard_links=no
 
7350
  ln conftest.a conftest.b 2>/dev/null && hard_links=no
 
7351
  echo "$as_me:$LINENO: result: $hard_links" >&5
 
7352
echo "${ECHO_T}$hard_links" >&6
 
7353
  if test "$hard_links" = no; then
 
7354
    { echo "$as_me:$LINENO: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&5
 
7355
echo "$as_me: WARNING: \`$CC' does not support \`-c -o', so \`make -j' may be unsafe" >&2;}
 
7356
    need_locks=warn
 
7357
  fi
 
7358
else
 
7359
  need_locks=no
 
7360
fi
 
7361
 
 
7362
 
 
7363
 
 
7364
 
 
7365
 
 
7366
 
 
7367
  echo "$as_me:$LINENO: checking whether the $compiler linker ($LD) supports shared libraries" >&5
 
7368
echo $ECHO_N "checking whether the $compiler linker ($LD) supports shared libraries... $ECHO_C" >&6
 
7369
 
 
7370
  runpath_var=
 
7371
  allow_undefined_flag=
 
7372
  always_export_symbols=no
 
7373
  archive_cmds=
 
7374
  archive_expsym_cmds=
 
7375
  compiler_needs_object=no
 
7376
  enable_shared_with_static_runtimes=no
 
7377
  export_dynamic_flag_spec=
 
7378
  export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
 
7379
  hardcode_automatic=no
 
7380
  hardcode_direct=no
 
7381
  hardcode_direct_absolute=no
 
7382
  hardcode_libdir_flag_spec=
 
7383
  hardcode_libdir_flag_spec_ld=
 
7384
  hardcode_libdir_separator=
 
7385
  hardcode_minus_L=no
 
7386
  hardcode_shlibpath_var=unsupported
 
7387
  inherit_rpath=no
 
7388
  link_all_deplibs=unknown
 
7389
  module_cmds=
 
7390
  module_expsym_cmds=
 
7391
  old_archive_from_new_cmds=
 
7392
  old_archive_from_expsyms_cmds=
 
7393
  thread_safe_flag_spec=
 
7394
  whole_archive_flag_spec=
 
7395
  # include_expsyms should be a list of space-separated symbols to be *always*
 
7396
  # included in the symbol list
 
7397
  include_expsyms=
 
7398
  # exclude_expsyms can be an extended regexp of symbols to exclude
 
7399
  # it will be wrapped by ` (' and `)$', so one must not match beginning or
 
7400
  # end of line.  Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
 
7401
  # as well as any symbol that contains `d'.
 
7402
  exclude_expsyms="_GLOBAL_OFFSET_TABLE_"
 
7403
  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
 
7404
  # platforms (ab)use it in PIC code, but their linkers get confused if
 
7405
  # the symbol is explicitly referenced.  Since portable code cannot
 
7406
  # rely on this symbol name, it's probably fine to never include it in
 
7407
  # preloaded symbol tables.
 
7408
  extract_expsyms_cmds=
 
7409
 
 
7410
  case $host_os in
 
7411
  cygwin* | mingw* | pw32*)
 
7412
    # FIXME: the MSVC++ port hasn't been tested in a loooong time
 
7413
    # When not using gcc, we currently assume that we are using
 
7414
    # Microsoft Visual C++.
 
7415
    if test "$GCC" != yes; then
 
7416
      with_gnu_ld=no
 
7417
    fi
 
7418
    ;;
 
7419
  interix*)
 
7420
    # we just hope/assume this is gcc and not c89 (= MSVC++)
 
7421
    with_gnu_ld=yes
 
7422
    ;;
 
7423
  openbsd*)
 
7424
    with_gnu_ld=no
 
7425
    ;;
 
7426
  esac
 
7427
 
 
7428
  ld_shlibs=yes
 
7429
  if test "$with_gnu_ld" = yes; then
 
7430
    # If archive_cmds runs LD, not CC, wlarc should be empty
 
7431
    wlarc='${wl}'
 
7432
 
 
7433
    # Set some defaults for GNU ld with shared library support. These
 
7434
    # are reset later if shared libraries are not supported. Putting them
 
7435
    # here allows them to be overridden if necessary.
 
7436
    runpath_var=LD_RUN_PATH
 
7437
    hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
 
7438
    export_dynamic_flag_spec='${wl}--export-dynamic'
 
7439
    # ancient GNU ld didn't support --whole-archive et. al.
 
7440
    if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
 
7441
      whole_archive_flag_spec="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
 
7442
    else
 
7443
      whole_archive_flag_spec=
 
7444
    fi
 
7445
    supports_anon_versioning=no
 
7446
    case `$LD -v 2>&1` in
 
7447
      *\ [01].* | *\ 2.[0-9].* | *\ 2.10.*) ;; # catch versions < 2.11
 
7448
      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
 
7449
      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
 
7450
      *\ 2.11.*) ;; # other 2.11 versions
 
7451
      *) supports_anon_versioning=yes ;;
 
7452
    esac
 
7453
 
 
7454
    # See if GNU ld supports shared libraries.
 
7455
    case $host_os in
 
7456
    aix3* | aix4* | aix5*)
 
7457
      # On AIX/PPC, the GNU linker is very broken
 
7458
      if test "$host_cpu" != ia64; then
 
7459
        ld_shlibs=no
 
7460
        cat <<_LT_EOF 1>&2
 
7461
 
 
7462
*** Warning: the GNU linker, at least up to release 2.9.1, is reported
 
7463
*** to be unable to reliably create shared libraries on AIX.
 
7464
*** Therefore, libtool is disabling shared libraries support.  If you
 
7465
*** really care for shared libraries, you may want to modify your PATH
 
7466
*** so that a non-GNU linker is found, and then restart.
 
7467
 
 
7468
_LT_EOF
 
7469
      fi
 
7470
      ;;
 
7471
 
 
7472
    amigaos*)
 
7473
      if test "$host_cpu" = m68k; then
 
7474
        archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
 
7475
        hardcode_libdir_flag_spec='-L$libdir'
 
7476
        hardcode_minus_L=yes
 
7477
      fi
 
7478
 
 
7479
      # Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports
 
7480
      # that the semantics of dynamic libraries on AmigaOS, at least up
 
7481
      # to version 4, is to share data among multiple programs linked
 
7482
      # with the same dynamic library.  Since this doesn't match the
 
7483
      # behavior of shared libraries on other platforms, we can't use
 
7484
      # them.
 
7485
      ld_shlibs=no
 
7486
      ;;
 
7487
 
 
7488
    beos*)
 
7489
      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
 
7490
        allow_undefined_flag=unsupported
 
7491
        # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
 
7492
        # support --undefined.  This deserves some investigation.  FIXME
 
7493
        archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
 
7494
      else
 
7495
        ld_shlibs=no
 
7496
      fi
 
7497
      ;;
 
7498
 
 
7499
    cygwin* | mingw* | pw32*)
 
7500
      # _LT_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless,
 
7501
      # as there is no search path for DLLs.
 
7502
      hardcode_libdir_flag_spec='-L$libdir'
 
7503
      allow_undefined_flag=unsupported
 
7504
      always_export_symbols=no
 
7505
      enable_shared_with_static_runtimes=yes
 
7506
      export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[BCDGRS][ ]/s/.*[ ]\([^ ]*\)/\1 DATA/'\'' | $SED -e '\''/^[AITW][ ]/s/.*[ ]//'\'' | sort | uniq > $export_symbols'
 
7507
 
 
7508
      if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
 
7509
        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
 
7510
        # If the export-symbols file already is a .def file (1st line
 
7511
        # is EXPORTS), use it as is; otherwise, prepend...
 
7512
        archive_expsym_cmds='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
 
7513
          cp $export_symbols $output_objdir/$soname.def;
 
7514
        else
 
7515
          echo EXPORTS > $output_objdir/$soname.def;
 
7516
          cat $export_symbols >> $output_objdir/$soname.def;
 
7517
        fi~
 
7518
        $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
 
7519
      else
 
7520
        ld_shlibs=no
 
7521
      fi
 
7522
      ;;
 
7523
 
 
7524
    interix[3-9]*)
 
7525
      hardcode_direct=no
 
7526
      hardcode_shlibpath_var=no
 
7527
      hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
 
7528
      export_dynamic_flag_spec='${wl}-E'
 
7529
      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
 
7530
      # Instead, shared libraries are loaded at an image base (0x10000000 by
 
7531
      # default) and relocated if they conflict, which is a slow very memory
 
7532
      # consuming and fragmenting process.  To avoid this, we pick a random,
 
7533
      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
 
7534
      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
 
7535
      archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
 
7536
      archive_expsym_cmds='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
 
7537
      ;;
 
7538
 
 
7539
    gnu* | linux* | tpf* | k*bsd*-gnu)
 
7540
      tmp_diet=no
 
7541
      if test "$host_os" = linux-dietlibc; then
 
7542
        case $cc_basename in
 
7543
          diet\ *) tmp_diet=yes;;       # linux-dietlibc with static linking (!diet-dyn)
 
7544
        esac
 
7545
      fi
 
7546
      if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
 
7547
         && test "$tmp_diet" = no
 
7548
      then
 
7549
        tmp_addflag=
 
7550
        case $cc_basename,$host_cpu in
 
7551
        pgcc*)                          # Portland Group C compiler
 
7552
          whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'
 
7553
          tmp_addflag=' $pic_flag'
 
7554
          ;;
 
7555
        pgf77* | pgf90* | pgf95*)       # Portland Group f77 and f90 compilers
 
7556
          whole_archive_flag_spec='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'
 
7557
          tmp_addflag=' $pic_flag -Mnomain' ;;
 
7558
        ecc*,ia64* | icc*,ia64*)        # Intel C compiler on ia64
 
7559
          tmp_addflag=' -i_dynamic' ;;
 
7560
        efc*,ia64* | ifort*,ia64*)      # Intel Fortran compiler on ia64
 
7561
          tmp_addflag=' -i_dynamic -nofor_main' ;;
 
7562
        ifc* | ifort*)                  # Intel Fortran compiler
 
7563
          tmp_addflag=' -nofor_main' ;;
 
7564
        esac
 
7565
        case `$CC -V 2>&1 | sed 5q` in
 
7566
        *Sun\ C*)                       # Sun C 5.9
 
7567
          whole_archive_flag_spec='${wl}--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; $ECHO \"$new_convenience\"` ${wl}--no-whole-archive'
 
7568
          compiler_needs_object=yes
 
7569
          tmp_sharedflag='-G' ;;
 
7570
        *Sun\ F*)                       # Sun Fortran 8.3
 
7571
          tmp_sharedflag='-G' ;;
 
7572
        *)
 
7573
          tmp_sharedflag='-shared' ;;
 
7574
        esac
 
7575
        archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
 
7576
 
 
7577
        if test "x$supports_anon_versioning" = xyes; then
 
7578
          archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
 
7579
            cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
 
7580
            echo "local: *; };" >> $output_objdir/$libname.ver~
 
7581
            $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
 
7582
        fi
 
7583
      else
 
7584
        ld_shlibs=no
 
7585
      fi
 
7586
      ;;
 
7587
 
 
7588
    netbsd*)
 
7589
      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
 
7590
        archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
 
7591
        wlarc=
 
7592
      else
 
7593
        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
 
7594
        archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
 
7595
      fi
 
7596
      ;;
 
7597
 
 
7598
    solaris*)
 
7599
      if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
 
7600
        ld_shlibs=no
 
7601
        cat <<_LT_EOF 1>&2
 
7602
 
 
7603
*** Warning: The releases 2.8.* of the GNU linker cannot reliably
 
7604
*** create shared libraries on Solaris systems.  Therefore, libtool
 
7605
*** is disabling shared libraries support.  We urge you to upgrade GNU
 
7606
*** binutils to release 2.9.1 or newer.  Another option is to modify
 
7607
*** your PATH or compiler configuration so that the native linker is
 
7608
*** used, and then restart.
 
7609
 
 
7610
_LT_EOF
 
7611
      elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
 
7612
        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
 
7613
        archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
 
7614
      else
 
7615
        ld_shlibs=no
 
7616
      fi
 
7617
      ;;
 
7618
 
 
7619
    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
 
7620
      case `$LD -v 2>&1` in
 
7621
        *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*)
 
7622
        ld_shlibs=no
 
7623
        cat <<_LT_EOF 1>&2
 
7624
 
 
7625
*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not
 
7626
*** reliably create shared libraries on SCO systems.  Therefore, libtool
 
7627
*** is disabling shared libraries support.  We urge you to upgrade GNU
 
7628
*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
 
7629
*** your PATH or compiler configuration so that the native linker is
 
7630
*** used, and then restart.
 
7631
 
 
7632
_LT_EOF
 
7633
        ;;
 
7634
        *)
 
7635
          # For security reasons, it is highly recommended that you always
 
7636
          # use absolute paths for naming shared libraries, and exclude the
 
7637
          # DT_RUNPATH tag from executables and libraries.  But doing so
 
7638
          # requires that you compile everything twice, which is a pain.
 
7639
          if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
 
7640
            hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
 
7641
            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
 
7642
            archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
 
7643
          else
 
7644
            ld_shlibs=no
 
7645
          fi
 
7646
        ;;
 
7647
      esac
 
7648
      ;;
 
7649
 
 
7650
    sunos4*)
 
7651
      archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
 
7652
      wlarc=
 
7653
      hardcode_direct=yes
 
7654
      hardcode_shlibpath_var=no
 
7655
      ;;
 
7656
 
 
7657
    *)
 
7658
      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
 
7659
        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
 
7660
        archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
 
7661
      else
 
7662
        ld_shlibs=no
 
7663
      fi
 
7664
      ;;
 
7665
    esac
 
7666
 
 
7667
    if test "$ld_shlibs" = no; then
 
7668
      runpath_var=
 
7669
      hardcode_libdir_flag_spec=
 
7670
      export_dynamic_flag_spec=
 
7671
      whole_archive_flag_spec=
 
7672
    fi
 
7673
  else
 
7674
    # PORTME fill in a description of your system's linker (not GNU ld)
 
7675
    case $host_os in
 
7676
    aix3*)
 
7677
      allow_undefined_flag=unsupported
 
7678
      always_export_symbols=yes
 
7679
      archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
 
7680
      # Note: this linker hardcodes the directories in LIBPATH if there
 
7681
      # are no directories specified by -L.
 
7682
      hardcode_minus_L=yes
 
7683
      if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then
 
7684
        # Neither direct hardcoding nor static linking is supported with a
 
7685
        # broken collect2.
 
7686
        hardcode_direct=unsupported
 
7687
      fi
 
7688
      ;;
 
7689
 
 
7690
    aix4* | aix5*)
 
7691
      if test "$host_cpu" = ia64; then
 
7692
        # On IA64, the linker does run time linking by default, so we don't
 
7693
        # have to do anything special.
 
7694
        aix_use_runtimelinking=no
 
7695
        exp_sym_flag='-Bexport'
 
7696
        no_entry_flag=""
 
7697
      else
 
7698
        # If we're using GNU nm, then we don't want the "-C" option.
 
7699
        # -C means demangle to AIX nm, but means don't demangle with GNU nm
 
7700
        if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
 
7701
          export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
 
7702
        else
 
7703
          export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
 
7704
        fi
 
7705
        aix_use_runtimelinking=no
 
7706
 
 
7707
        # Test if we are trying to use run time linking or normal
 
7708
        # AIX style linking. If -brtl is somewhere in LDFLAGS, we
 
7709
        # need to do runtime linking.
 
7710
        case $host_os in aix4.[23]|aix4.[23].*|aix5*)
 
7711
          for ld_flag in $LDFLAGS; do
 
7712
          if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
 
7713
            aix_use_runtimelinking=yes
 
7714
            break
 
7715
          fi
 
7716
          done
 
7717
          ;;
 
7718
        esac
 
7719
 
 
7720
        exp_sym_flag='-bexport'
 
7721
        no_entry_flag='-bnoentry'
 
7722
      fi
 
7723
 
 
7724
      # When large executables or shared objects are built, AIX ld can
 
7725
      # have problems creating the table of contents.  If linking a library
 
7726
      # or program results in "error TOC overflow" add -mminimal-toc to
 
7727
      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
 
7728
      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
 
7729
 
 
7730
      archive_cmds=''
 
7731
      hardcode_direct=yes
 
7732
      hardcode_direct_absolute=yes
 
7733
      hardcode_libdir_separator=':'
 
7734
      link_all_deplibs=yes
 
7735
      file_list_spec='${wl}-f,'
 
7736
 
 
7737
      if test "$GCC" = yes; then
 
7738
        case $host_os in aix4.[012]|aix4.[012].*)
 
7739
        # We only want to do this on AIX 4.2 and lower, the check
 
7740
        # below for broken collect2 doesn't work under 4.3+
 
7741
          collect2name=`${CC} -print-prog-name=collect2`
 
7742
          if test -f "$collect2name" &&
 
7743
           strings "$collect2name" | $GREP resolve_lib_name >/dev/null
 
7744
          then
 
7745
          # We have reworked collect2
 
7746
          :
 
7747
          else
 
7748
          # We have old collect2
 
7749
          hardcode_direct=unsupported
 
7750
          # It fails to find uninstalled libraries when the uninstalled
 
7751
          # path is not listed in the libpath.  Setting hardcode_minus_L
 
7752
          # to unsupported forces relinking
 
7753
          hardcode_minus_L=yes
 
7754
          hardcode_libdir_flag_spec='-L$libdir'
 
7755
          hardcode_libdir_separator=
 
7756
          fi
 
7757
          ;;
 
7758
        esac
 
7759
        shared_flag='-shared'
 
7760
        if test "$aix_use_runtimelinking" = yes; then
 
7761
          shared_flag="$shared_flag "'${wl}-G'
 
7762
        fi
 
7763
      else
 
7764
        # not using gcc
 
7765
        if test "$host_cpu" = ia64; then
 
7766
        # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
 
7767
        # chokes on -Wl,-G. The following line is correct:
 
7768
          shared_flag='-G'
 
7769
        else
 
7770
          if test "$aix_use_runtimelinking" = yes; then
 
7771
            shared_flag='${wl}-G'
 
7772
          else
 
7773
            shared_flag='${wl}-bM:SRE'
 
7774
          fi
 
7775
        fi
 
7776
      fi
 
7777
 
 
7778
      # It seems that -bexpall does not export symbols beginning with
 
7779
      # underscore (_), so it is better to generate a list of symbols to export.
 
7780
      always_export_symbols=yes
 
7781
      if test "$aix_use_runtimelinking" = yes; then
 
7782
        # Warning - without using the other runtime loading flags (-brtl),
 
7783
        # -berok will link without error, but may produce a broken library.
 
7784
        allow_undefined_flag='-berok'
 
7785
        # Determine the default libpath from the value encoded in an
 
7786
        # empty executable.
 
7787
        cat >conftest.$ac_ext <<_ACEOF
 
7788
/* confdefs.h.  */
 
7789
_ACEOF
 
7790
cat confdefs.h >>conftest.$ac_ext
 
7791
cat >>conftest.$ac_ext <<_ACEOF
 
7792
/* end confdefs.h.  */
 
7793
 
 
7794
int
 
7795
main ()
 
7796
{
 
7797
 
 
7798
  ;
 
7799
  return 0;
 
7800
}
 
7801
_ACEOF
 
7802
rm -f conftest.$ac_objext conftest$ac_exeext
 
7803
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
7804
  (eval $ac_link) 2>conftest.er1
 
7805
  ac_status=$?
 
7806
  grep -v '^ *+' conftest.er1 >conftest.err
 
7807
  rm -f conftest.er1
 
7808
  cat conftest.err >&5
 
7809
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7810
  (exit $ac_status); } &&
 
7811
         { ac_try='test -z "$ac_c_werror_flag"
 
7812
                         || test ! -s conftest.err'
 
7813
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
7814
  (eval $ac_try) 2>&5
 
7815
  ac_status=$?
 
7816
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7817
  (exit $ac_status); }; } &&
 
7818
         { ac_try='test -s conftest$ac_exeext'
 
7819
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
7820
  (eval $ac_try) 2>&5
 
7821
  ac_status=$?
 
7822
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7823
  (exit $ac_status); }; }; then
 
7824
 
 
7825
lt_aix_libpath_sed='
 
7826
    /Import File Strings/,/^$/ {
 
7827
        /^0/ {
 
7828
            s/^0  *\(.*\)$/\1/
 
7829
            p
 
7830
        }
 
7831
    }'
 
7832
aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
 
7833
# Check for a 64-bit object if we didn't find anything.
 
7834
if test -z "$aix_libpath"; then
 
7835
  aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
 
7836
fi
 
7837
else
 
7838
  echo "$as_me: failed program was:" >&5
 
7839
sed 's/^/| /' conftest.$ac_ext >&5
 
7840
 
 
7841
fi
 
7842
rm -f conftest.err conftest.$ac_objext \
 
7843
      conftest$ac_exeext conftest.$ac_ext
 
7844
if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
 
7845
 
 
7846
        hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
 
7847
        archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then $ECHO "X${wl}${allow_undefined_flag}" | $Xsed; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
 
7848
      else
 
7849
        if test "$host_cpu" = ia64; then
 
7850
          hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib'
 
7851
          allow_undefined_flag="-z nodefs"
 
7852
          archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
 
7853
        else
 
7854
         # Determine the default libpath from the value encoded in an
 
7855
         # empty executable.
 
7856
         cat >conftest.$ac_ext <<_ACEOF
 
7857
/* confdefs.h.  */
 
7858
_ACEOF
 
7859
cat confdefs.h >>conftest.$ac_ext
 
7860
cat >>conftest.$ac_ext <<_ACEOF
 
7861
/* end confdefs.h.  */
 
7862
 
 
7863
int
 
7864
main ()
 
7865
{
 
7866
 
 
7867
  ;
 
7868
  return 0;
 
7869
}
 
7870
_ACEOF
 
7871
rm -f conftest.$ac_objext conftest$ac_exeext
 
7872
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
7873
  (eval $ac_link) 2>conftest.er1
 
7874
  ac_status=$?
 
7875
  grep -v '^ *+' conftest.er1 >conftest.err
 
7876
  rm -f conftest.er1
 
7877
  cat conftest.err >&5
 
7878
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7879
  (exit $ac_status); } &&
 
7880
         { ac_try='test -z "$ac_c_werror_flag"
 
7881
                         || test ! -s conftest.err'
 
7882
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
7883
  (eval $ac_try) 2>&5
 
7884
  ac_status=$?
 
7885
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7886
  (exit $ac_status); }; } &&
 
7887
         { ac_try='test -s conftest$ac_exeext'
 
7888
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
7889
  (eval $ac_try) 2>&5
 
7890
  ac_status=$?
 
7891
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
7892
  (exit $ac_status); }; }; then
 
7893
 
 
7894
lt_aix_libpath_sed='
 
7895
    /Import File Strings/,/^$/ {
 
7896
        /^0/ {
 
7897
            s/^0  *\(.*\)$/\1/
 
7898
            p
 
7899
        }
 
7900
    }'
 
7901
aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
 
7902
# Check for a 64-bit object if we didn't find anything.
 
7903
if test -z "$aix_libpath"; then
 
7904
  aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
 
7905
fi
 
7906
else
 
7907
  echo "$as_me: failed program was:" >&5
 
7908
sed 's/^/| /' conftest.$ac_ext >&5
 
7909
 
 
7910
fi
 
7911
rm -f conftest.err conftest.$ac_objext \
 
7912
      conftest$ac_exeext conftest.$ac_ext
 
7913
if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
 
7914
 
 
7915
         hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath"
 
7916
          # Warning - without using the other run time loading flags,
 
7917
          # -berok will link without error, but may produce a broken library.
 
7918
          no_undefined_flag=' ${wl}-bernotok'
 
7919
          allow_undefined_flag=' ${wl}-berok'
 
7920
          # Exported symbols can be pulled into shared objects from archives
 
7921
          whole_archive_flag_spec='$convenience'
 
7922
          archive_cmds_need_lc=yes
 
7923
          # This is similar to how AIX traditionally builds its shared libraries.
 
7924
          archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
 
7925
        fi
 
7926
      fi
 
7927
      ;;
 
7928
 
 
7929
    amigaos*)
 
7930
      if test "$host_cpu" = m68k; then
 
7931
        archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
 
7932
        hardcode_libdir_flag_spec='-L$libdir'
 
7933
        hardcode_minus_L=yes
 
7934
      fi
 
7935
      # see comment about different semantics on the GNU ld section
 
7936
      ld_shlibs=no
 
7937
      ;;
 
7938
 
 
7939
    bsdi[45]*)
 
7940
      export_dynamic_flag_spec=-rdynamic
 
7941
      ;;
 
7942
 
 
7943
    cygwin* | mingw* | pw32*)
 
7944
      # When not using gcc, we currently assume that we are using
 
7945
      # Microsoft Visual C++.
 
7946
      # hardcode_libdir_flag_spec is actually meaningless, as there is
 
7947
      # no search path for DLLs.
 
7948
      hardcode_libdir_flag_spec=' '
 
7949
      allow_undefined_flag=unsupported
 
7950
      # Tell ltmain to make .lib files, not .a files.
 
7951
      libext=lib
 
7952
      # Tell ltmain to make .dll files, not .so files.
 
7953
      shrext_cmds=".dll"
 
7954
      # FIXME: Setting linknames here is a bad hack.
 
7955
      archive_cmds='$CC -o $lib $libobjs $compiler_flags `$ECHO "X$deplibs" | $Xsed -e '\''s/ -lc$//'\''` -link -dll~linknames='
 
7956
      # The linker will automatically build a .lib file if we build a DLL.
 
7957
      old_archive_from_new_cmds='true'
 
7958
      # FIXME: Should let the user specify the lib program.
 
7959
      old_archive_cmds='lib -OUT:$oldlib$oldobjs$old_deplibs'
 
7960
      fix_srcfile_path='`cygpath -w "$srcfile"`'
 
7961
      enable_shared_with_static_runtimes=yes
 
7962
      ;;
 
7963
 
 
7964
    darwin* | rhapsody*)
 
7965
      case $host_os in
 
7966
      rhapsody* | darwin1.[012])
 
7967
        allow_undefined_flag='${wl}-undefined ${wl}suppress'
 
7968
        ;;
 
7969
      *) # Darwin 1.3 on
 
7970
        case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
 
7971
        10.[012])
 
7972
          allow_undefined_flag='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
 
7973
          ;;
 
7974
        10.*)
 
7975
          allow_undefined_flag='${wl}-undefined ${wl}dynamic_lookup'
 
7976
          ;;
 
7977
        esac
 
7978
        ;;
 
7979
      esac
 
7980
      archive_cmds_need_lc=no
 
7981
      hardcode_direct=no
 
7982
      hardcode_automatic=yes
 
7983
      hardcode_shlibpath_var=unsupported
 
7984
      whole_archive_flag_spec=''
 
7985
      link_all_deplibs=yes
 
7986
      if test "$GCC" = yes ; then
 
7987
        if test "${lt_cv_apple_cc_single_mod+set}" = set; then
 
7988
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
7989
else
 
7990
  lt_cv_apple_cc_single_mod=no
 
7991
        if test -z "${LT_MULTI_MODULE}"; then
 
7992
          # By default we will add the -single_module flag. You can override
 
7993
          # by either setting the environment variable LT_MULTI_MODULE
 
7994
          # non-empty at configure time, or by adding -multi-module to the
 
7995
          # link flags.
 
7996
          echo "int foo(void){return 1;}" > conftest.c
 
7997
          $LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
 
7998
              -dynamiclib ${wl}-single_module conftest.c
 
7999
          if test -f libconftest.dylib; then
 
8000
              lt_cv_apple_cc_single_mod=yes
 
8001
              rm libconftest.dylib
 
8002
          fi
 
8003
          rm conftest.$ac_ext
 
8004
        fi
 
8005
fi
 
8006
 
 
8007
        output_verbose_link_cmd=echo
 
8008
        if test "X$lt_cv_apple_cc_single_mod" = Xyes ; then
 
8009
          archive_cmds='$CC -dynamiclib $single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
 
8010
          archive_expsym_cmds='sed "s,^,_," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $single_module -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
 
8011
        else
 
8012
          archive_cmds='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
 
8013
          archive_expsym_cmds='sed "s,^,_," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
 
8014
        fi
 
8015
        module_cmds='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
 
8016
        module_expsym_cmds='sed -e "s,^,_," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
 
8017
      else
 
8018
        case $cc_basename in
 
8019
        xlc*)
 
8020
          output_verbose_link_cmd=echo
 
8021
          archive_cmds='$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`$ECHO $rpath/$soname` $verstring'
 
8022
          module_cmds='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
 
8023
          # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
 
8024
          archive_expsym_cmds='sed "s,^,_," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
 
8025
          module_expsym_cmds='sed "s,^,_," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
 
8026
          ;;
 
8027
        *)
 
8028
          ld_shlibs=no
 
8029
          ;;
 
8030
        esac
 
8031
      fi
 
8032
      ;;
 
8033
 
 
8034
    dgux*)
 
8035
      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
 
8036
      hardcode_libdir_flag_spec='-L$libdir'
 
8037
      hardcode_shlibpath_var=no
 
8038
      ;;
 
8039
 
 
8040
    freebsd1*)
 
8041
      ld_shlibs=no
 
8042
      ;;
 
8043
 
 
8044
    # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
 
8045
    # support.  Future versions do this automatically, but an explicit c++rt0.o
 
8046
    # does not break anything, and helps significantly (at the cost of a little
 
8047
    # extra space).
 
8048
    freebsd2.2*)
 
8049
      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
 
8050
      hardcode_libdir_flag_spec='-R$libdir'
 
8051
      hardcode_direct=yes
 
8052
      hardcode_shlibpath_var=no
 
8053
      ;;
 
8054
 
 
8055
    # Unfortunately, older versions of FreeBSD 2 do not have this feature.
 
8056
    freebsd2*)
 
8057
      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
 
8058
      hardcode_direct=yes
 
8059
      hardcode_minus_L=yes
 
8060
      hardcode_shlibpath_var=no
 
8061
      ;;
 
8062
 
 
8063
    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
 
8064
    freebsd* | dragonfly*)
 
8065
      archive_cmds='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'
 
8066
      hardcode_libdir_flag_spec='-R$libdir'
 
8067
      hardcode_direct=yes
 
8068
      hardcode_shlibpath_var=no
 
8069
      ;;
 
8070
 
 
8071
    hpux9*)
 
8072
      if test "$GCC" = yes; then
 
8073
        archive_cmds='$RM $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
 
8074
      else
 
8075
        archive_cmds='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
 
8076
      fi
 
8077
      hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
 
8078
      hardcode_libdir_separator=:
 
8079
      hardcode_direct=yes
 
8080
 
 
8081
      # hardcode_minus_L: Not really in the search PATH,
 
8082
      # but as the default location of the library.
 
8083
      hardcode_minus_L=yes
 
8084
      export_dynamic_flag_spec='${wl}-E'
 
8085
      ;;
 
8086
 
 
8087
    hpux10*)
 
8088
      if test "$GCC" = yes -a "$with_gnu_ld" = no; then
 
8089
        archive_cmds='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
 
8090
      else
 
8091
        archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
 
8092
      fi
 
8093
      if test "$with_gnu_ld" = no; then
 
8094
        hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
 
8095
        hardcode_libdir_flag_spec_ld='+b $libdir'
 
8096
        hardcode_libdir_separator=:
 
8097
        hardcode_direct=yes
 
8098
        hardcode_direct_absolute=yes
 
8099
        export_dynamic_flag_spec='${wl}-E'
 
8100
        # hardcode_minus_L: Not really in the search PATH,
 
8101
        # but as the default location of the library.
 
8102
        hardcode_minus_L=yes
 
8103
      fi
 
8104
      ;;
 
8105
 
 
8106
    hpux11*)
 
8107
      if test "$GCC" = yes -a "$with_gnu_ld" = no; then
 
8108
        case $host_cpu in
 
8109
        hppa*64*)
 
8110
          archive_cmds='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
 
8111
          ;;
 
8112
        ia64*)
 
8113
          archive_cmds='$CC -shared ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
 
8114
          ;;
 
8115
        *)
 
8116
          archive_cmds='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
 
8117
          ;;
 
8118
        esac
 
8119
      else
 
8120
        case $host_cpu in
 
8121
        hppa*64*)
 
8122
          archive_cmds='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
 
8123
          ;;
 
8124
        ia64*)
 
8125
          archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
 
8126
          ;;
 
8127
        *)
 
8128
          archive_cmds='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
 
8129
          ;;
 
8130
        esac
 
8131
      fi
 
8132
      if test "$with_gnu_ld" = no; then
 
8133
        hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir'
 
8134
        hardcode_libdir_separator=:
 
8135
 
 
8136
        case $host_cpu in
 
8137
        hppa*64*|ia64*)
 
8138
          hardcode_direct=no
 
8139
          hardcode_shlibpath_var=no
 
8140
          ;;
 
8141
        *)
 
8142
          hardcode_direct=yes
 
8143
          hardcode_direct_absolute=yes
 
8144
          export_dynamic_flag_spec='${wl}-E'
 
8145
 
 
8146
          # hardcode_minus_L: Not really in the search PATH,
 
8147
          # but as the default location of the library.
 
8148
          hardcode_minus_L=yes
 
8149
          ;;
 
8150
        esac
 
8151
      fi
 
8152
      ;;
 
8153
 
 
8154
    irix5* | irix6* | nonstopux*)
 
8155
      if test "$GCC" = yes; then
 
8156
        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
 
8157
        # Try to use the -exported_symbol ld option, if it does not
 
8158
        # work, assume that -exports_file does not work either and
 
8159
        # implicitly export all symbols.
 
8160
        save_LDFLAGS="$LDFLAGS"
 
8161
        LDFLAGS="$LDFLAGS -shared ${wl}-exported_symbol ${wl}foo ${wl}-update_registry ${wl}/dev/null"
 
8162
        cat >conftest.$ac_ext <<_ACEOF
 
8163
int foo(void) {}
 
8164
_ACEOF
 
8165
rm -f conftest.$ac_objext conftest$ac_exeext
 
8166
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
8167
  (eval $ac_link) 2>conftest.er1
 
8168
  ac_status=$?
 
8169
  grep -v '^ *+' conftest.er1 >conftest.err
 
8170
  rm -f conftest.er1
 
8171
  cat conftest.err >&5
 
8172
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8173
  (exit $ac_status); } &&
 
8174
         { ac_try='test -z "$ac_c_werror_flag"
 
8175
                         || test ! -s conftest.err'
 
8176
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
8177
  (eval $ac_try) 2>&5
 
8178
  ac_status=$?
 
8179
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8180
  (exit $ac_status); }; } &&
 
8181
         { ac_try='test -s conftest$ac_exeext'
 
8182
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
8183
  (eval $ac_try) 2>&5
 
8184
  ac_status=$?
 
8185
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8186
  (exit $ac_status); }; }; then
 
8187
  archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib'
 
8188
 
 
8189
else
 
8190
  echo "$as_me: failed program was:" >&5
 
8191
sed 's/^/| /' conftest.$ac_ext >&5
 
8192
 
 
8193
fi
 
8194
rm -f conftest.err conftest.$ac_objext \
 
8195
      conftest$ac_exeext conftest.$ac_ext
 
8196
        LDFLAGS="$save_LDFLAGS"
 
8197
      else
 
8198
        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'
 
8199
        archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib'
 
8200
      fi
 
8201
      archive_cmds_need_lc='no'
 
8202
      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
 
8203
      hardcode_libdir_separator=:
 
8204
      inherit_rpath=yes
 
8205
      link_all_deplibs=yes
 
8206
      ;;
 
8207
 
 
8208
    netbsd*)
 
8209
      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
 
8210
        archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
 
8211
      else
 
8212
        archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
 
8213
      fi
 
8214
      hardcode_libdir_flag_spec='-R$libdir'
 
8215
      hardcode_direct=yes
 
8216
      hardcode_shlibpath_var=no
 
8217
      ;;
 
8218
 
 
8219
    newsos6)
 
8220
      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
 
8221
      hardcode_direct=yes
 
8222
      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
 
8223
      hardcode_libdir_separator=:
 
8224
      hardcode_shlibpath_var=no
 
8225
      ;;
 
8226
 
 
8227
    *nto* | *qnx*)
 
8228
      ;;
 
8229
 
 
8230
    openbsd*)
 
8231
      hardcode_direct=yes
 
8232
      hardcode_shlibpath_var=no
 
8233
      hardcode_direct_absolute=yes
 
8234
      if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
 
8235
        archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
 
8236
        archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'
 
8237
        hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
 
8238
        export_dynamic_flag_spec='${wl}-E'
 
8239
      else
 
8240
        case $host_os in
 
8241
        openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*)
 
8242
          archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
 
8243
          hardcode_libdir_flag_spec='-R$libdir'
 
8244
          ;;
 
8245
        *)
 
8246
          archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
 
8247
          hardcode_libdir_flag_spec='${wl}-rpath,$libdir'
 
8248
          ;;
 
8249
        esac
 
8250
      fi
 
8251
      ;;
 
8252
 
 
8253
    os2*)
 
8254
      hardcode_libdir_flag_spec='-L$libdir'
 
8255
      hardcode_minus_L=yes
 
8256
      allow_undefined_flag=unsupported
 
8257
      archive_cmds='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$ECHO DATA >> $output_objdir/$libname.def~$ECHO " SINGLE NONSHARED" >> $output_objdir/$libname.def~$ECHO EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
 
8258
      old_archive_from_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
 
8259
      ;;
 
8260
 
 
8261
    osf3*)
 
8262
      if test "$GCC" = yes; then
 
8263
        allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'
 
8264
        archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
 
8265
      else
 
8266
        allow_undefined_flag=' -expect_unresolved \*'
 
8267
        archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'
 
8268
      fi
 
8269
      archive_cmds_need_lc='no'
 
8270
      hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
 
8271
      hardcode_libdir_separator=:
 
8272
      ;;
 
8273
 
 
8274
    osf4* | osf5*)      # as osf3* with the addition of -msym flag
 
8275
      if test "$GCC" = yes; then
 
8276
        allow_undefined_flag=' ${wl}-expect_unresolved ${wl}\*'
 
8277
        archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && $ECHO "X${wl}-set_version ${wl}$verstring" | $Xsed` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
 
8278
        hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir'
 
8279
      else
 
8280
        allow_undefined_flag=' -expect_unresolved \*'
 
8281
        archive_cmds='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib'
 
8282
        archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
 
8283
        $CC -shared${allow_undefined_flag} ${wl}-input ${wl}$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "X-set_version $verstring" | $Xsed` -update_registry ${output_objdir}/so_locations -o $lib~$RM $lib.exp'
 
8284
 
 
8285
        # Both c and cxx compiler support -rpath directly
 
8286
        hardcode_libdir_flag_spec='-rpath $libdir'
 
8287
      fi
 
8288
      archive_cmds_need_lc='no'
 
8289
      hardcode_libdir_separator=:
 
8290
      ;;
 
8291
 
 
8292
    solaris*)
 
8293
      no_undefined_flag=' -z defs'
 
8294
      if test "$GCC" = yes; then
 
8295
        wlarc='${wl}'
 
8296
        archive_cmds='$CC -shared ${wl}-z ${wl}text ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
 
8297
        archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
 
8298
          $CC -shared ${wl}-z ${wl}text ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
 
8299
      else
 
8300
        case `$CC -V 2>&1` in
 
8301
        *"Compilers 5.0"*)
 
8302
          wlarc=''
 
8303
          archive_cmds='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
 
8304
          archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
 
8305
          $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
 
8306
          ;;
 
8307
        *)
 
8308
          wlarc='${wl}'
 
8309
          archive_cmds='$CC -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $compiler_flags'
 
8310
          archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
 
8311
          $CC -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
 
8312
          ;;
 
8313
        esac
 
8314
      fi
 
8315
      hardcode_libdir_flag_spec='-R$libdir'
 
8316
      hardcode_shlibpath_var=no
 
8317
      case $host_os in
 
8318
      solaris2.[0-5] | solaris2.[0-5].*) ;;
 
8319
      *)
 
8320
        # The compiler driver will combine and reorder linker options,
 
8321
        # but understands `-z linker_flag'.  GCC discards it without `$wl',
 
8322
        # but is careful enough not to reorder.
 
8323
        # Supported since Solaris 2.6 (maybe 2.5.1?)
 
8324
        if test "$GCC" = yes; then
 
8325
          whole_archive_flag_spec='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
 
8326
        else
 
8327
          whole_archive_flag_spec='-z allextract$convenience -z defaultextract'
 
8328
        fi
 
8329
        ;;
 
8330
      esac
 
8331
      link_all_deplibs=yes
 
8332
      ;;
 
8333
 
 
8334
    sunos4*)
 
8335
      if test "x$host_vendor" = xsequent; then
 
8336
        # Use $CC to link under sequent, because it throws in some extra .o
 
8337
        # files that make .init and .fini sections work.
 
8338
        archive_cmds='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'
 
8339
      else
 
8340
        archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
 
8341
      fi
 
8342
      hardcode_libdir_flag_spec='-L$libdir'
 
8343
      hardcode_direct=yes
 
8344
      hardcode_minus_L=yes
 
8345
      hardcode_shlibpath_var=no
 
8346
      ;;
 
8347
 
 
8348
    sysv4)
 
8349
      case $host_vendor in
 
8350
        sni)
 
8351
          archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
 
8352
          hardcode_direct=yes # is this really true???
 
8353
        ;;
 
8354
        siemens)
 
8355
          ## LD is ld it makes a PLAMLIB
 
8356
          ## CC just makes a GrossModule.
 
8357
          archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags'
 
8358
          reload_cmds='$CC -r -o $output$reload_objs'
 
8359
          hardcode_direct=no
 
8360
        ;;
 
8361
        motorola)
 
8362
          archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
 
8363
          hardcode_direct=no #Motorola manual says yes, but my tests say they lie
 
8364
        ;;
 
8365
      esac
 
8366
      runpath_var='LD_RUN_PATH'
 
8367
      hardcode_shlibpath_var=no
 
8368
      ;;
 
8369
 
 
8370
    sysv4.3*)
 
8371
      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
 
8372
      hardcode_shlibpath_var=no
 
8373
      export_dynamic_flag_spec='-Bexport'
 
8374
      ;;
 
8375
 
 
8376
    sysv4*MP*)
 
8377
      if test -d /usr/nec; then
 
8378
        archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
 
8379
        hardcode_shlibpath_var=no
 
8380
        runpath_var=LD_RUN_PATH
 
8381
        hardcode_runpath_var=yes
 
8382
        ld_shlibs=yes
 
8383
      fi
 
8384
      ;;
 
8385
 
 
8386
    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*)
 
8387
      no_undefined_flag='${wl}-z,text'
 
8388
      archive_cmds_need_lc=no
 
8389
      hardcode_shlibpath_var=no
 
8390
      runpath_var='LD_RUN_PATH'
 
8391
 
 
8392
      if test "$GCC" = yes; then
 
8393
        archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 
8394
        archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 
8395
      else
 
8396
        archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 
8397
        archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 
8398
      fi
 
8399
      ;;
 
8400
 
 
8401
    sysv5* | sco3.2v5* | sco5v6*)
 
8402
      # Note: We can NOT use -z defs as we might desire, because we do not
 
8403
      # link with -lc, and that would cause any symbols used from libc to
 
8404
      # always be unresolved, which means just about no library would
 
8405
      # ever link correctly.  If we're not using GNU ld we use -z text
 
8406
      # though, which does catch some bad symbols but isn't as heavy-handed
 
8407
      # as -z defs.
 
8408
      no_undefined_flag='${wl}-z,text'
 
8409
      allow_undefined_flag='${wl}-z,nodefs'
 
8410
      archive_cmds_need_lc=no
 
8411
      hardcode_shlibpath_var=no
 
8412
      hardcode_libdir_flag_spec='${wl}-R,$libdir'
 
8413
      hardcode_libdir_separator=':'
 
8414
      link_all_deplibs=yes
 
8415
      export_dynamic_flag_spec='${wl}-Bexport'
 
8416
      runpath_var='LD_RUN_PATH'
 
8417
 
 
8418
      if test "$GCC" = yes; then
 
8419
        archive_cmds='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 
8420
        archive_expsym_cmds='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 
8421
      else
 
8422
        archive_cmds='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 
8423
        archive_expsym_cmds='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 
8424
      fi
 
8425
      ;;
 
8426
 
 
8427
    uts4*)
 
8428
      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
 
8429
      hardcode_libdir_flag_spec='-L$libdir'
 
8430
      hardcode_shlibpath_var=no
 
8431
      ;;
 
8432
 
 
8433
    *)
 
8434
      ld_shlibs=no
 
8435
      ;;
 
8436
    esac
 
8437
 
 
8438
    if test x$host_vendor = xsni; then
 
8439
      case $host in
 
8440
      sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
 
8441
        export_dynamic_flag_spec='${wl}-Blargedynsym'
 
8442
        ;;
 
8443
      esac
 
8444
    fi
 
8445
  fi
 
8446
 
 
8447
echo "$as_me:$LINENO: result: $ld_shlibs" >&5
 
8448
echo "${ECHO_T}$ld_shlibs" >&6
 
8449
test "$ld_shlibs" = no && can_build_shared=no
 
8450
 
 
8451
with_gnu_ld=$with_gnu_ld
 
8452
 
 
8453
 
 
8454
 
 
8455
 
 
8456
 
 
8457
 
 
8458
 
 
8459
 
 
8460
 
 
8461
 
 
8462
 
 
8463
 
 
8464
 
 
8465
 
 
8466
 
 
8467
#
 
8468
# Do we need to explicitly link libc?
 
8469
#
 
8470
case "x$archive_cmds_need_lc" in
 
8471
x|xyes)
 
8472
  # Assume -lc should be added
 
8473
  archive_cmds_need_lc=yes
 
8474
 
 
8475
  if test "$enable_shared" = yes && test "$GCC" = yes; then
 
8476
    case $archive_cmds in
 
8477
    *'~'*)
 
8478
      # FIXME: we may have to deal with multi-command sequences.
 
8479
      ;;
 
8480
    '$CC '*)
 
8481
      # Test whether the compiler implicitly links with -lc since on some
 
8482
      # systems, -lgcc has to come before -lc. If gcc already passes -lc
 
8483
      # to ld, don't add -lc before -lgcc.
 
8484
      echo "$as_me:$LINENO: checking whether -lc should be explicitly linked in" >&5
 
8485
echo $ECHO_N "checking whether -lc should be explicitly linked in... $ECHO_C" >&6
 
8486
      $RM conftest*
 
8487
      echo "$lt_simple_compile_test_code" > conftest.$ac_ext
 
8488
 
 
8489
      if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
8490
  (eval $ac_compile) 2>&5
 
8491
  ac_status=$?
 
8492
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8493
  (exit $ac_status); } 2>conftest.err; then
 
8494
        soname=conftest
 
8495
        lib=conftest
 
8496
        libobjs=conftest.$ac_objext
 
8497
        deplibs=
 
8498
        wl=$lt_prog_compiler_wl
 
8499
        pic_flag=$lt_prog_compiler_pic
 
8500
        compiler_flags=-v
 
8501
        linker_flags=-v
 
8502
        verstring=
 
8503
        output_objdir=.
 
8504
        libname=conftest
 
8505
        lt_save_allow_undefined_flag=$allow_undefined_flag
 
8506
        allow_undefined_flag=
 
8507
        if { (eval echo "$as_me:$LINENO: \"$archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\"") >&5
 
8508
  (eval $archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5
 
8509
  ac_status=$?
 
8510
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
8511
  (exit $ac_status); }
 
8512
        then
 
8513
          archive_cmds_need_lc=no
 
8514
        else
 
8515
          archive_cmds_need_lc=yes
 
8516
        fi
 
8517
        allow_undefined_flag=$lt_save_allow_undefined_flag
 
8518
      else
 
8519
        cat conftest.err 1>&5
 
8520
      fi
 
8521
      $RM conftest*
 
8522
      echo "$as_me:$LINENO: result: $archive_cmds_need_lc" >&5
 
8523
echo "${ECHO_T}$archive_cmds_need_lc" >&6
 
8524
      ;;
 
8525
    esac
 
8526
  fi
 
8527
  ;;
 
8528
esac
 
8529
 
 
8530
 
 
8531
 
 
8532
 
 
8533
 
 
8534
 
 
8535
 
 
8536
 
 
8537
 
 
8538
 
 
8539
 
 
8540
 
 
8541
 
 
8542
 
 
8543
 
 
8544
 
 
8545
 
 
8546
 
 
8547
 
 
8548
 
 
8549
 
 
8550
 
 
8551
 
 
8552
 
 
8553
 
 
8554
 
 
8555
 
 
8556
 
 
8557
 
 
8558
 
 
8559
 
 
8560
 
 
8561
 
 
8562
 
 
8563
 
 
8564
 
 
8565
 
 
8566
 
 
8567
 
 
8568
 
 
8569
 
 
8570
 
 
8571
 
 
8572
 
 
8573
 
 
8574
 
 
8575
 
 
8576
 
 
8577
 
 
8578
 
 
8579
 
 
8580
 
 
8581
 
 
8582
 
 
8583
 
 
8584
 
 
8585
 
 
8586
 
 
8587
 
 
8588
 
 
8589
 
 
8590
 
 
8591
 
 
8592
 
 
8593
 
 
8594
 
 
8595
 
 
8596
 
 
8597
 
 
8598
 
 
8599
 
 
8600
 
 
8601
 
 
8602
 
 
8603
 
 
8604
 
 
8605
 
 
8606
 
 
8607
 
 
8608
 
 
8609
 
 
8610
 
 
8611
 
 
8612
 
 
8613
 
 
8614
 
 
8615
 
 
8616
 
 
8617
 
 
8618
 
 
8619
 
 
8620
 
 
8621
 
 
8622
 
 
8623
 
 
8624
 
 
8625
 
 
8626
 
 
8627
 
 
8628
 
 
8629
 
 
8630
 
 
8631
 
 
8632
 
 
8633
 
 
8634
 
 
8635
 
 
8636
 
 
8637
 
 
8638
 
 
8639
 
 
8640
 
 
8641
 
 
8642
 
 
8643
 
 
8644
 
 
8645
 
 
8646
 
 
8647
 
 
8648
 
 
8649
 
 
8650
 
 
8651
 
 
8652
 
 
8653
 
 
8654
 
 
8655
 
 
8656
 
 
8657
 
 
8658
 
 
8659
 
 
8660
 
 
8661
 
 
8662
 
 
8663
 
 
8664
 
 
8665
 
 
8666
 
 
8667
 
 
8668
 
 
8669
 
 
8670
 
 
8671
 
 
8672
 
 
8673
 
 
8674
 
 
8675
 
 
8676
 
 
8677
 
 
8678
 
 
8679
 
 
8680
 
 
8681
 
 
8682
 
 
8683
 
 
8684
 
 
8685
 
 
8686
  echo "$as_me:$LINENO: checking dynamic linker characteristics" >&5
 
8687
echo $ECHO_N "checking dynamic linker characteristics... $ECHO_C" >&6
 
8688
withGCC=$GCC
 
8689
if test "$withGCC" = yes; then
 
8690
  case $host_os in
 
8691
    darwin*) lt_awk_arg="/^libraries:/,/LR/" ;;
 
8692
    *) lt_awk_arg="/^libraries:/" ;;
 
8693
  esac
 
8694
  lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e "s,=/,/,g"`
 
8695
  if $ECHO "$lt_search_path_spec" | $GREP ';' >/dev/null ; then
 
8696
    # if the path contains ";" then we assume it to be the separator
 
8697
    # otherwise default to the standard path separator (i.e. ":") - it is
 
8698
    # assumed that no part of a normal pathname contains ";" but that should
 
8699
    # okay in the real world where ";" in dirpaths is itself problematic.
 
8700
    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED -e 's/;/ /g'`
 
8701
  else
 
8702
    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
 
8703
  fi
 
8704
  # Ok, now we have the path, separated by spaces, we can step through it
 
8705
  # and add multilib dir if necessary.
 
8706
  lt_tmp_lt_search_path_spec=
 
8707
  lt_multi_os_dir=`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null`
 
8708
  for lt_sys_path in $lt_search_path_spec; do
 
8709
    if test -d "$lt_sys_path/$lt_multi_os_dir"; then
 
8710
      lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path/$lt_multi_os_dir"
 
8711
    else
 
8712
      test -d "$lt_sys_path" && \
 
8713
        lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path"
 
8714
    fi
 
8715
  done
 
8716
  lt_search_path_spec=`$ECHO $lt_tmp_lt_search_path_spec | awk '
 
8717
BEGIN {RS=" "; FS="/|\n";} {
 
8718
  lt_foo="";
 
8719
  lt_count=0;
 
8720
  for (lt_i = NF; lt_i > 0; lt_i--) {
 
8721
    if ($lt_i != "" && $lt_i != ".") {
 
8722
      if ($lt_i == "..") {
 
8723
        lt_count++;
 
8724
      } else {
 
8725
        if (lt_count == 0) {
 
8726
          lt_foo="/" $lt_i lt_foo;
 
8727
        } else {
 
8728
          lt_count--;
 
8729
        }
 
8730
      }
 
8731
    }
 
8732
  }
 
8733
  if (lt_foo != "") { lt_freq[lt_foo]++; }
 
8734
  if (lt_freq[lt_foo] == 1) { print lt_foo; }
 
8735
}'`
 
8736
  sys_lib_search_path_spec=`$ECHO $lt_search_path_spec`
 
8737
else
 
8738
  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
 
8739
fi
 
8740
library_names_spec=
 
8741
libname_spec='lib$name'
 
8742
soname_spec=
 
8743
shrext_cmds=".so"
 
8744
postinstall_cmds=
 
8745
postuninstall_cmds=
 
8746
finish_cmds=
 
8747
finish_eval=
 
8748
shlibpath_var=
 
8749
shlibpath_overrides_runpath=unknown
 
8750
version_type=none
 
8751
dynamic_linker="$host_os ld.so"
 
8752
sys_lib_dlsearch_path_spec="/lib /usr/lib"
 
8753
need_lib_prefix=unknown
 
8754
hardcode_into_libs=no
 
8755
 
 
8756
# when you set need_version to no, make sure it does not cause -set_version
 
8757
# flags to be left without arguments
 
8758
need_version=unknown
 
8759
 
 
8760
case $host_os in
 
8761
aix3*)
 
8762
  version_type=linux
 
8763
  library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
 
8764
  shlibpath_var=LIBPATH
 
8765
 
 
8766
  # AIX 3 has no versioning support, so we append a major version to the name.
 
8767
  soname_spec='${libname}${release}${shared_ext}$major'
 
8768
  ;;
 
8769
 
 
8770
aix4* | aix5*)
 
8771
  version_type=linux
 
8772
  need_lib_prefix=no
 
8773
  need_version=no
 
8774
  hardcode_into_libs=yes
 
8775
  if test "$host_cpu" = ia64; then
 
8776
    # AIX 5 supports IA64
 
8777
    library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
 
8778
    shlibpath_var=LD_LIBRARY_PATH
 
8779
  else
 
8780
    # With GCC up to 2.95.x, collect2 would create an import file
 
8781
    # for dependence libraries.  The import file would start with
 
8782
    # the line `#! .'.  This would cause the generated library to
 
8783
    # depend on `.', always an invalid library.  This was fixed in
 
8784
    # development snapshots of GCC prior to 3.0.
 
8785
    case $host_os in
 
8786
      aix4 | aix4.[01] | aix4.[01].*)
 
8787
      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
 
8788
           echo ' yes '
 
8789
           echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then
 
8790
        :
 
8791
      else
 
8792
        can_build_shared=no
 
8793
      fi
 
8794
      ;;
 
8795
    esac
 
8796
    # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
 
8797
    # soname into executable. Probably we can add versioning support to
 
8798
    # collect2, so additional links can be useful in future.
 
8799
    if test "$aix_use_runtimelinking" = yes; then
 
8800
      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
 
8801
      # instead of lib<name>.a to let people know that these are not
 
8802
      # typical AIX shared libraries.
 
8803
      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
 
8804
    else
 
8805
      # We preserve .a as extension for shared libraries through AIX4.2
 
8806
      # and later when we are not doing run time linking.
 
8807
      library_names_spec='${libname}${release}.a $libname.a'
 
8808
      soname_spec='${libname}${release}${shared_ext}$major'
 
8809
    fi
 
8810
    shlibpath_var=LIBPATH
 
8811
  fi
 
8812
  ;;
 
8813
 
 
8814
amigaos*)
 
8815
  if test "$host_cpu" = m68k; then
 
8816
    library_names_spec='$libname.ixlibrary $libname.a'
 
8817
    # Create ${libname}_ixlibrary.a entries in /sys/libs.
 
8818
    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$ECHO "X$lib" | $Xsed -e '\''s%^.*/\([^/]*\)\.ixlibrary$%\1%'\''`; test $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
 
8819
  else
 
8820
    dynamic_linker=no
 
8821
  fi
 
8822
  ;;
 
8823
 
 
8824
beos*)
 
8825
  library_names_spec='${libname}${shared_ext}'
 
8826
  dynamic_linker="$host_os ld.so"
 
8827
  shlibpath_var=LIBRARY_PATH
 
8828
  ;;
 
8829
 
 
8830
bsdi[45]*)
 
8831
  version_type=linux
 
8832
  need_version=no
 
8833
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
 
8834
  soname_spec='${libname}${release}${shared_ext}$major'
 
8835
  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
 
8836
  shlibpath_var=LD_LIBRARY_PATH
 
8837
  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
 
8838
  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
 
8839
  # the default ld.so.conf also contains /usr/contrib/lib and
 
8840
  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
 
8841
  # libtool to hard-code these into programs
 
8842
  ;;
 
8843
 
 
8844
cygwin* | mingw* | pw32*)
 
8845
  version_type=windows
 
8846
  shrext_cmds=".dll"
 
8847
  need_version=no
 
8848
  need_lib_prefix=no
 
8849
 
 
8850
  case $withGCC,$host_os in
 
8851
  yes,cygwin* | yes,mingw* | yes,pw32*)
 
8852
    library_names_spec='$libname.dll.a'
 
8853
    # DLL is installed to $(libdir)/../bin by postinstall_cmds
 
8854
    postinstall_cmds='base_file=`basename \${file}`~
 
8855
      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i; echo \$dlname'\''`~
 
8856
      dldir=$destdir/`dirname \$dlpath`~
 
8857
      test -d \$dldir || mkdir -p \$dldir~
 
8858
      $install_prog $dir/$dlname \$dldir/$dlname~
 
8859
      chmod a+x \$dldir/$dlname~
 
8860
      if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
 
8861
        eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
 
8862
      fi'
 
8863
    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
 
8864
      dlpath=$dir/\$dldll~
 
8865
       $RM \$dlpath'
 
8866
    shlibpath_overrides_runpath=yes
 
8867
 
 
8868
    case $host_os in
 
8869
    cygwin*)
 
8870
      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
 
8871
      soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
 
8872
      sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"
 
8873
      ;;
 
8874
    mingw*)
 
8875
      # MinGW DLLs use traditional 'lib' prefix
 
8876
      soname_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
 
8877
      sys_lib_search_path_spec=`$CC -print-search-dirs | $GREP "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
 
8878
      if $ECHO "$sys_lib_search_path_spec" | $GREP ';[c-zC-Z]:/' >/dev/null; then
 
8879
        # It is most probably a Windows format PATH printed by
 
8880
        # mingw gcc, but we are running on Cygwin. Gcc prints its search
 
8881
        # path with ; separators, and with drive letters. We can handle the
 
8882
        # drive letters (cygwin fileutils understands them), so leave them,
 
8883
        # especially as we might pass files found there to a mingw objdump,
 
8884
        # which wouldn't understand a cygwinified path. Ahh.
 
8885
        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
 
8886
      else
 
8887
        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED  -e "s/$PATH_SEPARATOR/ /g"`
 
8888
      fi
 
8889
      ;;
 
8890
    pw32*)
 
8891
      # pw32 DLLs use 'pw' prefix rather than 'lib'
 
8892
      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
 
8893
      ;;
 
8894
    esac
 
8895
    ;;
 
8896
 
 
8897
  *)
 
8898
    library_names_spec='${libname}`echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext} $libname.lib'
 
8899
    ;;
 
8900
  esac
 
8901
  dynamic_linker='Win32 ld.exe'
 
8902
  # FIXME: first we should search . and the directory the executable is in
 
8903
  shlibpath_var=PATH
 
8904
  ;;
 
8905
 
 
8906
darwin* | rhapsody*)
 
8907
  dynamic_linker="$host_os dyld"
 
8908
  version_type=darwin
 
8909
  need_lib_prefix=no
 
8910
  need_version=no
 
8911
  library_names_spec='${libname}${release}${major}$shared_ext ${libname}$shared_ext'
 
8912
  soname_spec='${libname}${release}${major}$shared_ext'
 
8913
  shlibpath_overrides_runpath=yes
 
8914
  shlibpath_var=DYLD_LIBRARY_PATH
 
8915
  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
 
8916
 
 
8917
  sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"
 
8918
  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
 
8919
  ;;
 
8920
 
 
8921
dgux*)
 
8922
  version_type=linux
 
8923
  need_lib_prefix=no
 
8924
  need_version=no
 
8925
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
 
8926
  soname_spec='${libname}${release}${shared_ext}$major'
 
8927
  shlibpath_var=LD_LIBRARY_PATH
 
8928
  ;;
 
8929
 
 
8930
freebsd1*)
 
8931
  dynamic_linker=no
 
8932
  ;;
 
8933
 
 
8934
freebsd* | dragonfly*)
 
8935
  # DragonFly does not have aout.  When/if they implement a new
 
8936
  # versioning mechanism, adjust this.
 
8937
  if test -x /usr/bin/objformat; then
 
8938
    objformat=`/usr/bin/objformat`
 
8939
  else
 
8940
    case $host_os in
 
8941
    freebsd[123]*) objformat=aout ;;
 
8942
    *) objformat=elf ;;
 
8943
    esac
 
8944
  fi
 
8945
  version_type=freebsd-$objformat
 
8946
  case $version_type in
 
8947
    freebsd-elf*)
 
8948
      library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
 
8949
      need_version=no
 
8950
      need_lib_prefix=no
 
8951
      ;;
 
8952
    freebsd-*)
 
8953
      library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
 
8954
      need_version=yes
 
8955
      ;;
 
8956
  esac
 
8957
  shlibpath_var=LD_LIBRARY_PATH
 
8958
  case $host_os in
 
8959
  freebsd2*)
 
8960
    shlibpath_overrides_runpath=yes
 
8961
    ;;
 
8962
  freebsd3.[01]* | freebsdelf3.[01]*)
 
8963
    shlibpath_overrides_runpath=yes
 
8964
    hardcode_into_libs=yes
 
8965
    ;;
 
8966
  freebsd3.[2-9]* | freebsdelf3.[2-9]* | \
 
8967
  freebsd4.[0-5] | freebsdelf4.[0-5] | freebsd4.1.1 | freebsdelf4.1.1)
 
8968
    shlibpath_overrides_runpath=no
 
8969
    hardcode_into_libs=yes
 
8970
    ;;
 
8971
  *) # from 4.6 on, and DragonFly
 
8972
    shlibpath_overrides_runpath=yes
 
8973
    hardcode_into_libs=yes
 
8974
    ;;
 
8975
  esac
 
8976
  ;;
 
8977
 
 
8978
gnu*)
 
8979
  version_type=linux
 
8980
  need_lib_prefix=no
 
8981
  need_version=no
 
8982
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
 
8983
  soname_spec='${libname}${release}${shared_ext}$major'
 
8984
  shlibpath_var=LD_LIBRARY_PATH
 
8985
  hardcode_into_libs=yes
 
8986
  ;;
 
8987
 
 
8988
hpux9* | hpux10* | hpux11*)
 
8989
  # Give a soname corresponding to the major version so that dld.sl refuses to
 
8990
  # link against other versions.
 
8991
  version_type=sunos
 
8992
  need_lib_prefix=no
 
8993
  need_version=no
 
8994
  case $host_cpu in
 
8995
  ia64*)
 
8996
    shrext_cmds='.so'
 
8997
    hardcode_into_libs=yes
 
8998
    dynamic_linker="$host_os dld.so"
 
8999
    shlibpath_var=LD_LIBRARY_PATH
 
9000
    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
 
9001
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
 
9002
    soname_spec='${libname}${release}${shared_ext}$major'
 
9003
    if test "X$HPUX_IA64_MODE" = X32; then
 
9004
      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
 
9005
    else
 
9006
      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
 
9007
    fi
 
9008
    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
 
9009
    ;;
 
9010
  hppa*64*)
 
9011
    shrext_cmds='.sl'
 
9012
    hardcode_into_libs=yes
 
9013
    dynamic_linker="$host_os dld.sl"
 
9014
    shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
 
9015
    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
 
9016
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
 
9017
    soname_spec='${libname}${release}${shared_ext}$major'
 
9018
    sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
 
9019
    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
 
9020
    ;;
 
9021
  *)
 
9022
    shrext_cmds='.sl'
 
9023
    dynamic_linker="$host_os dld.sl"
 
9024
    shlibpath_var=SHLIB_PATH
 
9025
    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
 
9026
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
 
9027
    soname_spec='${libname}${release}${shared_ext}$major'
 
9028
    ;;
 
9029
  esac
 
9030
  # HP-UX runs *really* slowly unless shared libraries are mode 555.
 
9031
  postinstall_cmds='chmod 555 $lib'
 
9032
  ;;
 
9033
 
 
9034
interix[3-9]*)
 
9035
  version_type=linux
 
9036
  need_lib_prefix=no
 
9037
  need_version=no
 
9038
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
 
9039
  soname_spec='${libname}${release}${shared_ext}$major'
 
9040
  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
 
9041
  shlibpath_var=LD_LIBRARY_PATH
 
9042
  shlibpath_overrides_runpath=no
 
9043
  hardcode_into_libs=yes
 
9044
  ;;
 
9045
 
 
9046
irix5* | irix6* | nonstopux*)
 
9047
  case $host_os in
 
9048
    nonstopux*) version_type=nonstopux ;;
 
9049
    *)
 
9050
        if test "$lt_cv_prog_gnu_ld" = yes; then
 
9051
                version_type=linux
 
9052
        else
 
9053
                version_type=irix
 
9054
        fi ;;
 
9055
  esac
 
9056
  need_lib_prefix=no
 
9057
  need_version=no
 
9058
  soname_spec='${libname}${release}${shared_ext}$major'
 
9059
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
 
9060
  case $host_os in
 
9061
  irix5* | nonstopux*)
 
9062
    libsuff= shlibsuff=
 
9063
    ;;
 
9064
  *)
 
9065
    case $LD in # libtool.m4 will add one of these switches to LD
 
9066
    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
 
9067
      libsuff= shlibsuff= libmagic=32-bit;;
 
9068
    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
 
9069
      libsuff=32 shlibsuff=N32 libmagic=N32;;
 
9070
    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
 
9071
      libsuff=64 shlibsuff=64 libmagic=64-bit;;
 
9072
    *) libsuff= shlibsuff= libmagic=never-match;;
 
9073
    esac
 
9074
    ;;
 
9075
  esac
 
9076
  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
 
9077
  shlibpath_overrides_runpath=no
 
9078
  sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
 
9079
  sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
 
9080
  hardcode_into_libs=yes
 
9081
  ;;
 
9082
 
 
9083
# No shared lib support for Linux oldld, aout, or coff.
 
9084
linux*oldld* | linux*aout* | linux*coff*)
 
9085
  dynamic_linker=no
 
9086
  ;;
 
9087
 
 
9088
# This must be Linux ELF.
 
9089
linux* | k*bsd*-gnu)
 
9090
  version_type=linux
 
9091
  need_lib_prefix=no
 
9092
  need_version=no
 
9093
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
 
9094
  soname_spec='${libname}${release}${shared_ext}$major'
 
9095
  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
 
9096
  shlibpath_var=LD_LIBRARY_PATH
 
9097
  shlibpath_overrides_runpath=no
 
9098
  # Some binutils ld are patched to set DT_RUNPATH
 
9099
  save_LDFLAGS=$LDFLAGS
 
9100
  save_libdir=$libdir
 
9101
  eval "libdir=/foo; wl=\"$lt_prog_compiler_wl\"; \
 
9102
       LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec\""
 
9103
  cat >conftest.$ac_ext <<_ACEOF
 
9104
/* confdefs.h.  */
 
9105
_ACEOF
 
9106
cat confdefs.h >>conftest.$ac_ext
 
9107
cat >>conftest.$ac_ext <<_ACEOF
 
9108
/* end confdefs.h.  */
 
9109
 
 
9110
int
 
9111
main ()
 
9112
{
 
9113
 
 
9114
  ;
 
9115
  return 0;
 
9116
}
 
9117
_ACEOF
 
9118
rm -f conftest.$ac_objext conftest$ac_exeext
 
9119
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
9120
  (eval $ac_link) 2>conftest.er1
 
9121
  ac_status=$?
 
9122
  grep -v '^ *+' conftest.er1 >conftest.err
 
9123
  rm -f conftest.er1
 
9124
  cat conftest.err >&5
 
9125
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9126
  (exit $ac_status); } &&
 
9127
         { ac_try='test -z "$ac_c_werror_flag"
 
9128
                         || test ! -s conftest.err'
 
9129
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9130
  (eval $ac_try) 2>&5
 
9131
  ac_status=$?
 
9132
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9133
  (exit $ac_status); }; } &&
 
9134
         { ac_try='test -s conftest$ac_exeext'
 
9135
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9136
  (eval $ac_try) 2>&5
 
9137
  ac_status=$?
 
9138
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9139
  (exit $ac_status); }; }; then
 
9140
  if  ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir"; then
 
9141
  shlibpath_overrides_runpath=yes
 
9142
fi
 
9143
 
 
9144
else
 
9145
  echo "$as_me: failed program was:" >&5
 
9146
sed 's/^/| /' conftest.$ac_ext >&5
 
9147
 
 
9148
fi
 
9149
rm -f conftest.err conftest.$ac_objext \
 
9150
      conftest$ac_exeext conftest.$ac_ext
 
9151
  LDFLAGS=$save_LDFLAGS
 
9152
  libdir=$save_libdir
 
9153
 
 
9154
  # This implies no fast_install, which is unacceptable.
 
9155
  # Some rework will be needed to allow for fast_install
 
9156
  # before this can be enabled.
 
9157
  hardcode_into_libs=yes
 
9158
 
 
9159
  # Append ld.so.conf contents to the search path
 
9160
  if test -f /etc/ld.so.conf; then
 
9161
    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;s/[:,    ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;/^$/d' | tr '\n' ' '`
 
9162
    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
 
9163
  fi
 
9164
 
 
9165
  # We used to test for /lib/ld.so.1 and disable shared libraries on
 
9166
  # powerpc, because MkLinux only supported shared libraries with the
 
9167
  # GNU dynamic linker.  Since this was broken with cross compilers,
 
9168
  # most powerpc-linux boxes support dynamic linking these days and
 
9169
  # people can always --disable-shared, the test was removed, and we
 
9170
  # assume the GNU/Linux dynamic linker is in use.
 
9171
  dynamic_linker='GNU/Linux ld.so'
 
9172
  ;;
 
9173
 
 
9174
netbsd*)
 
9175
  version_type=sunos
 
9176
  need_lib_prefix=no
 
9177
  need_version=no
 
9178
  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
 
9179
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
 
9180
    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
 
9181
    dynamic_linker='NetBSD (a.out) ld.so'
 
9182
  else
 
9183
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
 
9184
    soname_spec='${libname}${release}${shared_ext}$major'
 
9185
    dynamic_linker='NetBSD ld.elf_so'
 
9186
  fi
 
9187
  shlibpath_var=LD_LIBRARY_PATH
 
9188
  shlibpath_overrides_runpath=yes
 
9189
  hardcode_into_libs=yes
 
9190
  ;;
 
9191
 
 
9192
newsos6)
 
9193
  version_type=linux
 
9194
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
 
9195
  shlibpath_var=LD_LIBRARY_PATH
 
9196
  shlibpath_overrides_runpath=yes
 
9197
  ;;
 
9198
 
 
9199
*nto* | *qnx*)
 
9200
  version_type=qnx
 
9201
  need_lib_prefix=no
 
9202
  need_version=no
 
9203
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
 
9204
  soname_spec='${libname}${release}${shared_ext}$major'
 
9205
  shlibpath_var=LD_LIBRARY_PATH
 
9206
  shlibpath_overrides_runpath=no
 
9207
  hardcode_into_libs=yes
 
9208
  dynamic_linker='ldqnx.so'
 
9209
  ;;
 
9210
 
 
9211
openbsd*)
 
9212
  version_type=sunos
 
9213
  sys_lib_dlsearch_path_spec="/usr/lib"
 
9214
  need_lib_prefix=no
 
9215
  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
 
9216
  case $host_os in
 
9217
    openbsd3.3 | openbsd3.3.*)  need_version=yes ;;
 
9218
    *)                          need_version=no  ;;
 
9219
  esac
 
9220
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
 
9221
  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
 
9222
  shlibpath_var=LD_LIBRARY_PATH
 
9223
  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
 
9224
    case $host_os in
 
9225
      openbsd2.[89] | openbsd2.[89].*)
 
9226
        shlibpath_overrides_runpath=no
 
9227
        ;;
 
9228
      *)
 
9229
        shlibpath_overrides_runpath=yes
 
9230
        ;;
 
9231
      esac
 
9232
  else
 
9233
    shlibpath_overrides_runpath=yes
 
9234
  fi
 
9235
  ;;
 
9236
 
 
9237
os2*)
 
9238
  libname_spec='$name'
 
9239
  shrext_cmds=".dll"
 
9240
  need_lib_prefix=no
 
9241
  library_names_spec='$libname${shared_ext} $libname.a'
 
9242
  dynamic_linker='OS/2 ld.exe'
 
9243
  shlibpath_var=LIBPATH
 
9244
  ;;
 
9245
 
 
9246
osf3* | osf4* | osf5*)
 
9247
  version_type=osf
 
9248
  need_lib_prefix=no
 
9249
  need_version=no
 
9250
  soname_spec='${libname}${release}${shared_ext}$major'
 
9251
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
 
9252
  shlibpath_var=LD_LIBRARY_PATH
 
9253
  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
 
9254
  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
 
9255
  ;;
 
9256
 
 
9257
rdos*)
 
9258
  dynamic_linker=no
 
9259
  ;;
 
9260
 
 
9261
solaris*)
 
9262
  version_type=linux
 
9263
  need_lib_prefix=no
 
9264
  need_version=no
 
9265
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
 
9266
  soname_spec='${libname}${release}${shared_ext}$major'
 
9267
  shlibpath_var=LD_LIBRARY_PATH
 
9268
  shlibpath_overrides_runpath=yes
 
9269
  hardcode_into_libs=yes
 
9270
  # ldd complains unless libraries are executable
 
9271
  postinstall_cmds='chmod +x $lib'
 
9272
  ;;
 
9273
 
 
9274
sunos4*)
 
9275
  version_type=sunos
 
9276
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
 
9277
  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
 
9278
  shlibpath_var=LD_LIBRARY_PATH
 
9279
  shlibpath_overrides_runpath=yes
 
9280
  if test "$with_gnu_ld" = yes; then
 
9281
    need_lib_prefix=no
 
9282
  fi
 
9283
  need_version=yes
 
9284
  ;;
 
9285
 
 
9286
sysv4 | sysv4.3*)
 
9287
  version_type=linux
 
9288
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
 
9289
  soname_spec='${libname}${release}${shared_ext}$major'
 
9290
  shlibpath_var=LD_LIBRARY_PATH
 
9291
  case $host_vendor in
 
9292
    sni)
 
9293
      shlibpath_overrides_runpath=no
 
9294
      need_lib_prefix=no
 
9295
      runpath_var=LD_RUN_PATH
 
9296
      ;;
 
9297
    siemens)
 
9298
      need_lib_prefix=no
 
9299
      ;;
 
9300
    motorola)
 
9301
      need_lib_prefix=no
 
9302
      need_version=no
 
9303
      shlibpath_overrides_runpath=no
 
9304
      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
 
9305
      ;;
 
9306
  esac
 
9307
  ;;
 
9308
 
 
9309
sysv4*MP*)
 
9310
  if test -d /usr/nec ;then
 
9311
    version_type=linux
 
9312
    library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
 
9313
    soname_spec='$libname${shared_ext}.$major'
 
9314
    shlibpath_var=LD_LIBRARY_PATH
 
9315
  fi
 
9316
  ;;
 
9317
 
 
9318
sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
 
9319
  version_type=freebsd-elf
 
9320
  need_lib_prefix=no
 
9321
  need_version=no
 
9322
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
 
9323
  soname_spec='${libname}${release}${shared_ext}$major'
 
9324
  shlibpath_var=LD_LIBRARY_PATH
 
9325
  shlibpath_overrides_runpath=yes
 
9326
  hardcode_into_libs=yes
 
9327
  if test "$with_gnu_ld" = yes; then
 
9328
    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
 
9329
  else
 
9330
    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
 
9331
    case $host_os in
 
9332
      sco3.2v5*)
 
9333
        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
 
9334
        ;;
 
9335
    esac
 
9336
  fi
 
9337
  sys_lib_dlsearch_path_spec='/usr/lib'
 
9338
  ;;
 
9339
 
 
9340
tpf*)
 
9341
  # TPF is a cross-target only.  Preferred cross-host = GNU/Linux.
 
9342
  version_type=linux
 
9343
  need_lib_prefix=no
 
9344
  need_version=no
 
9345
  library_name_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
 
9346
  shlibpath_var=LD_LIBRARY_PATH
 
9347
  shlibpath_overrides_runpath=no
 
9348
  hardcode_into_libs=yes
 
9349
  ;;
 
9350
 
 
9351
uts4*)
 
9352
  version_type=linux
 
9353
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
 
9354
  soname_spec='${libname}${release}${shared_ext}$major'
 
9355
  shlibpath_var=LD_LIBRARY_PATH
 
9356
  ;;
 
9357
 
 
9358
*)
 
9359
  dynamic_linker=no
 
9360
  ;;
 
9361
esac
 
9362
echo "$as_me:$LINENO: result: $dynamic_linker" >&5
 
9363
echo "${ECHO_T}$dynamic_linker" >&6
 
9364
test "$dynamic_linker" = no && can_build_shared=no
 
9365
 
 
9366
variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
 
9367
if test "$GCC" = yes; then
 
9368
  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
 
9369
fi
 
9370
 
 
9371
 
 
9372
 
 
9373
 
 
9374
 
 
9375
 
 
9376
 
 
9377
 
 
9378
 
 
9379
 
 
9380
 
 
9381
 
 
9382
 
 
9383
 
 
9384
 
 
9385
 
 
9386
 
 
9387
 
 
9388
 
 
9389
 
 
9390
 
 
9391
 
 
9392
 
 
9393
 
 
9394
 
 
9395
 
 
9396
 
 
9397
 
 
9398
 
 
9399
 
 
9400
 
 
9401
 
 
9402
 
 
9403
 
 
9404
 
 
9405
 
 
9406
 
 
9407
 
 
9408
 
 
9409
 
 
9410
 
 
9411
 
 
9412
 
 
9413
 
 
9414
 
 
9415
 
 
9416
 
 
9417
 
 
9418
 
 
9419
 
 
9420
 
 
9421
 
 
9422
 
 
9423
 
 
9424
 
 
9425
 
 
9426
 
 
9427
 
 
9428
 
 
9429
 
 
9430
 
 
9431
 
 
9432
 
 
9433
 
 
9434
 
 
9435
 
 
9436
 
 
9437
 
 
9438
 
 
9439
 
 
9440
 
 
9441
 
 
9442
 
 
9443
 
 
9444
 
 
9445
 
 
9446
 
 
9447
 
 
9448
 
 
9449
 
 
9450
 
 
9451
 
 
9452
 
 
9453
 
 
9454
 
 
9455
 
 
9456
 
 
9457
  echo "$as_me:$LINENO: checking how to hardcode library paths into programs" >&5
 
9458
echo $ECHO_N "checking how to hardcode library paths into programs... $ECHO_C" >&6
 
9459
hardcode_action=
 
9460
if test -n "$hardcode_libdir_flag_spec" ||
 
9461
   test -n "$runpath_var" ||
 
9462
   test "X$hardcode_automatic" = "Xyes" ; then
 
9463
 
 
9464
  # We can hardcode non-existent directories.
 
9465
  if test "$hardcode_direct" != no &&
 
9466
     # If the only mechanism to avoid hardcoding is shlibpath_var, we
 
9467
     # have to relink, otherwise we might link with an installed library
 
9468
     # when we should be linking with a yet-to-be-installed one
 
9469
     ## test "$_LT_TAGVAR(hardcode_shlibpath_var, )" != no &&
 
9470
     test "$hardcode_minus_L" != no; then
 
9471
    # Linking always hardcodes the temporary library directory.
 
9472
    hardcode_action=relink
 
9473
  else
 
9474
    # We can link without hardcoding, and we can hardcode nonexisting dirs.
 
9475
    hardcode_action=immediate
 
9476
  fi
 
9477
else
 
9478
  # We cannot hardcode anything, or else we can only hardcode existing
 
9479
  # directories.
 
9480
  hardcode_action=unsupported
 
9481
fi
 
9482
echo "$as_me:$LINENO: result: $hardcode_action" >&5
 
9483
echo "${ECHO_T}$hardcode_action" >&6
 
9484
 
 
9485
if test "$hardcode_action" = relink ||
 
9486
   test "$inherit_rpath" = yes; then
 
9487
  # Fast installation is not supported
 
9488
  enable_fast_install=no
 
9489
elif test "$shlibpath_overrides_runpath" = yes ||
 
9490
     test "$enable_shared" = no; then
 
9491
  # Fast installation is not necessary
 
9492
  enable_fast_install=needless
 
9493
fi
 
9494
 
 
9495
 
 
9496
 
 
9497
 
 
9498
 
 
9499
 
 
9500
  if test "x$enable_dlopen" != xyes; then
 
9501
  enable_dlopen=unknown
 
9502
  enable_dlopen_self=unknown
 
9503
  enable_dlopen_self_static=unknown
 
9504
else
 
9505
  lt_cv_dlopen=no
 
9506
  lt_cv_dlopen_libs=
 
9507
 
 
9508
  case $host_os in
 
9509
  beos*)
 
9510
    lt_cv_dlopen="load_add_on"
 
9511
    lt_cv_dlopen_libs=
 
9512
    lt_cv_dlopen_self=yes
 
9513
    ;;
 
9514
 
 
9515
  mingw* | pw32*)
 
9516
    lt_cv_dlopen="LoadLibrary"
 
9517
    lt_cv_dlopen_libs=
 
9518
    ;;
 
9519
 
 
9520
  cygwin*)
 
9521
    lt_cv_dlopen="dlopen"
 
9522
    lt_cv_dlopen_libs=
 
9523
    ;;
 
9524
 
 
9525
  darwin*)
 
9526
  # if libdl is installed we need to link against it
 
9527
    echo "$as_me:$LINENO: checking for dlopen in -ldl" >&5
 
9528
echo $ECHO_N "checking for dlopen in -ldl... $ECHO_C" >&6
 
9529
if test "${ac_cv_lib_dl_dlopen+set}" = set; then
 
9530
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9531
else
 
9532
  ac_check_lib_save_LIBS=$LIBS
 
9533
LIBS="-ldl  $LIBS"
 
9534
cat >conftest.$ac_ext <<_ACEOF
 
9535
/* confdefs.h.  */
 
9536
_ACEOF
 
9537
cat confdefs.h >>conftest.$ac_ext
 
9538
cat >>conftest.$ac_ext <<_ACEOF
 
9539
/* end confdefs.h.  */
 
9540
 
 
9541
/* Override any gcc2 internal prototype to avoid an error.  */
 
9542
#ifdef __cplusplus
 
9543
extern "C"
 
9544
#endif
 
9545
/* We use char because int might match the return type of a gcc2
 
9546
   builtin and then its argument prototype would still apply.  */
 
9547
char dlopen ();
 
9548
int
 
9549
main ()
 
9550
{
 
9551
dlopen ();
 
9552
  ;
 
9553
  return 0;
 
9554
}
 
9555
_ACEOF
 
9556
rm -f conftest.$ac_objext conftest$ac_exeext
 
9557
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
9558
  (eval $ac_link) 2>conftest.er1
 
9559
  ac_status=$?
 
9560
  grep -v '^ *+' conftest.er1 >conftest.err
 
9561
  rm -f conftest.er1
 
9562
  cat conftest.err >&5
 
9563
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9564
  (exit $ac_status); } &&
 
9565
         { ac_try='test -z "$ac_c_werror_flag"
 
9566
                         || test ! -s conftest.err'
 
9567
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9568
  (eval $ac_try) 2>&5
 
9569
  ac_status=$?
 
9570
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9571
  (exit $ac_status); }; } &&
 
9572
         { ac_try='test -s conftest$ac_exeext'
 
9573
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9574
  (eval $ac_try) 2>&5
 
9575
  ac_status=$?
 
9576
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9577
  (exit $ac_status); }; }; then
 
9578
  ac_cv_lib_dl_dlopen=yes
 
9579
else
 
9580
  echo "$as_me: failed program was:" >&5
 
9581
sed 's/^/| /' conftest.$ac_ext >&5
 
9582
 
 
9583
ac_cv_lib_dl_dlopen=no
 
9584
fi
 
9585
rm -f conftest.err conftest.$ac_objext \
 
9586
      conftest$ac_exeext conftest.$ac_ext
 
9587
LIBS=$ac_check_lib_save_LIBS
 
9588
fi
 
9589
echo "$as_me:$LINENO: result: $ac_cv_lib_dl_dlopen" >&5
 
9590
echo "${ECHO_T}$ac_cv_lib_dl_dlopen" >&6
 
9591
if test $ac_cv_lib_dl_dlopen = yes; then
 
9592
  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"
 
9593
else
 
9594
 
 
9595
    lt_cv_dlopen="dyld"
 
9596
    lt_cv_dlopen_libs=
 
9597
    lt_cv_dlopen_self=yes
 
9598
 
 
9599
fi
 
9600
 
 
9601
    ;;
 
9602
 
 
9603
  *)
 
9604
    echo "$as_me:$LINENO: checking for shl_load" >&5
 
9605
echo $ECHO_N "checking for shl_load... $ECHO_C" >&6
 
9606
if test "${ac_cv_func_shl_load+set}" = set; then
 
9607
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9608
else
 
9609
  cat >conftest.$ac_ext <<_ACEOF
 
9610
/* confdefs.h.  */
 
9611
_ACEOF
 
9612
cat confdefs.h >>conftest.$ac_ext
 
9613
cat >>conftest.$ac_ext <<_ACEOF
 
9614
/* end confdefs.h.  */
 
9615
/* Define shl_load to an innocuous variant, in case <limits.h> declares shl_load.
 
9616
   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
 
9617
#define shl_load innocuous_shl_load
 
9618
 
 
9619
/* System header to define __stub macros and hopefully few prototypes,
 
9620
    which can conflict with char shl_load (); below.
 
9621
    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
 
9622
    <limits.h> exists even on freestanding compilers.  */
 
9623
 
 
9624
#ifdef __STDC__
 
9625
# include <limits.h>
 
9626
#else
 
9627
# include <assert.h>
 
9628
#endif
 
9629
 
 
9630
#undef shl_load
 
9631
 
 
9632
/* Override any gcc2 internal prototype to avoid an error.  */
 
9633
#ifdef __cplusplus
 
9634
extern "C"
 
9635
{
 
9636
#endif
 
9637
/* We use char because int might match the return type of a gcc2
 
9638
   builtin and then its argument prototype would still apply.  */
 
9639
char shl_load ();
 
9640
/* The GNU C library defines this for functions which it implements
 
9641
    to always fail with ENOSYS.  Some functions are actually named
 
9642
    something starting with __ and the normal name is an alias.  */
 
9643
#if defined (__stub_shl_load) || defined (__stub___shl_load)
 
9644
choke me
 
9645
#else
 
9646
char (*f) () = shl_load;
 
9647
#endif
 
9648
#ifdef __cplusplus
 
9649
}
 
9650
#endif
 
9651
 
 
9652
int
 
9653
main ()
 
9654
{
 
9655
return f != shl_load;
 
9656
  ;
 
9657
  return 0;
 
9658
}
 
9659
_ACEOF
 
9660
rm -f conftest.$ac_objext conftest$ac_exeext
 
9661
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
9662
  (eval $ac_link) 2>conftest.er1
 
9663
  ac_status=$?
 
9664
  grep -v '^ *+' conftest.er1 >conftest.err
 
9665
  rm -f conftest.er1
 
9666
  cat conftest.err >&5
 
9667
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9668
  (exit $ac_status); } &&
 
9669
         { ac_try='test -z "$ac_c_werror_flag"
 
9670
                         || test ! -s conftest.err'
 
9671
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9672
  (eval $ac_try) 2>&5
 
9673
  ac_status=$?
 
9674
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9675
  (exit $ac_status); }; } &&
 
9676
         { ac_try='test -s conftest$ac_exeext'
 
9677
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9678
  (eval $ac_try) 2>&5
 
9679
  ac_status=$?
 
9680
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9681
  (exit $ac_status); }; }; then
 
9682
  ac_cv_func_shl_load=yes
 
9683
else
 
9684
  echo "$as_me: failed program was:" >&5
 
9685
sed 's/^/| /' conftest.$ac_ext >&5
 
9686
 
 
9687
ac_cv_func_shl_load=no
 
9688
fi
 
9689
rm -f conftest.err conftest.$ac_objext \
 
9690
      conftest$ac_exeext conftest.$ac_ext
 
9691
fi
 
9692
echo "$as_me:$LINENO: result: $ac_cv_func_shl_load" >&5
 
9693
echo "${ECHO_T}$ac_cv_func_shl_load" >&6
 
9694
if test $ac_cv_func_shl_load = yes; then
 
9695
  lt_cv_dlopen="shl_load"
 
9696
else
 
9697
  echo "$as_me:$LINENO: checking for shl_load in -ldld" >&5
 
9698
echo $ECHO_N "checking for shl_load in -ldld... $ECHO_C" >&6
 
9699
if test "${ac_cv_lib_dld_shl_load+set}" = set; then
 
9700
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9701
else
 
9702
  ac_check_lib_save_LIBS=$LIBS
 
9703
LIBS="-ldld  $LIBS"
 
9704
cat >conftest.$ac_ext <<_ACEOF
 
9705
/* confdefs.h.  */
 
9706
_ACEOF
 
9707
cat confdefs.h >>conftest.$ac_ext
 
9708
cat >>conftest.$ac_ext <<_ACEOF
 
9709
/* end confdefs.h.  */
 
9710
 
 
9711
/* Override any gcc2 internal prototype to avoid an error.  */
 
9712
#ifdef __cplusplus
 
9713
extern "C"
 
9714
#endif
 
9715
/* We use char because int might match the return type of a gcc2
 
9716
   builtin and then its argument prototype would still apply.  */
 
9717
char shl_load ();
 
9718
int
 
9719
main ()
 
9720
{
 
9721
shl_load ();
 
9722
  ;
 
9723
  return 0;
 
9724
}
 
9725
_ACEOF
 
9726
rm -f conftest.$ac_objext conftest$ac_exeext
 
9727
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
9728
  (eval $ac_link) 2>conftest.er1
 
9729
  ac_status=$?
 
9730
  grep -v '^ *+' conftest.er1 >conftest.err
 
9731
  rm -f conftest.er1
 
9732
  cat conftest.err >&5
 
9733
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9734
  (exit $ac_status); } &&
 
9735
         { ac_try='test -z "$ac_c_werror_flag"
 
9736
                         || test ! -s conftest.err'
 
9737
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9738
  (eval $ac_try) 2>&5
 
9739
  ac_status=$?
 
9740
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9741
  (exit $ac_status); }; } &&
 
9742
         { ac_try='test -s conftest$ac_exeext'
 
9743
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9744
  (eval $ac_try) 2>&5
 
9745
  ac_status=$?
 
9746
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9747
  (exit $ac_status); }; }; then
 
9748
  ac_cv_lib_dld_shl_load=yes
 
9749
else
 
9750
  echo "$as_me: failed program was:" >&5
 
9751
sed 's/^/| /' conftest.$ac_ext >&5
 
9752
 
 
9753
ac_cv_lib_dld_shl_load=no
 
9754
fi
 
9755
rm -f conftest.err conftest.$ac_objext \
 
9756
      conftest$ac_exeext conftest.$ac_ext
 
9757
LIBS=$ac_check_lib_save_LIBS
 
9758
fi
 
9759
echo "$as_me:$LINENO: result: $ac_cv_lib_dld_shl_load" >&5
 
9760
echo "${ECHO_T}$ac_cv_lib_dld_shl_load" >&6
 
9761
if test $ac_cv_lib_dld_shl_load = yes; then
 
9762
  lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld"
 
9763
else
 
9764
  echo "$as_me:$LINENO: checking for dlopen" >&5
 
9765
echo $ECHO_N "checking for dlopen... $ECHO_C" >&6
 
9766
if test "${ac_cv_func_dlopen+set}" = set; then
 
9767
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9768
else
 
9769
  cat >conftest.$ac_ext <<_ACEOF
 
9770
/* confdefs.h.  */
 
9771
_ACEOF
 
9772
cat confdefs.h >>conftest.$ac_ext
 
9773
cat >>conftest.$ac_ext <<_ACEOF
 
9774
/* end confdefs.h.  */
 
9775
/* Define dlopen to an innocuous variant, in case <limits.h> declares dlopen.
 
9776
   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
 
9777
#define dlopen innocuous_dlopen
 
9778
 
 
9779
/* System header to define __stub macros and hopefully few prototypes,
 
9780
    which can conflict with char dlopen (); below.
 
9781
    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
 
9782
    <limits.h> exists even on freestanding compilers.  */
 
9783
 
 
9784
#ifdef __STDC__
 
9785
# include <limits.h>
 
9786
#else
 
9787
# include <assert.h>
 
9788
#endif
 
9789
 
 
9790
#undef dlopen
 
9791
 
 
9792
/* Override any gcc2 internal prototype to avoid an error.  */
 
9793
#ifdef __cplusplus
 
9794
extern "C"
 
9795
{
 
9796
#endif
 
9797
/* We use char because int might match the return type of a gcc2
 
9798
   builtin and then its argument prototype would still apply.  */
 
9799
char dlopen ();
 
9800
/* The GNU C library defines this for functions which it implements
 
9801
    to always fail with ENOSYS.  Some functions are actually named
 
9802
    something starting with __ and the normal name is an alias.  */
 
9803
#if defined (__stub_dlopen) || defined (__stub___dlopen)
 
9804
choke me
 
9805
#else
 
9806
char (*f) () = dlopen;
 
9807
#endif
 
9808
#ifdef __cplusplus
 
9809
}
 
9810
#endif
 
9811
 
 
9812
int
 
9813
main ()
 
9814
{
 
9815
return f != dlopen;
 
9816
  ;
 
9817
  return 0;
 
9818
}
 
9819
_ACEOF
 
9820
rm -f conftest.$ac_objext conftest$ac_exeext
 
9821
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
9822
  (eval $ac_link) 2>conftest.er1
 
9823
  ac_status=$?
 
9824
  grep -v '^ *+' conftest.er1 >conftest.err
 
9825
  rm -f conftest.er1
 
9826
  cat conftest.err >&5
 
9827
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9828
  (exit $ac_status); } &&
 
9829
         { ac_try='test -z "$ac_c_werror_flag"
 
9830
                         || test ! -s conftest.err'
 
9831
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9832
  (eval $ac_try) 2>&5
 
9833
  ac_status=$?
 
9834
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9835
  (exit $ac_status); }; } &&
 
9836
         { ac_try='test -s conftest$ac_exeext'
 
9837
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9838
  (eval $ac_try) 2>&5
 
9839
  ac_status=$?
 
9840
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9841
  (exit $ac_status); }; }; then
 
9842
  ac_cv_func_dlopen=yes
 
9843
else
 
9844
  echo "$as_me: failed program was:" >&5
 
9845
sed 's/^/| /' conftest.$ac_ext >&5
 
9846
 
 
9847
ac_cv_func_dlopen=no
 
9848
fi
 
9849
rm -f conftest.err conftest.$ac_objext \
 
9850
      conftest$ac_exeext conftest.$ac_ext
 
9851
fi
 
9852
echo "$as_me:$LINENO: result: $ac_cv_func_dlopen" >&5
 
9853
echo "${ECHO_T}$ac_cv_func_dlopen" >&6
 
9854
if test $ac_cv_func_dlopen = yes; then
 
9855
  lt_cv_dlopen="dlopen"
 
9856
else
 
9857
  echo "$as_me:$LINENO: checking for dlopen in -ldl" >&5
 
9858
echo $ECHO_N "checking for dlopen in -ldl... $ECHO_C" >&6
 
9859
if test "${ac_cv_lib_dl_dlopen+set}" = set; then
 
9860
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9861
else
 
9862
  ac_check_lib_save_LIBS=$LIBS
 
9863
LIBS="-ldl  $LIBS"
 
9864
cat >conftest.$ac_ext <<_ACEOF
 
9865
/* confdefs.h.  */
 
9866
_ACEOF
 
9867
cat confdefs.h >>conftest.$ac_ext
 
9868
cat >>conftest.$ac_ext <<_ACEOF
 
9869
/* end confdefs.h.  */
 
9870
 
 
9871
/* Override any gcc2 internal prototype to avoid an error.  */
 
9872
#ifdef __cplusplus
 
9873
extern "C"
 
9874
#endif
 
9875
/* We use char because int might match the return type of a gcc2
 
9876
   builtin and then its argument prototype would still apply.  */
 
9877
char dlopen ();
 
9878
int
 
9879
main ()
 
9880
{
 
9881
dlopen ();
 
9882
  ;
 
9883
  return 0;
 
9884
}
 
9885
_ACEOF
 
9886
rm -f conftest.$ac_objext conftest$ac_exeext
 
9887
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
9888
  (eval $ac_link) 2>conftest.er1
 
9889
  ac_status=$?
 
9890
  grep -v '^ *+' conftest.er1 >conftest.err
 
9891
  rm -f conftest.er1
 
9892
  cat conftest.err >&5
 
9893
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9894
  (exit $ac_status); } &&
 
9895
         { ac_try='test -z "$ac_c_werror_flag"
 
9896
                         || test ! -s conftest.err'
 
9897
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9898
  (eval $ac_try) 2>&5
 
9899
  ac_status=$?
 
9900
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9901
  (exit $ac_status); }; } &&
 
9902
         { ac_try='test -s conftest$ac_exeext'
 
9903
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9904
  (eval $ac_try) 2>&5
 
9905
  ac_status=$?
 
9906
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9907
  (exit $ac_status); }; }; then
 
9908
  ac_cv_lib_dl_dlopen=yes
 
9909
else
 
9910
  echo "$as_me: failed program was:" >&5
 
9911
sed 's/^/| /' conftest.$ac_ext >&5
 
9912
 
 
9913
ac_cv_lib_dl_dlopen=no
 
9914
fi
 
9915
rm -f conftest.err conftest.$ac_objext \
 
9916
      conftest$ac_exeext conftest.$ac_ext
 
9917
LIBS=$ac_check_lib_save_LIBS
 
9918
fi
 
9919
echo "$as_me:$LINENO: result: $ac_cv_lib_dl_dlopen" >&5
 
9920
echo "${ECHO_T}$ac_cv_lib_dl_dlopen" >&6
 
9921
if test $ac_cv_lib_dl_dlopen = yes; then
 
9922
  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"
 
9923
else
 
9924
  echo "$as_me:$LINENO: checking for dlopen in -lsvld" >&5
 
9925
echo $ECHO_N "checking for dlopen in -lsvld... $ECHO_C" >&6
 
9926
if test "${ac_cv_lib_svld_dlopen+set}" = set; then
 
9927
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9928
else
 
9929
  ac_check_lib_save_LIBS=$LIBS
 
9930
LIBS="-lsvld  $LIBS"
 
9931
cat >conftest.$ac_ext <<_ACEOF
 
9932
/* confdefs.h.  */
 
9933
_ACEOF
 
9934
cat confdefs.h >>conftest.$ac_ext
 
9935
cat >>conftest.$ac_ext <<_ACEOF
 
9936
/* end confdefs.h.  */
 
9937
 
 
9938
/* Override any gcc2 internal prototype to avoid an error.  */
 
9939
#ifdef __cplusplus
 
9940
extern "C"
 
9941
#endif
 
9942
/* We use char because int might match the return type of a gcc2
 
9943
   builtin and then its argument prototype would still apply.  */
 
9944
char dlopen ();
 
9945
int
 
9946
main ()
 
9947
{
 
9948
dlopen ();
 
9949
  ;
 
9950
  return 0;
 
9951
}
 
9952
_ACEOF
 
9953
rm -f conftest.$ac_objext conftest$ac_exeext
 
9954
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
9955
  (eval $ac_link) 2>conftest.er1
 
9956
  ac_status=$?
 
9957
  grep -v '^ *+' conftest.er1 >conftest.err
 
9958
  rm -f conftest.er1
 
9959
  cat conftest.err >&5
 
9960
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9961
  (exit $ac_status); } &&
 
9962
         { ac_try='test -z "$ac_c_werror_flag"
 
9963
                         || test ! -s conftest.err'
 
9964
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9965
  (eval $ac_try) 2>&5
 
9966
  ac_status=$?
 
9967
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9968
  (exit $ac_status); }; } &&
 
9969
         { ac_try='test -s conftest$ac_exeext'
 
9970
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
9971
  (eval $ac_try) 2>&5
 
9972
  ac_status=$?
 
9973
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
9974
  (exit $ac_status); }; }; then
 
9975
  ac_cv_lib_svld_dlopen=yes
 
9976
else
 
9977
  echo "$as_me: failed program was:" >&5
 
9978
sed 's/^/| /' conftest.$ac_ext >&5
 
9979
 
 
9980
ac_cv_lib_svld_dlopen=no
 
9981
fi
 
9982
rm -f conftest.err conftest.$ac_objext \
 
9983
      conftest$ac_exeext conftest.$ac_ext
 
9984
LIBS=$ac_check_lib_save_LIBS
 
9985
fi
 
9986
echo "$as_me:$LINENO: result: $ac_cv_lib_svld_dlopen" >&5
 
9987
echo "${ECHO_T}$ac_cv_lib_svld_dlopen" >&6
 
9988
if test $ac_cv_lib_svld_dlopen = yes; then
 
9989
  lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"
 
9990
else
 
9991
  echo "$as_me:$LINENO: checking for dld_link in -ldld" >&5
 
9992
echo $ECHO_N "checking for dld_link in -ldld... $ECHO_C" >&6
 
9993
if test "${ac_cv_lib_dld_dld_link+set}" = set; then
 
9994
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
9995
else
 
9996
  ac_check_lib_save_LIBS=$LIBS
 
9997
LIBS="-ldld  $LIBS"
 
9998
cat >conftest.$ac_ext <<_ACEOF
 
9999
/* confdefs.h.  */
 
10000
_ACEOF
 
10001
cat confdefs.h >>conftest.$ac_ext
 
10002
cat >>conftest.$ac_ext <<_ACEOF
 
10003
/* end confdefs.h.  */
 
10004
 
 
10005
/* Override any gcc2 internal prototype to avoid an error.  */
 
10006
#ifdef __cplusplus
 
10007
extern "C"
 
10008
#endif
 
10009
/* We use char because int might match the return type of a gcc2
 
10010
   builtin and then its argument prototype would still apply.  */
 
10011
char dld_link ();
 
10012
int
 
10013
main ()
 
10014
{
 
10015
dld_link ();
 
10016
  ;
 
10017
  return 0;
 
10018
}
 
10019
_ACEOF
 
10020
rm -f conftest.$ac_objext conftest$ac_exeext
 
10021
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
10022
  (eval $ac_link) 2>conftest.er1
 
10023
  ac_status=$?
 
10024
  grep -v '^ *+' conftest.er1 >conftest.err
 
10025
  rm -f conftest.er1
 
10026
  cat conftest.err >&5
 
10027
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10028
  (exit $ac_status); } &&
 
10029
         { ac_try='test -z "$ac_c_werror_flag"
 
10030
                         || test ! -s conftest.err'
 
10031
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10032
  (eval $ac_try) 2>&5
 
10033
  ac_status=$?
 
10034
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10035
  (exit $ac_status); }; } &&
 
10036
         { ac_try='test -s conftest$ac_exeext'
 
10037
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
10038
  (eval $ac_try) 2>&5
 
10039
  ac_status=$?
 
10040
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10041
  (exit $ac_status); }; }; then
 
10042
  ac_cv_lib_dld_dld_link=yes
 
10043
else
 
10044
  echo "$as_me: failed program was:" >&5
 
10045
sed 's/^/| /' conftest.$ac_ext >&5
 
10046
 
 
10047
ac_cv_lib_dld_dld_link=no
 
10048
fi
 
10049
rm -f conftest.err conftest.$ac_objext \
 
10050
      conftest$ac_exeext conftest.$ac_ext
 
10051
LIBS=$ac_check_lib_save_LIBS
 
10052
fi
 
10053
echo "$as_me:$LINENO: result: $ac_cv_lib_dld_dld_link" >&5
 
10054
echo "${ECHO_T}$ac_cv_lib_dld_dld_link" >&6
 
10055
if test $ac_cv_lib_dld_dld_link = yes; then
 
10056
  lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"
 
10057
fi
 
10058
 
 
10059
 
 
10060
fi
 
10061
 
 
10062
 
 
10063
fi
 
10064
 
 
10065
 
 
10066
fi
 
10067
 
 
10068
 
 
10069
fi
 
10070
 
 
10071
 
 
10072
fi
 
10073
 
 
10074
    ;;
 
10075
  esac
 
10076
 
 
10077
  if test "x$lt_cv_dlopen" != xno; then
 
10078
    enable_dlopen=yes
 
10079
  else
 
10080
    enable_dlopen=no
 
10081
  fi
 
10082
 
 
10083
  case $lt_cv_dlopen in
 
10084
  dlopen)
 
10085
    save_CPPFLAGS="$CPPFLAGS"
 
10086
    test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
 
10087
 
 
10088
    save_LDFLAGS="$LDFLAGS"
 
10089
    wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
 
10090
 
 
10091
    save_LIBS="$LIBS"
 
10092
    LIBS="$lt_cv_dlopen_libs $LIBS"
 
10093
 
 
10094
    echo "$as_me:$LINENO: checking whether a program can dlopen itself" >&5
 
10095
echo $ECHO_N "checking whether a program can dlopen itself... $ECHO_C" >&6
 
10096
if test "${lt_cv_dlopen_self+set}" = set; then
 
10097
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10098
else
 
10099
          if test "$cross_compiling" = yes; then :
 
10100
  lt_cv_dlopen_self=cross
 
10101
else
 
10102
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
 
10103
  lt_status=$lt_dlunknown
 
10104
  cat > conftest.$ac_ext <<_LT_EOF
 
10105
#line 10105 "configure"
 
10106
#include "confdefs.h"
 
10107
 
 
10108
#if HAVE_DLFCN_H
 
10109
#include <dlfcn.h>
 
10110
#endif
 
10111
 
 
10112
#include <stdio.h>
 
10113
 
 
10114
#ifdef RTLD_GLOBAL
 
10115
#  define LT_DLGLOBAL           RTLD_GLOBAL
 
10116
#else
 
10117
#  ifdef DL_GLOBAL
 
10118
#    define LT_DLGLOBAL         DL_GLOBAL
 
10119
#  else
 
10120
#    define LT_DLGLOBAL         0
 
10121
#  endif
 
10122
#endif
 
10123
 
 
10124
/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
 
10125
   find out it does not work in some platform. */
 
10126
#ifndef LT_DLLAZY_OR_NOW
 
10127
#  ifdef RTLD_LAZY
 
10128
#    define LT_DLLAZY_OR_NOW            RTLD_LAZY
 
10129
#  else
 
10130
#    ifdef DL_LAZY
 
10131
#      define LT_DLLAZY_OR_NOW          DL_LAZY
 
10132
#    else
 
10133
#      ifdef RTLD_NOW
 
10134
#        define LT_DLLAZY_OR_NOW        RTLD_NOW
 
10135
#      else
 
10136
#        ifdef DL_NOW
 
10137
#          define LT_DLLAZY_OR_NOW      DL_NOW
 
10138
#        else
 
10139
#          define LT_DLLAZY_OR_NOW      0
 
10140
#        endif
 
10141
#      endif
 
10142
#    endif
 
10143
#  endif
 
10144
#endif
 
10145
 
 
10146
#ifdef __cplusplus
 
10147
extern "C" void exit (int);
 
10148
#endif
 
10149
 
 
10150
void fnord() { int i=42;}
 
10151
int main ()
 
10152
{
 
10153
  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
 
10154
  int status = $lt_dlunknown;
 
10155
 
 
10156
  if (self)
 
10157
    {
 
10158
      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
 
10159
      else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;
 
10160
      /* dlclose (self); */
 
10161
    }
 
10162
  else
 
10163
    puts (dlerror ());
 
10164
 
 
10165
    exit (status);
 
10166
}
 
10167
_LT_EOF
 
10168
  if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
10169
  (eval $ac_link) 2>&5
 
10170
  ac_status=$?
 
10171
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10172
  (exit $ac_status); } && test -s conftest${ac_exeext} 2>/dev/null; then
 
10173
    (./conftest; exit; ) >&5 2>/dev/null
 
10174
    lt_status=$?
 
10175
    case x$lt_status in
 
10176
      x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;;
 
10177
      x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;;
 
10178
      x$lt_dlunknown|x*) lt_cv_dlopen_self=no ;;
 
10179
    esac
 
10180
  else :
 
10181
    # compilation failed
 
10182
    lt_cv_dlopen_self=no
 
10183
  fi
 
10184
fi
 
10185
rm -fr conftest*
 
10186
 
 
10187
 
 
10188
fi
 
10189
echo "$as_me:$LINENO: result: $lt_cv_dlopen_self" >&5
 
10190
echo "${ECHO_T}$lt_cv_dlopen_self" >&6
 
10191
 
 
10192
    if test "x$lt_cv_dlopen_self" = xyes; then
 
10193
      wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
 
10194
      echo "$as_me:$LINENO: checking whether a statically linked program can dlopen itself" >&5
 
10195
echo $ECHO_N "checking whether a statically linked program can dlopen itself... $ECHO_C" >&6
 
10196
if test "${lt_cv_dlopen_self_static+set}" = set; then
 
10197
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
10198
else
 
10199
          if test "$cross_compiling" = yes; then :
 
10200
  lt_cv_dlopen_self_static=cross
 
10201
else
 
10202
  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
 
10203
  lt_status=$lt_dlunknown
 
10204
  cat > conftest.$ac_ext <<_LT_EOF
 
10205
#line 10205 "configure"
 
10206
#include "confdefs.h"
 
10207
 
 
10208
#if HAVE_DLFCN_H
 
10209
#include <dlfcn.h>
 
10210
#endif
 
10211
 
 
10212
#include <stdio.h>
 
10213
 
 
10214
#ifdef RTLD_GLOBAL
 
10215
#  define LT_DLGLOBAL           RTLD_GLOBAL
 
10216
#else
 
10217
#  ifdef DL_GLOBAL
 
10218
#    define LT_DLGLOBAL         DL_GLOBAL
 
10219
#  else
 
10220
#    define LT_DLGLOBAL         0
 
10221
#  endif
 
10222
#endif
 
10223
 
 
10224
/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
 
10225
   find out it does not work in some platform. */
 
10226
#ifndef LT_DLLAZY_OR_NOW
 
10227
#  ifdef RTLD_LAZY
 
10228
#    define LT_DLLAZY_OR_NOW            RTLD_LAZY
 
10229
#  else
 
10230
#    ifdef DL_LAZY
 
10231
#      define LT_DLLAZY_OR_NOW          DL_LAZY
 
10232
#    else
 
10233
#      ifdef RTLD_NOW
 
10234
#        define LT_DLLAZY_OR_NOW        RTLD_NOW
 
10235
#      else
 
10236
#        ifdef DL_NOW
 
10237
#          define LT_DLLAZY_OR_NOW      DL_NOW
 
10238
#        else
 
10239
#          define LT_DLLAZY_OR_NOW      0
 
10240
#        endif
 
10241
#      endif
 
10242
#    endif
 
10243
#  endif
 
10244
#endif
 
10245
 
 
10246
#ifdef __cplusplus
 
10247
extern "C" void exit (int);
 
10248
#endif
 
10249
 
 
10250
void fnord() { int i=42;}
 
10251
int main ()
 
10252
{
 
10253
  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
 
10254
  int status = $lt_dlunknown;
 
10255
 
 
10256
  if (self)
 
10257
    {
 
10258
      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
 
10259
      else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;
 
10260
      /* dlclose (self); */
 
10261
    }
 
10262
  else
 
10263
    puts (dlerror ());
 
10264
 
 
10265
    exit (status);
 
10266
}
 
10267
_LT_EOF
 
10268
  if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
 
10269
  (eval $ac_link) 2>&5
 
10270
  ac_status=$?
 
10271
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
10272
  (exit $ac_status); } && test -s conftest${ac_exeext} 2>/dev/null; then
 
10273
    (./conftest; exit; ) >&5 2>/dev/null
 
10274
    lt_status=$?
 
10275
    case x$lt_status in
 
10276
      x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;;
 
10277
      x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;;
 
10278
      x$lt_dlunknown|x*) lt_cv_dlopen_self_static=no ;;
 
10279
    esac
 
10280
  else :
 
10281
    # compilation failed
 
10282
    lt_cv_dlopen_self_static=no
 
10283
  fi
 
10284
fi
 
10285
rm -fr conftest*
 
10286
 
 
10287
 
 
10288
fi
 
10289
echo "$as_me:$LINENO: result: $lt_cv_dlopen_self_static" >&5
 
10290
echo "${ECHO_T}$lt_cv_dlopen_self_static" >&6
 
10291
    fi
 
10292
 
 
10293
    CPPFLAGS="$save_CPPFLAGS"
 
10294
    LDFLAGS="$save_LDFLAGS"
 
10295
    LIBS="$save_LIBS"
 
10296
    ;;
 
10297
  esac
 
10298
 
 
10299
  case $lt_cv_dlopen_self in
 
10300
  yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
 
10301
  *) enable_dlopen_self=unknown ;;
 
10302
  esac
 
10303
 
 
10304
  case $lt_cv_dlopen_self_static in
 
10305
  yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
 
10306
  *) enable_dlopen_self_static=unknown ;;
 
10307
  esac
 
10308
fi
 
10309
 
 
10310
 
 
10311
 
 
10312
 
 
10313
 
 
10314
 
 
10315
 
 
10316
 
 
10317
 
 
10318
 
 
10319
 
 
10320
 
 
10321
 
 
10322
 
 
10323
 
 
10324
 
 
10325
 
 
10326
striplib=
 
10327
old_striplib=
 
10328
echo "$as_me:$LINENO: checking whether stripping libraries is possible" >&5
 
10329
echo $ECHO_N "checking whether stripping libraries is possible... $ECHO_C" >&6
 
10330
if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
 
10331
  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
 
10332
  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
 
10333
  echo "$as_me:$LINENO: result: yes" >&5
 
10334
echo "${ECHO_T}yes" >&6
 
10335
else
 
10336
# FIXME - insert some real tests, host_os isn't really good enough
 
10337
  case $host_os in
 
10338
  darwin*)
 
10339
    if test -n "$STRIP" ; then
 
10340
      striplib="$STRIP -x"
 
10341
      old_striplib="$STRIP -S"
 
10342
      echo "$as_me:$LINENO: result: yes" >&5
 
10343
echo "${ECHO_T}yes" >&6
 
10344
    else
 
10345
      echo "$as_me:$LINENO: result: no" >&5
 
10346
echo "${ECHO_T}no" >&6
 
10347
    fi
 
10348
    ;;
 
10349
  *)
 
10350
    echo "$as_me:$LINENO: result: no" >&5
 
10351
echo "${ECHO_T}no" >&6
 
10352
    ;;
 
10353
  esac
 
10354
fi
 
10355
 
 
10356
 
 
10357
 
 
10358
 
 
10359
 
 
10360
 
 
10361
 
 
10362
 
 
10363
 
 
10364
 
 
10365
 
 
10366
 
 
10367
  # Report which library types will actually be built
 
10368
  echo "$as_me:$LINENO: checking if libtool supports shared libraries" >&5
 
10369
echo $ECHO_N "checking if libtool supports shared libraries... $ECHO_C" >&6
 
10370
  echo "$as_me:$LINENO: result: $can_build_shared" >&5
 
10371
echo "${ECHO_T}$can_build_shared" >&6
 
10372
 
 
10373
  echo "$as_me:$LINENO: checking whether to build shared libraries" >&5
 
10374
echo $ECHO_N "checking whether to build shared libraries... $ECHO_C" >&6
 
10375
  test "$can_build_shared" = "no" && enable_shared=no
 
10376
 
 
10377
  # On AIX, shared libraries and static libraries use the same namespace, and
 
10378
  # are all built from PIC.
 
10379
  case $host_os in
 
10380
  aix3*)
 
10381
    test "$enable_shared" = yes && enable_static=no
 
10382
    if test -n "$RANLIB"; then
 
10383
      archive_cmds="$archive_cmds~\$RANLIB \$lib"
 
10384
      postinstall_cmds='$RANLIB $lib'
 
10385
    fi
 
10386
    ;;
 
10387
 
 
10388
  aix4* | aix5*)
 
10389
    if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
 
10390
      test "$enable_shared" = yes && enable_static=no
 
10391
    fi
 
10392
    ;;
 
10393
  esac
 
10394
  echo "$as_me:$LINENO: result: $enable_shared" >&5
 
10395
echo "${ECHO_T}$enable_shared" >&6
 
10396
 
 
10397
  echo "$as_me:$LINENO: checking whether to build static libraries" >&5
 
10398
echo $ECHO_N "checking whether to build static libraries... $ECHO_C" >&6
 
10399
  # Make sure either enable_shared or enable_static is yes.
 
10400
  test "$enable_shared" = yes || enable_static=yes
 
10401
  echo "$as_me:$LINENO: result: $enable_static" >&5
 
10402
echo "${ECHO_T}$enable_static" >&6
 
10403
 
 
10404
 
 
10405
 
 
10406
 
 
10407
fi
 
10408
ac_ext=c
 
10409
ac_cpp='$CPP $CPPFLAGS'
 
10410
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
10411
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
10412
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
10413
 
 
10414
CC="$lt_save_CC"
 
10415
 
 
10416
 
 
10417
 
 
10418
 
 
10419
 
 
10420
 
 
10421
 
 
10422
 
 
10423
 
 
10424
 
 
10425
 
 
10426
 
 
10427
 
 
10428
                  ac_config_commands="$ac_config_commands libtool"
 
10429
 
 
10430
 
 
10431
 
 
10432
 
 
10433
# Only expand once:
4321
10434
 
4322
10435
 
4323
10436
 
4490
10603
 
4491
10604
# host-specific stuff:
4492
10605
 
4493
 
ac_ext=c
4494
 
ac_cpp='$CPP $CPPFLAGS'
4495
 
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
4496
 
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
4497
 
ac_compiler_gnu=$ac_cv_c_compiler_gnu
4498
 
if test -n "$ac_tool_prefix"; then
4499
 
  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
4500
 
set dummy ${ac_tool_prefix}gcc; ac_word=$2
4501
 
echo "$as_me:$LINENO: checking for $ac_word" >&5
4502
 
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4503
 
if test "${ac_cv_prog_CC+set}" = set; then
4504
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
4505
 
else
4506
 
  if test -n "$CC"; then
4507
 
  ac_cv_prog_CC="$CC" # Let the user override the test.
4508
 
else
4509
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4510
 
for as_dir in $PATH
4511
 
do
4512
 
  IFS=$as_save_IFS
4513
 
  test -z "$as_dir" && as_dir=.
4514
 
  for ac_exec_ext in '' $ac_executable_extensions; do
4515
 
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4516
 
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
4517
 
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4518
 
    break 2
4519
 
  fi
4520
 
done
4521
 
done
4522
 
 
4523
 
fi
4524
 
fi
4525
 
CC=$ac_cv_prog_CC
4526
 
if test -n "$CC"; then
4527
 
  echo "$as_me:$LINENO: result: $CC" >&5
4528
 
echo "${ECHO_T}$CC" >&6
4529
 
else
4530
 
  echo "$as_me:$LINENO: result: no" >&5
4531
 
echo "${ECHO_T}no" >&6
4532
 
fi
4533
 
 
4534
 
fi
4535
 
if test -z "$ac_cv_prog_CC"; then
4536
 
  ac_ct_CC=$CC
4537
 
  # Extract the first word of "gcc", so it can be a program name with args.
4538
 
set dummy gcc; ac_word=$2
4539
 
echo "$as_me:$LINENO: checking for $ac_word" >&5
4540
 
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4541
 
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
4542
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
4543
 
else
4544
 
  if test -n "$ac_ct_CC"; then
4545
 
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
4546
 
else
4547
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4548
 
for as_dir in $PATH
4549
 
do
4550
 
  IFS=$as_save_IFS
4551
 
  test -z "$as_dir" && as_dir=.
4552
 
  for ac_exec_ext in '' $ac_executable_extensions; do
4553
 
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4554
 
    ac_cv_prog_ac_ct_CC="gcc"
4555
 
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4556
 
    break 2
4557
 
  fi
4558
 
done
4559
 
done
4560
 
 
4561
 
fi
4562
 
fi
4563
 
ac_ct_CC=$ac_cv_prog_ac_ct_CC
4564
 
if test -n "$ac_ct_CC"; then
4565
 
  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
4566
 
echo "${ECHO_T}$ac_ct_CC" >&6
4567
 
else
4568
 
  echo "$as_me:$LINENO: result: no" >&5
4569
 
echo "${ECHO_T}no" >&6
4570
 
fi
4571
 
 
4572
 
  CC=$ac_ct_CC
4573
 
else
4574
 
  CC="$ac_cv_prog_CC"
4575
 
fi
4576
 
 
4577
 
if test -z "$CC"; then
4578
 
  if test -n "$ac_tool_prefix"; then
4579
 
  # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
4580
 
set dummy ${ac_tool_prefix}cc; ac_word=$2
4581
 
echo "$as_me:$LINENO: checking for $ac_word" >&5
4582
 
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4583
 
if test "${ac_cv_prog_CC+set}" = set; then
4584
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
4585
 
else
4586
 
  if test -n "$CC"; then
4587
 
  ac_cv_prog_CC="$CC" # Let the user override the test.
4588
 
else
4589
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4590
 
for as_dir in $PATH
4591
 
do
4592
 
  IFS=$as_save_IFS
4593
 
  test -z "$as_dir" && as_dir=.
4594
 
  for ac_exec_ext in '' $ac_executable_extensions; do
4595
 
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4596
 
    ac_cv_prog_CC="${ac_tool_prefix}cc"
4597
 
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4598
 
    break 2
4599
 
  fi
4600
 
done
4601
 
done
4602
 
 
4603
 
fi
4604
 
fi
4605
 
CC=$ac_cv_prog_CC
4606
 
if test -n "$CC"; then
4607
 
  echo "$as_me:$LINENO: result: $CC" >&5
4608
 
echo "${ECHO_T}$CC" >&6
4609
 
else
4610
 
  echo "$as_me:$LINENO: result: no" >&5
4611
 
echo "${ECHO_T}no" >&6
4612
 
fi
4613
 
 
4614
 
fi
4615
 
if test -z "$ac_cv_prog_CC"; then
4616
 
  ac_ct_CC=$CC
4617
 
  # Extract the first word of "cc", so it can be a program name with args.
4618
 
set dummy cc; ac_word=$2
4619
 
echo "$as_me:$LINENO: checking for $ac_word" >&5
4620
 
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4621
 
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
4622
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
4623
 
else
4624
 
  if test -n "$ac_ct_CC"; then
4625
 
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
4626
 
else
4627
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4628
 
for as_dir in $PATH
4629
 
do
4630
 
  IFS=$as_save_IFS
4631
 
  test -z "$as_dir" && as_dir=.
4632
 
  for ac_exec_ext in '' $ac_executable_extensions; do
4633
 
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4634
 
    ac_cv_prog_ac_ct_CC="cc"
4635
 
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4636
 
    break 2
4637
 
  fi
4638
 
done
4639
 
done
4640
 
 
4641
 
fi
4642
 
fi
4643
 
ac_ct_CC=$ac_cv_prog_ac_ct_CC
4644
 
if test -n "$ac_ct_CC"; then
4645
 
  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
4646
 
echo "${ECHO_T}$ac_ct_CC" >&6
4647
 
else
4648
 
  echo "$as_me:$LINENO: result: no" >&5
4649
 
echo "${ECHO_T}no" >&6
4650
 
fi
4651
 
 
4652
 
  CC=$ac_ct_CC
4653
 
else
4654
 
  CC="$ac_cv_prog_CC"
4655
 
fi
4656
 
 
4657
 
fi
4658
 
if test -z "$CC"; then
4659
 
  # Extract the first word of "cc", so it can be a program name with args.
4660
 
set dummy cc; ac_word=$2
4661
 
echo "$as_me:$LINENO: checking for $ac_word" >&5
4662
 
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4663
 
if test "${ac_cv_prog_CC+set}" = set; then
4664
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
4665
 
else
4666
 
  if test -n "$CC"; then
4667
 
  ac_cv_prog_CC="$CC" # Let the user override the test.
4668
 
else
4669
 
  ac_prog_rejected=no
4670
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4671
 
for as_dir in $PATH
4672
 
do
4673
 
  IFS=$as_save_IFS
4674
 
  test -z "$as_dir" && as_dir=.
4675
 
  for ac_exec_ext in '' $ac_executable_extensions; do
4676
 
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4677
 
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
4678
 
       ac_prog_rejected=yes
4679
 
       continue
4680
 
     fi
4681
 
    ac_cv_prog_CC="cc"
4682
 
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4683
 
    break 2
4684
 
  fi
4685
 
done
4686
 
done
4687
 
 
4688
 
if test $ac_prog_rejected = yes; then
4689
 
  # We found a bogon in the path, so make sure we never use it.
4690
 
  set dummy $ac_cv_prog_CC
4691
 
  shift
4692
 
  if test $# != 0; then
4693
 
    # We chose a different compiler from the bogus one.
4694
 
    # However, it has the same basename, so the bogon will be chosen
4695
 
    # first if we set CC to just the basename; use the full file name.
4696
 
    shift
4697
 
    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
4698
 
  fi
4699
 
fi
4700
 
fi
4701
 
fi
4702
 
CC=$ac_cv_prog_CC
4703
 
if test -n "$CC"; then
4704
 
  echo "$as_me:$LINENO: result: $CC" >&5
4705
 
echo "${ECHO_T}$CC" >&6
4706
 
else
4707
 
  echo "$as_me:$LINENO: result: no" >&5
4708
 
echo "${ECHO_T}no" >&6
4709
 
fi
4710
 
 
4711
 
fi
4712
 
if test -z "$CC"; then
4713
 
  if test -n "$ac_tool_prefix"; then
4714
 
  for ac_prog in cl
4715
 
  do
4716
 
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
4717
 
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
4718
 
echo "$as_me:$LINENO: checking for $ac_word" >&5
4719
 
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4720
 
if test "${ac_cv_prog_CC+set}" = set; then
4721
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
4722
 
else
4723
 
  if test -n "$CC"; then
4724
 
  ac_cv_prog_CC="$CC" # Let the user override the test.
4725
 
else
4726
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4727
 
for as_dir in $PATH
4728
 
do
4729
 
  IFS=$as_save_IFS
4730
 
  test -z "$as_dir" && as_dir=.
4731
 
  for ac_exec_ext in '' $ac_executable_extensions; do
4732
 
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4733
 
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
4734
 
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4735
 
    break 2
4736
 
  fi
4737
 
done
4738
 
done
4739
 
 
4740
 
fi
4741
 
fi
4742
 
CC=$ac_cv_prog_CC
4743
 
if test -n "$CC"; then
4744
 
  echo "$as_me:$LINENO: result: $CC" >&5
4745
 
echo "${ECHO_T}$CC" >&6
4746
 
else
4747
 
  echo "$as_me:$LINENO: result: no" >&5
4748
 
echo "${ECHO_T}no" >&6
4749
 
fi
4750
 
 
4751
 
    test -n "$CC" && break
4752
 
  done
4753
 
fi
4754
 
if test -z "$CC"; then
4755
 
  ac_ct_CC=$CC
4756
 
  for ac_prog in cl
4757
 
do
4758
 
  # Extract the first word of "$ac_prog", so it can be a program name with args.
4759
 
set dummy $ac_prog; ac_word=$2
4760
 
echo "$as_me:$LINENO: checking for $ac_word" >&5
4761
 
echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6
4762
 
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
4763
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
4764
 
else
4765
 
  if test -n "$ac_ct_CC"; then
4766
 
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
4767
 
else
4768
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
4769
 
for as_dir in $PATH
4770
 
do
4771
 
  IFS=$as_save_IFS
4772
 
  test -z "$as_dir" && as_dir=.
4773
 
  for ac_exec_ext in '' $ac_executable_extensions; do
4774
 
  if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
4775
 
    ac_cv_prog_ac_ct_CC="$ac_prog"
4776
 
    echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
4777
 
    break 2
4778
 
  fi
4779
 
done
4780
 
done
4781
 
 
4782
 
fi
4783
 
fi
4784
 
ac_ct_CC=$ac_cv_prog_ac_ct_CC
4785
 
if test -n "$ac_ct_CC"; then
4786
 
  echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
4787
 
echo "${ECHO_T}$ac_ct_CC" >&6
4788
 
else
4789
 
  echo "$as_me:$LINENO: result: no" >&5
4790
 
echo "${ECHO_T}no" >&6
4791
 
fi
4792
 
 
4793
 
  test -n "$ac_ct_CC" && break
4794
 
done
4795
 
 
4796
 
  CC=$ac_ct_CC
4797
 
fi
4798
 
 
4799
 
fi
4800
 
 
4801
 
 
4802
 
test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
4803
 
See \`config.log' for more details." >&5
4804
 
echo "$as_me: error: no acceptable C compiler found in \$PATH
4805
 
See \`config.log' for more details." >&2;}
4806
 
   { (exit 1); exit 1; }; }
4807
 
 
4808
 
# Provide some information about the compiler.
4809
 
echo "$as_me:$LINENO:" \
4810
 
     "checking for C compiler version" >&5
4811
 
ac_compiler=`set X $ac_compile; echo $2`
4812
 
{ (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5
4813
 
  (eval $ac_compiler --version </dev/null >&5) 2>&5
4814
 
  ac_status=$?
4815
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4816
 
  (exit $ac_status); }
4817
 
{ (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5
4818
 
  (eval $ac_compiler -v </dev/null >&5) 2>&5
4819
 
  ac_status=$?
4820
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4821
 
  (exit $ac_status); }
4822
 
{ (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5
4823
 
  (eval $ac_compiler -V </dev/null >&5) 2>&5
4824
 
  ac_status=$?
4825
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4826
 
  (exit $ac_status); }
4827
 
 
4828
 
echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
4829
 
echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6
4830
 
if test "${ac_cv_c_compiler_gnu+set}" = set; then
4831
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
4832
 
else
4833
 
  cat >conftest.$ac_ext <<_ACEOF
4834
 
/* confdefs.h.  */
4835
 
_ACEOF
4836
 
cat confdefs.h >>conftest.$ac_ext
4837
 
cat >>conftest.$ac_ext <<_ACEOF
4838
 
/* end confdefs.h.  */
4839
 
 
4840
 
int
4841
 
main ()
4842
 
{
4843
 
#ifndef __GNUC__
4844
 
       choke me
4845
 
#endif
4846
 
 
4847
 
  ;
4848
 
  return 0;
4849
 
}
4850
 
_ACEOF
4851
 
rm -f conftest.$ac_objext
4852
 
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4853
 
  (eval $ac_compile) 2>conftest.er1
4854
 
  ac_status=$?
4855
 
  grep -v '^ *+' conftest.er1 >conftest.err
4856
 
  rm -f conftest.er1
4857
 
  cat conftest.err >&5
4858
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4859
 
  (exit $ac_status); } &&
4860
 
         { ac_try='test -z "$ac_c_werror_flag"
4861
 
                         || test ! -s conftest.err'
4862
 
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4863
 
  (eval $ac_try) 2>&5
4864
 
  ac_status=$?
4865
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4866
 
  (exit $ac_status); }; } &&
4867
 
         { ac_try='test -s conftest.$ac_objext'
4868
 
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4869
 
  (eval $ac_try) 2>&5
4870
 
  ac_status=$?
4871
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4872
 
  (exit $ac_status); }; }; then
4873
 
  ac_compiler_gnu=yes
4874
 
else
4875
 
  echo "$as_me: failed program was:" >&5
4876
 
sed 's/^/| /' conftest.$ac_ext >&5
4877
 
 
4878
 
ac_compiler_gnu=no
4879
 
fi
4880
 
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4881
 
ac_cv_c_compiler_gnu=$ac_compiler_gnu
4882
 
 
4883
 
fi
4884
 
echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5
4885
 
echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6
4886
 
GCC=`test $ac_compiler_gnu = yes && echo yes`
4887
 
ac_test_CFLAGS=${CFLAGS+set}
4888
 
ac_save_CFLAGS=$CFLAGS
4889
 
CFLAGS="-g"
4890
 
echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5
4891
 
echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6
4892
 
if test "${ac_cv_prog_cc_g+set}" = set; then
4893
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
4894
 
else
4895
 
  cat >conftest.$ac_ext <<_ACEOF
4896
 
/* confdefs.h.  */
4897
 
_ACEOF
4898
 
cat confdefs.h >>conftest.$ac_ext
4899
 
cat >>conftest.$ac_ext <<_ACEOF
4900
 
/* end confdefs.h.  */
4901
 
 
4902
 
int
4903
 
main ()
4904
 
{
4905
 
 
4906
 
  ;
4907
 
  return 0;
4908
 
}
4909
 
_ACEOF
4910
 
rm -f conftest.$ac_objext
4911
 
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
4912
 
  (eval $ac_compile) 2>conftest.er1
4913
 
  ac_status=$?
4914
 
  grep -v '^ *+' conftest.er1 >conftest.err
4915
 
  rm -f conftest.er1
4916
 
  cat conftest.err >&5
4917
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4918
 
  (exit $ac_status); } &&
4919
 
         { ac_try='test -z "$ac_c_werror_flag"
4920
 
                         || test ! -s conftest.err'
4921
 
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4922
 
  (eval $ac_try) 2>&5
4923
 
  ac_status=$?
4924
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4925
 
  (exit $ac_status); }; } &&
4926
 
         { ac_try='test -s conftest.$ac_objext'
4927
 
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
4928
 
  (eval $ac_try) 2>&5
4929
 
  ac_status=$?
4930
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
4931
 
  (exit $ac_status); }; }; then
4932
 
  ac_cv_prog_cc_g=yes
4933
 
else
4934
 
  echo "$as_me: failed program was:" >&5
4935
 
sed 's/^/| /' conftest.$ac_ext >&5
4936
 
 
4937
 
ac_cv_prog_cc_g=no
4938
 
fi
4939
 
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
4940
 
fi
4941
 
echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5
4942
 
echo "${ECHO_T}$ac_cv_prog_cc_g" >&6
4943
 
if test "$ac_test_CFLAGS" = set; then
4944
 
  CFLAGS=$ac_save_CFLAGS
4945
 
elif test $ac_cv_prog_cc_g = yes; then
4946
 
  if test "$GCC" = yes; then
4947
 
    CFLAGS="-g -O2"
4948
 
  else
4949
 
    CFLAGS="-g"
4950
 
  fi
4951
 
else
4952
 
  if test "$GCC" = yes; then
4953
 
    CFLAGS="-O2"
4954
 
  else
4955
 
    CFLAGS=
4956
 
  fi
4957
 
fi
4958
 
echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5
4959
 
echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6
4960
 
if test "${ac_cv_prog_cc_stdc+set}" = set; then
4961
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
4962
 
else
4963
 
  ac_cv_prog_cc_stdc=no
4964
 
ac_save_CC=$CC
4965
 
cat >conftest.$ac_ext <<_ACEOF
4966
 
/* confdefs.h.  */
4967
 
_ACEOF
4968
 
cat confdefs.h >>conftest.$ac_ext
4969
 
cat >>conftest.$ac_ext <<_ACEOF
4970
 
/* end confdefs.h.  */
4971
 
#include <stdarg.h>
4972
 
#include <stdio.h>
4973
 
#include <sys/types.h>
4974
 
#include <sys/stat.h>
4975
 
/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
4976
 
struct buf { int x; };
4977
 
FILE * (*rcsopen) (struct buf *, struct stat *, int);
4978
 
static char *e (p, i)
4979
 
     char **p;
4980
 
     int i;
4981
 
{
4982
 
  return p[i];
4983
 
}
4984
 
static char *f (char * (*g) (char **, int), char **p, ...)
4985
 
{
4986
 
  char *s;
4987
 
  va_list v;
4988
 
  va_start (v,p);
4989
 
  s = g (p, va_arg (v,int));
4990
 
  va_end (v);
4991
 
  return s;
4992
 
}
4993
 
 
4994
 
/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
4995
 
   function prototypes and stuff, but not '\xHH' hex character constants.
4996
 
   These don't provoke an error unfortunately, instead are silently treated
4997
 
   as 'x'.  The following induces an error, until -std1 is added to get
4998
 
   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
4999
 
   array size at least.  It's necessary to write '\x00'==0 to get something
5000
 
   that's true only with -std1.  */
5001
 
int osf4_cc_array ['\x00' == 0 ? 1 : -1];
5002
 
 
5003
 
int test (int i, double x);
5004
 
struct s1 {int (*f) (int a);};
5005
 
struct s2 {int (*f) (double a);};
5006
 
int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
5007
 
int argc;
5008
 
char **argv;
5009
 
int
5010
 
main ()
5011
 
{
5012
 
return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
5013
 
  ;
5014
 
  return 0;
5015
 
}
5016
 
_ACEOF
5017
 
# Don't try gcc -ansi; that turns off useful extensions and
5018
 
# breaks some systems' header files.
5019
 
# AIX                   -qlanglvl=ansi
5020
 
# Ultrix and OSF/1      -std1
5021
 
# HP-UX 10.20 and later -Ae
5022
 
# HP-UX older versions  -Aa -D_HPUX_SOURCE
5023
 
# SVR4                  -Xc -D__EXTENSIONS__
5024
 
for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
5025
 
do
5026
 
  CC="$ac_save_CC $ac_arg"
5027
 
  rm -f conftest.$ac_objext
5028
 
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5029
 
  (eval $ac_compile) 2>conftest.er1
5030
 
  ac_status=$?
5031
 
  grep -v '^ *+' conftest.er1 >conftest.err
5032
 
  rm -f conftest.er1
5033
 
  cat conftest.err >&5
5034
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5035
 
  (exit $ac_status); } &&
5036
 
         { ac_try='test -z "$ac_c_werror_flag"
5037
 
                         || test ! -s conftest.err'
5038
 
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5039
 
  (eval $ac_try) 2>&5
5040
 
  ac_status=$?
5041
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5042
 
  (exit $ac_status); }; } &&
5043
 
         { ac_try='test -s conftest.$ac_objext'
5044
 
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5045
 
  (eval $ac_try) 2>&5
5046
 
  ac_status=$?
5047
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5048
 
  (exit $ac_status); }; }; then
5049
 
  ac_cv_prog_cc_stdc=$ac_arg
5050
 
break
5051
 
else
5052
 
  echo "$as_me: failed program was:" >&5
5053
 
sed 's/^/| /' conftest.$ac_ext >&5
5054
 
 
5055
 
fi
5056
 
rm -f conftest.err conftest.$ac_objext
5057
 
done
5058
 
rm -f conftest.$ac_ext conftest.$ac_objext
5059
 
CC=$ac_save_CC
5060
 
 
5061
 
fi
5062
 
 
5063
 
case "x$ac_cv_prog_cc_stdc" in
5064
 
  x|xno)
5065
 
    echo "$as_me:$LINENO: result: none needed" >&5
5066
 
echo "${ECHO_T}none needed" >&6 ;;
5067
 
  *)
5068
 
    echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5
5069
 
echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6
5070
 
    CC="$CC $ac_cv_prog_cc_stdc" ;;
5071
 
esac
5072
 
 
5073
 
# Some people use a C++ compiler to compile C.  Since we use `exit',
5074
 
# in C++ we need to declare it.  In case someone uses the same compiler
5075
 
# for both compiling C and C++ we need to have the C++ compiler decide
5076
 
# the declaration of exit, since it's the most demanding environment.
5077
 
cat >conftest.$ac_ext <<_ACEOF
5078
 
#ifndef __cplusplus
5079
 
  choke me
5080
 
#endif
5081
 
_ACEOF
5082
 
rm -f conftest.$ac_objext
5083
 
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5084
 
  (eval $ac_compile) 2>conftest.er1
5085
 
  ac_status=$?
5086
 
  grep -v '^ *+' conftest.er1 >conftest.err
5087
 
  rm -f conftest.er1
5088
 
  cat conftest.err >&5
5089
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5090
 
  (exit $ac_status); } &&
5091
 
         { ac_try='test -z "$ac_c_werror_flag"
5092
 
                         || test ! -s conftest.err'
5093
 
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5094
 
  (eval $ac_try) 2>&5
5095
 
  ac_status=$?
5096
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5097
 
  (exit $ac_status); }; } &&
5098
 
         { ac_try='test -s conftest.$ac_objext'
5099
 
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5100
 
  (eval $ac_try) 2>&5
5101
 
  ac_status=$?
5102
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5103
 
  (exit $ac_status); }; }; then
5104
 
  for ac_declaration in \
5105
 
   '' \
5106
 
   'extern "C" void std::exit (int) throw (); using std::exit;' \
5107
 
   'extern "C" void std::exit (int); using std::exit;' \
5108
 
   'extern "C" void exit (int) throw ();' \
5109
 
   'extern "C" void exit (int);' \
5110
 
   'void exit (int);'
5111
 
do
5112
 
  cat >conftest.$ac_ext <<_ACEOF
5113
 
/* confdefs.h.  */
5114
 
_ACEOF
5115
 
cat confdefs.h >>conftest.$ac_ext
5116
 
cat >>conftest.$ac_ext <<_ACEOF
5117
 
/* end confdefs.h.  */
5118
 
$ac_declaration
5119
 
#include <stdlib.h>
5120
 
int
5121
 
main ()
5122
 
{
5123
 
exit (42);
5124
 
  ;
5125
 
  return 0;
5126
 
}
5127
 
_ACEOF
5128
 
rm -f conftest.$ac_objext
5129
 
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5130
 
  (eval $ac_compile) 2>conftest.er1
5131
 
  ac_status=$?
5132
 
  grep -v '^ *+' conftest.er1 >conftest.err
5133
 
  rm -f conftest.er1
5134
 
  cat conftest.err >&5
5135
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5136
 
  (exit $ac_status); } &&
5137
 
         { ac_try='test -z "$ac_c_werror_flag"
5138
 
                         || test ! -s conftest.err'
5139
 
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5140
 
  (eval $ac_try) 2>&5
5141
 
  ac_status=$?
5142
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5143
 
  (exit $ac_status); }; } &&
5144
 
         { ac_try='test -s conftest.$ac_objext'
5145
 
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5146
 
  (eval $ac_try) 2>&5
5147
 
  ac_status=$?
5148
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5149
 
  (exit $ac_status); }; }; then
5150
 
  :
5151
 
else
5152
 
  echo "$as_me: failed program was:" >&5
5153
 
sed 's/^/| /' conftest.$ac_ext >&5
5154
 
 
5155
 
continue
5156
 
fi
5157
 
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5158
 
  cat >conftest.$ac_ext <<_ACEOF
5159
 
/* confdefs.h.  */
5160
 
_ACEOF
5161
 
cat confdefs.h >>conftest.$ac_ext
5162
 
cat >>conftest.$ac_ext <<_ACEOF
5163
 
/* end confdefs.h.  */
5164
 
$ac_declaration
5165
 
int
5166
 
main ()
5167
 
{
5168
 
exit (42);
5169
 
  ;
5170
 
  return 0;
5171
 
}
5172
 
_ACEOF
5173
 
rm -f conftest.$ac_objext
5174
 
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
5175
 
  (eval $ac_compile) 2>conftest.er1
5176
 
  ac_status=$?
5177
 
  grep -v '^ *+' conftest.er1 >conftest.err
5178
 
  rm -f conftest.er1
5179
 
  cat conftest.err >&5
5180
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5181
 
  (exit $ac_status); } &&
5182
 
         { ac_try='test -z "$ac_c_werror_flag"
5183
 
                         || test ! -s conftest.err'
5184
 
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5185
 
  (eval $ac_try) 2>&5
5186
 
  ac_status=$?
5187
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5188
 
  (exit $ac_status); }; } &&
5189
 
         { ac_try='test -s conftest.$ac_objext'
5190
 
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
5191
 
  (eval $ac_try) 2>&5
5192
 
  ac_status=$?
5193
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5194
 
  (exit $ac_status); }; }; then
5195
 
  break
5196
 
else
5197
 
  echo "$as_me: failed program was:" >&5
5198
 
sed 's/^/| /' conftest.$ac_ext >&5
5199
 
 
5200
 
fi
5201
 
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5202
 
done
5203
 
rm -f conftest*
5204
 
if test -n "$ac_declaration"; then
5205
 
  echo '#ifdef __cplusplus' >>confdefs.h
5206
 
  echo $ac_declaration      >>confdefs.h
5207
 
  echo '#endif'             >>confdefs.h
5208
 
fi
5209
 
 
5210
 
else
5211
 
  echo "$as_me: failed program was:" >&5
5212
 
sed 's/^/| /' conftest.$ac_ext >&5
5213
 
 
5214
 
fi
5215
 
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
5216
 
ac_ext=c
5217
 
ac_cpp='$CPP $CPPFLAGS'
5218
 
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5219
 
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5220
 
ac_compiler_gnu=$ac_cv_c_compiler_gnu
5221
 
 
5222
 
 
5223
10606
ALL_LINGUAS="fr sv tr es da de id pt_BR ro nl fi vi ga zh_CN"
5224
10607
# If we haven't got the data from the intl directory,
5225
10608
# assume NLS is disabled.
5722
11105
test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
5723
11106
 
5724
11107
 
5725
 
ac_ext=c
5726
 
ac_cpp='$CPP $CPPFLAGS'
5727
 
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5728
 
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5729
 
ac_compiler_gnu=$ac_cv_c_compiler_gnu
5730
 
echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5
5731
 
echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6
5732
 
# On Suns, sometimes $CPP names a directory.
5733
 
if test -n "$CPP" && test -d "$CPP"; then
5734
 
  CPP=
5735
 
fi
5736
 
if test -z "$CPP"; then
5737
 
  if test "${ac_cv_prog_CPP+set}" = set; then
5738
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
5739
 
else
5740
 
      # Double quotes because CPP needs to be expanded
5741
 
    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
5742
 
    do
5743
 
      ac_preproc_ok=false
5744
 
for ac_c_preproc_warn_flag in '' yes
5745
 
do
5746
 
  # Use a header file that comes with gcc, so configuring glibc
5747
 
  # with a fresh cross-compiler works.
5748
 
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5749
 
  # <limits.h> exists even on freestanding compilers.
5750
 
  # On the NeXT, cc -E runs the code through the compiler's parser,
5751
 
  # not just through cpp. "Syntax error" is here to catch this case.
5752
 
  cat >conftest.$ac_ext <<_ACEOF
5753
 
/* confdefs.h.  */
5754
 
_ACEOF
5755
 
cat confdefs.h >>conftest.$ac_ext
5756
 
cat >>conftest.$ac_ext <<_ACEOF
5757
 
/* end confdefs.h.  */
5758
 
#ifdef __STDC__
5759
 
# include <limits.h>
5760
 
#else
5761
 
# include <assert.h>
5762
 
#endif
5763
 
                     Syntax error
5764
 
_ACEOF
5765
 
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5766
 
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5767
 
  ac_status=$?
5768
 
  grep -v '^ *+' conftest.er1 >conftest.err
5769
 
  rm -f conftest.er1
5770
 
  cat conftest.err >&5
5771
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5772
 
  (exit $ac_status); } >/dev/null; then
5773
 
  if test -s conftest.err; then
5774
 
    ac_cpp_err=$ac_c_preproc_warn_flag
5775
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5776
 
  else
5777
 
    ac_cpp_err=
5778
 
  fi
5779
 
else
5780
 
  ac_cpp_err=yes
5781
 
fi
5782
 
if test -z "$ac_cpp_err"; then
5783
 
  :
5784
 
else
5785
 
  echo "$as_me: failed program was:" >&5
5786
 
sed 's/^/| /' conftest.$ac_ext >&5
5787
 
 
5788
 
  # Broken: fails on valid input.
5789
 
continue
5790
 
fi
5791
 
rm -f conftest.err conftest.$ac_ext
5792
 
 
5793
 
  # OK, works on sane cases.  Now check whether non-existent headers
5794
 
  # can be detected and how.
5795
 
  cat >conftest.$ac_ext <<_ACEOF
5796
 
/* confdefs.h.  */
5797
 
_ACEOF
5798
 
cat confdefs.h >>conftest.$ac_ext
5799
 
cat >>conftest.$ac_ext <<_ACEOF
5800
 
/* end confdefs.h.  */
5801
 
#include <ac_nonexistent.h>
5802
 
_ACEOF
5803
 
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5804
 
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5805
 
  ac_status=$?
5806
 
  grep -v '^ *+' conftest.er1 >conftest.err
5807
 
  rm -f conftest.er1
5808
 
  cat conftest.err >&5
5809
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5810
 
  (exit $ac_status); } >/dev/null; then
5811
 
  if test -s conftest.err; then
5812
 
    ac_cpp_err=$ac_c_preproc_warn_flag
5813
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5814
 
  else
5815
 
    ac_cpp_err=
5816
 
  fi
5817
 
else
5818
 
  ac_cpp_err=yes
5819
 
fi
5820
 
if test -z "$ac_cpp_err"; then
5821
 
  # Broken: success on invalid input.
5822
 
continue
5823
 
else
5824
 
  echo "$as_me: failed program was:" >&5
5825
 
sed 's/^/| /' conftest.$ac_ext >&5
5826
 
 
5827
 
  # Passes both tests.
5828
 
ac_preproc_ok=:
5829
 
break
5830
 
fi
5831
 
rm -f conftest.err conftest.$ac_ext
5832
 
 
5833
 
done
5834
 
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5835
 
rm -f conftest.err conftest.$ac_ext
5836
 
if $ac_preproc_ok; then
5837
 
  break
5838
 
fi
5839
 
 
5840
 
    done
5841
 
    ac_cv_prog_CPP=$CPP
5842
 
 
5843
 
fi
5844
 
  CPP=$ac_cv_prog_CPP
5845
 
else
5846
 
  ac_cv_prog_CPP=$CPP
5847
 
fi
5848
 
echo "$as_me:$LINENO: result: $CPP" >&5
5849
 
echo "${ECHO_T}$CPP" >&6
5850
 
ac_preproc_ok=false
5851
 
for ac_c_preproc_warn_flag in '' yes
5852
 
do
5853
 
  # Use a header file that comes with gcc, so configuring glibc
5854
 
  # with a fresh cross-compiler works.
5855
 
  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
5856
 
  # <limits.h> exists even on freestanding compilers.
5857
 
  # On the NeXT, cc -E runs the code through the compiler's parser,
5858
 
  # not just through cpp. "Syntax error" is here to catch this case.
5859
 
  cat >conftest.$ac_ext <<_ACEOF
5860
 
/* confdefs.h.  */
5861
 
_ACEOF
5862
 
cat confdefs.h >>conftest.$ac_ext
5863
 
cat >>conftest.$ac_ext <<_ACEOF
5864
 
/* end confdefs.h.  */
5865
 
#ifdef __STDC__
5866
 
# include <limits.h>
5867
 
#else
5868
 
# include <assert.h>
5869
 
#endif
5870
 
                     Syntax error
5871
 
_ACEOF
5872
 
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5873
 
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5874
 
  ac_status=$?
5875
 
  grep -v '^ *+' conftest.er1 >conftest.err
5876
 
  rm -f conftest.er1
5877
 
  cat conftest.err >&5
5878
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5879
 
  (exit $ac_status); } >/dev/null; then
5880
 
  if test -s conftest.err; then
5881
 
    ac_cpp_err=$ac_c_preproc_warn_flag
5882
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5883
 
  else
5884
 
    ac_cpp_err=
5885
 
  fi
5886
 
else
5887
 
  ac_cpp_err=yes
5888
 
fi
5889
 
if test -z "$ac_cpp_err"; then
5890
 
  :
5891
 
else
5892
 
  echo "$as_me: failed program was:" >&5
5893
 
sed 's/^/| /' conftest.$ac_ext >&5
5894
 
 
5895
 
  # Broken: fails on valid input.
5896
 
continue
5897
 
fi
5898
 
rm -f conftest.err conftest.$ac_ext
5899
 
 
5900
 
  # OK, works on sane cases.  Now check whether non-existent headers
5901
 
  # can be detected and how.
5902
 
  cat >conftest.$ac_ext <<_ACEOF
5903
 
/* confdefs.h.  */
5904
 
_ACEOF
5905
 
cat confdefs.h >>conftest.$ac_ext
5906
 
cat >>conftest.$ac_ext <<_ACEOF
5907
 
/* end confdefs.h.  */
5908
 
#include <ac_nonexistent.h>
5909
 
_ACEOF
5910
 
if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5
5911
 
  (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1
5912
 
  ac_status=$?
5913
 
  grep -v '^ *+' conftest.er1 >conftest.err
5914
 
  rm -f conftest.er1
5915
 
  cat conftest.err >&5
5916
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
5917
 
  (exit $ac_status); } >/dev/null; then
5918
 
  if test -s conftest.err; then
5919
 
    ac_cpp_err=$ac_c_preproc_warn_flag
5920
 
    ac_cpp_err=$ac_cpp_err$ac_c_werror_flag
5921
 
  else
5922
 
    ac_cpp_err=
5923
 
  fi
5924
 
else
5925
 
  ac_cpp_err=yes
5926
 
fi
5927
 
if test -z "$ac_cpp_err"; then
5928
 
  # Broken: success on invalid input.
5929
 
continue
5930
 
else
5931
 
  echo "$as_me: failed program was:" >&5
5932
 
sed 's/^/| /' conftest.$ac_ext >&5
5933
 
 
5934
 
  # Passes both tests.
5935
 
ac_preproc_ok=:
5936
 
break
5937
 
fi
5938
 
rm -f conftest.err conftest.$ac_ext
5939
 
 
5940
 
done
5941
 
# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
5942
 
rm -f conftest.err conftest.$ac_ext
5943
 
if $ac_preproc_ok; then
5944
 
  :
5945
 
else
5946
 
  { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check
5947
 
See \`config.log' for more details." >&5
5948
 
echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check
5949
 
See \`config.log' for more details." >&2;}
5950
 
   { (exit 1); exit 1; }; }
5951
 
fi
5952
 
 
5953
 
ac_ext=c
5954
 
ac_cpp='$CPP $CPPFLAGS'
5955
 
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
5956
 
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
5957
 
ac_compiler_gnu=$ac_cv_c_compiler_gnu
5958
 
 
5959
 
 
5960
 
echo "$as_me:$LINENO: checking for egrep" >&5
5961
 
echo $ECHO_N "checking for egrep... $ECHO_C" >&6
5962
 
if test "${ac_cv_prog_egrep+set}" = set; then
5963
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
5964
 
else
5965
 
  if echo a | (grep -E '(a|b)') >/dev/null 2>&1
5966
 
    then ac_cv_prog_egrep='grep -E'
5967
 
    else ac_cv_prog_egrep='egrep'
5968
 
    fi
5969
 
fi
5970
 
echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5
5971
 
echo "${ECHO_T}$ac_cv_prog_egrep" >&6
5972
 
 EGREP=$ac_cv_prog_egrep
5973
 
 
5974
 
 
5975
 
echo "$as_me:$LINENO: checking for ANSI C header files" >&5
5976
 
echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6
5977
 
if test "${ac_cv_header_stdc+set}" = set; then
5978
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
5979
 
else
5980
 
  cat >conftest.$ac_ext <<_ACEOF
5981
 
/* confdefs.h.  */
5982
 
_ACEOF
5983
 
cat confdefs.h >>conftest.$ac_ext
5984
 
cat >>conftest.$ac_ext <<_ACEOF
5985
 
/* end confdefs.h.  */
5986
 
#include <stdlib.h>
5987
 
#include <stdarg.h>
5988
 
#include <string.h>
5989
 
#include <float.h>
5990
 
 
5991
 
int
5992
 
main ()
5993
 
{
5994
 
 
5995
 
  ;
5996
 
  return 0;
5997
 
}
5998
 
_ACEOF
5999
 
rm -f conftest.$ac_objext
6000
 
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6001
 
  (eval $ac_compile) 2>conftest.er1
6002
 
  ac_status=$?
6003
 
  grep -v '^ *+' conftest.er1 >conftest.err
6004
 
  rm -f conftest.er1
6005
 
  cat conftest.err >&5
6006
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6007
 
  (exit $ac_status); } &&
6008
 
         { ac_try='test -z "$ac_c_werror_flag"
6009
 
                         || test ! -s conftest.err'
6010
 
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6011
 
  (eval $ac_try) 2>&5
6012
 
  ac_status=$?
6013
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6014
 
  (exit $ac_status); }; } &&
6015
 
         { ac_try='test -s conftest.$ac_objext'
6016
 
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6017
 
  (eval $ac_try) 2>&5
6018
 
  ac_status=$?
6019
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6020
 
  (exit $ac_status); }; }; then
6021
 
  ac_cv_header_stdc=yes
6022
 
else
6023
 
  echo "$as_me: failed program was:" >&5
6024
 
sed 's/^/| /' conftest.$ac_ext >&5
6025
 
 
6026
 
ac_cv_header_stdc=no
6027
 
fi
6028
 
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6029
 
 
6030
 
if test $ac_cv_header_stdc = yes; then
6031
 
  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
6032
 
  cat >conftest.$ac_ext <<_ACEOF
6033
 
/* confdefs.h.  */
6034
 
_ACEOF
6035
 
cat confdefs.h >>conftest.$ac_ext
6036
 
cat >>conftest.$ac_ext <<_ACEOF
6037
 
/* end confdefs.h.  */
6038
 
#include <string.h>
6039
 
 
6040
 
_ACEOF
6041
 
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6042
 
  $EGREP "memchr" >/dev/null 2>&1; then
6043
 
  :
6044
 
else
6045
 
  ac_cv_header_stdc=no
6046
 
fi
6047
 
rm -f conftest*
6048
 
 
6049
 
fi
6050
 
 
6051
 
if test $ac_cv_header_stdc = yes; then
6052
 
  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
6053
 
  cat >conftest.$ac_ext <<_ACEOF
6054
 
/* confdefs.h.  */
6055
 
_ACEOF
6056
 
cat confdefs.h >>conftest.$ac_ext
6057
 
cat >>conftest.$ac_ext <<_ACEOF
6058
 
/* end confdefs.h.  */
6059
 
#include <stdlib.h>
6060
 
 
6061
 
_ACEOF
6062
 
if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
6063
 
  $EGREP "free" >/dev/null 2>&1; then
6064
 
  :
6065
 
else
6066
 
  ac_cv_header_stdc=no
6067
 
fi
6068
 
rm -f conftest*
6069
 
 
6070
 
fi
6071
 
 
6072
 
if test $ac_cv_header_stdc = yes; then
6073
 
  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
6074
 
  if test "$cross_compiling" = yes; then
6075
 
  :
6076
 
else
6077
 
  cat >conftest.$ac_ext <<_ACEOF
6078
 
/* confdefs.h.  */
6079
 
_ACEOF
6080
 
cat confdefs.h >>conftest.$ac_ext
6081
 
cat >>conftest.$ac_ext <<_ACEOF
6082
 
/* end confdefs.h.  */
6083
 
#include <ctype.h>
6084
 
#if ((' ' & 0x0FF) == 0x020)
6085
 
# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
6086
 
# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
6087
 
#else
6088
 
# define ISLOWER(c) \
6089
 
                   (('a' <= (c) && (c) <= 'i') \
6090
 
                     || ('j' <= (c) && (c) <= 'r') \
6091
 
                     || ('s' <= (c) && (c) <= 'z'))
6092
 
# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
6093
 
#endif
6094
 
 
6095
 
#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
6096
 
int
6097
 
main ()
6098
 
{
6099
 
  int i;
6100
 
  for (i = 0; i < 256; i++)
6101
 
    if (XOR (islower (i), ISLOWER (i))
6102
 
        || toupper (i) != TOUPPER (i))
6103
 
      exit(2);
6104
 
  exit (0);
6105
 
}
6106
 
_ACEOF
6107
 
rm -f conftest$ac_exeext
6108
 
if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
6109
 
  (eval $ac_link) 2>&5
6110
 
  ac_status=$?
6111
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6112
 
  (exit $ac_status); } && { ac_try='./conftest$ac_exeext'
6113
 
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6114
 
  (eval $ac_try) 2>&5
6115
 
  ac_status=$?
6116
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6117
 
  (exit $ac_status); }; }; then
6118
 
  :
6119
 
else
6120
 
  echo "$as_me: program exited with status $ac_status" >&5
6121
 
echo "$as_me: failed program was:" >&5
6122
 
sed 's/^/| /' conftest.$ac_ext >&5
6123
 
 
6124
 
( exit $ac_status )
6125
 
ac_cv_header_stdc=no
6126
 
fi
6127
 
rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext
6128
 
fi
6129
 
fi
6130
 
fi
6131
 
echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5
6132
 
echo "${ECHO_T}$ac_cv_header_stdc" >&6
6133
 
if test $ac_cv_header_stdc = yes; then
6134
 
 
6135
 
cat >>confdefs.h <<\_ACEOF
6136
 
#define STDC_HEADERS 1
6137
 
_ACEOF
6138
 
 
6139
 
fi
6140
 
 
6141
 
# On IRIX 5.3, sys/types and inttypes.h are conflicting.
6142
 
 
6143
 
 
6144
 
 
6145
 
 
6146
 
 
6147
 
 
6148
 
 
6149
 
 
6150
 
 
6151
 
for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
6152
 
                  inttypes.h stdint.h unistd.h
6153
 
do
6154
 
as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`
6155
 
echo "$as_me:$LINENO: checking for $ac_header" >&5
6156
 
echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6
6157
 
if eval "test \"\${$as_ac_Header+set}\" = set"; then
6158
 
  echo $ECHO_N "(cached) $ECHO_C" >&6
6159
 
else
6160
 
  cat >conftest.$ac_ext <<_ACEOF
6161
 
/* confdefs.h.  */
6162
 
_ACEOF
6163
 
cat confdefs.h >>conftest.$ac_ext
6164
 
cat >>conftest.$ac_ext <<_ACEOF
6165
 
/* end confdefs.h.  */
6166
 
$ac_includes_default
6167
 
 
6168
 
#include <$ac_header>
6169
 
_ACEOF
6170
 
rm -f conftest.$ac_objext
6171
 
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
6172
 
  (eval $ac_compile) 2>conftest.er1
6173
 
  ac_status=$?
6174
 
  grep -v '^ *+' conftest.er1 >conftest.err
6175
 
  rm -f conftest.er1
6176
 
  cat conftest.err >&5
6177
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6178
 
  (exit $ac_status); } &&
6179
 
         { ac_try='test -z "$ac_c_werror_flag"
6180
 
                         || test ! -s conftest.err'
6181
 
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6182
 
  (eval $ac_try) 2>&5
6183
 
  ac_status=$?
6184
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6185
 
  (exit $ac_status); }; } &&
6186
 
         { ac_try='test -s conftest.$ac_objext'
6187
 
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
6188
 
  (eval $ac_try) 2>&5
6189
 
  ac_status=$?
6190
 
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
6191
 
  (exit $ac_status); }; }; then
6192
 
  eval "$as_ac_Header=yes"
6193
 
else
6194
 
  echo "$as_me: failed program was:" >&5
6195
 
sed 's/^/| /' conftest.$ac_ext >&5
6196
 
 
6197
 
eval "$as_ac_Header=no"
6198
 
fi
6199
 
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
6200
 
fi
6201
 
echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5
6202
 
echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6
6203
 
if test `eval echo '${'$as_ac_Header'}'` = yes; then
6204
 
  cat >>confdefs.h <<_ACEOF
6205
 
#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1
6206
 
_ACEOF
6207
 
 
6208
 
fi
6209
 
 
6210
 
done
6211
 
 
6212
 
 
6213
11108
 
6214
11109
 
6215
11110
 
6433
11328
 
6434
11329
 
6435
11330
fi
 
11331
echo "$as_me:$LINENO: checking whether stpcpy is declared" >&5
 
11332
echo $ECHO_N "checking whether stpcpy is declared... $ECHO_C" >&6
 
11333
if test "${ac_cv_have_decl_stpcpy+set}" = set; then
 
11334
  echo $ECHO_N "(cached) $ECHO_C" >&6
 
11335
else
 
11336
  cat >conftest.$ac_ext <<_ACEOF
 
11337
/* confdefs.h.  */
 
11338
_ACEOF
 
11339
cat confdefs.h >>conftest.$ac_ext
 
11340
cat >>conftest.$ac_ext <<_ACEOF
 
11341
/* end confdefs.h.  */
 
11342
$ac_includes_default
 
11343
int
 
11344
main ()
 
11345
{
 
11346
#ifndef stpcpy
 
11347
  char *p = (char *) stpcpy;
 
11348
#endif
 
11349
 
 
11350
  ;
 
11351
  return 0;
 
11352
}
 
11353
_ACEOF
 
11354
rm -f conftest.$ac_objext
 
11355
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
 
11356
  (eval $ac_compile) 2>conftest.er1
 
11357
  ac_status=$?
 
11358
  grep -v '^ *+' conftest.er1 >conftest.err
 
11359
  rm -f conftest.er1
 
11360
  cat conftest.err >&5
 
11361
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11362
  (exit $ac_status); } &&
 
11363
         { ac_try='test -z "$ac_c_werror_flag"
 
11364
                         || test ! -s conftest.err'
 
11365
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
11366
  (eval $ac_try) 2>&5
 
11367
  ac_status=$?
 
11368
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11369
  (exit $ac_status); }; } &&
 
11370
         { ac_try='test -s conftest.$ac_objext'
 
11371
  { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
 
11372
  (eval $ac_try) 2>&5
 
11373
  ac_status=$?
 
11374
  echo "$as_me:$LINENO: \$? = $ac_status" >&5
 
11375
  (exit $ac_status); }; }; then
 
11376
  ac_cv_have_decl_stpcpy=yes
 
11377
else
 
11378
  echo "$as_me: failed program was:" >&5
 
11379
sed 's/^/| /' conftest.$ac_ext >&5
 
11380
 
 
11381
ac_cv_have_decl_stpcpy=no
 
11382
fi
 
11383
rm -f conftest.err conftest.$ac_objext conftest.$ac_ext
 
11384
fi
 
11385
echo "$as_me:$LINENO: result: $ac_cv_have_decl_stpcpy" >&5
 
11386
echo "${ECHO_T}$ac_cv_have_decl_stpcpy" >&6
 
11387
if test $ac_cv_have_decl_stpcpy = yes; then
 
11388
 
 
11389
cat >>confdefs.h <<_ACEOF
 
11390
#define HAVE_DECL_STPCPY 1
 
11391
_ACEOF
 
11392
 
 
11393
 
 
11394
else
 
11395
  cat >>confdefs.h <<_ACEOF
 
11396
#define HAVE_DECL_STPCPY 0
 
11397
_ACEOF
 
11398
 
 
11399
 
 
11400
fi
6436
11401
 
6437
11402
 
6438
11403
 
6530
11495
        bfd_arm_arch)           ta="$ta arm-dis.lo" ;;
6531
11496
        bfd_avr_arch)           ta="$ta avr-dis.lo" ;;
6532
11497
        bfd_bfin_arch)          ta="$ta bfin-dis.lo" ;;
 
11498
        bfd_cr16_arch)          ta="$ta cr16-dis.lo cr16-opc.lo" ;;
6533
11499
        bfd_cris_arch)          ta="$ta cris-dis.lo cris-opc.lo cgen-bitset.lo" ;;
6534
11500
        bfd_crx_arch)           ta="$ta crx-dis.lo crx-opc.lo" ;;
6535
11501
        bfd_d10v_arch)          ta="$ta d10v-dis.lo d10v-opc.lo" ;;
6541
11507
        bfd_h8500_arch)         ta="$ta h8500-dis.lo" ;;
6542
11508
        bfd_hppa_arch)          ta="$ta hppa-dis.lo" ;;
6543
11509
        bfd_i370_arch)          ta="$ta i370-dis.lo i370-opc.lo" ;;
6544
 
        bfd_i386_arch)          ta="$ta i386-dis.lo" ;;
 
11510
        bfd_i386_arch)          ta="$ta i386-dis.lo i386-opc.lo" ;;
6545
11511
        bfd_i860_arch)          ta="$ta i860-dis.lo" ;;
6546
11512
        bfd_i960_arch)          ta="$ta i960-dis.lo" ;;
6547
11513
        bfd_ia64_arch)          ta="$ta ia64-dis.lo ia64-opc.lo" ;;
6555
11521
        bfd_m88k_arch)          ta="$ta m88k-dis.lo" ;;
6556
11522
        bfd_maxq_arch)          ta="$ta maxq-dis.lo" ;;
6557
11523
        bfd_mcore_arch)         ta="$ta mcore-dis.lo" ;;
 
11524
        bfd_mep_arch)           ta="$ta mep-asm.lo mep-desc.lo mep-dis.lo mep-ibld.lo mep-opc.lo" using_cgen=yes ;;
6558
11525
        bfd_mips_arch)          ta="$ta mips-dis.lo mips-opc.lo mips16-opc.lo" ;;
6559
11526
        bfd_mmix_arch)          ta="$ta mmix-dis.lo mmix-opc.lo" ;;
6560
11527
        bfd_mn10200_arch)       ta="$ta m10200-dis.lo m10200-opc.lo" ;;
7210
12177
#
7211
12178
 
7212
12179
AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
 
12180
 
 
12181
 
 
12182
# The HP-UX ksh and POSIX shell print the target directory to stdout
 
12183
# if CDPATH is set.
 
12184
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
 
12185
 
 
12186
sed_quote_subst='$sed_quote_subst'
 
12187
double_quote_subst='$double_quote_subst'
 
12188
delay_variable_subst='$delay_variable_subst'
 
12189
enable_shared='`$ECHO "X$enable_shared" | $Xsed -e "$delay_single_quote_subst"`'
 
12190
macro_version='`$ECHO "X$macro_version" | $Xsed -e "$delay_single_quote_subst"`'
 
12191
macro_revision='`$ECHO "X$macro_revision" | $Xsed -e "$delay_single_quote_subst"`'
 
12192
enable_static='`$ECHO "X$enable_static" | $Xsed -e "$delay_single_quote_subst"`'
 
12193
pic_mode='`$ECHO "X$pic_mode" | $Xsed -e "$delay_single_quote_subst"`'
 
12194
enable_fast_install='`$ECHO "X$enable_fast_install" | $Xsed -e "$delay_single_quote_subst"`'
 
12195
host_alias='`$ECHO "X$host_alias" | $Xsed -e "$delay_single_quote_subst"`'
 
12196
host='`$ECHO "X$host" | $Xsed -e "$delay_single_quote_subst"`'
 
12197
host_os='`$ECHO "X$host_os" | $Xsed -e "$delay_single_quote_subst"`'
 
12198
build_alias='`$ECHO "X$build_alias" | $Xsed -e "$delay_single_quote_subst"`'
 
12199
build='`$ECHO "X$build" | $Xsed -e "$delay_single_quote_subst"`'
 
12200
build_os='`$ECHO "X$build_os" | $Xsed -e "$delay_single_quote_subst"`'
 
12201
SED='`$ECHO "X$SED" | $Xsed -e "$delay_single_quote_subst"`'
 
12202
Xsed='`$ECHO "X$Xsed" | $Xsed -e "$delay_single_quote_subst"`'
 
12203
GREP='`$ECHO "X$GREP" | $Xsed -e "$delay_single_quote_subst"`'
 
12204
EGREP='`$ECHO "X$EGREP" | $Xsed -e "$delay_single_quote_subst"`'
 
12205
FGREP='`$ECHO "X$FGREP" | $Xsed -e "$delay_single_quote_subst"`'
 
12206
LD='`$ECHO "X$LD" | $Xsed -e "$delay_single_quote_subst"`'
 
12207
NM='`$ECHO "X$NM" | $Xsed -e "$delay_single_quote_subst"`'
 
12208
LN_S='`$ECHO "X$LN_S" | $Xsed -e "$delay_single_quote_subst"`'
 
12209
max_cmd_len='`$ECHO "X$max_cmd_len" | $Xsed -e "$delay_single_quote_subst"`'
 
12210
ac_objext='`$ECHO "X$ac_objext" | $Xsed -e "$delay_single_quote_subst"`'
 
12211
exeext='`$ECHO "X$exeext" | $Xsed -e "$delay_single_quote_subst"`'
 
12212
lt_unset='`$ECHO "X$lt_unset" | $Xsed -e "$delay_single_quote_subst"`'
 
12213
lt_SP2NL='`$ECHO "X$lt_SP2NL" | $Xsed -e "$delay_single_quote_subst"`'
 
12214
lt_NL2SP='`$ECHO "X$lt_NL2SP" | $Xsed -e "$delay_single_quote_subst"`'
 
12215
reload_flag='`$ECHO "X$reload_flag" | $Xsed -e "$delay_single_quote_subst"`'
 
12216
reload_cmds='`$ECHO "X$reload_cmds" | $Xsed -e "$delay_single_quote_subst"`'
 
12217
deplibs_check_method='`$ECHO "X$deplibs_check_method" | $Xsed -e "$delay_single_quote_subst"`'
 
12218
file_magic_cmd='`$ECHO "X$file_magic_cmd" | $Xsed -e "$delay_single_quote_subst"`'
 
12219
AR='`$ECHO "X$AR" | $Xsed -e "$delay_single_quote_subst"`'
 
12220
AR_FLAGS='`$ECHO "X$AR_FLAGS" | $Xsed -e "$delay_single_quote_subst"`'
 
12221
STRIP='`$ECHO "X$STRIP" | $Xsed -e "$delay_single_quote_subst"`'
 
12222
RANLIB='`$ECHO "X$RANLIB" | $Xsed -e "$delay_single_quote_subst"`'
 
12223
old_postinstall_cmds='`$ECHO "X$old_postinstall_cmds" | $Xsed -e "$delay_single_quote_subst"`'
 
12224
old_postuninstall_cmds='`$ECHO "X$old_postuninstall_cmds" | $Xsed -e "$delay_single_quote_subst"`'
 
12225
old_archive_cmds='`$ECHO "X$old_archive_cmds" | $Xsed -e "$delay_single_quote_subst"`'
 
12226
CC='`$ECHO "X$CC" | $Xsed -e "$delay_single_quote_subst"`'
 
12227
CFLAGS='`$ECHO "X$CFLAGS" | $Xsed -e "$delay_single_quote_subst"`'
 
12228
compiler='`$ECHO "X$compiler" | $Xsed -e "$delay_single_quote_subst"`'
 
12229
GCC='`$ECHO "X$GCC" | $Xsed -e "$delay_single_quote_subst"`'
 
12230
lt_cv_sys_global_symbol_pipe='`$ECHO "X$lt_cv_sys_global_symbol_pipe" | $Xsed -e "$delay_single_quote_subst"`'
 
12231
lt_cv_sys_global_symbol_to_cdecl='`$ECHO "X$lt_cv_sys_global_symbol_to_cdecl" | $Xsed -e "$delay_single_quote_subst"`'
 
12232
lt_cv_sys_global_symbol_to_c_name_address='`$ECHO "X$lt_cv_sys_global_symbol_to_c_name_address" | $Xsed -e "$delay_single_quote_subst"`'
 
12233
objdir='`$ECHO "X$objdir" | $Xsed -e "$delay_single_quote_subst"`'
 
12234
SHELL='`$ECHO "X$SHELL" | $Xsed -e "$delay_single_quote_subst"`'
 
12235
ECHO='`$ECHO "X$ECHO" | $Xsed -e "$delay_single_quote_subst"`'
 
12236
MAGIC_CMD='`$ECHO "X$MAGIC_CMD" | $Xsed -e "$delay_single_quote_subst"`'
 
12237
lt_prog_compiler_no_builtin_flag='`$ECHO "X$lt_prog_compiler_no_builtin_flag" | $Xsed -e "$delay_single_quote_subst"`'
 
12238
lt_prog_compiler_wl='`$ECHO "X$lt_prog_compiler_wl" | $Xsed -e "$delay_single_quote_subst"`'
 
12239
lt_prog_compiler_pic='`$ECHO "X$lt_prog_compiler_pic" | $Xsed -e "$delay_single_quote_subst"`'
 
12240
lt_prog_compiler_static='`$ECHO "X$lt_prog_compiler_static" | $Xsed -e "$delay_single_quote_subst"`'
 
12241
lt_cv_prog_compiler_c_o='`$ECHO "X$lt_cv_prog_compiler_c_o" | $Xsed -e "$delay_single_quote_subst"`'
 
12242
need_locks='`$ECHO "X$need_locks" | $Xsed -e "$delay_single_quote_subst"`'
 
12243
libext='`$ECHO "X$libext" | $Xsed -e "$delay_single_quote_subst"`'
 
12244
shrext_cmds='`$ECHO "X$shrext_cmds" | $Xsed -e "$delay_single_quote_subst"`'
 
12245
extract_expsyms_cmds='`$ECHO "X$extract_expsyms_cmds" | $Xsed -e "$delay_single_quote_subst"`'
 
12246
archive_cmds_need_lc='`$ECHO "X$archive_cmds_need_lc" | $Xsed -e "$delay_single_quote_subst"`'
 
12247
enable_shared_with_static_runtimes='`$ECHO "X$enable_shared_with_static_runtimes" | $Xsed -e "$delay_single_quote_subst"`'
 
12248
export_dynamic_flag_spec='`$ECHO "X$export_dynamic_flag_spec" | $Xsed -e "$delay_single_quote_subst"`'
 
12249
whole_archive_flag_spec='`$ECHO "X$whole_archive_flag_spec" | $Xsed -e "$delay_single_quote_subst"`'
 
12250
compiler_needs_object='`$ECHO "X$compiler_needs_object" | $Xsed -e "$delay_single_quote_subst"`'
 
12251
old_archive_from_new_cmds='`$ECHO "X$old_archive_from_new_cmds" | $Xsed -e "$delay_single_quote_subst"`'
 
12252
old_archive_from_expsyms_cmds='`$ECHO "X$old_archive_from_expsyms_cmds" | $Xsed -e "$delay_single_quote_subst"`'
 
12253
archive_cmds='`$ECHO "X$archive_cmds" | $Xsed -e "$delay_single_quote_subst"`'
 
12254
archive_expsym_cmds='`$ECHO "X$archive_expsym_cmds" | $Xsed -e "$delay_single_quote_subst"`'
 
12255
module_cmds='`$ECHO "X$module_cmds" | $Xsed -e "$delay_single_quote_subst"`'
 
12256
module_expsym_cmds='`$ECHO "X$module_expsym_cmds" | $Xsed -e "$delay_single_quote_subst"`'
 
12257
with_gnu_ld='`$ECHO "X$with_gnu_ld" | $Xsed -e "$delay_single_quote_subst"`'
 
12258
allow_undefined_flag='`$ECHO "X$allow_undefined_flag" | $Xsed -e "$delay_single_quote_subst"`'
 
12259
no_undefined_flag='`$ECHO "X$no_undefined_flag" | $Xsed -e "$delay_single_quote_subst"`'
 
12260
hardcode_libdir_flag_spec='`$ECHO "X$hardcode_libdir_flag_spec" | $Xsed -e "$delay_single_quote_subst"`'
 
12261
hardcode_libdir_flag_spec_ld='`$ECHO "X$hardcode_libdir_flag_spec_ld" | $Xsed -e "$delay_single_quote_subst"`'
 
12262
hardcode_libdir_separator='`$ECHO "X$hardcode_libdir_separator" | $Xsed -e "$delay_single_quote_subst"`'
 
12263
hardcode_direct='`$ECHO "X$hardcode_direct" | $Xsed -e "$delay_single_quote_subst"`'
 
12264
hardcode_direct_absolute='`$ECHO "X$hardcode_direct_absolute" | $Xsed -e "$delay_single_quote_subst"`'
 
12265
hardcode_minus_L='`$ECHO "X$hardcode_minus_L" | $Xsed -e "$delay_single_quote_subst"`'
 
12266
hardcode_shlibpath_var='`$ECHO "X$hardcode_shlibpath_var" | $Xsed -e "$delay_single_quote_subst"`'
 
12267
hardcode_automatic='`$ECHO "X$hardcode_automatic" | $Xsed -e "$delay_single_quote_subst"`'
 
12268
inherit_rpath='`$ECHO "X$inherit_rpath" | $Xsed -e "$delay_single_quote_subst"`'
 
12269
link_all_deplibs='`$ECHO "X$link_all_deplibs" | $Xsed -e "$delay_single_quote_subst"`'
 
12270
fix_srcfile_path='`$ECHO "X$fix_srcfile_path" | $Xsed -e "$delay_single_quote_subst"`'
 
12271
always_export_symbols='`$ECHO "X$always_export_symbols" | $Xsed -e "$delay_single_quote_subst"`'
 
12272
export_symbols_cmds='`$ECHO "X$export_symbols_cmds" | $Xsed -e "$delay_single_quote_subst"`'
 
12273
exclude_expsyms='`$ECHO "X$exclude_expsyms" | $Xsed -e "$delay_single_quote_subst"`'
 
12274
include_expsyms='`$ECHO "X$include_expsyms" | $Xsed -e "$delay_single_quote_subst"`'
 
12275
prelink_cmds='`$ECHO "X$prelink_cmds" | $Xsed -e "$delay_single_quote_subst"`'
 
12276
file_list_spec='`$ECHO "X$file_list_spec" | $Xsed -e "$delay_single_quote_subst"`'
 
12277
variables_saved_for_relink='`$ECHO "X$variables_saved_for_relink" | $Xsed -e "$delay_single_quote_subst"`'
 
12278
need_lib_prefix='`$ECHO "X$need_lib_prefix" | $Xsed -e "$delay_single_quote_subst"`'
 
12279
need_version='`$ECHO "X$need_version" | $Xsed -e "$delay_single_quote_subst"`'
 
12280
version_type='`$ECHO "X$version_type" | $Xsed -e "$delay_single_quote_subst"`'
 
12281
runpath_var='`$ECHO "X$runpath_var" | $Xsed -e "$delay_single_quote_subst"`'
 
12282
shlibpath_var='`$ECHO "X$shlibpath_var" | $Xsed -e "$delay_single_quote_subst"`'
 
12283
shlibpath_overrides_runpath='`$ECHO "X$shlibpath_overrides_runpath" | $Xsed -e "$delay_single_quote_subst"`'
 
12284
libname_spec='`$ECHO "X$libname_spec" | $Xsed -e "$delay_single_quote_subst"`'
 
12285
library_names_spec='`$ECHO "X$library_names_spec" | $Xsed -e "$delay_single_quote_subst"`'
 
12286
soname_spec='`$ECHO "X$soname_spec" | $Xsed -e "$delay_single_quote_subst"`'
 
12287
postinstall_cmds='`$ECHO "X$postinstall_cmds" | $Xsed -e "$delay_single_quote_subst"`'
 
12288
postuninstall_cmds='`$ECHO "X$postuninstall_cmds" | $Xsed -e "$delay_single_quote_subst"`'
 
12289
finish_cmds='`$ECHO "X$finish_cmds" | $Xsed -e "$delay_single_quote_subst"`'
 
12290
finish_eval='`$ECHO "X$finish_eval" | $Xsed -e "$delay_single_quote_subst"`'
 
12291
hardcode_into_libs='`$ECHO "X$hardcode_into_libs" | $Xsed -e "$delay_single_quote_subst"`'
 
12292
sys_lib_search_path_spec='`$ECHO "X$sys_lib_search_path_spec" | $Xsed -e "$delay_single_quote_subst"`'
 
12293
sys_lib_dlsearch_path_spec='`$ECHO "X$sys_lib_dlsearch_path_spec" | $Xsed -e "$delay_single_quote_subst"`'
 
12294
hardcode_action='`$ECHO "X$hardcode_action" | $Xsed -e "$delay_single_quote_subst"`'
 
12295
enable_dlopen='`$ECHO "X$enable_dlopen" | $Xsed -e "$delay_single_quote_subst"`'
 
12296
enable_dlopen_self='`$ECHO "X$enable_dlopen_self" | $Xsed -e "$delay_single_quote_subst"`'
 
12297
enable_dlopen_self_static='`$ECHO "X$enable_dlopen_self_static" | $Xsed -e "$delay_single_quote_subst"`'
 
12298
old_striplib='`$ECHO "X$old_striplib" | $Xsed -e "$delay_single_quote_subst"`'
 
12299
striplib='`$ECHO "X$striplib" | $Xsed -e "$delay_single_quote_subst"`'
 
12300
 
 
12301
LTCC='$LTCC'
 
12302
LTCFLAGS='$LTCFLAGS'
 
12303
compiler='$compiler_DEFAULT'
 
12304
 
 
12305
# Quote evaled strings.
 
12306
for var in SED \
 
12307
GREP \
 
12308
EGREP \
 
12309
FGREP \
 
12310
LD \
 
12311
NM \
 
12312
LN_S \
 
12313
lt_SP2NL \
 
12314
lt_NL2SP \
 
12315
reload_flag \
 
12316
deplibs_check_method \
 
12317
file_magic_cmd \
 
12318
AR \
 
12319
AR_FLAGS \
 
12320
STRIP \
 
12321
RANLIB \
 
12322
CC \
 
12323
CFLAGS \
 
12324
compiler \
 
12325
lt_cv_sys_global_symbol_pipe \
 
12326
lt_cv_sys_global_symbol_to_cdecl \
 
12327
lt_cv_sys_global_symbol_to_c_name_address \
 
12328
SHELL \
 
12329
ECHO \
 
12330
lt_prog_compiler_no_builtin_flag \
 
12331
lt_prog_compiler_wl \
 
12332
lt_prog_compiler_pic \
 
12333
lt_prog_compiler_static \
 
12334
lt_cv_prog_compiler_c_o \
 
12335
need_locks \
 
12336
shrext_cmds \
 
12337
export_dynamic_flag_spec \
 
12338
whole_archive_flag_spec \
 
12339
compiler_needs_object \
 
12340
with_gnu_ld \
 
12341
allow_undefined_flag \
 
12342
no_undefined_flag \
 
12343
hardcode_libdir_flag_spec \
 
12344
hardcode_libdir_flag_spec_ld \
 
12345
hardcode_libdir_separator \
 
12346
fix_srcfile_path \
 
12347
exclude_expsyms \
 
12348
include_expsyms \
 
12349
file_list_spec \
 
12350
variables_saved_for_relink \
 
12351
libname_spec \
 
12352
library_names_spec \
 
12353
soname_spec \
 
12354
finish_eval \
 
12355
old_striplib \
 
12356
striplib; do
 
12357
    case \`eval \\\\\$ECHO "X\\\\\$\$var"\` in
 
12358
    *[\\\\\\\`\\"\\\$]*)
 
12359
      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"X\\\$\$var\\" | \\\$Xsed -e \\"\\\$sed_quote_subst\\"\\\`\\\\\\""
 
12360
      ;;
 
12361
    *)
 
12362
      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
 
12363
      ;;
 
12364
    esac
 
12365
done
 
12366
 
 
12367
# Double-quote double-evaled strings.
 
12368
for var in reload_cmds \
 
12369
old_postinstall_cmds \
 
12370
old_postuninstall_cmds \
 
12371
old_archive_cmds \
 
12372
extract_expsyms_cmds \
 
12373
old_archive_from_new_cmds \
 
12374
old_archive_from_expsyms_cmds \
 
12375
archive_cmds \
 
12376
archive_expsym_cmds \
 
12377
module_cmds \
 
12378
module_expsym_cmds \
 
12379
export_symbols_cmds \
 
12380
prelink_cmds \
 
12381
postinstall_cmds \
 
12382
postuninstall_cmds \
 
12383
finish_cmds \
 
12384
sys_lib_search_path_spec \
 
12385
sys_lib_dlsearch_path_spec; do
 
12386
    case \`eval \\\\\$ECHO "X\\\\\$\$var"\` in
 
12387
    *[\\\\\\\`\\"\\\$]*)
 
12388
      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"X\\\$\$var\\" | \\\$Xsed -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\""
 
12389
      ;;
 
12390
    *)
 
12391
      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
 
12392
      ;;
 
12393
    esac
 
12394
done
 
12395
 
 
12396
# Fix-up fallback echo if it was mangled by the above quoting rules.
 
12397
case \$lt_ECHO in
 
12398
*'\\\$0 --fallback-echo"')  lt_ECHO=\`\$ECHO "X\$lt_ECHO" | \$Xsed -e 's/\\\\\\\\\\\\\\\$0 --fallback-echo"\$/\$0 --fallback-echo"/'\`
 
12399
  ;;
 
12400
esac
 
12401
 
 
12402
ac_aux_dir='$ac_aux_dir'
 
12403
xsi_shell='$xsi_shell'
 
12404
lt_shell_append='$lt_shell_append'
 
12405
 
 
12406
# See if we are running on zsh, and set the options which allow our
 
12407
# commands through without removal of \ escapes INIT.
 
12408
if test -n "\${ZSH_VERSION+set}" ; then
 
12409
   setopt NO_GLOB_SUBST
 
12410
fi
 
12411
 
 
12412
 
 
12413
    PACKAGE='$PACKAGE'
 
12414
    VERSION='$VERSION'
 
12415
    TIMESTAMP='$TIMESTAMP'
 
12416
    RM='$RM'
 
12417
    ofile='$ofile'
 
12418
 
 
12419
 
 
12420
 
7213
12421
# Capture the value of obsolete ALL_LINGUAS because we need it to compute
7214
12422
    # POFILES, GMOFILES, UPDATEPOFILES, DUMMYPOFILES, CATALOGS. But hide it
7215
12423
    # from automake.
7230
12438
  "Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;
7231
12439
  "po/Makefile.in" ) CONFIG_FILES="$CONFIG_FILES po/Makefile.in:po/Make-in" ;;
7232
12440
  "depfiles" ) CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
 
12441
  "libtool" ) CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;;
7233
12442
  "default-1" ) CONFIG_COMMANDS="$CONFIG_COMMANDS default-1" ;;
7234
12443
  "config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h:config.in" ;;
7235
12444
  *) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5
7371
12580
s,@ac_ct_AR@,$ac_ct_AR,;t t
7372
12581
s,@RANLIB@,$RANLIB,;t t
7373
12582
s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t
 
12583
s,@LIBTOOL@,$LIBTOOL,;t t
 
12584
s,@SED@,$SED,;t t
 
12585
s,@EGREP@,$EGREP,;t t
 
12586
s,@FGREP@,$FGREP,;t t
 
12587
s,@GREP@,$GREP,;t t
 
12588
s,@LD@,$LD,;t t
 
12589
s,@DUMPBIN@,$DUMPBIN,;t t
 
12590
s,@ac_ct_DUMPBIN@,$ac_ct_DUMPBIN,;t t
 
12591
s,@NM@,$NM,;t t
7374
12592
s,@LN_S@,$LN_S,;t t
7375
 
s,@LIBTOOL@,$LIBTOOL,;t t
 
12593
s,@lt_ECHO@,$lt_ECHO,;t t
 
12594
s,@CPP@,$CPP,;t t
7376
12595
s,@WARN_CFLAGS@,$WARN_CFLAGS,;t t
7377
12596
s,@NO_WERROR@,$NO_WERROR,;t t
7378
12597
s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
7402
12621
s,@CC_FOR_BUILD@,$CC_FOR_BUILD,;t t
7403
12622
s,@EXEEXT_FOR_BUILD@,$EXEEXT_FOR_BUILD,;t t
7404
12623
s,@HDEFINES@,$HDEFINES,;t t
7405
 
s,@CPP@,$CPP,;t t
7406
 
s,@EGREP@,$EGREP,;t t
7407
12624
s,@CGEN_MAINT_TRUE@,$CGEN_MAINT_TRUE,;t t
7408
12625
s,@CGEN_MAINT_FALSE@,$CGEN_MAINT_FALSE,;t t
7409
12626
s,@cgendir@,$cgendir,;t t
8095
13312
  done
8096
13313
done
8097
13314
 ;;
 
13315
    libtool )
 
13316
 
 
13317
    # See if we are running on zsh, and set the options which allow our
 
13318
    # commands through without removal of \ escapes.
 
13319
    if test -n "${ZSH_VERSION+set}" ; then
 
13320
      setopt NO_GLOB_SUBST
 
13321
    fi
 
13322
 
 
13323
    cfgfile="${ofile}T"
 
13324
    trap "$RM \"$cfgfile\"; exit 1" 1 2 15
 
13325
    $RM "$cfgfile"
 
13326
 
 
13327
    cat <<_LT_EOF >> "$cfgfile"
 
13328
#! $SHELL
 
13329
 
 
13330
# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
 
13331
# Generated automatically by $as_me (GNU $PACKAGE$TIMESTAMP) $VERSION
 
13332
# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
 
13333
# NOTE: Changes made to this file will be lost: look at ltmain.sh.
 
13334
#
 
13335
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
 
13336
# 2006, 2007 Free Software Foundation, Inc.
 
13337
#
 
13338
# This file is part of GNU Libtool:
 
13339
# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
 
13340
#
 
13341
# This program is free software; you can redistribute it and/or modify
 
13342
# it under the terms of the GNU General Public License as published by
 
13343
# the Free Software Foundation; either version 2 of the License, or
 
13344
# (at your option) any later version.
 
13345
#
 
13346
# This program is distributed in the hope that it will be useful, but
 
13347
# WITHOUT ANY WARRANTY; without even the implied warranty of
 
13348
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
13349
# General Public License for more details.
 
13350
#
 
13351
# You should have received a copy of the GNU General Public License
 
13352
# along with this program; if not, a copy can be downloaded from
 
13353
# http://www.gnu.org/copyleft/gpl.html, or by writing to the Free
 
13354
# Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 
13355
# MA 02110-1301, USA.
 
13356
#
 
13357
# As a special exception to the GNU General Public License, if you
 
13358
# distribute this file as part of a program that contains a
 
13359
# configuration script generated by Autoconf, you may include it under
 
13360
# the same distribution terms that you use for the rest of that program.
 
13361
 
 
13362
 
 
13363
# The names of the tagged configurations supported by this script.
 
13364
available_tags=""
 
13365
 
 
13366
# ### BEGIN LIBTOOL CONFIG
 
13367
 
 
13368
# Whether or not to build shared libraries.
 
13369
build_libtool_libs=$enable_shared
 
13370
 
 
13371
# Which release of libtool.m4 was used?
 
13372
macro_version=$macro_version
 
13373
macro_revision=$macro_revision
 
13374
 
 
13375
# Whether or not to build static libraries.
 
13376
build_old_libs=$enable_static
 
13377
 
 
13378
# What type of objects to build.
 
13379
pic_mode=$pic_mode
 
13380
 
 
13381
# Whether or not to optimize for fast installation.
 
13382
fast_install=$enable_fast_install
 
13383
 
 
13384
# The host system.
 
13385
host_alias=$host_alias
 
13386
host=$host
 
13387
host_os=$host_os
 
13388
 
 
13389
# The build system.
 
13390
build_alias=$build_alias
 
13391
build=$build
 
13392
build_os=$build_os
 
13393
 
 
13394
# A sed program that does not truncate output.
 
13395
SED=$lt_SED
 
13396
 
 
13397
# Sed that helps us avoid accidentally triggering echo(1) options like -n.
 
13398
Xsed="\$SED -e 1s/^X//"
 
13399
 
 
13400
# A grep program that handles long lines.
 
13401
GREP=$lt_GREP
 
13402
 
 
13403
# An ERE matcher.
 
13404
EGREP=$lt_EGREP
 
13405
 
 
13406
# A literal string matcher.
 
13407
FGREP=$lt_FGREP
 
13408
 
 
13409
# A BSD- or MS-compatible name lister.
 
13410
NM=$lt_NM
 
13411
 
 
13412
# Whether we need soft or hard links.
 
13413
LN_S=$lt_LN_S
 
13414
 
 
13415
# What is the maximum length of a command?
 
13416
max_cmd_len=$max_cmd_len
 
13417
 
 
13418
# Object file suffix (normally "o").
 
13419
objext=$ac_objext
 
13420
 
 
13421
# Executable file suffix (normally "").
 
13422
exeext=$exeext
 
13423
 
 
13424
# whether the shell understands "unset".
 
13425
lt_unset=$lt_unset
 
13426
 
 
13427
# turn spaces into newlines.
 
13428
SP2NL=$lt_lt_SP2NL
 
13429
 
 
13430
# turn newlines into spaces.
 
13431
NL2SP=$lt_lt_NL2SP
 
13432
 
 
13433
# How to create reloadable object files.
 
13434
reload_flag=$lt_reload_flag
 
13435
reload_cmds=$lt_reload_cmds
 
13436
 
 
13437
# Method to check whether dependent libraries are shared objects.
 
13438
deplibs_check_method=$lt_deplibs_check_method
 
13439
 
 
13440
# Command to use when deplibs_check_method == "file_magic".
 
13441
file_magic_cmd=$lt_file_magic_cmd
 
13442
 
 
13443
# The archiver.
 
13444
AR=$lt_AR
 
13445
AR_FLAGS=$lt_AR_FLAGS
 
13446
 
 
13447
# A symbol stripping program.
 
13448
STRIP=$lt_STRIP
 
13449
 
 
13450
# Commands used to install an old-style archive.
 
13451
RANLIB=$lt_RANLIB
 
13452
old_postinstall_cmds=$lt_old_postinstall_cmds
 
13453
old_postuninstall_cmds=$lt_old_postuninstall_cmds
 
13454
 
 
13455
# A C compiler.
 
13456
LTCC=$lt_CC
 
13457
 
 
13458
# LTCC compiler flags.
 
13459
LTCFLAGS=$lt_CFLAGS
 
13460
 
 
13461
# Take the output of nm and produce a listing of raw symbols and C names.
 
13462
global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe
 
13463
 
 
13464
# Transform the output of nm in a proper C declaration.
 
13465
global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl
 
13466
 
 
13467
# Transform the output of nm in a C name address pair.
 
13468
global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address
 
13469
 
 
13470
# The name of the directory that contains temporary libtool files.
 
13471
objdir=$objdir
 
13472
 
 
13473
# Shell to use when invoking shell scripts.
 
13474
SHELL=$lt_SHELL
 
13475
 
 
13476
# An echo program that does not interpret backslashes.
 
13477
ECHO=$lt_ECHO
 
13478
 
 
13479
# Used to examine libraries when file_magic_cmd begins with "file".
 
13480
MAGIC_CMD=$MAGIC_CMD
 
13481
 
 
13482
# Must we lock files when doing compilation?
 
13483
need_locks=$lt_need_locks
 
13484
 
 
13485
# Old archive suffix (normally "a").
 
13486
libext=$libext
 
13487
 
 
13488
# Shared library suffix (normally ".so").
 
13489
shrext_cmds=$lt_shrext_cmds
 
13490
 
 
13491
# The commands to extract the exported symbol list from a shared archive.
 
13492
extract_expsyms_cmds=$lt_extract_expsyms_cmds
 
13493
 
 
13494
# Variables whose values should be saved in libtool wrapper scripts and
 
13495
# restored at link time.
 
13496
variables_saved_for_relink=$lt_variables_saved_for_relink
 
13497
 
 
13498
# Do we need the "lib" prefix for modules?
 
13499
need_lib_prefix=$need_lib_prefix
 
13500
 
 
13501
# Do we need a version for libraries?
 
13502
need_version=$need_version
 
13503
 
 
13504
# Library versioning type.
 
13505
version_type=$version_type
 
13506
 
 
13507
# Shared library runtime path variable.
 
13508
runpath_var=$runpath_var
 
13509
 
 
13510
# Shared library path variable.
 
13511
shlibpath_var=$shlibpath_var
 
13512
 
 
13513
# Is shlibpath searched before the hard-coded library search path?
 
13514
shlibpath_overrides_runpath=$shlibpath_overrides_runpath
 
13515
 
 
13516
# Format of library name prefix.
 
13517
libname_spec=$lt_libname_spec
 
13518
 
 
13519
# List of archive names.  First name is the real one, the rest are links.
 
13520
# The last name is the one that the linker finds with -lNAME
 
13521
library_names_spec=$lt_library_names_spec
 
13522
 
 
13523
# The coded name of the library, if different from the real name.
 
13524
soname_spec=$lt_soname_spec
 
13525
 
 
13526
# Command to use after installation of a shared archive.
 
13527
postinstall_cmds=$lt_postinstall_cmds
 
13528
 
 
13529
# Command to use after uninstallation of a shared archive.
 
13530
postuninstall_cmds=$lt_postuninstall_cmds
 
13531
 
 
13532
# Commands used to finish a libtool library installation in a directory.
 
13533
finish_cmds=$lt_finish_cmds
 
13534
 
 
13535
# As "finish_cmds", except a single script fragment to be evaled but
 
13536
# not shown.
 
13537
finish_eval=$lt_finish_eval
 
13538
 
 
13539
# Whether we should hardcode library paths into libraries.
 
13540
hardcode_into_libs=$hardcode_into_libs
 
13541
 
 
13542
# Compile-time system search path for libraries.
 
13543
sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
 
13544
 
 
13545
# Run-time system search path for libraries.
 
13546
sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
 
13547
 
 
13548
# Whether dlopen is supported.
 
13549
dlopen_support=$enable_dlopen
 
13550
 
 
13551
# Whether dlopen of programs is supported.
 
13552
dlopen_self=$enable_dlopen_self
 
13553
 
 
13554
# Whether dlopen of statically linked programs is supported.
 
13555
dlopen_self_static=$enable_dlopen_self_static
 
13556
 
 
13557
# Commands to strip libraries.
 
13558
old_striplib=$lt_old_striplib
 
13559
striplib=$lt_striplib
 
13560
 
 
13561
 
 
13562
# The linker used to build libraries.
 
13563
LD=$lt_LD
 
13564
 
 
13565
# Commands used to build an old-style archive.
 
13566
old_archive_cmds=$lt_old_archive_cmds
 
13567
 
 
13568
# A language specific compiler.
 
13569
CC=$lt_compiler
 
13570
 
 
13571
# Is the compiler the GNU compiler?
 
13572
with_gcc=$GCC
 
13573
 
 
13574
# Compiler flag to turn off builtin functions.
 
13575
no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag
 
13576
 
 
13577
# How to pass a linker flag through the compiler.
 
13578
wl=$lt_lt_prog_compiler_wl
 
13579
 
 
13580
# Additional compiler flags for building library objects.
 
13581
pic_flag=$lt_lt_prog_compiler_pic
 
13582
 
 
13583
# Compiler flag to prevent dynamic linking.
 
13584
link_static_flag=$lt_lt_prog_compiler_static
 
13585
 
 
13586
# Does compiler simultaneously support -c and -o options?
 
13587
compiler_c_o=$lt_lt_cv_prog_compiler_c_o
 
13588
 
 
13589
# Whether or not to add -lc for building shared libraries.
 
13590
build_libtool_need_lc=$archive_cmds_need_lc
 
13591
 
 
13592
# Whether or not to disallow shared libs when runtime libs are static.
 
13593
allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes
 
13594
 
 
13595
# Compiler flag to allow reflexive dlopens.
 
13596
export_dynamic_flag_spec=$lt_export_dynamic_flag_spec
 
13597
 
 
13598
# Compiler flag to generate shared objects directly from archives.
 
13599
whole_archive_flag_spec=$lt_whole_archive_flag_spec
 
13600
 
 
13601
# Whether the compiler copes with passing no objects directly.
 
13602
compiler_needs_object=$lt_compiler_needs_object
 
13603
 
 
13604
# Create an old-style archive from a shared archive.
 
13605
old_archive_from_new_cmds=$lt_old_archive_from_new_cmds
 
13606
 
 
13607
# Create a temporary old-style archive to link instead of a shared archive.
 
13608
old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds
 
13609
 
 
13610
# Commands used to build a shared archive.
 
13611
archive_cmds=$lt_archive_cmds
 
13612
archive_expsym_cmds=$lt_archive_expsym_cmds
 
13613
 
 
13614
# Commands used to build a loadable module if different from building
 
13615
# a shared archive.
 
13616
module_cmds=$lt_module_cmds
 
13617
module_expsym_cmds=$lt_module_expsym_cmds
 
13618
 
 
13619
# Whether we are building with GNU ld or not.
 
13620
with_gnu_ld=$lt_with_gnu_ld
 
13621
 
 
13622
# Flag that allows shared libraries with undefined symbols to be built.
 
13623
allow_undefined_flag=$lt_allow_undefined_flag
 
13624
 
 
13625
# Flag that enforces no undefined symbols.
 
13626
no_undefined_flag=$lt_no_undefined_flag
 
13627
 
 
13628
# Flag to hardcode \$libdir into a binary during linking.
 
13629
# This must work even if \$libdir does not exist
 
13630
hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec
 
13631
 
 
13632
# If ld is used when linking, flag to hardcode \$libdir into a binary
 
13633
# during linking.  This must work even if \$libdir does not exist.
 
13634
hardcode_libdir_flag_spec_ld=$lt_hardcode_libdir_flag_spec_ld
 
13635
 
 
13636
# Whether we need a single "-rpath" flag with a separated argument.
 
13637
hardcode_libdir_separator=$lt_hardcode_libdir_separator
 
13638
 
 
13639
# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
 
13640
# DIR into the resulting binary.
 
13641
hardcode_direct=$hardcode_direct
 
13642
 
 
13643
# Set to "yes" if using DIR/libNAME\${shared_ext} during linking hardcodes
 
13644
# DIR into the resulting binary and the resulting library dependency is
 
13645
# "absolute",i.e impossible to change by setting \${shlibpath_var} if the
 
13646
# library is relocated.
 
13647
hardcode_direct_absolute=$hardcode_direct_absolute
 
13648
 
 
13649
# Set to "yes" if using the -LDIR flag during linking hardcodes DIR
 
13650
# into the resulting binary.
 
13651
hardcode_minus_L=$hardcode_minus_L
 
13652
 
 
13653
# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
 
13654
# into the resulting binary.
 
13655
hardcode_shlibpath_var=$hardcode_shlibpath_var
 
13656
 
 
13657
# Set to "yes" if building a shared library automatically hardcodes DIR
 
13658
# into the library and all subsequent libraries and executables linked
 
13659
# against it.
 
13660
hardcode_automatic=$hardcode_automatic
 
13661
 
 
13662
# Set to yes if linker adds runtime paths of dependent libraries
 
13663
# to runtime path list.
 
13664
inherit_rpath=$inherit_rpath
 
13665
 
 
13666
# Whether libtool must link a program against all its dependency libraries.
 
13667
link_all_deplibs=$link_all_deplibs
 
13668
 
 
13669
# Fix the shell variable \$srcfile for the compiler.
 
13670
fix_srcfile_path=$lt_fix_srcfile_path
 
13671
 
 
13672
# Set to "yes" if exported symbols are required.
 
13673
always_export_symbols=$always_export_symbols
 
13674
 
 
13675
# The commands to list exported symbols.
 
13676
export_symbols_cmds=$lt_export_symbols_cmds
 
13677
 
 
13678
# Symbols that should not be listed in the preloaded symbols.
 
13679
exclude_expsyms=$lt_exclude_expsyms
 
13680
 
 
13681
# Symbols that must always be exported.
 
13682
include_expsyms=$lt_include_expsyms
 
13683
 
 
13684
# Commands necessary for linking programs (against libraries) with templates.
 
13685
prelink_cmds=$lt_prelink_cmds
 
13686
 
 
13687
# Specify filename containing input files.
 
13688
file_list_spec=$lt_file_list_spec
 
13689
 
 
13690
# How to hardcode a shared library path into an executable.
 
13691
hardcode_action=$hardcode_action
 
13692
 
 
13693
# ### END LIBTOOL CONFIG
 
13694
 
 
13695
_LT_EOF
 
13696
 
 
13697
  case $host_os in
 
13698
  aix3*)
 
13699
    cat <<\_LT_EOF >> "$cfgfile"
 
13700
# AIX sometimes has problems with the GCC collect2 program.  For some
 
13701
# reason, if we set the COLLECT_NAMES environment variable, the problems
 
13702
# vanish in a puff of smoke.
 
13703
if test "X${COLLECT_NAMES+set}" != Xset; then
 
13704
  COLLECT_NAMES=
 
13705
  export COLLECT_NAMES
 
13706
fi
 
13707
_LT_EOF
 
13708
    ;;
 
13709
  esac
 
13710
 
 
13711
 
 
13712
ltmain="$ac_aux_dir/ltmain.sh"
 
13713
 
 
13714
 
 
13715
  # We use sed instead of cat because bash on DJGPP gets confused if
 
13716
  # if finds mixed CR/LF and LF-only lines.  Since sed operates in
 
13717
  # text mode, it properly converts lines to CR/LF.  This bash problem
 
13718
  # is reportedly fixed, but why not run on old versions too?
 
13719
  sed '/^# Generated shell functions inserted here/q' "$ltmain" >> "$cfgfile" \
 
13720
    || (rm -f "$cfgfile"; exit 1)
 
13721
 
 
13722
  case $xsi_shell in
 
13723
  yes)
 
13724
    cat << \_LT_EOF >> "$cfgfile"
 
13725
# func_dirname file append nondir_replacement
 
13726
# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
 
13727
# otherwise set result to NONDIR_REPLACEMENT.
 
13728
func_dirname ()
 
13729
{
 
13730
  case ${1} in
 
13731
    */*) func_dirname_result="${1%/*}${2}" ;;
 
13732
    *  ) func_dirname_result="${3}" ;;
 
13733
  esac
 
13734
}
 
13735
 
 
13736
# func_basename file
 
13737
func_basename ()
 
13738
{
 
13739
  func_basename_result="${1##*/}"
 
13740
}
 
13741
 
 
13742
# func_stripname prefix suffix name
 
13743
# strip PREFIX and SUFFIX off of NAME.
 
13744
# PREFIX and SUFFIX must not contain globbing or regex special
 
13745
# characters, hashes, percent signs, but SUFFIX may contain a leading
 
13746
# dot (in which case that matches only a dot).
 
13747
func_stripname ()
 
13748
{
 
13749
  # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
 
13750
  # positional parameters, so assign one to ordinary parameter first.
 
13751
  func_stripname_result=${3}
 
13752
  func_stripname_result=${func_stripname_result#"${1}"}
 
13753
  func_stripname_result=${func_stripname_result%"${2}"}
 
13754
}
 
13755
 
 
13756
# func_opt_split
 
13757
func_opt_split ()
 
13758
{
 
13759
  func_opt_split_opt=${1%%=*}
 
13760
  func_opt_split_arg=${1#*=}
 
13761
}
 
13762
 
 
13763
# func_lo2o object
 
13764
func_lo2o ()
 
13765
{
 
13766
  case ${1} in
 
13767
    *.lo) func_lo2o_result=${1%.lo}.${objext} ;;
 
13768
    *)    func_lo2o_result=${1} ;;
 
13769
  esac
 
13770
}
 
13771
_LT_EOF
 
13772
    ;;
 
13773
  *) # Bourne compatible functions.
 
13774
    cat << \_LT_EOF >> "$cfgfile"
 
13775
# func_dirname file append nondir_replacement
 
13776
# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
 
13777
# otherwise set result to NONDIR_REPLACEMENT.
 
13778
func_dirname ()
 
13779
{
 
13780
  # Extract subdirectory from the argument.
 
13781
  func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
 
13782
  if test "X$func_dirname_result" = "X${1}"; then
 
13783
    func_dirname_result="${3}"
 
13784
  else
 
13785
    func_dirname_result="$func_dirname_result${2}"
 
13786
  fi
 
13787
}
 
13788
 
 
13789
# func_basename file
 
13790
func_basename ()
 
13791
{
 
13792
  func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
 
13793
}
 
13794
 
 
13795
# func_stripname prefix suffix name
 
13796
# strip PREFIX and SUFFIX off of NAME.
 
13797
# PREFIX and SUFFIX must not contain globbing or regex special
 
13798
# characters, hashes, percent signs, but SUFFIX may contain a leading
 
13799
# dot (in which case that matches only a dot).
 
13800
# func_strip_suffix prefix name
 
13801
func_stripname ()
 
13802
{
 
13803
  case ${2} in
 
13804
    .*) func_stripname_result=`$ECHO "X${3}" \
 
13805
           | $Xsed -e "s%^${1}%%" -e "s%\\\\${2}\$%%"`;;
 
13806
    *)  func_stripname_result=`$ECHO "X${3}" \
 
13807
           | $Xsed -e "s%^${1}%%" -e "s%${2}\$%%"`;;
 
13808
  esac
 
13809
}
 
13810
 
 
13811
# sed scripts:
 
13812
my_sed_long_opt='1s/^\(-[^=]*\)=.*/\1/;q'
 
13813
my_sed_long_arg='1s/^-[^=]*=//'
 
13814
 
 
13815
# func_opt_split
 
13816
func_opt_split ()
 
13817
{
 
13818
  func_opt_split_opt=`$ECHO "X${1}" | $Xsed -e "$my_sed_long_opt"`
 
13819
  func_opt_split_arg=`$ECHO "X${1}" | $Xsed -e "$my_sed_long_arg"`
 
13820
}
 
13821
 
 
13822
# func_lo2o object
 
13823
func_lo2o ()
 
13824
{
 
13825
  func_lo2o_result=`$ECHO "X${1}" | $Xsed -e "$lo2o"`
 
13826
}
 
13827
_LT_EOF
 
13828
esac
 
13829
 
 
13830
case $lt_shell_append in
 
13831
  yes)
 
13832
    cat << \_LT_EOF >> "$cfgfile"
 
13833
 
 
13834
# func_append var value
 
13835
# Append VALUE to the end of shell variable VAR.
 
13836
func_append ()
 
13837
{
 
13838
  eval "$1+=\$2"
 
13839
}
 
13840
_LT_EOF
 
13841
    ;;
 
13842
  *)
 
13843
    cat << \_LT_EOF >> "$cfgfile"
 
13844
 
 
13845
# func_append var value
 
13846
# Append VALUE to the end of shell variable VAR.
 
13847
func_append ()
 
13848
{
 
13849
  eval "$1=\$$1\$2"
 
13850
}
 
13851
_LT_EOF
 
13852
    ;;
 
13853
  esac
 
13854
 
 
13855
 
 
13856
  sed -n '/^# Generated shell functions inserted here/,$p' "$ltmain" >> "$cfgfile" \
 
13857
    || (rm -f "$cfgfile"; exit 1)
 
13858
 
 
13859
  mv -f "$cfgfile" "$ofile" ||
 
13860
    (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
 
13861
  chmod +x "$ofile"
 
13862
 
 
13863
 ;;
8098
13864
    default-1 )
8099
13865
    for ac_file in $CONFIG_FILES; do
8100
13866
      # Support "outfile[:infile[:infile...]]"