~ubuntu-branches/debian/squeeze/psmisc/squeeze

« back to all changes in this revision

Viewing changes to configure

  • Committer: Bazaar Package Importer
  • Author(s): Craig Small
  • Date: 2009-07-25 09:40:01 UTC
  • mfrom: (1.2.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20090725094001-gam144a7layjx6cl
Tags: 22.8-1
* New upstream release
 - fuser will print mounts,nfs exports and swaps with -v Closes: #356655
 - pstree and fuser have long options Closes: #517412
 - Fixed pstree -a off-by-one error in buffer, Closes: #536243

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
1
#! /bin/sh
2
2
# Guess values for system-dependent variables and create Makefiles.
3
 
# Generated by GNU Autoconf 2.63 for psmisc 22.7.
 
3
# Generated by GNU Autoconf 2.63 for psmisc 22.8.
4
4
#
5
5
# Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
6
6
# 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
594
594
# Identity of this package.
595
595
PACKAGE_NAME='psmisc'
596
596
PACKAGE_TARNAME='psmisc'
597
 
PACKAGE_VERSION='22.7'
598
 
PACKAGE_STRING='psmisc 22.7'
 
597
PACKAGE_VERSION='22.8'
 
598
PACKAGE_STRING='psmisc 22.8'
599
599
PACKAGE_BUGREPORT=''
600
600
 
601
601
ac_unique_file="src/comm.h"
678
678
am__fastdepCC_FALSE
679
679
am__fastdepCC_TRUE
680
680
CCDEPMODE
681
 
ac_ct_CC
682
 
CFLAGS
683
 
CC
684
 
am__fastdepCXX_FALSE
685
 
am__fastdepCXX_TRUE
686
 
CXXDEPMODE
687
681
AMDEPBACKSLASH
688
682
AMDEP_FALSE
689
683
AMDEP_TRUE
692
686
DEPDIR
693
687
OBJEXT
694
688
EXEEXT
695
 
ac_ct_CXX
 
689
ac_ct_CC
696
690
CPPFLAGS
697
691
LDFLAGS
698
 
CXXFLAGS
699
 
CXX
 
692
CFLAGS
 
693
CC
700
694
am__untar
701
695
am__tar
702
696
AMTAR
773
767
      ac_precious_vars='build_alias
774
768
host_alias
775
769
target_alias
776
 
CXX
777
 
CXXFLAGS
 
770
CC
 
771
CFLAGS
778
772
LDFLAGS
779
773
LIBS
780
774
CPPFLAGS
781
 
CCC
782
 
CC
783
 
CFLAGS
784
775
CPP'
785
776
 
786
777
 
1334
1325
  # Omit some internal or obsolete options to make the list less imposing.
1335
1326
  # This message is too long to be a string in the A/UX 3.1 sh.
1336
1327
  cat <<_ACEOF
1337
 
\`configure' configures psmisc 22.7 to adapt to many kinds of systems.
 
1328
\`configure' configures psmisc 22.8 to adapt to many kinds of systems.
1338
1329
 
1339
1330
Usage: $0 [OPTION]... [VAR=VALUE]...
1340
1331
 
1404
1395
 
1405
1396
if test -n "$ac_init_help"; then
1406
1397
  case $ac_init_help in
1407
 
     short | recursive ) echo "Configuration of psmisc 22.7:";;
 
1398
     short | recursive ) echo "Configuration of psmisc 22.8:";;
1408
1399
   esac
1409
1400
  cat <<\_ACEOF
1410
1401
 
1430
1421
  --without-libintl-prefix     don't search for libintl in includedir and libdir
1431
1422
 
1432
1423
Some influential environment variables:
1433
 
  CXX         C++ compiler command
1434
 
  CXXFLAGS    C++ compiler flags
 
1424
  CC          C compiler command
 
1425
  CFLAGS      C compiler flags
1435
1426
  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
1436
1427
              nonstandard directory <lib dir>
1437
1428
  LIBS        libraries to pass to the linker, e.g. -l<library>
1438
1429
  CPPFLAGS    C/C++/Objective C preprocessor flags, e.g. -I<include dir> if
1439
1430
              you have headers in a nonstandard directory <include dir>
1440
 
  CC          C compiler command
1441
 
  CFLAGS      C compiler flags
1442
1431
  CPP         C preprocessor
1443
1432
 
1444
1433
Use these variables to override the choices made by `configure' or to help
1506
1495
test -n "$ac_init_help" && exit $ac_status
1507
1496
if $ac_init_version; then
1508
1497
  cat <<\_ACEOF
1509
 
psmisc configure 22.7
 
1498
psmisc configure 22.8
1510
1499
generated by GNU Autoconf 2.63
1511
1500
 
1512
1501
Copyright (C) 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001,
1520
1509
This file contains any messages produced by compilers while
1521
1510
running configure, to aid debugging if configure makes a mistake.
1522
1511
 
1523
 
It was created by psmisc $as_me 22.7, which was
 
1512
It was created by psmisc $as_me 22.8, which was
1524
1513
generated by GNU Autoconf 2.63.  Invocation command line was
1525
1514
 
1526
1515
  $ $0 $@
2240
2229
 
2241
2230
# Define the identity of the package.
2242
2231
 PACKAGE='psmisc'
2243
 
 VERSION='22.7'
 
2232
 VERSION='22.8'
2244
2233
 
2245
2234
 
2246
2235
cat >>confdefs.h <<_ACEOF
2383
2372
 
2384
2373
 
2385
2374
 
2386
 
ac_ext=cpp
2387
 
ac_cpp='$CXXCPP $CPPFLAGS'
2388
 
ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
2389
 
ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
2390
 
ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
2391
 
if test -z "$CXX"; then
2392
 
  if test -n "$CCC"; then
2393
 
    CXX=$CCC
 
2375
ac_ext=c
 
2376
ac_cpp='$CPP $CPPFLAGS'
 
2377
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 
2378
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 
2379
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
2380
if test -n "$ac_tool_prefix"; then
 
2381
  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
 
2382
set dummy ${ac_tool_prefix}gcc; ac_word=$2
 
2383
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
 
2384
$as_echo_n "checking for $ac_word... " >&6; }
 
2385
if test "${ac_cv_prog_CC+set}" = set; then
 
2386
  $as_echo_n "(cached) " >&6
 
2387
else
 
2388
  if test -n "$CC"; then
 
2389
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
2390
else
 
2391
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
2392
for as_dir in $PATH
 
2393
do
 
2394
  IFS=$as_save_IFS
 
2395
  test -z "$as_dir" && as_dir=.
 
2396
  for ac_exec_ext in '' $ac_executable_extensions; do
 
2397
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2398
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
 
2399
    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
2400
    break 2
 
2401
  fi
 
2402
done
 
2403
done
 
2404
IFS=$as_save_IFS
 
2405
 
 
2406
fi
 
2407
fi
 
2408
CC=$ac_cv_prog_CC
 
2409
if test -n "$CC"; then
 
2410
  { $as_echo "$as_me:$LINENO: result: $CC" >&5
 
2411
$as_echo "$CC" >&6; }
 
2412
else
 
2413
  { $as_echo "$as_me:$LINENO: result: no" >&5
 
2414
$as_echo "no" >&6; }
 
2415
fi
 
2416
 
 
2417
 
 
2418
fi
 
2419
if test -z "$ac_cv_prog_CC"; then
 
2420
  ac_ct_CC=$CC
 
2421
  # Extract the first word of "gcc", so it can be a program name with args.
 
2422
set dummy gcc; ac_word=$2
 
2423
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
 
2424
$as_echo_n "checking for $ac_word... " >&6; }
 
2425
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
 
2426
  $as_echo_n "(cached) " >&6
 
2427
else
 
2428
  if test -n "$ac_ct_CC"; then
 
2429
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
 
2430
else
 
2431
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
2432
for as_dir in $PATH
 
2433
do
 
2434
  IFS=$as_save_IFS
 
2435
  test -z "$as_dir" && as_dir=.
 
2436
  for ac_exec_ext in '' $ac_executable_extensions; do
 
2437
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2438
    ac_cv_prog_ac_ct_CC="gcc"
 
2439
    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
2440
    break 2
 
2441
  fi
 
2442
done
 
2443
done
 
2444
IFS=$as_save_IFS
 
2445
 
 
2446
fi
 
2447
fi
 
2448
ac_ct_CC=$ac_cv_prog_ac_ct_CC
 
2449
if test -n "$ac_ct_CC"; then
 
2450
  { $as_echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
 
2451
$as_echo "$ac_ct_CC" >&6; }
 
2452
else
 
2453
  { $as_echo "$as_me:$LINENO: result: no" >&5
 
2454
$as_echo "no" >&6; }
 
2455
fi
 
2456
 
 
2457
  if test "x$ac_ct_CC" = x; then
 
2458
    CC=""
2394
2459
  else
2395
 
    if test -n "$ac_tool_prefix"; then
2396
 
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
 
2460
    case $cross_compiling:$ac_tool_warned in
 
2461
yes:)
 
2462
{ $as_echo "$as_me:$LINENO: WARNING: using cross tools not prefixed with host triplet" >&5
 
2463
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
 
2464
ac_tool_warned=yes ;;
 
2465
esac
 
2466
    CC=$ac_ct_CC
 
2467
  fi
 
2468
else
 
2469
  CC="$ac_cv_prog_CC"
 
2470
fi
 
2471
 
 
2472
if test -z "$CC"; then
 
2473
          if test -n "$ac_tool_prefix"; then
 
2474
    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
 
2475
set dummy ${ac_tool_prefix}cc; ac_word=$2
 
2476
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
 
2477
$as_echo_n "checking for $ac_word... " >&6; }
 
2478
if test "${ac_cv_prog_CC+set}" = set; then
 
2479
  $as_echo_n "(cached) " >&6
 
2480
else
 
2481
  if test -n "$CC"; then
 
2482
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
2483
else
 
2484
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
2485
for as_dir in $PATH
 
2486
do
 
2487
  IFS=$as_save_IFS
 
2488
  test -z "$as_dir" && as_dir=.
 
2489
  for ac_exec_ext in '' $ac_executable_extensions; do
 
2490
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2491
    ac_cv_prog_CC="${ac_tool_prefix}cc"
 
2492
    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
2493
    break 2
 
2494
  fi
 
2495
done
 
2496
done
 
2497
IFS=$as_save_IFS
 
2498
 
 
2499
fi
 
2500
fi
 
2501
CC=$ac_cv_prog_CC
 
2502
if test -n "$CC"; then
 
2503
  { $as_echo "$as_me:$LINENO: result: $CC" >&5
 
2504
$as_echo "$CC" >&6; }
 
2505
else
 
2506
  { $as_echo "$as_me:$LINENO: result: no" >&5
 
2507
$as_echo "no" >&6; }
 
2508
fi
 
2509
 
 
2510
 
 
2511
  fi
 
2512
fi
 
2513
if test -z "$CC"; then
 
2514
  # Extract the first word of "cc", so it can be a program name with args.
 
2515
set dummy cc; ac_word=$2
 
2516
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
 
2517
$as_echo_n "checking for $ac_word... " >&6; }
 
2518
if test "${ac_cv_prog_CC+set}" = set; then
 
2519
  $as_echo_n "(cached) " >&6
 
2520
else
 
2521
  if test -n "$CC"; then
 
2522
  ac_cv_prog_CC="$CC" # Let the user override the test.
 
2523
else
 
2524
  ac_prog_rejected=no
 
2525
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
 
2526
for as_dir in $PATH
 
2527
do
 
2528
  IFS=$as_save_IFS
 
2529
  test -z "$as_dir" && as_dir=.
 
2530
  for ac_exec_ext in '' $ac_executable_extensions; do
 
2531
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
 
2532
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
 
2533
       ac_prog_rejected=yes
 
2534
       continue
 
2535
     fi
 
2536
    ac_cv_prog_CC="cc"
 
2537
    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
 
2538
    break 2
 
2539
  fi
 
2540
done
 
2541
done
 
2542
IFS=$as_save_IFS
 
2543
 
 
2544
if test $ac_prog_rejected = yes; then
 
2545
  # We found a bogon in the path, so make sure we never use it.
 
2546
  set dummy $ac_cv_prog_CC
 
2547
  shift
 
2548
  if test $# != 0; then
 
2549
    # We chose a different compiler from the bogus one.
 
2550
    # However, it has the same basename, so the bogon will be chosen
 
2551
    # first if we set CC to just the basename; use the full file name.
 
2552
    shift
 
2553
    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
 
2554
  fi
 
2555
fi
 
2556
fi
 
2557
fi
 
2558
CC=$ac_cv_prog_CC
 
2559
if test -n "$CC"; then
 
2560
  { $as_echo "$as_me:$LINENO: result: $CC" >&5
 
2561
$as_echo "$CC" >&6; }
 
2562
else
 
2563
  { $as_echo "$as_me:$LINENO: result: no" >&5
 
2564
$as_echo "no" >&6; }
 
2565
fi
 
2566
 
 
2567
 
 
2568
fi
 
2569
if test -z "$CC"; then
 
2570
  if test -n "$ac_tool_prefix"; then
 
2571
  for ac_prog in cl.exe
2397
2572
  do
2398
2573
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
2399
2574
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
2400
2575
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2401
2576
$as_echo_n "checking for $ac_word... " >&6; }
2402
 
if test "${ac_cv_prog_CXX+set}" = set; then
 
2577
if test "${ac_cv_prog_CC+set}" = set; then
2403
2578
  $as_echo_n "(cached) " >&6
2404
2579
else
2405
 
  if test -n "$CXX"; then
2406
 
  ac_cv_prog_CXX="$CXX" # Let the user override the test.
 
2580
  if test -n "$CC"; then
 
2581
  ac_cv_prog_CC="$CC" # Let the user override the test.
2407
2582
else
2408
2583
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2409
2584
for as_dir in $PATH
2412
2587
  test -z "$as_dir" && as_dir=.
2413
2588
  for ac_exec_ext in '' $ac_executable_extensions; do
2414
2589
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2415
 
    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
 
2590
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
2416
2591
    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2417
2592
    break 2
2418
2593
  fi
2422
2597
 
2423
2598
fi
2424
2599
fi
2425
 
CXX=$ac_cv_prog_CXX
2426
 
if test -n "$CXX"; then
2427
 
  { $as_echo "$as_me:$LINENO: result: $CXX" >&5
2428
 
$as_echo "$CXX" >&6; }
 
2600
CC=$ac_cv_prog_CC
 
2601
if test -n "$CC"; then
 
2602
  { $as_echo "$as_me:$LINENO: result: $CC" >&5
 
2603
$as_echo "$CC" >&6; }
2429
2604
else
2430
2605
  { $as_echo "$as_me:$LINENO: result: no" >&5
2431
2606
$as_echo "no" >&6; }
2432
2607
fi
2433
2608
 
2434
2609
 
2435
 
    test -n "$CXX" && break
 
2610
    test -n "$CC" && break
2436
2611
  done
2437
2612
fi
2438
 
if test -z "$CXX"; then
2439
 
  ac_ct_CXX=$CXX
2440
 
  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
 
2613
if test -z "$CC"; then
 
2614
  ac_ct_CC=$CC
 
2615
  for ac_prog in cl.exe
2441
2616
do
2442
2617
  # Extract the first word of "$ac_prog", so it can be a program name with args.
2443
2618
set dummy $ac_prog; ac_word=$2
2444
2619
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
2445
2620
$as_echo_n "checking for $ac_word... " >&6; }
2446
 
if test "${ac_cv_prog_ac_ct_CXX+set}" = set; then
 
2621
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
2447
2622
  $as_echo_n "(cached) " >&6
2448
2623
else
2449
 
  if test -n "$ac_ct_CXX"; then
2450
 
  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
 
2624
  if test -n "$ac_ct_CC"; then
 
2625
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
2451
2626
else
2452
2627
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
2453
2628
for as_dir in $PATH
2456
2631
  test -z "$as_dir" && as_dir=.
2457
2632
  for ac_exec_ext in '' $ac_executable_extensions; do
2458
2633
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
2459
 
    ac_cv_prog_ac_ct_CXX="$ac_prog"
 
2634
    ac_cv_prog_ac_ct_CC="$ac_prog"
2460
2635
    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
2461
2636
    break 2
2462
2637
  fi
2466
2641
 
2467
2642
fi
2468
2643
fi
2469
 
ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
2470
 
if test -n "$ac_ct_CXX"; then
2471
 
  { $as_echo "$as_me:$LINENO: result: $ac_ct_CXX" >&5
2472
 
$as_echo "$ac_ct_CXX" >&6; }
 
2644
ac_ct_CC=$ac_cv_prog_ac_ct_CC
 
2645
if test -n "$ac_ct_CC"; then
 
2646
  { $as_echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
 
2647
$as_echo "$ac_ct_CC" >&6; }
2473
2648
else
2474
2649
  { $as_echo "$as_me:$LINENO: result: no" >&5
2475
2650
$as_echo "no" >&6; }
2476
2651
fi
2477
2652
 
2478
2653
 
2479
 
  test -n "$ac_ct_CXX" && break
 
2654
  test -n "$ac_ct_CC" && break
2480
2655
done
2481
2656
 
2482
 
  if test "x$ac_ct_CXX" = x; then
2483
 
    CXX="g++"
 
2657
  if test "x$ac_ct_CC" = x; then
 
2658
    CC=""
2484
2659
  else
2485
2660
    case $cross_compiling:$ac_tool_warned in
2486
2661
yes:)
2488
2663
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
2489
2664
ac_tool_warned=yes ;;
2490
2665
esac
2491
 
    CXX=$ac_ct_CXX
2492
 
  fi
2493
 
fi
2494
 
 
2495
 
  fi
2496
 
fi
 
2666
    CC=$ac_ct_CC
 
2667
  fi
 
2668
fi
 
2669
 
 
2670
fi
 
2671
 
 
2672
 
 
2673
test -z "$CC" && { { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
 
2674
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
 
2675
{ { $as_echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
 
2676
See \`config.log' for more details." >&5
 
2677
$as_echo "$as_me: error: no acceptable C compiler found in \$PATH
 
2678
See \`config.log' for more details." >&2;}
 
2679
   { (exit 1); exit 1; }; }; }
 
2680
 
2497
2681
# Provide some information about the compiler.
2498
 
$as_echo "$as_me:$LINENO: checking for C++ compiler version" >&5
 
2682
$as_echo "$as_me:$LINENO: checking for C compiler version" >&5
2499
2683
set X $ac_compile
2500
2684
ac_compiler=$2
2501
2685
{ (ac_try="$ac_compiler --version >&5"
2552
2736
# Try to create an executable without -o first, disregard a.out.
2553
2737
# It will help us diagnose broken compilers, and finding out an intuition
2554
2738
# of exeext.
2555
 
{ $as_echo "$as_me:$LINENO: checking for C++ compiler default output file name" >&5
2556
 
$as_echo_n "checking for C++ compiler default output file name... " >&6; }
 
2739
{ $as_echo "$as_me:$LINENO: checking for C compiler default output file name" >&5
 
2740
$as_echo_n "checking for C compiler default output file name... " >&6; }
2557
2741
ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
2558
2742
 
2559
2743
# The possible output files:
2624
2808
 
2625
2809
{ { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
2626
2810
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
2627
 
{ { $as_echo "$as_me:$LINENO: error: C++ compiler cannot create executables
 
2811
{ { $as_echo "$as_me:$LINENO: error: C compiler cannot create executables
2628
2812
See \`config.log' for more details." >&5
2629
 
$as_echo "$as_me: error: C++ compiler cannot create executables
 
2813
$as_echo "$as_me: error: C compiler cannot create executables
2630
2814
See \`config.log' for more details." >&2;}
2631
2815
   { (exit 77); exit 77; }; }; }
2632
2816
fi
2635
2819
 
2636
2820
# Check that the compiler produces executables we can run.  If not, either
2637
2821
# the compiler is broken, or we cross compile.
2638
 
{ $as_echo "$as_me:$LINENO: checking whether the C++ compiler works" >&5
2639
 
$as_echo_n "checking whether the C++ compiler works... " >&6; }
 
2822
{ $as_echo "$as_me:$LINENO: checking whether the C compiler works" >&5
 
2823
$as_echo_n "checking whether the C compiler works... " >&6; }
2640
2824
# FIXME: These cross compiler hacks should be removed for Autoconf 3.0
2641
2825
# If not cross compiling, check that we can run a simple program.
2642
2826
if test "$cross_compiling" != yes; then
2658
2842
    else
2659
2843
        { { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
2660
2844
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
2661
 
{ { $as_echo "$as_me:$LINENO: error: cannot run C++ compiled programs.
 
2845
{ { $as_echo "$as_me:$LINENO: error: cannot run C compiled programs.
2662
2846
If you meant to cross compile, use \`--host'.
2663
2847
See \`config.log' for more details." >&5
2664
 
$as_echo "$as_me: error: cannot run C++ compiled programs.
 
2848
$as_echo "$as_me: error: cannot run C compiled programs.
2665
2849
If you meant to cross compile, use \`--host'.
2666
2850
See \`config.log' for more details." >&2;}
2667
2851
   { (exit 1); exit 1; }; }; }
2782
2966
$as_echo "$ac_cv_objext" >&6; }
2783
2967
OBJEXT=$ac_cv_objext
2784
2968
ac_objext=$OBJEXT
2785
 
{ $as_echo "$as_me:$LINENO: checking whether we are using the GNU C++ compiler" >&5
2786
 
$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
2787
 
if test "${ac_cv_cxx_compiler_gnu+set}" = set; then
2788
 
  $as_echo_n "(cached) " >&6
2789
 
else
2790
 
  cat >conftest.$ac_ext <<_ACEOF
2791
 
/* confdefs.h.  */
2792
 
_ACEOF
2793
 
cat confdefs.h >>conftest.$ac_ext
2794
 
cat >>conftest.$ac_ext <<_ACEOF
2795
 
/* end confdefs.h.  */
2796
 
 
2797
 
int
2798
 
main ()
2799
 
{
2800
 
#ifndef __GNUC__
2801
 
       choke me
2802
 
#endif
2803
 
 
2804
 
  ;
2805
 
  return 0;
2806
 
}
2807
 
_ACEOF
2808
 
rm -f conftest.$ac_objext
2809
 
if { (ac_try="$ac_compile"
2810
 
case "(($ac_try" in
2811
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2812
 
  *) ac_try_echo=$ac_try;;
2813
 
esac
2814
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
2815
 
$as_echo "$ac_try_echo") >&5
2816
 
  (eval "$ac_compile") 2>conftest.er1
2817
 
  ac_status=$?
2818
 
  grep -v '^ *+' conftest.er1 >conftest.err
2819
 
  rm -f conftest.er1
2820
 
  cat conftest.err >&5
2821
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
2822
 
  (exit $ac_status); } && {
2823
 
         test -z "$ac_cxx_werror_flag" ||
2824
 
         test ! -s conftest.err
2825
 
       } && test -s conftest.$ac_objext; then
2826
 
  ac_compiler_gnu=yes
2827
 
else
2828
 
  $as_echo "$as_me: failed program was:" >&5
2829
 
sed 's/^/| /' conftest.$ac_ext >&5
2830
 
 
2831
 
        ac_compiler_gnu=no
2832
 
fi
2833
 
 
2834
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2835
 
ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
2836
 
 
2837
 
fi
2838
 
{ $as_echo "$as_me:$LINENO: result: $ac_cv_cxx_compiler_gnu" >&5
2839
 
$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
2840
 
if test $ac_compiler_gnu = yes; then
2841
 
  GXX=yes
2842
 
else
2843
 
  GXX=
2844
 
fi
2845
 
ac_test_CXXFLAGS=${CXXFLAGS+set}
2846
 
ac_save_CXXFLAGS=$CXXFLAGS
2847
 
{ $as_echo "$as_me:$LINENO: checking whether $CXX accepts -g" >&5
2848
 
$as_echo_n "checking whether $CXX accepts -g... " >&6; }
2849
 
if test "${ac_cv_prog_cxx_g+set}" = set; then
2850
 
  $as_echo_n "(cached) " >&6
2851
 
else
2852
 
  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
2853
 
   ac_cxx_werror_flag=yes
2854
 
   ac_cv_prog_cxx_g=no
2855
 
   CXXFLAGS="-g"
2856
 
   cat >conftest.$ac_ext <<_ACEOF
2857
 
/* confdefs.h.  */
2858
 
_ACEOF
2859
 
cat confdefs.h >>conftest.$ac_ext
2860
 
cat >>conftest.$ac_ext <<_ACEOF
2861
 
/* end confdefs.h.  */
2862
 
 
2863
 
int
2864
 
main ()
2865
 
{
2866
 
 
2867
 
  ;
2868
 
  return 0;
2869
 
}
2870
 
_ACEOF
2871
 
rm -f conftest.$ac_objext
2872
 
if { (ac_try="$ac_compile"
2873
 
case "(($ac_try" in
2874
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2875
 
  *) ac_try_echo=$ac_try;;
2876
 
esac
2877
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
2878
 
$as_echo "$ac_try_echo") >&5
2879
 
  (eval "$ac_compile") 2>conftest.er1
2880
 
  ac_status=$?
2881
 
  grep -v '^ *+' conftest.er1 >conftest.err
2882
 
  rm -f conftest.er1
2883
 
  cat conftest.err >&5
2884
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
2885
 
  (exit $ac_status); } && {
2886
 
         test -z "$ac_cxx_werror_flag" ||
2887
 
         test ! -s conftest.err
2888
 
       } && test -s conftest.$ac_objext; then
2889
 
  ac_cv_prog_cxx_g=yes
2890
 
else
2891
 
  $as_echo "$as_me: failed program was:" >&5
2892
 
sed 's/^/| /' conftest.$ac_ext >&5
2893
 
 
2894
 
        CXXFLAGS=""
2895
 
      cat >conftest.$ac_ext <<_ACEOF
2896
 
/* confdefs.h.  */
2897
 
_ACEOF
2898
 
cat confdefs.h >>conftest.$ac_ext
2899
 
cat >>conftest.$ac_ext <<_ACEOF
2900
 
/* end confdefs.h.  */
2901
 
 
2902
 
int
2903
 
main ()
2904
 
{
2905
 
 
2906
 
  ;
2907
 
  return 0;
2908
 
}
2909
 
_ACEOF
2910
 
rm -f conftest.$ac_objext
2911
 
if { (ac_try="$ac_compile"
2912
 
case "(($ac_try" in
2913
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2914
 
  *) ac_try_echo=$ac_try;;
2915
 
esac
2916
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
2917
 
$as_echo "$ac_try_echo") >&5
2918
 
  (eval "$ac_compile") 2>conftest.er1
2919
 
  ac_status=$?
2920
 
  grep -v '^ *+' conftest.er1 >conftest.err
2921
 
  rm -f conftest.er1
2922
 
  cat conftest.err >&5
2923
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
2924
 
  (exit $ac_status); } && {
2925
 
         test -z "$ac_cxx_werror_flag" ||
2926
 
         test ! -s conftest.err
2927
 
       } && test -s conftest.$ac_objext; then
2928
 
  :
2929
 
else
2930
 
  $as_echo "$as_me: failed program was:" >&5
2931
 
sed 's/^/| /' conftest.$ac_ext >&5
2932
 
 
2933
 
        ac_cxx_werror_flag=$ac_save_cxx_werror_flag
2934
 
         CXXFLAGS="-g"
2935
 
         cat >conftest.$ac_ext <<_ACEOF
2936
 
/* confdefs.h.  */
2937
 
_ACEOF
2938
 
cat confdefs.h >>conftest.$ac_ext
2939
 
cat >>conftest.$ac_ext <<_ACEOF
2940
 
/* end confdefs.h.  */
2941
 
 
2942
 
int
2943
 
main ()
2944
 
{
2945
 
 
2946
 
  ;
2947
 
  return 0;
2948
 
}
2949
 
_ACEOF
2950
 
rm -f conftest.$ac_objext
2951
 
if { (ac_try="$ac_compile"
2952
 
case "(($ac_try" in
2953
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
2954
 
  *) ac_try_echo=$ac_try;;
2955
 
esac
2956
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
2957
 
$as_echo "$ac_try_echo") >&5
2958
 
  (eval "$ac_compile") 2>conftest.er1
2959
 
  ac_status=$?
2960
 
  grep -v '^ *+' conftest.er1 >conftest.err
2961
 
  rm -f conftest.er1
2962
 
  cat conftest.err >&5
2963
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
2964
 
  (exit $ac_status); } && {
2965
 
         test -z "$ac_cxx_werror_flag" ||
2966
 
         test ! -s conftest.err
2967
 
       } && test -s conftest.$ac_objext; then
2968
 
  ac_cv_prog_cxx_g=yes
2969
 
else
2970
 
  $as_echo "$as_me: failed program was:" >&5
2971
 
sed 's/^/| /' conftest.$ac_ext >&5
2972
 
 
2973
 
 
2974
 
fi
2975
 
 
2976
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2977
 
fi
2978
 
 
2979
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2980
 
fi
2981
 
 
2982
 
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
2983
 
   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
2984
 
fi
2985
 
{ $as_echo "$as_me:$LINENO: result: $ac_cv_prog_cxx_g" >&5
2986
 
$as_echo "$ac_cv_prog_cxx_g" >&6; }
2987
 
if test "$ac_test_CXXFLAGS" = set; then
2988
 
  CXXFLAGS=$ac_save_CXXFLAGS
2989
 
elif test $ac_cv_prog_cxx_g = yes; then
2990
 
  if test "$GXX" = yes; then
2991
 
    CXXFLAGS="-g -O2"
2992
 
  else
2993
 
    CXXFLAGS="-g"
2994
 
  fi
2995
 
else
2996
 
  if test "$GXX" = yes; then
2997
 
    CXXFLAGS="-O2"
2998
 
  else
2999
 
    CXXFLAGS=
3000
 
  fi
3001
 
fi
3002
 
ac_ext=c
3003
 
ac_cpp='$CPP $CPPFLAGS'
3004
 
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3005
 
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3006
 
ac_compiler_gnu=$ac_cv_c_compiler_gnu
3007
 
DEPDIR="${am__leading_dot}deps"
3008
 
 
3009
 
ac_config_commands="$ac_config_commands depfiles"
3010
 
 
3011
 
 
3012
 
am_make=${MAKE-make}
3013
 
cat > confinc << 'END'
3014
 
am__doit:
3015
 
        @echo done
3016
 
.PHONY: am__doit
3017
 
END
3018
 
# If we don't find an include directive, just comment out the code.
3019
 
{ $as_echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
3020
 
$as_echo_n "checking for style of include used by $am_make... " >&6; }
3021
 
am__include="#"
3022
 
am__quote=
3023
 
_am_result=none
3024
 
# First try GNU make style include.
3025
 
echo "include confinc" > confmf
3026
 
# We grep out `Entering directory' and `Leaving directory'
3027
 
# messages which can occur if `w' ends up in MAKEFLAGS.
3028
 
# In particular we don't look at `^make:' because GNU make might
3029
 
# be invoked under some other name (usually "gmake"), in which
3030
 
# case it prints its new name instead of `make'.
3031
 
if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then
3032
 
   am__include=include
3033
 
   am__quote=
3034
 
   _am_result=GNU
3035
 
fi
3036
 
# Now try BSD make style include.
3037
 
if test "$am__include" = "#"; then
3038
 
   echo '.include "confinc"' > confmf
3039
 
   if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then
3040
 
      am__include=.include
3041
 
      am__quote="\""
3042
 
      _am_result=BSD
3043
 
   fi
3044
 
fi
3045
 
 
3046
 
 
3047
 
{ $as_echo "$as_me:$LINENO: result: $_am_result" >&5
3048
 
$as_echo "$_am_result" >&6; }
3049
 
rm -f confinc confmf
3050
 
 
3051
 
# Check whether --enable-dependency-tracking was given.
3052
 
if test "${enable_dependency_tracking+set}" = set; then
3053
 
  enableval=$enable_dependency_tracking;
3054
 
fi
3055
 
 
3056
 
if test "x$enable_dependency_tracking" != xno; then
3057
 
  am_depcomp="$ac_aux_dir/depcomp"
3058
 
  AMDEPBACKSLASH='\'
3059
 
fi
3060
 
 if test "x$enable_dependency_tracking" != xno; then
3061
 
  AMDEP_TRUE=
3062
 
  AMDEP_FALSE='#'
3063
 
else
3064
 
  AMDEP_TRUE='#'
3065
 
  AMDEP_FALSE=
3066
 
fi
3067
 
 
3068
 
 
3069
 
 
3070
 
depcc="$CXX"  am_compiler_list=
3071
 
 
3072
 
{ $as_echo "$as_me:$LINENO: checking dependency style of $depcc" >&5
3073
 
$as_echo_n "checking dependency style of $depcc... " >&6; }
3074
 
if test "${am_cv_CXX_dependencies_compiler_type+set}" = set; then
3075
 
  $as_echo_n "(cached) " >&6
3076
 
else
3077
 
  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
3078
 
  # We make a subdir and do the tests there.  Otherwise we can end up
3079
 
  # making bogus files that we don't know about and never remove.  For
3080
 
  # instance it was reported that on HP-UX the gcc test will end up
3081
 
  # making a dummy file named `D' -- because `-MD' means `put the output
3082
 
  # in D'.
3083
 
  mkdir conftest.dir
3084
 
  # Copy depcomp to subdir because otherwise we won't find it if we're
3085
 
  # using a relative directory.
3086
 
  cp "$am_depcomp" conftest.dir
3087
 
  cd conftest.dir
3088
 
  # We will build objects and dependencies in a subdirectory because
3089
 
  # it helps to detect inapplicable dependency modes.  For instance
3090
 
  # both Tru64's cc and ICC support -MD to output dependencies as a
3091
 
  # side effect of compilation, but ICC will put the dependencies in
3092
 
  # the current directory while Tru64 will put them in the object
3093
 
  # directory.
3094
 
  mkdir sub
3095
 
 
3096
 
  am_cv_CXX_dependencies_compiler_type=none
3097
 
  if test "$am_compiler_list" = ""; then
3098
 
     am_compiler_list=`sed -n 's/^#*\([a-zA-Z0-9]*\))$/\1/p' < ./depcomp`
3099
 
  fi
3100
 
  for depmode in $am_compiler_list; do
3101
 
    # Setup a source with many dependencies, because some compilers
3102
 
    # like to wrap large dependency lists on column 80 (with \), and
3103
 
    # we should not choose a depcomp mode which is confused by this.
3104
 
    #
3105
 
    # We need to recreate these files for each test, as the compiler may
3106
 
    # overwrite some of them when testing with obscure command lines.
3107
 
    # This happens at least with the AIX C compiler.
3108
 
    : > sub/conftest.c
3109
 
    for i in 1 2 3 4 5 6; do
3110
 
      echo '#include "conftst'$i'.h"' >> sub/conftest.c
3111
 
      # Using `: > sub/conftst$i.h' creates only sub/conftst1.h with
3112
 
      # Solaris 8's {/usr,}/bin/sh.
3113
 
      touch sub/conftst$i.h
3114
 
    done
3115
 
    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
3116
 
 
3117
 
    case $depmode in
3118
 
    nosideeffect)
3119
 
      # after this tag, mechanisms are not by side-effect, so they'll
3120
 
      # only be used when explicitly requested
3121
 
      if test "x$enable_dependency_tracking" = xyes; then
3122
 
        continue
3123
 
      else
3124
 
        break
3125
 
      fi
3126
 
      ;;
3127
 
    none) break ;;
3128
 
    esac
3129
 
    # We check with `-c' and `-o' for the sake of the "dashmstdout"
3130
 
    # mode.  It turns out that the SunPro C++ compiler does not properly
3131
 
    # handle `-M -o', and we need to detect this.
3132
 
    if depmode=$depmode \
3133
 
       source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \
3134
 
       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
3135
 
       $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \
3136
 
         >/dev/null 2>conftest.err &&
3137
 
       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
3138
 
       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
3139
 
       grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&
3140
 
       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
3141
 
      # icc doesn't choke on unknown options, it will just issue warnings
3142
 
      # or remarks (even with -Werror).  So we grep stderr for any message
3143
 
      # that says an option was ignored or not supported.
3144
 
      # When given -MP, icc 7.0 and 7.1 complain thusly:
3145
 
      #   icc: Command line warning: ignoring option '-M'; no argument required
3146
 
      # The diagnosis changed in icc 8.0:
3147
 
      #   icc: Command line remark: option '-MP' not supported
3148
 
      if (grep 'ignoring option' conftest.err ||
3149
 
          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
3150
 
        am_cv_CXX_dependencies_compiler_type=$depmode
3151
 
        break
3152
 
      fi
3153
 
    fi
3154
 
  done
3155
 
 
3156
 
  cd ..
3157
 
  rm -rf conftest.dir
3158
 
else
3159
 
  am_cv_CXX_dependencies_compiler_type=none
3160
 
fi
3161
 
 
3162
 
fi
3163
 
{ $as_echo "$as_me:$LINENO: result: $am_cv_CXX_dependencies_compiler_type" >&5
3164
 
$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; }
3165
 
CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type
3166
 
 
3167
 
 if
3168
 
  test "x$enable_dependency_tracking" != xno \
3169
 
  && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then
3170
 
  am__fastdepCXX_TRUE=
3171
 
  am__fastdepCXX_FALSE='#'
3172
 
else
3173
 
  am__fastdepCXX_TRUE='#'
3174
 
  am__fastdepCXX_FALSE=
3175
 
fi
3176
 
 
3177
 
 
3178
 
ac_ext=c
3179
 
ac_cpp='$CPP $CPPFLAGS'
3180
 
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3181
 
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3182
 
ac_compiler_gnu=$ac_cv_c_compiler_gnu
3183
 
if test -n "$ac_tool_prefix"; then
3184
 
  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
3185
 
set dummy ${ac_tool_prefix}gcc; ac_word=$2
3186
 
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3187
 
$as_echo_n "checking for $ac_word... " >&6; }
3188
 
if test "${ac_cv_prog_CC+set}" = set; then
3189
 
  $as_echo_n "(cached) " >&6
3190
 
else
3191
 
  if test -n "$CC"; then
3192
 
  ac_cv_prog_CC="$CC" # Let the user override the test.
3193
 
else
3194
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3195
 
for as_dir in $PATH
3196
 
do
3197
 
  IFS=$as_save_IFS
3198
 
  test -z "$as_dir" && as_dir=.
3199
 
  for ac_exec_ext in '' $ac_executable_extensions; do
3200
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3201
 
    ac_cv_prog_CC="${ac_tool_prefix}gcc"
3202
 
    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3203
 
    break 2
3204
 
  fi
3205
 
done
3206
 
done
3207
 
IFS=$as_save_IFS
3208
 
 
3209
 
fi
3210
 
fi
3211
 
CC=$ac_cv_prog_CC
3212
 
if test -n "$CC"; then
3213
 
  { $as_echo "$as_me:$LINENO: result: $CC" >&5
3214
 
$as_echo "$CC" >&6; }
3215
 
else
3216
 
  { $as_echo "$as_me:$LINENO: result: no" >&5
3217
 
$as_echo "no" >&6; }
3218
 
fi
3219
 
 
3220
 
 
3221
 
fi
3222
 
if test -z "$ac_cv_prog_CC"; then
3223
 
  ac_ct_CC=$CC
3224
 
  # Extract the first word of "gcc", so it can be a program name with args.
3225
 
set dummy gcc; ac_word=$2
3226
 
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3227
 
$as_echo_n "checking for $ac_word... " >&6; }
3228
 
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3229
 
  $as_echo_n "(cached) " >&6
3230
 
else
3231
 
  if test -n "$ac_ct_CC"; then
3232
 
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3233
 
else
3234
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3235
 
for as_dir in $PATH
3236
 
do
3237
 
  IFS=$as_save_IFS
3238
 
  test -z "$as_dir" && as_dir=.
3239
 
  for ac_exec_ext in '' $ac_executable_extensions; do
3240
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3241
 
    ac_cv_prog_ac_ct_CC="gcc"
3242
 
    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3243
 
    break 2
3244
 
  fi
3245
 
done
3246
 
done
3247
 
IFS=$as_save_IFS
3248
 
 
3249
 
fi
3250
 
fi
3251
 
ac_ct_CC=$ac_cv_prog_ac_ct_CC
3252
 
if test -n "$ac_ct_CC"; then
3253
 
  { $as_echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3254
 
$as_echo "$ac_ct_CC" >&6; }
3255
 
else
3256
 
  { $as_echo "$as_me:$LINENO: result: no" >&5
3257
 
$as_echo "no" >&6; }
3258
 
fi
3259
 
 
3260
 
  if test "x$ac_ct_CC" = x; then
3261
 
    CC=""
3262
 
  else
3263
 
    case $cross_compiling:$ac_tool_warned in
3264
 
yes:)
3265
 
{ $as_echo "$as_me:$LINENO: WARNING: using cross tools not prefixed with host triplet" >&5
3266
 
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3267
 
ac_tool_warned=yes ;;
3268
 
esac
3269
 
    CC=$ac_ct_CC
3270
 
  fi
3271
 
else
3272
 
  CC="$ac_cv_prog_CC"
3273
 
fi
3274
 
 
3275
 
if test -z "$CC"; then
3276
 
          if test -n "$ac_tool_prefix"; then
3277
 
    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
3278
 
set dummy ${ac_tool_prefix}cc; ac_word=$2
3279
 
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3280
 
$as_echo_n "checking for $ac_word... " >&6; }
3281
 
if test "${ac_cv_prog_CC+set}" = set; then
3282
 
  $as_echo_n "(cached) " >&6
3283
 
else
3284
 
  if test -n "$CC"; then
3285
 
  ac_cv_prog_CC="$CC" # Let the user override the test.
3286
 
else
3287
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3288
 
for as_dir in $PATH
3289
 
do
3290
 
  IFS=$as_save_IFS
3291
 
  test -z "$as_dir" && as_dir=.
3292
 
  for ac_exec_ext in '' $ac_executable_extensions; do
3293
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3294
 
    ac_cv_prog_CC="${ac_tool_prefix}cc"
3295
 
    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3296
 
    break 2
3297
 
  fi
3298
 
done
3299
 
done
3300
 
IFS=$as_save_IFS
3301
 
 
3302
 
fi
3303
 
fi
3304
 
CC=$ac_cv_prog_CC
3305
 
if test -n "$CC"; then
3306
 
  { $as_echo "$as_me:$LINENO: result: $CC" >&5
3307
 
$as_echo "$CC" >&6; }
3308
 
else
3309
 
  { $as_echo "$as_me:$LINENO: result: no" >&5
3310
 
$as_echo "no" >&6; }
3311
 
fi
3312
 
 
3313
 
 
3314
 
  fi
3315
 
fi
3316
 
if test -z "$CC"; then
3317
 
  # Extract the first word of "cc", so it can be a program name with args.
3318
 
set dummy cc; ac_word=$2
3319
 
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3320
 
$as_echo_n "checking for $ac_word... " >&6; }
3321
 
if test "${ac_cv_prog_CC+set}" = set; then
3322
 
  $as_echo_n "(cached) " >&6
3323
 
else
3324
 
  if test -n "$CC"; then
3325
 
  ac_cv_prog_CC="$CC" # Let the user override the test.
3326
 
else
3327
 
  ac_prog_rejected=no
3328
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3329
 
for as_dir in $PATH
3330
 
do
3331
 
  IFS=$as_save_IFS
3332
 
  test -z "$as_dir" && as_dir=.
3333
 
  for ac_exec_ext in '' $ac_executable_extensions; do
3334
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3335
 
    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
3336
 
       ac_prog_rejected=yes
3337
 
       continue
3338
 
     fi
3339
 
    ac_cv_prog_CC="cc"
3340
 
    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3341
 
    break 2
3342
 
  fi
3343
 
done
3344
 
done
3345
 
IFS=$as_save_IFS
3346
 
 
3347
 
if test $ac_prog_rejected = yes; then
3348
 
  # We found a bogon in the path, so make sure we never use it.
3349
 
  set dummy $ac_cv_prog_CC
3350
 
  shift
3351
 
  if test $# != 0; then
3352
 
    # We chose a different compiler from the bogus one.
3353
 
    # However, it has the same basename, so the bogon will be chosen
3354
 
    # first if we set CC to just the basename; use the full file name.
3355
 
    shift
3356
 
    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
3357
 
  fi
3358
 
fi
3359
 
fi
3360
 
fi
3361
 
CC=$ac_cv_prog_CC
3362
 
if test -n "$CC"; then
3363
 
  { $as_echo "$as_me:$LINENO: result: $CC" >&5
3364
 
$as_echo "$CC" >&6; }
3365
 
else
3366
 
  { $as_echo "$as_me:$LINENO: result: no" >&5
3367
 
$as_echo "no" >&6; }
3368
 
fi
3369
 
 
3370
 
 
3371
 
fi
3372
 
if test -z "$CC"; then
3373
 
  if test -n "$ac_tool_prefix"; then
3374
 
  for ac_prog in cl.exe
3375
 
  do
3376
 
    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
3377
 
set dummy $ac_tool_prefix$ac_prog; ac_word=$2
3378
 
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3379
 
$as_echo_n "checking for $ac_word... " >&6; }
3380
 
if test "${ac_cv_prog_CC+set}" = set; then
3381
 
  $as_echo_n "(cached) " >&6
3382
 
else
3383
 
  if test -n "$CC"; then
3384
 
  ac_cv_prog_CC="$CC" # Let the user override the test.
3385
 
else
3386
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3387
 
for as_dir in $PATH
3388
 
do
3389
 
  IFS=$as_save_IFS
3390
 
  test -z "$as_dir" && as_dir=.
3391
 
  for ac_exec_ext in '' $ac_executable_extensions; do
3392
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3393
 
    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
3394
 
    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3395
 
    break 2
3396
 
  fi
3397
 
done
3398
 
done
3399
 
IFS=$as_save_IFS
3400
 
 
3401
 
fi
3402
 
fi
3403
 
CC=$ac_cv_prog_CC
3404
 
if test -n "$CC"; then
3405
 
  { $as_echo "$as_me:$LINENO: result: $CC" >&5
3406
 
$as_echo "$CC" >&6; }
3407
 
else
3408
 
  { $as_echo "$as_me:$LINENO: result: no" >&5
3409
 
$as_echo "no" >&6; }
3410
 
fi
3411
 
 
3412
 
 
3413
 
    test -n "$CC" && break
3414
 
  done
3415
 
fi
3416
 
if test -z "$CC"; then
3417
 
  ac_ct_CC=$CC
3418
 
  for ac_prog in cl.exe
3419
 
do
3420
 
  # Extract the first word of "$ac_prog", so it can be a program name with args.
3421
 
set dummy $ac_prog; ac_word=$2
3422
 
{ $as_echo "$as_me:$LINENO: checking for $ac_word" >&5
3423
 
$as_echo_n "checking for $ac_word... " >&6; }
3424
 
if test "${ac_cv_prog_ac_ct_CC+set}" = set; then
3425
 
  $as_echo_n "(cached) " >&6
3426
 
else
3427
 
  if test -n "$ac_ct_CC"; then
3428
 
  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
3429
 
else
3430
 
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
3431
 
for as_dir in $PATH
3432
 
do
3433
 
  IFS=$as_save_IFS
3434
 
  test -z "$as_dir" && as_dir=.
3435
 
  for ac_exec_ext in '' $ac_executable_extensions; do
3436
 
  if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
3437
 
    ac_cv_prog_ac_ct_CC="$ac_prog"
3438
 
    $as_echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5
3439
 
    break 2
3440
 
  fi
3441
 
done
3442
 
done
3443
 
IFS=$as_save_IFS
3444
 
 
3445
 
fi
3446
 
fi
3447
 
ac_ct_CC=$ac_cv_prog_ac_ct_CC
3448
 
if test -n "$ac_ct_CC"; then
3449
 
  { $as_echo "$as_me:$LINENO: result: $ac_ct_CC" >&5
3450
 
$as_echo "$ac_ct_CC" >&6; }
3451
 
else
3452
 
  { $as_echo "$as_me:$LINENO: result: no" >&5
3453
 
$as_echo "no" >&6; }
3454
 
fi
3455
 
 
3456
 
 
3457
 
  test -n "$ac_ct_CC" && break
3458
 
done
3459
 
 
3460
 
  if test "x$ac_ct_CC" = x; then
3461
 
    CC=""
3462
 
  else
3463
 
    case $cross_compiling:$ac_tool_warned in
3464
 
yes:)
3465
 
{ $as_echo "$as_me:$LINENO: WARNING: using cross tools not prefixed with host triplet" >&5
3466
 
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
3467
 
ac_tool_warned=yes ;;
3468
 
esac
3469
 
    CC=$ac_ct_CC
3470
 
  fi
3471
 
fi
3472
 
 
3473
 
fi
3474
 
 
3475
 
 
3476
 
test -z "$CC" && { { $as_echo "$as_me:$LINENO: error: in \`$ac_pwd':" >&5
3477
 
$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
3478
 
{ { $as_echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH
3479
 
See \`config.log' for more details." >&5
3480
 
$as_echo "$as_me: error: no acceptable C compiler found in \$PATH
3481
 
See \`config.log' for more details." >&2;}
3482
 
   { (exit 1); exit 1; }; }; }
3483
 
 
3484
 
# Provide some information about the compiler.
3485
 
$as_echo "$as_me:$LINENO: checking for C compiler version" >&5
3486
 
set X $ac_compile
3487
 
ac_compiler=$2
3488
 
{ (ac_try="$ac_compiler --version >&5"
3489
 
case "(($ac_try" in
3490
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3491
 
  *) ac_try_echo=$ac_try;;
3492
 
esac
3493
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3494
 
$as_echo "$ac_try_echo") >&5
3495
 
  (eval "$ac_compiler --version >&5") 2>&5
3496
 
  ac_status=$?
3497
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3498
 
  (exit $ac_status); }
3499
 
{ (ac_try="$ac_compiler -v >&5"
3500
 
case "(($ac_try" in
3501
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3502
 
  *) ac_try_echo=$ac_try;;
3503
 
esac
3504
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3505
 
$as_echo "$ac_try_echo") >&5
3506
 
  (eval "$ac_compiler -v >&5") 2>&5
3507
 
  ac_status=$?
3508
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3509
 
  (exit $ac_status); }
3510
 
{ (ac_try="$ac_compiler -V >&5"
3511
 
case "(($ac_try" in
3512
 
  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
3513
 
  *) ac_try_echo=$ac_try;;
3514
 
esac
3515
 
eval ac_try_echo="\"\$as_me:$LINENO: $ac_try_echo\""
3516
 
$as_echo "$ac_try_echo") >&5
3517
 
  (eval "$ac_compiler -V >&5") 2>&5
3518
 
  ac_status=$?
3519
 
  $as_echo "$as_me:$LINENO: \$? = $ac_status" >&5
3520
 
  (exit $ac_status); }
3521
 
 
3522
2969
{ $as_echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5
3523
2970
$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
3524
2971
if test "${ac_cv_c_compiler_gnu+set}" = set; then
3857
3304
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
3858
3305
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
3859
3306
ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
3307
DEPDIR="${am__leading_dot}deps"
 
3308
 
 
3309
ac_config_commands="$ac_config_commands depfiles"
 
3310
 
 
3311
 
 
3312
am_make=${MAKE-make}
 
3313
cat > confinc << 'END'
 
3314
am__doit:
 
3315
        @echo done
 
3316
.PHONY: am__doit
 
3317
END
 
3318
# If we don't find an include directive, just comment out the code.
 
3319
{ $as_echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5
 
3320
$as_echo_n "checking for style of include used by $am_make... " >&6; }
 
3321
am__include="#"
 
3322
am__quote=
 
3323
_am_result=none
 
3324
# First try GNU make style include.
 
3325
echo "include confinc" > confmf
 
3326
# We grep out `Entering directory' and `Leaving directory'
 
3327
# messages which can occur if `w' ends up in MAKEFLAGS.
 
3328
# In particular we don't look at `^make:' because GNU make might
 
3329
# be invoked under some other name (usually "gmake"), in which
 
3330
# case it prints its new name instead of `make'.
 
3331
if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then
 
3332
   am__include=include
 
3333
   am__quote=
 
3334
   _am_result=GNU
 
3335
fi
 
3336
# Now try BSD make style include.
 
3337
if test "$am__include" = "#"; then
 
3338
   echo '.include "confinc"' > confmf
 
3339
   if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then
 
3340
      am__include=.include
 
3341
      am__quote="\""
 
3342
      _am_result=BSD
 
3343
   fi
 
3344
fi
 
3345
 
 
3346
 
 
3347
{ $as_echo "$as_me:$LINENO: result: $_am_result" >&5
 
3348
$as_echo "$_am_result" >&6; }
 
3349
rm -f confinc confmf
 
3350
 
 
3351
# Check whether --enable-dependency-tracking was given.
 
3352
if test "${enable_dependency_tracking+set}" = set; then
 
3353
  enableval=$enable_dependency_tracking;
 
3354
fi
 
3355
 
 
3356
if test "x$enable_dependency_tracking" != xno; then
 
3357
  am_depcomp="$ac_aux_dir/depcomp"
 
3358
  AMDEPBACKSLASH='\'
 
3359
fi
 
3360
 if test "x$enable_dependency_tracking" != xno; then
 
3361
  AMDEP_TRUE=
 
3362
  AMDEP_FALSE='#'
 
3363
else
 
3364
  AMDEP_TRUE='#'
 
3365
  AMDEP_FALSE=
 
3366
fi
 
3367
 
 
3368
 
3860
3369
 
3861
3370
depcc="$CC"   am_compiler_list=
3862
3371
 
3966
3475
fi
3967
3476
 
3968
3477
 
3969
 
#AC_PROG_CPP
3970
3478
{ $as_echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5
3971
3479
$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
3972
3480
set x ${MAKE-make}
5908
5416
cat confdefs.h >>conftest.$ac_ext
5909
5417
cat >>conftest.$ac_ext <<_ACEOF
5910
5418
/* end confdefs.h.  */
5911
 
#include <linux/user.h>
 
5419
#include <sys/user.h>
5912
5420
 
5913
5421
int
5914
5422
main ()
5949
5457
cat confdefs.h >>conftest.$ac_ext
5950
5458
cat >>conftest.$ac_ext <<_ACEOF
5951
5459
/* end confdefs.h.  */
5952
 
#include <linux/user.h>
 
5460
#include <sys/user.h>
5953
5461
 
5954
5462
int
5955
5463
main ()
6013
5521
cat confdefs.h >>conftest.$ac_ext
6014
5522
cat >>conftest.$ac_ext <<_ACEOF
6015
5523
/* end confdefs.h.  */
6016
 
#include <linux/user.h>
 
5524
#include <sys/user.h>
6017
5525
 
6018
5526
int
6019
5527
main ()
6054
5562
cat confdefs.h >>conftest.$ac_ext
6055
5563
cat >>conftest.$ac_ext <<_ACEOF
6056
5564
/* end confdefs.h.  */
6057
 
#include <linux/user.h>
 
5565
#include <sys/user.h>
6058
5566
 
6059
5567
int
6060
5568
main ()
6118
5626
cat confdefs.h >>conftest.$ac_ext
6119
5627
cat >>conftest.$ac_ext <<_ACEOF
6120
5628
/* end confdefs.h.  */
6121
 
#include <linux/user.h>
 
5629
#include <sys/user.h>
6122
5630
 
6123
5631
int
6124
5632
main ()
6159
5667
cat confdefs.h >>conftest.$ac_ext
6160
5668
cat >>conftest.$ac_ext <<_ACEOF
6161
5669
/* end confdefs.h.  */
6162
 
#include <linux/user.h>
 
5670
#include <sys/user.h>
6163
5671
 
6164
5672
int
6165
5673
main ()
6223
5731
cat confdefs.h >>conftest.$ac_ext
6224
5732
cat >>conftest.$ac_ext <<_ACEOF
6225
5733
/* end confdefs.h.  */
6226
 
#include <linux/user.h>
 
5734
#include <sys/user.h>
6227
5735
 
6228
5736
int
6229
5737
main ()
6264
5772
cat confdefs.h >>conftest.$ac_ext
6265
5773
cat >>conftest.$ac_ext <<_ACEOF
6266
5774
/* end confdefs.h.  */
6267
 
#include <linux/user.h>
 
5775
#include <sys/user.h>
6268
5776
 
6269
5777
int
6270
5778
main ()
6328
5836
cat confdefs.h >>conftest.$ac_ext
6329
5837
cat >>conftest.$ac_ext <<_ACEOF
6330
5838
/* end confdefs.h.  */
6331
 
#include <linux/user.h>
 
5839
#include <sys/user.h>
6332
5840
 
6333
5841
int
6334
5842
main ()
6369
5877
cat confdefs.h >>conftest.$ac_ext
6370
5878
cat >>conftest.$ac_ext <<_ACEOF
6371
5879
/* end confdefs.h.  */
6372
 
#include <linux/user.h>
 
5880
#include <sys/user.h>
6373
5881
 
6374
5882
int
6375
5883
main ()
6433
5941
cat confdefs.h >>conftest.$ac_ext
6434
5942
cat >>conftest.$ac_ext <<_ACEOF
6435
5943
/* end confdefs.h.  */
6436
 
#include <linux/user.h>
 
5944
#include <sys/user.h>
6437
5945
 
6438
5946
int
6439
5947
main ()
6474
5982
cat confdefs.h >>conftest.$ac_ext
6475
5983
cat >>conftest.$ac_ext <<_ACEOF
6476
5984
/* end confdefs.h.  */
6477
 
#include <linux/user.h>
 
5985
#include <sys/user.h>
6478
5986
 
6479
5987
int
6480
5988
main ()
6538
6046
cat confdefs.h >>conftest.$ac_ext
6539
6047
cat >>conftest.$ac_ext <<_ACEOF
6540
6048
/* end confdefs.h.  */
6541
 
#include <linux/user.h>
 
6049
#include <sys/user.h>
6542
6050
 
6543
6051
int
6544
6052
main ()
6579
6087
cat confdefs.h >>conftest.$ac_ext
6580
6088
cat >>conftest.$ac_ext <<_ACEOF
6581
6089
/* end confdefs.h.  */
6582
 
#include <linux/user.h>
 
6090
#include <sys/user.h>
6583
6091
 
6584
6092
int
6585
6093
main ()
6643
6151
cat confdefs.h >>conftest.$ac_ext
6644
6152
cat >>conftest.$ac_ext <<_ACEOF
6645
6153
/* end confdefs.h.  */
6646
 
#include <linux/user.h>
 
6154
#include <sys/user.h>
6647
6155
 
6648
6156
int
6649
6157
main ()
6684
6192
cat confdefs.h >>conftest.$ac_ext
6685
6193
cat >>conftest.$ac_ext <<_ACEOF
6686
6194
/* end confdefs.h.  */
6687
 
#include <linux/user.h>
 
6195
#include <sys/user.h>
6688
6196
 
6689
6197
int
6690
6198
main ()
6748
6256
cat confdefs.h >>conftest.$ac_ext
6749
6257
cat >>conftest.$ac_ext <<_ACEOF
6750
6258
/* end confdefs.h.  */
6751
 
#include <linux/user.h>
 
6259
#include <sys/user.h>
6752
6260
 
6753
6261
int
6754
6262
main ()
6789
6297
cat confdefs.h >>conftest.$ac_ext
6790
6298
cat >>conftest.$ac_ext <<_ACEOF
6791
6299
/* end confdefs.h.  */
6792
 
#include <linux/user.h>
 
6300
#include <sys/user.h>
6793
6301
 
6794
6302
int
6795
6303
main ()
6853
6361
cat confdefs.h >>conftest.$ac_ext
6854
6362
cat >>conftest.$ac_ext <<_ACEOF
6855
6363
/* end confdefs.h.  */
6856
 
#include <linux/user.h>
 
6364
#include <sys/user.h>
6857
6365
 
6858
6366
int
6859
6367
main ()
6894
6402
cat confdefs.h >>conftest.$ac_ext
6895
6403
cat >>conftest.$ac_ext <<_ACEOF
6896
6404
/* end confdefs.h.  */
6897
 
#include <linux/user.h>
 
6405
#include <sys/user.h>
6898
6406
 
6899
6407
int
6900
6408
main ()
10928
10436
Usually this means the macro was only invoked conditionally." >&2;}
10929
10437
   { (exit 1); exit 1; }; }
10930
10438
fi
10931
 
if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then
10932
 
  { { $as_echo "$as_me:$LINENO: error: conditional \"am__fastdepCXX\" was never defined.
10933
 
Usually this means the macro was only invoked conditionally." >&5
10934
 
$as_echo "$as_me: error: conditional \"am__fastdepCXX\" was never defined.
10935
 
Usually this means the macro was only invoked conditionally." >&2;}
10936
 
   { (exit 1); exit 1; }; }
10937
 
fi
10938
10439
if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
10939
10440
  { { $as_echo "$as_me:$LINENO: error: conditional \"am__fastdepCC\" was never defined.
10940
10441
Usually this means the macro was only invoked conditionally." >&5
11285
10786
# report actual input values of CONFIG_FILES etc. instead of their
11286
10787
# values after options handling.
11287
10788
ac_log="
11288
 
This file was extended by psmisc $as_me 22.7, which was
 
10789
This file was extended by psmisc $as_me 22.8, which was
11289
10790
generated by GNU Autoconf 2.63.  Invocation command line was
11290
10791
 
11291
10792
  CONFIG_FILES    = $CONFIG_FILES
11348
10849
_ACEOF
11349
10850
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
11350
10851
ac_cs_version="\\
11351
 
psmisc config.status 22.7
 
10852
psmisc config.status 22.8
11352
10853
configured by $0, generated by GNU Autoconf 2.63,
11353
10854
  with options \\"`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`\\"
11354
10855