masqmail: 08114f7dcc23 configure

315 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 INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA CYGPATH_W PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO AMTAR install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM AWK SET_MAKE am__leading_dot CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE am__fastdepCC_TRUE am__fastdepCC_FALSE CPP EGREP RANLIB ac_ct_RANLIB PKG_CONFIG ac_pt_PKG_CONFIG GLIB_CFLAGS GLIB_LIBS RESOLV_LIBS with_user with_group BASE64_LIBS MD5_LIBS has_ident IDENT_LIBS LOCKFILE_LIBS USE_LIBLOCKFILE with_logdir with_spooldir with_confdir LIBOBJS LTLIBOBJS'

316 ac_subst_files=''

317

318 # Initialize some variables set by options.

319 ac_init_help=

320 ac_init_version=false

321 # The variables have the same names as the options, with

322 # dashes changed to underlines.

323 cache_file=/dev/null

324 exec_prefix=NONE

325 no_create=

326 no_recursion=

327 prefix=NONE

328 program_prefix=NONE

329 program_suffix=NONE

330 program_transform_name=s,x,x,

331 silent=

332 site=

333 srcdir=

334 verbose=

335 x_includes=NONE

336 x_libraries=NONE

337

338 # Installation directory options.

339 # These are left unexpanded so users can "make install exec_prefix=/foo"

340 # and all the variables that are supposed to be based on exec_prefix

341 # by default will actually change.

342 # Use braces instead of parens because sh, perl, etc. also accept them.

343 bindir='${exec_prefix}/bin'

344 sbindir='${exec_prefix}/sbin'

345 libexecdir='${exec_prefix}/libexec'

346 datadir='${prefix}/share'

347 sysconfdir='${prefix}/etc'

348 sharedstatedir='${prefix}/com'

349 localstatedir='${prefix}/var'

350 libdir='${exec_prefix}/lib'

351 includedir='${prefix}/include'

352 oldincludedir='/usr/include'

353 infodir='${prefix}/info'

354 mandir='${prefix}/man'

355

356 ac_prev=

357 for ac_option

358 do

359 # If the previous option needs an argument, assign it.

360 if test -n "$ac_prev"; then

361 eval "$ac_prev=\$ac_option"

362 ac_prev=

363 continue

364 fi

365

366 ac_optarg=`expr "x$ac_option" : 'x[^=]*=$.*$'`

367

368 # Accept the important Cygnus configure options, so we can diagnose typos.

369

370 case $ac_option in

371

373 ac_prev=bindir ;;

375 bindir=$ac_optarg ;;

376

377 -build | --build | --buil | --bui | --bu)

378 ac_prev=build_alias ;;

379 -build=* | --build=* | --buil=* | --bui=* | --bu=*)

380 build_alias=$ac_optarg ;;

381

382 -cache-file | --cache-file | --cache-fil | --cache-fi \

383 | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)

384 ac_prev=cache_file ;;

385 -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \

386 | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)

387 cache_file=$ac_optarg ;;

388

389 --config-cache | -C)

390 cache_file=config.cache ;;

391

393 ac_prev=datadir ;;

395 | --da=*)

396 datadir=$ac_optarg ;;

397

398 -disable-* | --disable-*)

399 ac_feature=`expr "x$ac_option" : 'x-*disable-$.*$'`

400 # Reject names that are not valid shell variable names.

401 expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&

402 { echo "$as_me: error: invalid feature name: $ac_feature" >&2

403 { (exit 1); exit 1; }; }

404 ac_feature=`echo $ac_feature | sed 's/-/_/g'`

405 eval "enable_$ac_feature=no" ;;

406

407 -enable-* | --enable-*)

408 ac_feature=`expr "x$ac_option" : 'x-*enable-$[^=]*$'`

409 # Reject names that are not valid shell variable names.

410 expr "x$ac_feature" : ".*[^-_$as_cr_alnum]" >/dev/null &&

411 { echo "$as_me: error: invalid feature name: $ac_feature" >&2

412 { (exit 1); exit 1; }; }

413 ac_feature=`echo $ac_feature | sed 's/-/_/g'`

414 case $ac_option in

415 *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;

416 *) ac_optarg=yes ;;

417 esac

418 eval "enable_$ac_feature='$ac_optarg'" ;;

419

420 -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \

422 | --exec | --exe | --ex)

423 ac_prev=exec_prefix ;;

424 -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \

426 | --exec=* | --exe=* | --ex=*)

427 exec_prefix=$ac_optarg ;;

428

429 -gas | --gas | --ga | --g)

430 # Obsolete; use --with-gas.

431 with_gas=yes ;;

432

433 -help | --help | --hel | --he | -h)

434 ac_init_help=long ;;

435 -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)

436 ac_init_help=recursive ;;

437 -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)

438 ac_init_help=short ;;

439

440 -host | --host | --hos | --ho)

441 ac_prev=host_alias ;;

442 -host=* | --host=* | --hos=* | --ho=*)

443 host_alias=$ac_optarg ;;

444

445 -includedir | --includedir | --includedi | --included | --include \

446 | --includ | --inclu | --incl | --inc)

447 ac_prev=includedir ;;

448 -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \

449 | --includ=* | --inclu=* | --incl=* | --inc=*)

450 includedir=$ac_optarg ;;

451

453 ac_prev=infodir ;;

455 infodir=$ac_optarg ;;

456

457 -libdir | --libdir | --libdi | --libd)

458 ac_prev=libdir ;;

459 -libdir=* | --libdir=* | --libdi=* | --libd=*)

460 libdir=$ac_optarg ;;

461

462 -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \

463 | --libexe | --libex | --libe)

464 ac_prev=libexecdir ;;

465 -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \

466 | --libexe=* | --libex=* | --libe=*)

467 libexecdir=$ac_optarg ;;

468

469 -localstatedir | --localstatedir | --localstatedi | --localstated \

470 | --localstate | --localstat | --localsta | --localst \

471 | --locals | --local | --loca | --loc | --lo)

472 ac_prev=localstatedir ;;

473 -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \

474 | --localstate=* | --localstat=* | --localsta=* | --localst=* \

475 | --locals=* | --local=* | --loca=* | --loc=* | --lo=*)

476 localstatedir=$ac_optarg ;;

477

478 -mandir | --mandir | --mandi | --mand | --man | --ma | --m)

479 ac_prev=mandir ;;

480 -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)

481 mandir=$ac_optarg ;;

482

483 -nfp | --nfp | --nf)

484 # Obsolete; use --without-fp.

485 with_fp=no ;;

486

487 -no-create | --no-create | --no-creat | --no-crea | --no-cre \

488 | --no-cr | --no-c | -n)

489 no_create=yes ;;

490

491 -no-recursion | --no-recursion | --no-recursio | --no-recursi \

493 no_recursion=yes ;;

494

495 -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \

497 | --oldin | --oldi | --old | --ol | --o)

498 ac_prev=oldincludedir ;;

499 -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \

501 | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)

502 oldincludedir=$ac_optarg ;;

503

504 -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)

505 ac_prev=prefix ;;

506 -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)

507 prefix=$ac_optarg ;;

508

509 -program-prefix | --program-prefix | --program-prefi | --program-pref \

510 | --program-pre | --program-pr | --program-p)

511 ac_prev=program_prefix ;;

512 -program-prefix=* | --program-prefix=* | --program-prefi=* \

513 | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)

514 program_prefix=$ac_optarg ;;

515

516 -program-suffix | --program-suffix | --program-suffi | --program-suff \

517 | --program-suf | --program-su | --program-s)

518 ac_prev=program_suffix ;;

519 -program-suffix=* | --program-suffix=* | --program-suffi=* \

520 | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)

521 program_suffix=$ac_optarg ;;

522

523 -program-transform-name | --program-transform-name \

524 | --program-transform-nam | --program-transform-na \

525 | --program-transform-n | --program-transform- \

526 | --program-transform | --program-transfor \

527 | --program-transfo | --program-transf \

528 | --program-trans | --program-tran \

529 | --progr-tra | --program-tr | --program-t)

530 ac_prev=program_transform_name ;;

531 -program-transform-name=* | --program-transform-name=* \

532 | --program-transform-nam=* | --program-transform-na=* \

533 | --program-transform-n=* | --program-transform-=* \

534 | --program-transform=* | --program-transfor=* \

535 | --program-transfo=* | --program-transf=* \

536 | --program-trans=* | --program-tran=* \

537 | --progr-tra=* | --program-tr=* | --program-t=*)

538 program_transform_name=$ac_optarg ;;

539

540 -q | -quiet | --quiet | --quie | --qui | --qu | --q \

542 silent=yes ;;

543

545 ac_prev=sbindir ;;

546 -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \

547 | --sbi=* | --sb=*)

548 sbindir=$ac_optarg ;;

549

550 -sharedstatedir | --sharedstatedir | --sharedstatedi \

551 | --sharedstated | --sharedstate | --sharedstat | --sharedsta \

553 | --sha | --sh)

554 ac_prev=sharedstatedir ;;

555 -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \

556 | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \

558 | --sha=* | --sh=*)

559 sharedstatedir=$ac_optarg ;;

560

561 -site | --site | --sit)

562 ac_prev=site ;;

563 -site=* | --site=* | --sit=*)

564 site=$ac_optarg ;;

565

567 ac_prev=srcdir ;;

569 srcdir=$ac_optarg ;;

570

571 -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \

572 | --syscon | --sysco | --sysc | --sys | --sy)

573 ac_prev=sysconfdir ;;

574 -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \

575 | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)

576 sysconfdir=$ac_optarg ;;

577

578 -target | --target | --targe | --targ | --tar | --ta | --t)

579 ac_prev=target_alias ;;

580 -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)

581 target_alias=$ac_optarg ;;

582

584 verbose=yes ;;

585

587 ac_init_version=: ;;

588

589 -with-* | --with-*)

590 ac_package=`expr "x$ac_option" : 'x-*with-$[^=]*$'`

591 # Reject names that are not valid shell variable names.

592 expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&

593 { echo "$as_me: error: invalid package name: $ac_package" >&2

594 { (exit 1); exit 1; }; }

595 ac_package=`echo $ac_package| sed 's/-/_/g'`

596 case $ac_option in

597 *=*) ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`;;

598 *) ac_optarg=yes ;;

599 esac

600 eval "with_$ac_package='$ac_optarg'" ;;

601

602 -without-* | --without-*)

603 ac_package=`expr "x$ac_option" : 'x-*without-$.*$'`

604 # Reject names that are not valid shell variable names.

605 expr "x$ac_package" : ".*[^-_$as_cr_alnum]" >/dev/null &&

606 { echo "$as_me: error: invalid package name: $ac_package" >&2

607 { (exit 1); exit 1; }; }

608 ac_package=`echo $ac_package | sed 's/-/_/g'`

609 eval "with_$ac_package=no" ;;

610

611 --x)

612 # Obsolete; use --with-x.

613 with_x=yes ;;

614

615 -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \

616 | --x-incl | --x-inc | --x-in | --x-i)

617 ac_prev=x_includes ;;

618 -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \

619 | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)

620 x_includes=$ac_optarg ;;

621

622 -x-libraries | --x-libraries | --x-librarie | --x-librari \

623 | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)

624 ac_prev=x_libraries ;;

625 -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \

626 | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)

627 x_libraries=$ac_optarg ;;

628

629 -*) { echo "$as_me: error: unrecognized option: $ac_option

630 Try \`$0 --help' for more information." >&2

631 { (exit 1); exit 1; }; }

632 ;;

633

634 *=*)

635 ac_envvar=`expr "x$ac_option" : 'x$[^=]*$='`

636 # Reject names that are not valid shell variable names.

637 expr "x$ac_envvar" : ".*[^_$as_cr_alnum]" >/dev/null &&

638 { echo "$as_me: error: invalid variable name: $ac_envvar" >&2

639 { (exit 1); exit 1; }; }

640 ac_optarg=`echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"`

641 eval "$ac_envvar='$ac_optarg'"

642 export $ac_envvar ;;

643

644 *)

645 # FIXME: should be removed in autoconf 3.0.

646 echo "$as_me: WARNING: you should use --build, --host, --target" >&2

647 expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&

648 echo "$as_me: WARNING: invalid host type: $ac_option" >&2

649 : ${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}

650 ;;

651

652 esac

653 done

654

655 if test -n "$ac_prev"; then

656 ac_option=--`echo $ac_prev | sed 's/_/-/g'`

657 { echo "$as_me: error: missing argument to $ac_option" >&2

658 { (exit 1); exit 1; }; }

659 fi

660

661 # Be sure to have absolute paths.

662 for ac_var in exec_prefix prefix

663 do

664 eval ac_val=$`echo $ac_var`

665 case $ac_val in

666 [\\/$]* | ?:[\\/]* | NONE | '' ) ;;

667 *) { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2

668 { (exit 1); exit 1; }; };;

669 esac

670 done

671

672 # Be sure to have absolute paths.

673 for ac_var in bindir sbindir libexecdir datadir sysconfdir sharedstatedir \

674 localstatedir libdir includedir oldincludedir infodir mandir

675 do

676 eval ac_val=$`echo $ac_var`

677 case $ac_val in

678 [\\/$]* | ?:[\\/]* ) ;;

679 *) { echo "$as_me: error: expected an absolute directory name for --$ac_var: $ac_val" >&2

680 { (exit 1); exit 1; }; };;

681 esac

682 done

683

684 # There might be people who depend on the old broken behavior: `$host'

685 # used to hold the argument of --host etc.

686 # FIXME: To remove some day.

687 build=$build_alias

688 host=$host_alias

689 target=$target_alias

690

691 # FIXME: To remove some day.

692 if test "x$host_alias" != x; then

693 if test "x$build_alias" = x; then

694 cross_compiling=maybe

695 echo "$as_me: WARNING: If you wanted to set the --build type, don't use --host.

696 If a cross compiler is detected then cross compile mode will be used." >&2

697 elif test "x$build_alias" != "x$host_alias"; then

698 cross_compiling=yes

699 fi

700 fi

701

702 ac_tool_prefix=

703 test -n "$host_alias" && ac_tool_prefix=$host_alias-

704

705 test "$silent" = yes && exec 6>/dev/null

706

707

708 # Find the source files, if location was not specified.

709 if test -z "$srcdir"; then

710 ac_srcdir_defaulted=yes

711 # Try the directory containing this script, then its parent.

712 ac_confdir=`(dirname "$0") 2>/dev/null ||

713 $as_expr X"$0" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

714 X"$0" : 'X$//$[^/]' \| \

715 X"$0" : 'X$//$$' \| \

716 X"$0" : 'X$/$' \| \

717 . : '$.$' 2>/dev/null ||

718 echo X"$0" |

719 sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

720 /^X$\/\/$[^/].*/{ s//\1/; q; }

721 /^X$\/\/$$/{ s//\1/; q; }

722 /^X$\/$.*/{ s//\1/; q; }

723 s/.*/./; q'`

724 srcdir=$ac_confdir

725 if test ! -r $srcdir/$ac_unique_file; then

726 srcdir=..

727 fi

728 else

729 ac_srcdir_defaulted=no

730 fi

731 if test ! -r $srcdir/$ac_unique_file; then

732 if test "$ac_srcdir_defaulted" = yes; then

733 { echo "$as_me: error: cannot find sources ($ac_unique_file) in $ac_confdir or .." >&2

734 { (exit 1); exit 1; }; }

735 else

736 { echo "$as_me: error: cannot find sources ($ac_unique_file) in $srcdir" >&2

737 { (exit 1); exit 1; }; }

738 fi

739 fi

740 (cd $srcdir && test -r ./$ac_unique_file) 2>/dev/null ||

741 { echo "$as_me: error: sources are in $srcdir, but \`cd $srcdir' does not work" >&2

742 { (exit 1); exit 1; }; }

743 srcdir=`echo "$srcdir" | sed 's%$[^\\/]$[\\/]*$%\1%'`

744 ac_env_build_alias_set=${build_alias+set}

745 ac_env_build_alias_value=$build_alias

746 ac_cv_env_build_alias_set=${build_alias+set}

747 ac_cv_env_build_alias_value=$build_alias

748 ac_env_host_alias_set=${host_alias+set}

749 ac_env_host_alias_value=$host_alias

750 ac_cv_env_host_alias_set=${host_alias+set}

751 ac_cv_env_host_alias_value=$host_alias

752 ac_env_target_alias_set=${target_alias+set}

753 ac_env_target_alias_value=$target_alias

754 ac_cv_env_target_alias_set=${target_alias+set}

755 ac_cv_env_target_alias_value=$target_alias

756 ac_env_CC_set=${CC+set}

757 ac_env_CC_value=$CC

758 ac_cv_env_CC_set=${CC+set}

759 ac_cv_env_CC_value=$CC

760 ac_env_CFLAGS_set=${CFLAGS+set}

761 ac_env_CFLAGS_value=$CFLAGS

762 ac_cv_env_CFLAGS_set=${CFLAGS+set}

763 ac_cv_env_CFLAGS_value=$CFLAGS

764 ac_env_LDFLAGS_set=${LDFLAGS+set}

765 ac_env_LDFLAGS_value=$LDFLAGS

766 ac_cv_env_LDFLAGS_set=${LDFLAGS+set}

767 ac_cv_env_LDFLAGS_value=$LDFLAGS

768 ac_env_CPPFLAGS_set=${CPPFLAGS+set}

769 ac_env_CPPFLAGS_value=$CPPFLAGS

770 ac_cv_env_CPPFLAGS_set=${CPPFLAGS+set}

771 ac_cv_env_CPPFLAGS_value=$CPPFLAGS

772 ac_env_CPP_set=${CPP+set}

773 ac_env_CPP_value=$CPP

774 ac_cv_env_CPP_set=${CPP+set}

775 ac_cv_env_CPP_value=$CPP

776 ac_env_PKG_CONFIG_set=${PKG_CONFIG+set}

777 ac_env_PKG_CONFIG_value=$PKG_CONFIG

778 ac_cv_env_PKG_CONFIG_set=${PKG_CONFIG+set}

779 ac_cv_env_PKG_CONFIG_value=$PKG_CONFIG

780 ac_env_GLIB_CFLAGS_set=${GLIB_CFLAGS+set}

781 ac_env_GLIB_CFLAGS_value=$GLIB_CFLAGS

782 ac_cv_env_GLIB_CFLAGS_set=${GLIB_CFLAGS+set}

783 ac_cv_env_GLIB_CFLAGS_value=$GLIB_CFLAGS

784 ac_env_GLIB_LIBS_set=${GLIB_LIBS+set}

785 ac_env_GLIB_LIBS_value=$GLIB_LIBS

786 ac_cv_env_GLIB_LIBS_set=${GLIB_LIBS+set}

787 ac_cv_env_GLIB_LIBS_value=$GLIB_LIBS

788

789 #

790 # Report the --help message.

791 #

792 if test "$ac_init_help" = "long"; then

793 # Omit some internal or obsolete options to make the list less imposing.

794 # This message is too long to be a string in the A/UX 3.1 sh.

795 cat <<_ACEOF

796 \`configure' configures masqmail 0.2.21 to adapt to many kinds of systems.

797

798 Usage: $0 [OPTION]... [VAR=VALUE]...

799

800 To assign environment variables (e.g., CC, CFLAGS...), specify them as

801 VAR=VALUE. See below for descriptions of some of the useful variables.

802

803 Defaults for the options are specified in brackets.

804

805 Configuration:

806 -h, --help display this help and exit

807 --help=short display options specific to this package

808 --help=recursive display the short help of all the included packages

809 -V, --version display version information and exit

810 -q, --quiet, --silent do not print \`checking...' messages

811 --cache-file=FILE cache test results in FILE [disabled]

812 -C, --config-cache alias for \`--cache-file=config.cache'

813 -n, --no-create do not create output files

814 --srcdir=DIR find the sources in DIR [configure dir or \`..']

815

816 _ACEOF

817

818 cat <<_ACEOF

819 Installation directories:

820 --prefix=PREFIX install architecture-independent files in PREFIX

821 [$ac_default_prefix]

822 --exec-prefix=EPREFIX install architecture-dependent files in EPREFIX

823 [PREFIX]

824

825 By default, \`make install' will install all the files in

826 \`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc. You can specify

827 an installation prefix other than \`$ac_default_prefix' using \`--prefix',

828 for instance \`--prefix=\$HOME'.

829

830 For better control, use the options below.

831

832 Fine tuning of the installation directories:

833 --bindir=DIR user executables [EPREFIX/bin]

834 --sbindir=DIR system admin executables [EPREFIX/sbin]

835 --libexecdir=DIR program executables [EPREFIX/libexec]

836 --datadir=DIR read-only architecture-independent data [PREFIX/share]

837 --sysconfdir=DIR read-only single-machine data [PREFIX/etc]

838 --sharedstatedir=DIR modifiable architecture-independent data [PREFIX/com]

839 --localstatedir=DIR modifiable single-machine data [PREFIX/var]

840 --libdir=DIR object code libraries [EPREFIX/lib]

841 --includedir=DIR C header files [PREFIX/include]

842 --oldincludedir=DIR C header files for non-gcc [/usr/include]

843 --infodir=DIR info documentation [PREFIX/info]

844 --mandir=DIR man documentation [PREFIX/man]

845 _ACEOF

846

847 cat <<\_ACEOF

848

849 Program names:

850 --program-prefix=PREFIX prepend PREFIX to installed program names

851 --program-suffix=SUFFIX append SUFFIX to installed program names

852 --program-transform-name=PROGRAM run sed PROGRAM on installed program names

853 _ACEOF

854 fi

855

856 if test -n "$ac_init_help"; then

857 case $ac_init_help in

858 short | recursive ) echo "Configuration of masqmail 0.2.21:";;

859 esac

860 cat <<\_ACEOF

861

862 Optional Features:

863 --disable-FEATURE do not include FEATURE (same as --enable-FEATURE=no)

864 --enable-FEATURE[=ARG] include FEATURE [ARG=yes]

865 --disable-dependency-tracking Speeds up one-time builds

866 --enable-dependency-tracking Do not reject slow dependency extractors

867 --disable-resolver disable resolver support

868 --disable-debug disable debugging

869 --disable-smtp-server disable smtp server support

870 --disable-pop3 disable pop3 support

871 --enable-auth enable AUTH (RFC 2554) client support

872 --enable-maildir enable qmail style maildir support

873 --enable-ident enable ident (RFC 1413) support

874 --enable-mserver enable mserver support

875

876 Optional Packages:

877 --with-PACKAGE[=ARG] use PACKAGE [ARG=yes]

878 --without-PACKAGE do not use PACKAGE (same as --with-PACKAGE=no)

879 --with-user=USER set user mail

880 --with-group=GROUP set group trusted

881 --with-glib-static=path link glib statically (path mandatory!)

882 --with-libcrypto use libcrypto

883 --with-liblockfile use liblock (for Debian)

884 --with-logdir=DIR set log directory /var/masqmail

885 --with-spooldir=DIR set spool directory /var/spool/masqmail

886 --with-confdir directory for configuration /etc/masqmail

887

888 Some influential environment variables:

889 CC C compiler command

890 CFLAGS C compiler flags

891 LDFLAGS linker flags, e.g. -L<lib dir> if you have libraries in a

892 nonstandard directory <lib dir>

893 CPPFLAGS C/C++ preprocessor flags, e.g. -I<include dir> if you have

894 headers in a nonstandard directory <include dir>

895 CPP C preprocessor

896 PKG_CONFIG path to pkg-config utility

897 GLIB_CFLAGS C compiler flags for GLIB, overriding pkg-config

898 GLIB_LIBS linker flags for GLIB, overriding pkg-config

899

900 Use these variables to override the choices made by `configure' or to help

901 it to find libraries and programs with nonstandard names/locations.

902

903 Report bugs to <oku@debian.org>.

904 _ACEOF

905 fi

906

907 if test "$ac_init_help" = "recursive"; then

908 # If there are subdirs, report their specific --help.

909 ac_popdir=`pwd`

910 for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue

911 test -d $ac_dir || continue

912 ac_builddir=.

913

914 if test "$ac_dir" != .; then

915 ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`

916 # A "../" for each directory in $ac_dir_suffix.

917 ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`

918 else

919 ac_dir_suffix= ac_top_builddir=

920 fi

921

922 case $srcdir in

923 .) # No --srcdir option. We are building in place.

924 ac_srcdir=.

925 if test -z "$ac_top_builddir"; then

926 ac_top_srcdir=.

927 else

928 ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`

929 fi ;;

930 [\\/]* | ?:[\\/]* ) # Absolute path.

931 ac_srcdir=$srcdir$ac_dir_suffix;

932 ac_top_srcdir=$srcdir ;;

933 *) # Relative path.

934 ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix

935 ac_top_srcdir=$ac_top_builddir$srcdir ;;

936 esac

937

938 # Do not use `cd foo && pwd` to compute absolute paths, because

939 # the directories may not exist.

940 case `pwd` in

941 .) ac_abs_builddir="$ac_dir";;

942 *)

943 case "$ac_dir" in

944 .) ac_abs_builddir=`pwd`;;

945 [\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;

946 *) ac_abs_builddir=`pwd`/"$ac_dir";;

947 esac;;

948 esac

949 case $ac_abs_builddir in

950 .) ac_abs_top_builddir=${ac_top_builddir}.;;

951 *)

952 case ${ac_top_builddir}. in

953 .) ac_abs_top_builddir=$ac_abs_builddir;;

954 [\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;

955 *) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;

956 esac;;

957 esac

958 case $ac_abs_builddir in

959 .) ac_abs_srcdir=$ac_srcdir;;

960 *)

961 case $ac_srcdir in

962 .) ac_abs_srcdir=$ac_abs_builddir;;

963 [\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;

964 *) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;

965 esac;;

966 esac

967 case $ac_abs_builddir in

968 .) ac_abs_top_srcdir=$ac_top_srcdir;;

969 *)

970 case $ac_top_srcdir in

971 .) ac_abs_top_srcdir=$ac_abs_builddir;;

972 [\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;

973 *) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;

974 esac;;

975 esac

976

977 cd $ac_dir

978 # Check for guested configure; otherwise get Cygnus style configure.

979 if test -f $ac_srcdir/configure.gnu; then

980 echo

981 $SHELL $ac_srcdir/configure.gnu --help=recursive

982 elif test -f $ac_srcdir/configure; then

983 echo

984 $SHELL $ac_srcdir/configure --help=recursive

985 elif test -f $ac_srcdir/configure.ac ||

986 test -f $ac_srcdir/configure.in; then

987 echo

988 $ac_configure --help

989 else

990 echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2

991 fi

992 cd "$ac_popdir"

993 done

994 fi

995

996 test -n "$ac_init_help" && exit 0

997 if $ac_init_version; then

998 cat <<\_ACEOF

999 masqmail configure 0.2.21

1000 generated by GNU Autoconf 2.59

1001

1003 This configure script is free software; the Free Software Foundation

1004 gives unlimited permission to copy, distribute and modify it.

1005 _ACEOF

1006 exit 0

1007 fi

1008 exec 5>config.log

1009 cat >&5 <<_ACEOF

1010 This file contains any messages produced by compilers while

1011 running configure, to aid debugging if configure makes a mistake.

1012

1013 It was created by masqmail $as_me 0.2.21, which was

1014 generated by GNU Autoconf 2.59. Invocation command line was

1015

1016 $ $0 $@

1017

1018 _ACEOF

1019 {

1020 cat <<_ASUNAME

1021 ## --------- ##

1022 ## Platform. ##

1023 ## --------- ##

1024

1025 hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`

1026 uname -m = `(uname -m) 2>/dev/null || echo unknown`

1027 uname -r = `(uname -r) 2>/dev/null || echo unknown`

1028 uname -s = `(uname -s) 2>/dev/null || echo unknown`

1029 uname -v = `(uname -v) 2>/dev/null || echo unknown`

1030

1031 /usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`

1032 /bin/uname -X = `(/bin/uname -X) 2>/dev/null || echo unknown`

1033

1034 /bin/arch = `(/bin/arch) 2>/dev/null || echo unknown`

1035 /usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null || echo unknown`

1036 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`

1037 hostinfo = `(hostinfo) 2>/dev/null || echo unknown`

1038 /bin/machine = `(/bin/machine) 2>/dev/null || echo unknown`

1039 /usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null || echo unknown`

1040 /bin/universe = `(/bin/universe) 2>/dev/null || echo unknown`

1041

1042 _ASUNAME

1043

1044 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1045 for as_dir in $PATH

1046 do

1047 IFS=$as_save_IFS

1048 test -z "$as_dir" && as_dir=.

1049 echo "PATH: $as_dir"

1050 done

1051

1052 } >&5

1053

1054 cat >&5 <<_ACEOF

1055

1056

1057 ## ----------- ##

1058 ## Core tests. ##

1059 ## ----------- ##

1060

1061 _ACEOF

1062

1063

1064 # Keep a trace of the command line.

1065 # Strip out --no-create and --no-recursion so they do not pile up.

1066 # Strip out --silent because we don't want to record it for future runs.

1067 # Also quote any args containing shell meta-characters.

1068 # Make two passes to allow for proper duplicate-argument suppression.

1069 ac_configure_args=

1070 ac_configure_args0=

1071 ac_configure_args1=

1072 ac_sep=

1073 ac_must_keep_next=false

1074 for ac_pass in 1 2

1075 do

1076 for ac_arg

1077 do

1078 case $ac_arg in

1079 -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;

1080 -q | -quiet | --quiet | --quie | --qui | --qu | --q \

1082 continue ;;

1083 *" "*|*" "*|*[\[\]\~\#\$\^\&\*\{\}\\\|\;\<\>\?\"\']*)

1084 ac_arg=`echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;

1085 esac

1086 case $ac_pass in

1087 1) ac_configure_args0="$ac_configure_args0 '$ac_arg'" ;;

1088 2)

1089 ac_configure_args1="$ac_configure_args1 '$ac_arg'"

1090 if test $ac_must_keep_next = true; then

1091 ac_must_keep_next=false # Got value, back to normal.

1092 else

1093 case $ac_arg in

1094 *=* | --config-cache | -C | -disable-* | --disable-* \

1095 | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \

1096 | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \

1098 case "$ac_configure_args0 " in

1099 "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;

1100 esac

1101 ;;

1102 -* ) ac_must_keep_next=true ;;

1103 esac

1104 fi

1105 ac_configure_args="$ac_configure_args$ac_sep'$ac_arg'"

1106 # Get rid of the leading space.

1107 ac_sep=" "

1108 ;;

1109 esac

1110 done

1111 done

1112 $as_unset ac_configure_args0 || test "${ac_configure_args0+set}" != set || { ac_configure_args0=; export ac_configure_args0; }

1113 $as_unset ac_configure_args1 || test "${ac_configure_args1+set}" != set || { ac_configure_args1=; export ac_configure_args1; }

1114

1115 # When interrupted or exit'd, cleanup temporary files, and complete

1116 # config.log. We remove comments because anyway the quotes in there

1117 # would cause problems or look ugly.

1118 # WARNING: Be sure not to use single quotes in there, as some shells,

1119 # such as our DU 5.0 friend, will then `close' the trap.

1120 trap 'exit_status=$?

1121 # Save into config.log some information that might help in debugging.

1122 {

1123 echo

1124

1125 cat <<\_ASBOX

1126 ## ---------------- ##

1127 ## Cache variables. ##

1128 ## ---------------- ##

1129 _ASBOX

1130 echo

1131 # The following way of writing the cache mishandles newlines in values,

1132 {

1133 (set) 2>&1 |

1134 case `(ac_space='"'"' '"'"'; set | grep ac_space) 2>&1` in

1135 *ac_space=\ *)

1136 sed -n \

1137 "s/'"'"'/'"'"'\\\\'"'"''"'"'/g;

1138 s/^\$[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\$=\$.*\$/\\1='"'"'\\2'"'"'/p"

1139 ;;

1140 *)

1141 sed -n \

1142 "s/^\$[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\$=\$.*\$/\\1=\\2/p"

1143 ;;

1144 esac;

1145 }

1146 echo

1147

1148 cat <<\_ASBOX

1149 ## ----------------- ##

1150 ## Output variables. ##

1151 ## ----------------- ##

1152 _ASBOX

1153 echo

1154 for ac_var in $ac_subst_vars

1155 do

1156 eval ac_val=$`echo $ac_var`

1157 echo "$ac_var='"'"'$ac_val'"'"'"

1158 done | sort

1159 echo

1160

1161 if test -n "$ac_subst_files"; then

1162 cat <<\_ASBOX

1163 ## ------------- ##

1164 ## Output files. ##

1165 ## ------------- ##

1166 _ASBOX

1167 echo

1168 for ac_var in $ac_subst_files

1169 do

1170 eval ac_val=$`echo $ac_var`

1171 echo "$ac_var='"'"'$ac_val'"'"'"

1172 done | sort

1173 echo

1174 fi

1175

1176 if test -s confdefs.h; then

1177 cat <<\_ASBOX

1178 ## ----------- ##

1179 ## confdefs.h. ##

1180 ## ----------- ##

1181 _ASBOX

1182 echo

1183 sed "/^$/d" confdefs.h | sort

1184 echo

1185 fi

1186 test "$ac_signal" != 0 &&

1187 echo "$as_me: caught signal $ac_signal"

1188 echo "$as_me: exit $exit_status"

1189 } >&5

1190 rm -f core *.core &&

1191 rm -rf conftest* confdefs* conf$$* $ac_clean_files &&

1192 exit $exit_status

1193 ' 0

1194 for ac_signal in 1 2 13 15; do

1195 trap 'ac_signal='$ac_signal'; { (exit 1); exit 1; }' $ac_signal

1196 done

1197 ac_signal=0

1198

1199 # confdefs.h avoids OS command line length limits that DEFS can exceed.

1200 rm -rf conftest* confdefs.h

1201 # AIX cpp loses on an empty file, so make sure it contains at least a newline.

1202 echo >confdefs.h

1203

1204 # Predefined preprocessor variables.

1205

1206 cat >>confdefs.h <<_ACEOF

1207 #define PACKAGE_NAME "$PACKAGE_NAME"

1208 _ACEOF

1209

1210

1211 cat >>confdefs.h <<_ACEOF

1212 #define PACKAGE_TARNAME "$PACKAGE_TARNAME"

1213 _ACEOF

1214

1215

1216 cat >>confdefs.h <<_ACEOF

1217 #define PACKAGE_VERSION "$PACKAGE_VERSION"

1218 _ACEOF

1219

1220

1221 cat >>confdefs.h <<_ACEOF

1222 #define PACKAGE_STRING "$PACKAGE_STRING"

1223 _ACEOF

1224

1225

1226 cat >>confdefs.h <<_ACEOF

1227 #define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"

1228 _ACEOF

1229

1230

1231 # Let the site file select an alternate cache file if it wants to.

1232 # Prefer explicitly selected file to automatically selected ones.

1233 if test -z "$CONFIG_SITE"; then

1234 if test "x$prefix" != xNONE; then

1235 CONFIG_SITE="$prefix/share/config.site $prefix/etc/config.site"

1236 else

1237 CONFIG_SITE="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"

1238 fi

1239 fi

1240 for ac_site_file in $CONFIG_SITE; do

1241 if test -r "$ac_site_file"; then

1242 { echo "$as_me:$LINENO: loading site script $ac_site_file" >&5

1243 echo "$as_me: loading site script $ac_site_file" >&6;}

1244 sed 's/^/| /' "$ac_site_file" >&5

1245 . "$ac_site_file"

1246 fi

1247 done

1248

1249 if test -r "$cache_file"; then

1250 # Some versions of bash will fail to source /dev/null (special

1251 # files actually), so we avoid doing that.

1252 if test -f "$cache_file"; then

1253 { echo "$as_me:$LINENO: loading cache $cache_file" >&5

1254 echo "$as_me: loading cache $cache_file" >&6;}

1255 case $cache_file in

1256 [\\/]* | ?:[\\/]* ) . $cache_file;;

1257 *) . ./$cache_file;;

1258 esac

1259 fi

1260 else

1261 { echo "$as_me:$LINENO: creating cache $cache_file" >&5

1262 echo "$as_me: creating cache $cache_file" >&6;}

1263 >$cache_file

1264 fi

1265

1266 # Check that the precious variables saved in the cache have kept the same

1267 # value.

1268 ac_cache_corrupted=false

1269 for ac_var in `(set) 2>&1 |

1270 sed -n 's/^ac_env_$[a-zA-Z_0-9]*$_set=.*/\1/p'`; do

1271 eval ac_old_set=\$ac_cv_env_${ac_var}_set

1272 eval ac_new_set=\$ac_env_${ac_var}_set

1273 eval ac_old_val="\$ac_cv_env_${ac_var}_value"

1274 eval ac_new_val="\$ac_env_${ac_var}_value"

1275 case $ac_old_set,$ac_new_set in

1276 set,)

1277 { echo "$as_me:$LINENO: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5

1278 echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}

1279 ac_cache_corrupted=: ;;

1280 ,set)

1281 { echo "$as_me:$LINENO: error: \`$ac_var' was not set in the previous run" >&5

1282 echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}

1283 ac_cache_corrupted=: ;;

1284 ,);;

1285 *)

1286 if test "x$ac_old_val" != "x$ac_new_val"; then

1287 { echo "$as_me:$LINENO: error: \`$ac_var' has changed since the previous run:" >&5

1288 echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}

1289 { echo "$as_me:$LINENO: former value: $ac_old_val" >&5

1290 echo "$as_me: former value: $ac_old_val" >&2;}

1291 { echo "$as_me:$LINENO: current value: $ac_new_val" >&5

1292 echo "$as_me: current value: $ac_new_val" >&2;}

1293 ac_cache_corrupted=:

1294 fi;;

1295 esac

1296 # Pass precious variables to config.status.

1297 if test "$ac_new_set" = set; then

1298 case $ac_new_val in

1299 *" "*|*" "*|*[\[\]\~\#\$\^\&\*\{\}\\\|\;\<\>\?\"\']*)

1300 ac_arg=$ac_var=`echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;

1301 *) ac_arg=$ac_var=$ac_new_val ;;

1302 esac

1303 case " $ac_configure_args " in

1304 *" '$ac_arg' "*) ;; # Avoid dups. Use of quotes ensures accuracy.

1305 *) ac_configure_args="$ac_configure_args '$ac_arg'" ;;

1306 esac

1307 fi

1308 done

1309 if $ac_cache_corrupted; then

1310 { echo "$as_me:$LINENO: error: changes in the environment can compromise the build" >&5

1311 echo "$as_me: error: changes in the environment can compromise the build" >&2;}

1312 { { echo "$as_me:$LINENO: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&5

1313 echo "$as_me: error: run \`make distclean' and/or \`rm $cache_file' and start over" >&2;}

1314 { (exit 1); exit 1; }; }

1315 fi

1316

1317 ac_ext=c

1318 ac_cpp='$CPP $CPPFLAGS'

1319 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

1320 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

1321 ac_compiler_gnu=$ac_cv_c_compiler_gnu

1322

1323

1324

1325

1326

1327

1328

1329

1330

1331

1332

1333

1334

1335

1336

1337

1338

1339

1340

1341

1342

1343

1344

1345

1346

1347

1348

1349

1350 ac_config_headers="$ac_config_headers config.h"

1351

1352 am__api_version="1.7"

1353 ac_aux_dir=

1354 for ac_dir in $srcdir $srcdir/.. $srcdir/../..; do

1355 if test -f $ac_dir/install-sh; then

1356 ac_aux_dir=$ac_dir

1357 ac_install_sh="$ac_aux_dir/install-sh -c"

1358 break

1359 elif test -f $ac_dir/install.sh; then

1360 ac_aux_dir=$ac_dir

1361 ac_install_sh="$ac_aux_dir/install.sh -c"

1362 break

1363 elif test -f $ac_dir/shtool; then

1364 ac_aux_dir=$ac_dir

1365 ac_install_sh="$ac_aux_dir/shtool install -c"

1366 break

1367 fi

1368 done

1369 if test -z "$ac_aux_dir"; then

1370 { { echo "$as_me:$LINENO: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&5

1371 echo "$as_me: error: cannot find install-sh or install.sh in $srcdir $srcdir/.. $srcdir/../.." >&2;}

1372 { (exit 1); exit 1; }; }

1373 fi

1374 ac_config_guess="$SHELL $ac_aux_dir/config.guess"

1375 ac_config_sub="$SHELL $ac_aux_dir/config.sub"

1376 ac_configure="$SHELL $ac_aux_dir/configure" # This should be Cygnus configure.

1377

1378 # Find a good install program. We prefer a C program (faster),

1379 # so one script is as good as another. But avoid the broken or

1380 # incompatible versions:

1381 # SysV /etc/install, /usr/sbin/install

1382 # SunOS /usr/etc/install

1383 # IRIX /sbin/install

1384 # AIX /bin/install

1385 # AmigaOS /C/install, which installs bootblocks on floppy discs

1386 # AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag

1387 # AFS /usr/afsws/bin/install, which mishandles nonexistent args

1388 # SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"

1389 # OS/2's system install, which has a completely different semantic

1390 # ./install, which can be erroneously created by make from ./install.sh.

1391 echo "$as_me:$LINENO: checking for a BSD-compatible install" >&5

1392 echo $ECHO_N "checking for a BSD-compatible install... $ECHO_C" >&6

1393 if test -z "$INSTALL"; then

1394 if test "${ac_cv_path_install+set}" = set; then

1395 echo $ECHO_N "(cached) $ECHO_C" >&6

1396 else

1397 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1398 for as_dir in $PATH

1399 do

1400 IFS=$as_save_IFS

1401 test -z "$as_dir" && as_dir=.

1402 # Account for people who put trailing slashes in PATH elements.

1403 case $as_dir/ in

1404 ./ | .// | /cC/* | \

1405 /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \

1406 ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \

1407 /usr/ucb/* ) ;;

1408 *)

1409 # OSF1 and SCO ODT 3.0 have their own names for install.

1410 # Don't use installbsd from OSF since it installs stuff as root

1411 # by default.

1412 for ac_prog in ginstall scoinst install; do

1413 for ac_exec_ext in '' $ac_executable_extensions; do

1414 if $as_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then

1415 if test $ac_prog = install &&

1416 grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then

1417 # AIX install. It has an incompatible calling convention.

1418 :

1419 elif test $ac_prog = install &&

1420 grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then

1421 # program-specific install script used by HP pwplus--don't use.

1422 :

1423 else

1424 ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"

1425 break 3

1426 fi

1427 fi

1428 done

1429 done

1430 ;;

1431 esac

1432 done

1433

1434

1435 fi

1436 if test "${ac_cv_path_install+set}" = set; then

1437 INSTALL=$ac_cv_path_install

1438 else

1439 # As a last resort, use the slow shell script. We don't cache a

1440 # path for INSTALL within a source directory, because that will

1441 # break other packages using the cache if that directory is

1442 # removed, or if the path is relative.

1443 INSTALL=$ac_install_sh

1444 fi

1445 fi

1446 echo "$as_me:$LINENO: result: $INSTALL" >&5

1447 echo "${ECHO_T}$INSTALL" >&6

1448

1449 # Use test -z because SunOS4 sh mishandles braces in ${var-val}.

1450 # It thinks the first close brace ends the variable substitution.

1451 test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'

1452

1453 test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'

1454

1455 test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'

1456

1457 echo "$as_me:$LINENO: checking whether build environment is sane" >&5

1458 echo $ECHO_N "checking whether build environment is sane... $ECHO_C" >&6

1459 # Just in case

1460 sleep 1

1461 echo timestamp > conftest.file

1462 # Do `set' in a subshell so we don't clobber the current shell's

1463 # arguments. Must try -L first in case configure is actually a

1464 # symlink; some systems play weird games with the mod time of symlinks

1465 # (eg FreeBSD returns the mod time of the symlink's containing

1466 # directory).

1467 if (

1468 set X `ls -Lt $srcdir/configure conftest.file 2> /dev/null`

1469 if test "$*" = "X"; then

1470 # -L didn't work.

1471 set X `ls -t $srcdir/configure conftest.file`

1472 fi

1473 rm -f conftest.file

1474 if test "$*" != "X $srcdir/configure conftest.file" \

1475 && test "$*" != "X conftest.file $srcdir/configure"; then

1476

1477 # If neither matched, then we have a broken ls. This can happen

1478 # if, for instance, CONFIG_SHELL is bash and it inherits a

1479 # broken ls alias from the environment. This has actually

1480 # happened. Such a system could not be considered "sane".

1481 { { echo "$as_me:$LINENO: error: ls -t appears to fail. Make sure there is not a broken

1482 alias in your environment" >&5

1483 echo "$as_me: error: ls -t appears to fail. Make sure there is not a broken

1484 alias in your environment" >&2;}

1485 { (exit 1); exit 1; }; }

1486 fi

1487

1488 test "$2" = conftest.file

1489 )

1490 then

1491 # Ok.

1492 :

1493 else

1494 { { echo "$as_me:$LINENO: error: newly created file is older than distributed files!

1495 Check your system clock" >&5

1496 echo "$as_me: error: newly created file is older than distributed files!

1497 Check your system clock" >&2;}

1498 { (exit 1); exit 1; }; }

1499 fi

1500 echo "$as_me:$LINENO: result: yes" >&5

1501 echo "${ECHO_T}yes" >&6

1502 test "$program_prefix" != NONE &&

1503 program_transform_name="s,^,$program_prefix,;$program_transform_name"

1504 # Use a double $ so make ignores it.

1505 test "$program_suffix" != NONE &&

1506 program_transform_name="s,\$,$program_suffix,;$program_transform_name"

1507 # Double any \ or $. echo might interpret backslashes.

1508 # By default was `s,x,x', remove it if useless.

1509 cat <<\_ACEOF >conftest.sed

1510 s/[\\$]/&&/g;s/;s,x,x,$//

1511 _ACEOF

1512 program_transform_name=`echo $program_transform_name | sed -f conftest.sed`

1513 rm conftest.sed

1514

1515

1516 # expand $ac_aux_dir to an absolute path

1517 am_aux_dir=`cd $ac_aux_dir && pwd`

1518

1519 test x"${MISSING+set}" = xset || MISSING="\${SHELL} $am_aux_dir/missing"

1520 # Use eval to expand $SHELL

1521 if eval "$MISSING --run true"; then

1522 am_missing_run="$MISSING --run "

1523 else

1524 am_missing_run=

1525 { echo "$as_me:$LINENO: WARNING: \`missing' script is too old or missing" >&5

1526 echo "$as_me: WARNING: \`missing' script is too old or missing" >&2;}

1527 fi

1528

1529 for ac_prog in gawk mawk nawk awk

1530 do

1531 # Extract the first word of "$ac_prog", so it can be a program name with args.

1532 set dummy $ac_prog; ac_word=$2

1533 echo "$as_me:$LINENO: checking for $ac_word" >&5

1534 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

1535 if test "${ac_cv_prog_AWK+set}" = set; then

1536 echo $ECHO_N "(cached) $ECHO_C" >&6

1537 else

1538 if test -n "$AWK"; then

1539 ac_cv_prog_AWK="$AWK" # Let the user override the test.

1540 else

1541 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1542 for as_dir in $PATH

1543 do

1544 IFS=$as_save_IFS

1545 test -z "$as_dir" && as_dir=.

1546 for ac_exec_ext in '' $ac_executable_extensions; do

1547 if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

1548 ac_cv_prog_AWK="$ac_prog"

1549 echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

1550 break 2

1551 fi

1552 done

1553 done

1554

1555 fi

1556 fi

1557 AWK=$ac_cv_prog_AWK

1558 if test -n "$AWK"; then

1559 echo "$as_me:$LINENO: result: $AWK" >&5

1560 echo "${ECHO_T}$AWK" >&6

1561 else

1562 echo "$as_me:$LINENO: result: no" >&5

1563 echo "${ECHO_T}no" >&6

1564 fi

1565

1566 test -n "$AWK" && break

1567 done

1568

1569 echo "$as_me:$LINENO: checking whether ${MAKE-make} sets \$(MAKE)" >&5

1570 echo $ECHO_N "checking whether ${MAKE-make} sets \$(MAKE)... $ECHO_C" >&6

1571 set dummy ${MAKE-make}; ac_make=`echo "$2" | sed 'y,:./+-,___p_,'`

1572 if eval "test \"\${ac_cv_prog_make_${ac_make}_set+set}\" = set"; then

1573 echo $ECHO_N "(cached) $ECHO_C" >&6

1574 else

1575 cat >conftest.make <<\_ACEOF

1576 all:

1577 @echo 'ac_maketemp="$(MAKE)"'

1578 _ACEOF

1579 # GNU make sometimes prints "make[1]: Entering...", which would confuse us.

1580 eval `${MAKE-make} -f conftest.make 2>/dev/null | grep temp=`

1581 if test -n "$ac_maketemp"; then

1582 eval ac_cv_prog_make_${ac_make}_set=yes

1583 else

1584 eval ac_cv_prog_make_${ac_make}_set=no

1585 fi

1586 rm -f conftest.make

1587 fi

1588 if eval "test \"`echo '$ac_cv_prog_make_'${ac_make}_set`\" = yes"; then

1589 echo "$as_me:$LINENO: result: yes" >&5

1590 echo "${ECHO_T}yes" >&6

1591 SET_MAKE=

1592 else

1593 echo "$as_me:$LINENO: result: no" >&5

1594 echo "${ECHO_T}no" >&6

1595 SET_MAKE="MAKE=${MAKE-make}"

1596 fi

1597

1598 rm -rf .tst 2>/dev/null

1599 mkdir .tst 2>/dev/null

1600 if test -d .tst; then

1601 am__leading_dot=.

1602 else

1603 am__leading_dot=_

1604 fi

1605 rmdir .tst 2>/dev/null

1606

1607 # test to see if srcdir already configured

1608 if test "`cd $srcdir && pwd`" != "`pwd`" &&

1609 test -f $srcdir/config.status; then

1610 { { echo "$as_me:$LINENO: error: source directory already configured; run \"make distclean\" there first" >&5

1611 echo "$as_me: error: source directory already configured; run \"make distclean\" there first" >&2;}

1612 { (exit 1); exit 1; }; }

1613 fi

1614

1615 # test whether we have cygpath

1616 if test -z "$CYGPATH_W"; then

1617 if (cygpath --version) >/dev/null 2>/dev/null; then

1618 CYGPATH_W='cygpath -w'

1619 else

1620 CYGPATH_W=echo

1621 fi

1622 fi

1623

1624

1625 # Define the identity of the package.

1626 PACKAGE='masqmail'

1627 VERSION='0.2.21'

1628

1629

1630 cat >>confdefs.h <<_ACEOF

1631 #define PACKAGE "$PACKAGE"

1632 _ACEOF

1633

1634

1635 cat >>confdefs.h <<_ACEOF

1636 #define VERSION "$VERSION"

1637 _ACEOF

1638

1639 # Some tools Automake needs.

1640

1641 ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}

1642

1643

1644 AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}

1645

1646

1647 AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}

1648

1649

1650 AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}

1651

1652

1653 MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}

1654

1655

1656 AMTAR=${AMTAR-"${am_missing_run}tar"}

1657

1658 install_sh=${install_sh-"$am_aux_dir/install-sh"}

1659

1660 # Installed binaries are usually stripped using `strip' when the user

1661 # run `make install-strip'. However `strip' might not be the right

1662 # tool to use in cross-compilation environments, therefore Automake

1663 # will honor the `STRIP' environment variable to overrule this program.

1664 if test "$cross_compiling" != no; then

1665 if test -n "$ac_tool_prefix"; then

1666 # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.

1667 set dummy ${ac_tool_prefix}strip; ac_word=$2

1668 echo "$as_me:$LINENO: checking for $ac_word" >&5

1669 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

1670 if test "${ac_cv_prog_STRIP+set}" = set; then

1671 echo $ECHO_N "(cached) $ECHO_C" >&6

1672 else

1673 if test -n "$STRIP"; then

1674 ac_cv_prog_STRIP="$STRIP" # Let the user override the test.

1675 else

1676 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1677 for as_dir in $PATH

1678 do

1679 IFS=$as_save_IFS

1680 test -z "$as_dir" && as_dir=.

1681 for ac_exec_ext in '' $ac_executable_extensions; do

1682 if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

1683 ac_cv_prog_STRIP="${ac_tool_prefix}strip"

1684 echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

1685 break 2

1686 fi

1687 done

1688 done

1689

1690 fi

1691 fi

1692 STRIP=$ac_cv_prog_STRIP

1693 if test -n "$STRIP"; then

1694 echo "$as_me:$LINENO: result: $STRIP" >&5

1695 echo "${ECHO_T}$STRIP" >&6

1696 else

1697 echo "$as_me:$LINENO: result: no" >&5

1698 echo "${ECHO_T}no" >&6

1699 fi

1700

1701 fi

1702 if test -z "$ac_cv_prog_STRIP"; then

1703 ac_ct_STRIP=$STRIP

1704 # Extract the first word of "strip", so it can be a program name with args.

1705 set dummy strip; ac_word=$2

1706 echo "$as_me:$LINENO: checking for $ac_word" >&5

1707 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

1708 if test "${ac_cv_prog_ac_ct_STRIP+set}" = set; then

1709 echo $ECHO_N "(cached) $ECHO_C" >&6

1710 else

1711 if test -n "$ac_ct_STRIP"; then

1712 ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.

1713 else

1714 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1715 for as_dir in $PATH

1716 do

1717 IFS=$as_save_IFS

1718 test -z "$as_dir" && as_dir=.

1719 for ac_exec_ext in '' $ac_executable_extensions; do

1720 if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

1721 ac_cv_prog_ac_ct_STRIP="strip"

1722 echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

1723 break 2

1724 fi

1725 done

1726 done

1727

1728 test -z "$ac_cv_prog_ac_ct_STRIP" && ac_cv_prog_ac_ct_STRIP=":"

1729 fi

1730 fi

1731 ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP

1732 if test -n "$ac_ct_STRIP"; then

1733 echo "$as_me:$LINENO: result: $ac_ct_STRIP" >&5

1734 echo "${ECHO_T}$ac_ct_STRIP" >&6

1735 else

1736 echo "$as_me:$LINENO: result: no" >&5

1737 echo "${ECHO_T}no" >&6

1738 fi

1739

1740 STRIP=$ac_ct_STRIP

1741 else

1742 STRIP="$ac_cv_prog_STRIP"

1743 fi

1744

1745 fi

1746 INSTALL_STRIP_PROGRAM="\${SHELL} \$(install_sh) -c -s"

1747

1748 # We need awk for the "check" target. The system "awk" is bad on

1749 # some platforms.

1750

1751

1752

1753

1754

1755

1756

1757

1758 ac_ext=c

1759 ac_cpp='$CPP $CPPFLAGS'

1760 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

1761 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

1762 ac_compiler_gnu=$ac_cv_c_compiler_gnu

1763 if test -n "$ac_tool_prefix"; then

1764 # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.

1765 set dummy ${ac_tool_prefix}gcc; ac_word=$2

1766 echo "$as_me:$LINENO: checking for $ac_word" >&5

1767 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

1768 if test "${ac_cv_prog_CC+set}" = set; then

1769 echo $ECHO_N "(cached) $ECHO_C" >&6

1770 else

1771 if test -n "$CC"; then

1772 ac_cv_prog_CC="$CC" # Let the user override the test.

1773 else

1774 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1775 for as_dir in $PATH

1776 do

1777 IFS=$as_save_IFS

1778 test -z "$as_dir" && as_dir=.

1779 for ac_exec_ext in '' $ac_executable_extensions; do

1780 if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

1781 ac_cv_prog_CC="${ac_tool_prefix}gcc"

1782 echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

1783 break 2

1784 fi

1785 done

1786 done

1787

1788 fi

1789 fi

1790 CC=$ac_cv_prog_CC

1791 if test -n "$CC"; then

1792 echo "$as_me:$LINENO: result: $CC" >&5

1793 echo "${ECHO_T}$CC" >&6

1794 else

1795 echo "$as_me:$LINENO: result: no" >&5

1796 echo "${ECHO_T}no" >&6

1797 fi

1798

1799 fi

1800 if test -z "$ac_cv_prog_CC"; then

1801 ac_ct_CC=$CC

1802 # Extract the first word of "gcc", so it can be a program name with args.

1803 set dummy gcc; ac_word=$2

1804 echo "$as_me:$LINENO: checking for $ac_word" >&5

1805 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

1806 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then

1807 echo $ECHO_N "(cached) $ECHO_C" >&6

1808 else

1809 if test -n "$ac_ct_CC"; then

1810 ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.

1811 else

1812 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1813 for as_dir in $PATH

1814 do

1815 IFS=$as_save_IFS

1816 test -z "$as_dir" && as_dir=.

1817 for ac_exec_ext in '' $ac_executable_extensions; do

1818 if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

1819 ac_cv_prog_ac_ct_CC="gcc"

1820 echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

1821 break 2

1822 fi

1823 done

1824 done

1825

1826 fi

1827 fi

1828 ac_ct_CC=$ac_cv_prog_ac_ct_CC

1829 if test -n "$ac_ct_CC"; then

1830 echo "$as_me:$LINENO: result: $ac_ct_CC" >&5

1831 echo "${ECHO_T}$ac_ct_CC" >&6

1832 else

1833 echo "$as_me:$LINENO: result: no" >&5

1834 echo "${ECHO_T}no" >&6

1835 fi

1836

1837 CC=$ac_ct_CC

1838 else

1839 CC="$ac_cv_prog_CC"

1840 fi

1841

1842 if test -z "$CC"; then

1843 if test -n "$ac_tool_prefix"; then

1844 # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.

1845 set dummy ${ac_tool_prefix}cc; ac_word=$2

1846 echo "$as_me:$LINENO: checking for $ac_word" >&5

1847 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

1848 if test "${ac_cv_prog_CC+set}" = set; then

1849 echo $ECHO_N "(cached) $ECHO_C" >&6

1850 else

1851 if test -n "$CC"; then

1852 ac_cv_prog_CC="$CC" # Let the user override the test.

1853 else

1854 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1855 for as_dir in $PATH

1856 do

1857 IFS=$as_save_IFS

1858 test -z "$as_dir" && as_dir=.

1859 for ac_exec_ext in '' $ac_executable_extensions; do

1860 if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

1861 ac_cv_prog_CC="${ac_tool_prefix}cc"

1862 echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

1863 break 2

1864 fi

1865 done

1866 done

1867

1868 fi

1869 fi

1870 CC=$ac_cv_prog_CC

1871 if test -n "$CC"; then

1872 echo "$as_me:$LINENO: result: $CC" >&5

1873 echo "${ECHO_T}$CC" >&6

1874 else

1875 echo "$as_me:$LINENO: result: no" >&5

1876 echo "${ECHO_T}no" >&6

1877 fi

1878

1879 fi

1880 if test -z "$ac_cv_prog_CC"; then

1881 ac_ct_CC=$CC

1882 # Extract the first word of "cc", so it can be a program name with args.

1883 set dummy cc; ac_word=$2

1884 echo "$as_me:$LINENO: checking for $ac_word" >&5

1885 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

1886 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then

1887 echo $ECHO_N "(cached) $ECHO_C" >&6

1888 else

1889 if test -n "$ac_ct_CC"; then

1890 ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.

1891 else

1892 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1893 for as_dir in $PATH

1894 do

1895 IFS=$as_save_IFS

1896 test -z "$as_dir" && as_dir=.

1897 for ac_exec_ext in '' $ac_executable_extensions; do

1898 if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

1899 ac_cv_prog_ac_ct_CC="cc"

1900 echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

1901 break 2

1902 fi

1903 done

1904 done

1905

1906 fi

1907 fi

1908 ac_ct_CC=$ac_cv_prog_ac_ct_CC

1909 if test -n "$ac_ct_CC"; then

1910 echo "$as_me:$LINENO: result: $ac_ct_CC" >&5

1911 echo "${ECHO_T}$ac_ct_CC" >&6

1912 else

1913 echo "$as_me:$LINENO: result: no" >&5

1914 echo "${ECHO_T}no" >&6

1915 fi

1916

1917 CC=$ac_ct_CC

1918 else

1919 CC="$ac_cv_prog_CC"

1920 fi

1921

1922 fi

1923 if test -z "$CC"; then

1924 # Extract the first word of "cc", so it can be a program name with args.

1925 set dummy cc; ac_word=$2

1926 echo "$as_me:$LINENO: checking for $ac_word" >&5

1927 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

1928 if test "${ac_cv_prog_CC+set}" = set; then

1929 echo $ECHO_N "(cached) $ECHO_C" >&6

1930 else

1931 if test -n "$CC"; then

1932 ac_cv_prog_CC="$CC" # Let the user override the test.

1933 else

1934 ac_prog_rejected=no

1935 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1936 for as_dir in $PATH

1937 do

1938 IFS=$as_save_IFS

1939 test -z "$as_dir" && as_dir=.

1940 for ac_exec_ext in '' $ac_executable_extensions; do

1941 if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

1942 if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then

1943 ac_prog_rejected=yes

1944 continue

1945 fi

1946 ac_cv_prog_CC="cc"

1947 echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

1948 break 2

1949 fi

1950 done

1951 done

1952

1953 if test $ac_prog_rejected = yes; then

1954 # We found a bogon in the path, so make sure we never use it.

1955 set dummy $ac_cv_prog_CC

1956 shift

1957 if test $# != 0; then

1958 # We chose a different compiler from the bogus one.

1959 # However, it has the same basename, so the bogon will be chosen

1960 # first if we set CC to just the basename; use the full file name.

1961 shift

1962 ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"

1963 fi

1964 fi

1965 fi

1966 fi

1967 CC=$ac_cv_prog_CC

1968 if test -n "$CC"; then

1969 echo "$as_me:$LINENO: result: $CC" >&5

1970 echo "${ECHO_T}$CC" >&6

1971 else

1972 echo "$as_me:$LINENO: result: no" >&5

1973 echo "${ECHO_T}no" >&6

1974 fi

1975

1976 fi

1977 if test -z "$CC"; then

1978 if test -n "$ac_tool_prefix"; then

1979 for ac_prog in cl

1980 do

1981 # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.

1982 set dummy $ac_tool_prefix$ac_prog; ac_word=$2

1983 echo "$as_me:$LINENO: checking for $ac_word" >&5

1984 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

1985 if test "${ac_cv_prog_CC+set}" = set; then

1986 echo $ECHO_N "(cached) $ECHO_C" >&6

1987 else

1988 if test -n "$CC"; then

1989 ac_cv_prog_CC="$CC" # Let the user override the test.

1990 else

1991 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1992 for as_dir in $PATH

1993 do

1994 IFS=$as_save_IFS

1995 test -z "$as_dir" && as_dir=.

1996 for ac_exec_ext in '' $ac_executable_extensions; do

1997 if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

1998 ac_cv_prog_CC="$ac_tool_prefix$ac_prog"

1999 echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

2000 break 2

2001 fi

2002 done

2003 done

2004

2005 fi

2006 fi

2007 CC=$ac_cv_prog_CC

2008 if test -n "$CC"; then

2009 echo "$as_me:$LINENO: result: $CC" >&5

2010 echo "${ECHO_T}$CC" >&6

2011 else

2012 echo "$as_me:$LINENO: result: no" >&5

2013 echo "${ECHO_T}no" >&6

2014 fi

2015

2016 test -n "$CC" && break

2017 done

2018 fi

2019 if test -z "$CC"; then

2020 ac_ct_CC=$CC

2021 for ac_prog in cl

2022 do

2023 # Extract the first word of "$ac_prog", so it can be a program name with args.

2024 set dummy $ac_prog; ac_word=$2

2025 echo "$as_me:$LINENO: checking for $ac_word" >&5

2026 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

2027 if test "${ac_cv_prog_ac_ct_CC+set}" = set; then

2028 echo $ECHO_N "(cached) $ECHO_C" >&6

2029 else

2030 if test -n "$ac_ct_CC"; then

2031 ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.

2032 else

2033 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

2034 for as_dir in $PATH

2035 do

2036 IFS=$as_save_IFS

2037 test -z "$as_dir" && as_dir=.

2038 for ac_exec_ext in '' $ac_executable_extensions; do

2039 if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

2040 ac_cv_prog_ac_ct_CC="$ac_prog"

2041 echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

2042 break 2

2043 fi

2044 done

2045 done

2046

2047 fi

2048 fi

2049 ac_ct_CC=$ac_cv_prog_ac_ct_CC

2050 if test -n "$ac_ct_CC"; then

2051 echo "$as_me:$LINENO: result: $ac_ct_CC" >&5

2052 echo "${ECHO_T}$ac_ct_CC" >&6

2053 else

2054 echo "$as_me:$LINENO: result: no" >&5

2055 echo "${ECHO_T}no" >&6

2056 fi

2057

2058 test -n "$ac_ct_CC" && break

2059 done

2060

2061 CC=$ac_ct_CC

2062 fi

2063

2064 fi

2065

2066

2067 test -z "$CC" && { { echo "$as_me:$LINENO: error: no acceptable C compiler found in \$PATH

2068 See \`config.log' for more details." >&5

2069 echo "$as_me: error: no acceptable C compiler found in \$PATH

2070 See \`config.log' for more details." >&2;}

2071 { (exit 1); exit 1; }; }

2072

2073 # Provide some information about the compiler.

2074 echo "$as_me:$LINENO:" \

2075 "checking for C compiler version" >&5

2076 ac_compiler=`set X $ac_compile; echo $2`

2077 { (eval echo "$as_me:$LINENO: \"$ac_compiler --version </dev/null >&5\"") >&5

2078 (eval $ac_compiler --version </dev/null >&5) 2>&5

2079 ac_status=$?

2080 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2081 (exit $ac_status); }

2082 { (eval echo "$as_me:$LINENO: \"$ac_compiler -v </dev/null >&5\"") >&5

2083 (eval $ac_compiler -v </dev/null >&5) 2>&5

2084 ac_status=$?

2085 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2086 (exit $ac_status); }

2087 { (eval echo "$as_me:$LINENO: \"$ac_compiler -V </dev/null >&5\"") >&5

2088 (eval $ac_compiler -V </dev/null >&5) 2>&5

2089 ac_status=$?

2090 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2091 (exit $ac_status); }

2092

2093 cat >conftest.$ac_ext <<_ACEOF

2094 /* confdefs.h. */

2095 _ACEOF

2096 cat confdefs.h >>conftest.$ac_ext

2097 cat >>conftest.$ac_ext <<_ACEOF

2098 /* end confdefs.h. */

2099

2100 int

2101 main ()

2102 {

2103

2104 ;

2105 return 0;

2106 }

2107 _ACEOF

2108 ac_clean_files_save=$ac_clean_files

2109 ac_clean_files="$ac_clean_files a.out a.exe b.out"

2110 # Try to create an executable without -o first, disregard a.out.

2111 # It will help us diagnose broken compilers, and finding out an intuition

2112 # of exeext.

2113 echo "$as_me:$LINENO: checking for C compiler default output file name" >&5

2114 echo $ECHO_N "checking for C compiler default output file name... $ECHO_C" >&6

2115 ac_link_default=`echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`

2116 if { (eval echo "$as_me:$LINENO: \"$ac_link_default\"") >&5

2117 (eval $ac_link_default) 2>&5

2118 ac_status=$?

2119 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2120 (exit $ac_status); }; then

2121 # Find the output, starting from the most likely. This scheme is

2122 # not robust to junk in `.', hence go to wildcards (a.*) only as a last

2123 # resort.

2124

2125 # Be careful to initialize this variable, since it used to be cached.

2126 # Otherwise an old cache value of `no' led to `EXEEXT = no' in a Makefile.

2127 ac_cv_exeext=

2128 # b.out is created by i960 compilers.

2129 for ac_file in a_out.exe a.exe conftest.exe a.out conftest a.* conftest.* b.out

2130 do

2131 test -f "$ac_file" || continue

2132 case $ac_file in

2133 *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj )

2134 ;;

2135 conftest.$ac_ext )

2136 # This is the source file.

2137 ;;

2138 [ab].out )

2139 # We found the default executable, but exeext='' is most

2140 # certainly right.

2141 break;;

2142 *.* )

2143 ac_cv_exeext=`expr "$ac_file" : '[^.]*$\..*$'`

2144 # FIXME: I believe we export ac_cv_exeext for Libtool,

2145 # but it would be cool to find out if it's true. Does anybody

2146 # maintain Libtool? --akim.

2147 export ac_cv_exeext

2148 break;;

2149 * )

2150 break;;

2151 esac

2152 done

2153 else

2154 echo "$as_me: failed program was:" >&5

2155 sed 's/^/| /' conftest.$ac_ext >&5

2156

2157 { { echo "$as_me:$LINENO: error: C compiler cannot create executables

2158 See \`config.log' for more details." >&5

2159 echo "$as_me: error: C compiler cannot create executables

2160 See \`config.log' for more details." >&2;}

2161 { (exit 77); exit 77; }; }

2162 fi

2163

2164 ac_exeext=$ac_cv_exeext

2165 echo "$as_me:$LINENO: result: $ac_file" >&5

2166 echo "${ECHO_T}$ac_file" >&6

2167

2168 # Check the compiler produces executables we can run. If not, either

2169 # the compiler is broken, or we cross compile.

2170 echo "$as_me:$LINENO: checking whether the C compiler works" >&5

2171 echo $ECHO_N "checking whether the C compiler works... $ECHO_C" >&6

2172 # FIXME: These cross compiler hacks should be removed for Autoconf 3.0

2173 # If not cross compiling, check that we can run a simple program.

2174 if test "$cross_compiling" != yes; then

2175 if { ac_try='./$ac_file'

2176 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

2177 (eval $ac_try) 2>&5

2178 ac_status=$?

2179 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2180 (exit $ac_status); }; }; then

2181 cross_compiling=no

2182 else

2183 if test "$cross_compiling" = maybe; then

2184 cross_compiling=yes

2185 else

2186 { { echo "$as_me:$LINENO: error: cannot run C compiled programs.

2187 If you meant to cross compile, use \`--host'.

2188 See \`config.log' for more details." >&5

2189 echo "$as_me: error: cannot run C compiled programs.

2190 If you meant to cross compile, use \`--host'.

2191 See \`config.log' for more details." >&2;}

2192 { (exit 1); exit 1; }; }

2193 fi

2194 fi

2195 fi

2196 echo "$as_me:$LINENO: result: yes" >&5

2197 echo "${ECHO_T}yes" >&6

2198

2199 rm -f a.out a.exe conftest$ac_cv_exeext b.out

2200 ac_clean_files=$ac_clean_files_save

2201 # Check the compiler produces executables we can run. If not, either

2202 # the compiler is broken, or we cross compile.

2203 echo "$as_me:$LINENO: checking whether we are cross compiling" >&5

2204 echo $ECHO_N "checking whether we are cross compiling... $ECHO_C" >&6

2205 echo "$as_me:$LINENO: result: $cross_compiling" >&5

2206 echo "${ECHO_T}$cross_compiling" >&6

2207

2208 echo "$as_me:$LINENO: checking for suffix of executables" >&5

2209 echo $ECHO_N "checking for suffix of executables... $ECHO_C" >&6

2210 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

2211 (eval $ac_link) 2>&5

2212 ac_status=$?

2213 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2214 (exit $ac_status); }; then

2215 # If both `conftest.exe' and `conftest' are `present' (well, observable)

2216 # catch `conftest.exe'. For instance with Cygwin, `ls conftest' will

2217 # work properly (i.e., refer to `conftest.exe'), while it won't with

2218 # `rm'.

2219 for ac_file in conftest.exe conftest conftest.*; do

2220 test -f "$ac_file" || continue

2221 case $ac_file in

2222 *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.o | *.obj ) ;;

2223 *.* ) ac_cv_exeext=`expr "$ac_file" : '[^.]*$\..*$'`

2224 export ac_cv_exeext

2225 break;;

2226 * ) break;;

2227 esac

2228 done

2229 else

2230 { { echo "$as_me:$LINENO: error: cannot compute suffix of executables: cannot compile and link

2231 See \`config.log' for more details." >&5

2232 echo "$as_me: error: cannot compute suffix of executables: cannot compile and link

2233 See \`config.log' for more details." >&2;}

2234 { (exit 1); exit 1; }; }

2235 fi

2236

2237 rm -f conftest$ac_cv_exeext

2238 echo "$as_me:$LINENO: result: $ac_cv_exeext" >&5

2239 echo "${ECHO_T}$ac_cv_exeext" >&6

2240

2241 rm -f conftest.$ac_ext

2242 EXEEXT=$ac_cv_exeext

2243 ac_exeext=$EXEEXT

2244 echo "$as_me:$LINENO: checking for suffix of object files" >&5

2245 echo $ECHO_N "checking for suffix of object files... $ECHO_C" >&6

2246 if test "${ac_cv_objext+set}" = set; then

2247 echo $ECHO_N "(cached) $ECHO_C" >&6

2248 else

2249 cat >conftest.$ac_ext <<_ACEOF

2250 /* confdefs.h. */

2251 _ACEOF

2252 cat confdefs.h >>conftest.$ac_ext

2253 cat >>conftest.$ac_ext <<_ACEOF

2254 /* end confdefs.h. */

2255

2256 int

2257 main ()

2258 {

2259

2260 ;

2261 return 0;

2262 }

2263 _ACEOF

2264 rm -f conftest.o conftest.obj

2265 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

2266 (eval $ac_compile) 2>&5

2267 ac_status=$?

2268 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2269 (exit $ac_status); }; then

2270 for ac_file in `(ls conftest.o conftest.obj; ls conftest.*) 2>/dev/null`; do

2271 case $ac_file in

2272 *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg ) ;;

2273 *) ac_cv_objext=`expr "$ac_file" : '.*\.$.*$'`

2274 break;;

2275 esac

2276 done

2277 else

2278 echo "$as_me: failed program was:" >&5

2279 sed 's/^/| /' conftest.$ac_ext >&5

2280

2281 { { echo "$as_me:$LINENO: error: cannot compute suffix of object files: cannot compile

2282 See \`config.log' for more details." >&5

2283 echo "$as_me: error: cannot compute suffix of object files: cannot compile

2284 See \`config.log' for more details." >&2;}

2285 { (exit 1); exit 1; }; }

2286 fi

2287

2288 rm -f conftest.$ac_cv_objext conftest.$ac_ext

2289 fi

2290 echo "$as_me:$LINENO: result: $ac_cv_objext" >&5

2291 echo "${ECHO_T}$ac_cv_objext" >&6

2292 OBJEXT=$ac_cv_objext

2293 ac_objext=$OBJEXT

2294 echo "$as_me:$LINENO: checking whether we are using the GNU C compiler" >&5

2295 echo $ECHO_N "checking whether we are using the GNU C compiler... $ECHO_C" >&6

2296 if test "${ac_cv_c_compiler_gnu+set}" = set; then

2297 echo $ECHO_N "(cached) $ECHO_C" >&6

2298 else

2299 cat >conftest.$ac_ext <<_ACEOF

2300 /* confdefs.h. */

2301 _ACEOF

2302 cat confdefs.h >>conftest.$ac_ext

2303 cat >>conftest.$ac_ext <<_ACEOF

2304 /* end confdefs.h. */

2305

2306 int

2307 main ()

2308 {

2309 #ifndef __GNUC__

2310 choke me

2311 #endif

2312

2313 ;

2314 return 0;

2315 }

2316 _ACEOF

2317 rm -f conftest.$ac_objext

2318 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

2319 (eval $ac_compile) 2>conftest.er1

2320 ac_status=$?

2321 grep -v '^ *+' conftest.er1 >conftest.err

2322 rm -f conftest.er1

2323 cat conftest.err >&5

2324 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2325 (exit $ac_status); } &&

2326 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

2327 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

2328 (eval $ac_try) 2>&5

2329 ac_status=$?

2330 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2331 (exit $ac_status); }; } &&

2332 { ac_try='test -s conftest.$ac_objext'

2333 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

2334 (eval $ac_try) 2>&5

2335 ac_status=$?

2336 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2337 (exit $ac_status); }; }; then

2338 ac_compiler_gnu=yes

2339 else

2340 echo "$as_me: failed program was:" >&5

2341 sed 's/^/| /' conftest.$ac_ext >&5

2342

2343 ac_compiler_gnu=no

2344 fi

2345 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

2346 ac_cv_c_compiler_gnu=$ac_compiler_gnu

2347

2348 fi

2349 echo "$as_me:$LINENO: result: $ac_cv_c_compiler_gnu" >&5

2350 echo "${ECHO_T}$ac_cv_c_compiler_gnu" >&6

2351 GCC=`test $ac_compiler_gnu = yes && echo yes`

2352 ac_test_CFLAGS=${CFLAGS+set}

2353 ac_save_CFLAGS=$CFLAGS

2354 CFLAGS="-g"

2355 echo "$as_me:$LINENO: checking whether $CC accepts -g" >&5

2356 echo $ECHO_N "checking whether $CC accepts -g... $ECHO_C" >&6

2357 if test "${ac_cv_prog_cc_g+set}" = set; then

2358 echo $ECHO_N "(cached) $ECHO_C" >&6

2359 else

2360 cat >conftest.$ac_ext <<_ACEOF

2361 /* confdefs.h. */

2362 _ACEOF

2363 cat confdefs.h >>conftest.$ac_ext

2364 cat >>conftest.$ac_ext <<_ACEOF

2365 /* end confdefs.h. */

2366

2367 int

2368 main ()

2369 {

2370

2371 ;

2372 return 0;

2373 }

2374 _ACEOF

2375 rm -f conftest.$ac_objext

2376 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

2377 (eval $ac_compile) 2>conftest.er1

2378 ac_status=$?

2379 grep -v '^ *+' conftest.er1 >conftest.err

2380 rm -f conftest.er1

2381 cat conftest.err >&5

2382 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2383 (exit $ac_status); } &&

2384 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

2385 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

2386 (eval $ac_try) 2>&5

2387 ac_status=$?

2388 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2389 (exit $ac_status); }; } &&

2390 { ac_try='test -s conftest.$ac_objext'

2391 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

2392 (eval $ac_try) 2>&5

2393 ac_status=$?

2394 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2395 (exit $ac_status); }; }; then

2396 ac_cv_prog_cc_g=yes

2397 else

2398 echo "$as_me: failed program was:" >&5

2399 sed 's/^/| /' conftest.$ac_ext >&5

2400

2401 ac_cv_prog_cc_g=no

2402 fi

2403 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

2404 fi

2405 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_g" >&5

2406 echo "${ECHO_T}$ac_cv_prog_cc_g" >&6

2407 if test "$ac_test_CFLAGS" = set; then

2408 CFLAGS=$ac_save_CFLAGS

2409 elif test $ac_cv_prog_cc_g = yes; then

2410 if test "$GCC" = yes; then

2411 CFLAGS="-g -O2"

2412 else

2413 CFLAGS="-g"

2414 fi

2415 else

2416 if test "$GCC" = yes; then

2417 CFLAGS="-O2"

2418 else

2419 CFLAGS=

2420 fi

2421 fi

2422 echo "$as_me:$LINENO: checking for $CC option to accept ANSI C" >&5

2423 echo $ECHO_N "checking for $CC option to accept ANSI C... $ECHO_C" >&6

2424 if test "${ac_cv_prog_cc_stdc+set}" = set; then

2425 echo $ECHO_N "(cached) $ECHO_C" >&6

2426 else

2427 ac_cv_prog_cc_stdc=no

2428 ac_save_CC=$CC

2429 cat >conftest.$ac_ext <<_ACEOF

2430 /* confdefs.h. */

2431 _ACEOF

2432 cat confdefs.h >>conftest.$ac_ext

2433 cat >>conftest.$ac_ext <<_ACEOF

2434 /* end confdefs.h. */

2435 #include <stdarg.h>

2436 #include <stdio.h>

2437 #include <sys/types.h>

2438 #include <sys/stat.h>

2439 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh. */

2440 struct buf { int x; };

2441 FILE * (*rcsopen) (struct buf *, struct stat *, int);

2442 static char *e (p, i)

2443 char **p;

2444 int i;

2445 {

2446 return p[i];

2447 }

2448 static char *f (char * (*g) (char **, int), char **p, ...)

2449 {

2450 char *s;

2451 va_list v;

2452 va_start (v,p);

2453 s = g (p, va_arg (v,int));

2454 va_end (v);

2455 return s;

2456 }

2457

2458 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default. It has

2459 function prototypes and stuff, but not '\xHH' hex character constants.

2460 These don't provoke an error unfortunately, instead are silently treated

2461 as 'x'. The following induces an error, until -std1 is added to get

2462 proper ANSI mode. Curiously '\x00'!='x' always comes out true, for an

2463 array size at least. It's necessary to write '\x00'==0 to get something

2464 that's true only with -std1. */

2465 int osf4_cc_array ['\x00' == 0 ? 1 : -1];

2466

2467 int test (int i, double x);

2468 struct s1 {int (*f) (int a);};

2469 struct s2 {int (*f) (double a);};

2470 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);

2471 int argc;

2472 char **argv;

2473 int

2474 main ()

2475 {

2476 return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];

2477 ;

2478 return 0;

2479 }

2480 _ACEOF

2481 # Don't try gcc -ansi; that turns off useful extensions and

2482 # breaks some systems' header files.

2483 # AIX -qlanglvl=ansi

2484 # Ultrix and OSF/1 -std1

2485 # HP-UX 10.20 and later -Ae

2486 # HP-UX older versions -Aa -D_HPUX_SOURCE

2487 # SVR4 -Xc -D__EXTENSIONS__

2488 for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"

2489 do

2490 CC="$ac_save_CC $ac_arg"

2491 rm -f conftest.$ac_objext

2492 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

2493 (eval $ac_compile) 2>conftest.er1

2494 ac_status=$?

2495 grep -v '^ *+' conftest.er1 >conftest.err

2496 rm -f conftest.er1

2497 cat conftest.err >&5

2498 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2499 (exit $ac_status); } &&

2500 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

2501 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

2502 (eval $ac_try) 2>&5

2503 ac_status=$?

2504 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2505 (exit $ac_status); }; } &&

2506 { ac_try='test -s conftest.$ac_objext'

2507 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

2508 (eval $ac_try) 2>&5

2509 ac_status=$?

2510 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2511 (exit $ac_status); }; }; then

2512 ac_cv_prog_cc_stdc=$ac_arg

2513 break

2514 else

2515 echo "$as_me: failed program was:" >&5

2516 sed 's/^/| /' conftest.$ac_ext >&5

2517

2518 fi

2519 rm -f conftest.err conftest.$ac_objext

2520 done

2521 rm -f conftest.$ac_ext conftest.$ac_objext

2522 CC=$ac_save_CC

2523

2524 fi

2525

2526 case "x$ac_cv_prog_cc_stdc" in

2527 x|xno)

2528 echo "$as_me:$LINENO: result: none needed" >&5

2529 echo "${ECHO_T}none needed" >&6 ;;

2530 *)

2531 echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5

2532 echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6

2533 CC="$CC $ac_cv_prog_cc_stdc" ;;

2534 esac

2535

2536 # Some people use a C++ compiler to compile C. Since we use `exit',

2537 # in C++ we need to declare it. In case someone uses the same compiler

2538 # for both compiling C and C++ we need to have the C++ compiler decide

2539 # the declaration of exit, since it's the most demanding environment.

2540 cat >conftest.$ac_ext <<_ACEOF

2541 #ifndef __cplusplus

2542 choke me

2543 #endif

2544 _ACEOF

2545 rm -f conftest.$ac_objext

2546 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

2547 (eval $ac_compile) 2>conftest.er1

2548 ac_status=$?

2549 grep -v '^ *+' conftest.er1 >conftest.err

2550 rm -f conftest.er1

2551 cat conftest.err >&5

2552 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2553 (exit $ac_status); } &&

2554 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

2555 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

2556 (eval $ac_try) 2>&5

2557 ac_status=$?

2558 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2559 (exit $ac_status); }; } &&

2560 { ac_try='test -s conftest.$ac_objext'

2561 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

2562 (eval $ac_try) 2>&5

2563 ac_status=$?

2564 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2565 (exit $ac_status); }; }; then

2566 for ac_declaration in \

2567 '' \

2568 'extern "C" void std::exit (int) throw (); using std::exit;' \

2569 'extern "C" void std::exit (int); using std::exit;' \

2570 'extern "C" void exit (int) throw ();' \

2571 'extern "C" void exit (int);' \

2572 'void exit (int);'

2573 do

2574 cat >conftest.$ac_ext <<_ACEOF

2575 /* confdefs.h. */

2576 _ACEOF

2577 cat confdefs.h >>conftest.$ac_ext

2578 cat >>conftest.$ac_ext <<_ACEOF

2579 /* end confdefs.h. */

2580 $ac_declaration

2581 #include <stdlib.h>

2582 int

2583 main ()

2584 {

2585 exit (42);

2586 ;

2587 return 0;

2588 }

2589 _ACEOF

2590 rm -f conftest.$ac_objext

2591 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

2592 (eval $ac_compile) 2>conftest.er1

2593 ac_status=$?

2594 grep -v '^ *+' conftest.er1 >conftest.err

2595 rm -f conftest.er1

2596 cat conftest.err >&5

2597 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2598 (exit $ac_status); } &&

2599 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

2600 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

2601 (eval $ac_try) 2>&5

2602 ac_status=$?

2603 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2604 (exit $ac_status); }; } &&

2605 { ac_try='test -s conftest.$ac_objext'

2606 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

2607 (eval $ac_try) 2>&5

2608 ac_status=$?

2609 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2610 (exit $ac_status); }; }; then

2611 :

2612 else

2613 echo "$as_me: failed program was:" >&5

2614 sed 's/^/| /' conftest.$ac_ext >&5

2615

2616 continue

2617 fi

2618 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

2619 cat >conftest.$ac_ext <<_ACEOF

2620 /* confdefs.h. */

2621 _ACEOF

2622 cat confdefs.h >>conftest.$ac_ext

2623 cat >>conftest.$ac_ext <<_ACEOF

2624 /* end confdefs.h. */

2625 $ac_declaration

2626 int

2627 main ()

2628 {

2629 exit (42);

2630 ;

2631 return 0;

2632 }

2633 _ACEOF

2634 rm -f conftest.$ac_objext

2635 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

2636 (eval $ac_compile) 2>conftest.er1

2637 ac_status=$?

2638 grep -v '^ *+' conftest.er1 >conftest.err

2639 rm -f conftest.er1

2640 cat conftest.err >&5

2641 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2642 (exit $ac_status); } &&

2643 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

2644 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

2645 (eval $ac_try) 2>&5

2646 ac_status=$?

2647 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2648 (exit $ac_status); }; } &&

2649 { ac_try='test -s conftest.$ac_objext'

2650 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

2651 (eval $ac_try) 2>&5

2652 ac_status=$?

2653 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2654 (exit $ac_status); }; }; then

2655 break

2656 else

2657 echo "$as_me: failed program was:" >&5

2658 sed 's/^/| /' conftest.$ac_ext >&5

2659

2660 fi

2661 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

2662 done

2663 rm -f conftest*

2664 if test -n "$ac_declaration"; then

2665 echo '#ifdef __cplusplus' >>confdefs.h

2666 echo $ac_declaration >>confdefs.h

2667 echo '#endif' >>confdefs.h

2668 fi

2669

2670 else

2671 echo "$as_me: failed program was:" >&5

2672 sed 's/^/| /' conftest.$ac_ext >&5

2673

2674 fi

2675 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

2676 ac_ext=c

2677 ac_cpp='$CPP $CPPFLAGS'

2678 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

2679 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

2680 ac_compiler_gnu=$ac_cv_c_compiler_gnu

2681 DEPDIR="${am__leading_dot}deps"

2682

2683 ac_config_commands="$ac_config_commands depfiles"

2684

2685

2686 am_make=${MAKE-make}

2687 cat > confinc << 'END'

2688 am__doit:

2689 @echo done

2690 .PHONY: am__doit

2691 END

2692 # If we don't find an include directive, just comment out the code.

2693 echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5

2694 echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6

2695 am__include="#"

2696 am__quote=

2697 _am_result=none

2698 # First try GNU make style include.

2699 echo "include confinc" > confmf

2700 # We grep out `Entering directory' and `Leaving directory'

2701 # messages which can occur if `w' ends up in MAKEFLAGS.

2702 # In particular we don't look at `^make:' because GNU make might

2703 # be invoked under some other name (usually "gmake"), in which

2704 # case it prints its new name instead of `make'.

2705 if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then

2706 am__include=include

2707 am__quote=

2708 _am_result=GNU

2709 fi

2710 # Now try BSD make style include.

2711 if test "$am__include" = "#"; then

2712 echo '.include "confinc"' > confmf

2713 if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then

2714 am__include=.include

2715 am__quote="\""

2716 _am_result=BSD

2717 fi

2718 fi

2719

2720

2721 echo "$as_me:$LINENO: result: $_am_result" >&5

2722 echo "${ECHO_T}$_am_result" >&6

2723 rm -f confinc confmf

2724

2725 # Check whether --enable-dependency-tracking or --disable-dependency-tracking was given.

2726 if test "${enable_dependency_tracking+set}" = set; then

2727 enableval="$enable_dependency_tracking"

2728

2729 fi;

2730 if test "x$enable_dependency_tracking" != xno; then

2731 am_depcomp="$ac_aux_dir/depcomp"

2732 AMDEPBACKSLASH='\'

2733 fi

2734

2735

2736 if test "x$enable_dependency_tracking" != xno; then

2737 AMDEP_TRUE=

2738 AMDEP_FALSE='#'

2739 else

2740 AMDEP_TRUE='#'

2741 AMDEP_FALSE=

2742 fi

2743

2744

2745

2746

2747 depcc="$CC" am_compiler_list=

2748

2749 echo "$as_me:$LINENO: checking dependency style of $depcc" >&5

2750 echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6

2751 if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then

2752 echo $ECHO_N "(cached) $ECHO_C" >&6

2753 else

2754 if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then

2755 # We make a subdir and do the tests there. Otherwise we can end up

2756 # making bogus files that we don't know about and never remove. For

2757 # instance it was reported that on HP-UX the gcc test will end up

2758 # making a dummy file named `D' -- because `-MD' means `put the output

2759 # in D'.

2760 mkdir conftest.dir

2761 # Copy depcomp to subdir because otherwise we won't find it if we're

2762 # using a relative directory.

2763 cp "$am_depcomp" conftest.dir

2764 cd conftest.dir

2765 # We will build objects and dependencies in a subdirectory because

2766 # it helps to detect inapplicable dependency modes. For instance

2767 # both Tru64's cc and ICC support -MD to output dependencies as a

2768 # side effect of compilation, but ICC will put the dependencies in

2769 # the current directory while Tru64 will put them in the object

2770 # directory.

2771 mkdir sub

2772

2773 am_cv_CC_dependencies_compiler_type=none

2774 if test "$am_compiler_list" = ""; then

2775 am_compiler_list=`sed -n 's/^#*$[a-zA-Z0-9]*$)$/\1/p' < ./depcomp`

2776 fi

2777 for depmode in $am_compiler_list; do

2778 # Setup a source with many dependencies, because some compilers

2779 # like to wrap large dependency lists on column 80 (with \), and

2780 # we should not choose a depcomp mode which is confused by this.

2781 #

2782 # We need to recreate these files for each test, as the compiler may

2783 # overwrite some of them when testing with obscure command lines.

2784 # This happens at least with the AIX C compiler.

2785 : > sub/conftest.c

2786 for i in 1 2 3 4 5 6; do

2787 echo '#include "conftst'$i'.h"' >> sub/conftest.c

2788 : > sub/conftst$i.h

2789 done

2790 echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf

2791

2792 case $depmode in

2793 nosideeffect)

2794 # after this tag, mechanisms are not by side-effect, so they'll

2795 # only be used when explicitly requested

2796 if test "x$enable_dependency_tracking" = xyes; then

2797 continue

2798 else

2799 break

2800 fi

2801 ;;

2802 none) break ;;

2803 esac

2804 # We check with `-c' and `-o' for the sake of the "dashmstdout"

2805 # mode. It turns out that the SunPro C++ compiler does not properly

2806 # handle `-M -o', and we need to detect this.

2807 if depmode=$depmode \

2808 source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \

2809 depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \

2810 $SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \

2811 >/dev/null 2>conftest.err &&

2812 grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&

2813 grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&

2814 ${MAKE-make} -s -f confmf > /dev/null 2>&1; then

2815 # icc doesn't choke on unknown options, it will just issue warnings

2816 # (even with -Werror). So we grep stderr for any message

2817 # that says an option was ignored.

2818 if grep 'ignoring option' conftest.err >/dev/null 2>&1; then :; else

2819 am_cv_CC_dependencies_compiler_type=$depmode

2820 break

2821 fi

2822 fi

2823 done

2824

2825 cd ..

2826 rm -rf conftest.dir

2827 else

2828 am_cv_CC_dependencies_compiler_type=none

2829 fi

2830

2831 fi

2832 echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5

2833 echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6

2834 CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type

2835

2836

2837

2838 if

2839 test "x$enable_dependency_tracking" != xno \

2840 && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then

2841 am__fastdepCC_TRUE=

2842 am__fastdepCC_FALSE='#'

2843 else

2844 am__fastdepCC_TRUE='#'

2845 am__fastdepCC_FALSE=

2846 fi

2847

2848

2849

2850

2851 echo "$as_me:$LINENO: checking for strerror in -lcposix" >&5

2852 echo $ECHO_N "checking for strerror in -lcposix... $ECHO_C" >&6

2853 if test "${ac_cv_lib_cposix_strerror+set}" = set; then

2854 echo $ECHO_N "(cached) $ECHO_C" >&6

2855 else

2856 ac_check_lib_save_LIBS=$LIBS

2857 LIBS="-lcposix $LIBS"

2858 cat >conftest.$ac_ext <<_ACEOF

2859 /* confdefs.h. */

2860 _ACEOF

2861 cat confdefs.h >>conftest.$ac_ext

2862 cat >>conftest.$ac_ext <<_ACEOF

2863 /* end confdefs.h. */

2864

2865 /* Override any gcc2 internal prototype to avoid an error. */

2866 #ifdef __cplusplus

2867 extern "C"

2868 #endif

2869 /* We use char because int might match the return type of a gcc2

2870 builtin and then its argument prototype would still apply. */

2871 char strerror ();

2872 int

2873 main ()

2874 {

2875 strerror ();

2876 ;

2877 return 0;

2878 }

2879 _ACEOF

2880 rm -f conftest.$ac_objext conftest$ac_exeext

2881 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

2882 (eval $ac_link) 2>conftest.er1

2883 ac_status=$?

2884 grep -v '^ *+' conftest.er1 >conftest.err

2885 rm -f conftest.er1

2886 cat conftest.err >&5

2887 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2888 (exit $ac_status); } &&

2889 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

2890 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

2891 (eval $ac_try) 2>&5

2892 ac_status=$?

2893 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2894 (exit $ac_status); }; } &&

2895 { ac_try='test -s conftest$ac_exeext'

2896 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

2897 (eval $ac_try) 2>&5

2898 ac_status=$?

2899 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2900 (exit $ac_status); }; }; then

2901 ac_cv_lib_cposix_strerror=yes

2902 else

2903 echo "$as_me: failed program was:" >&5

2904 sed 's/^/| /' conftest.$ac_ext >&5

2905

2906 ac_cv_lib_cposix_strerror=no

2907 fi

2908 rm -f conftest.err conftest.$ac_objext \

2909 conftest$ac_exeext conftest.$ac_ext

2910 LIBS=$ac_check_lib_save_LIBS

2911 fi

2912 echo "$as_me:$LINENO: result: $ac_cv_lib_cposix_strerror" >&5

2913 echo "${ECHO_T}$ac_cv_lib_cposix_strerror" >&6

2914 if test $ac_cv_lib_cposix_strerror = yes; then

2915 LIBS="$LIBS -lcposix"

2916 fi

2917

2918

2919

2920 ac_ext=c

2921 ac_cpp='$CPP $CPPFLAGS'

2922 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

2923 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

2924 ac_compiler_gnu=$ac_cv_c_compiler_gnu

2925 echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5

2926 echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6

2927 # On Suns, sometimes $CPP names a directory.

2928 if test -n "$CPP" && test -d "$CPP"; then

2929 CPP=

2930 fi

2931 if test -z "$CPP"; then

2932 if test "${ac_cv_prog_CPP+set}" = set; then

2933 echo $ECHO_N "(cached) $ECHO_C" >&6

2934 else

2935 # Double quotes because CPP needs to be expanded

2936 for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"

2937 do

2938 ac_preproc_ok=false

2939 for ac_c_preproc_warn_flag in '' yes

2940 do

2941 # Use a header file that comes with gcc, so configuring glibc

2942 # with a fresh cross-compiler works.

2943 # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

2944 # <limits.h> exists even on freestanding compilers.

2945 # On the NeXT, cc -E runs the code through the compiler's parser,

2946 # not just through cpp. "Syntax error" is here to catch this case.

2947 cat >conftest.$ac_ext <<_ACEOF

2948 /* confdefs.h. */

2949 _ACEOF

2950 cat confdefs.h >>conftest.$ac_ext

2951 cat >>conftest.$ac_ext <<_ACEOF

2952 /* end confdefs.h. */

2953 #ifdef __STDC__

2954 # include <limits.h>

2955 #else

2956 # include <assert.h>

2957 #endif

2958 Syntax error

2959 _ACEOF

2960 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

2961 (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

2962 ac_status=$?

2963 grep -v '^ *+' conftest.er1 >conftest.err

2964 rm -f conftest.er1

2965 cat conftest.err >&5

2966 echo "$as_me:$LINENO: \$? = $ac_status" >&5

2967 (exit $ac_status); } >/dev/null; then

2968 if test -s conftest.err; then

2969 ac_cpp_err=$ac_c_preproc_warn_flag

2970 ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

2971 else

2972 ac_cpp_err=

2973 fi

2974 else

2975 ac_cpp_err=yes

2976 fi

2977 if test -z "$ac_cpp_err"; then

2978 :

2979 else

2980 echo "$as_me: failed program was:" >&5

2981 sed 's/^/| /' conftest.$ac_ext >&5

2982

2983 # Broken: fails on valid input.

2984 continue

2985 fi

2986 rm -f conftest.err conftest.$ac_ext

2987

2988 # OK, works on sane cases. Now check whether non-existent headers

2989 # can be detected and how.

2990 cat >conftest.$ac_ext <<_ACEOF

2991 /* confdefs.h. */

2992 _ACEOF

2993 cat confdefs.h >>conftest.$ac_ext

2994 cat >>conftest.$ac_ext <<_ACEOF

2995 /* end confdefs.h. */

2996 #include <ac_nonexistent.h>

2997 _ACEOF

2998 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

2999 (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

3000 ac_status=$?

3001 grep -v '^ *+' conftest.er1 >conftest.err

3002 rm -f conftest.er1

3003 cat conftest.err >&5

3004 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3005 (exit $ac_status); } >/dev/null; then

3006 if test -s conftest.err; then

3007 ac_cpp_err=$ac_c_preproc_warn_flag

3008 ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

3009 else

3010 ac_cpp_err=

3011 fi

3012 else

3013 ac_cpp_err=yes

3014 fi

3015 if test -z "$ac_cpp_err"; then

3016 # Broken: success on invalid input.

3017 continue

3018 else

3019 echo "$as_me: failed program was:" >&5

3020 sed 's/^/| /' conftest.$ac_ext >&5

3021

3022 # Passes both tests.

3023 ac_preproc_ok=:

3024 break

3025 fi

3026 rm -f conftest.err conftest.$ac_ext

3027

3028 done

3029 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.

3030 rm -f conftest.err conftest.$ac_ext

3031 if $ac_preproc_ok; then

3032 break

3033 fi

3034

3035 done

3036 ac_cv_prog_CPP=$CPP

3037

3038 fi

3039 CPP=$ac_cv_prog_CPP

3040 else

3041 ac_cv_prog_CPP=$CPP

3042 fi

3043 echo "$as_me:$LINENO: result: $CPP" >&5

3044 echo "${ECHO_T}$CPP" >&6

3045 ac_preproc_ok=false

3046 for ac_c_preproc_warn_flag in '' yes

3047 do

3048 # Use a header file that comes with gcc, so configuring glibc

3049 # with a fresh cross-compiler works.

3050 # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

3051 # <limits.h> exists even on freestanding compilers.

3052 # On the NeXT, cc -E runs the code through the compiler's parser,

3053 # not just through cpp. "Syntax error" is here to catch this case.

3054 cat >conftest.$ac_ext <<_ACEOF

3055 /* confdefs.h. */

3056 _ACEOF

3057 cat confdefs.h >>conftest.$ac_ext

3058 cat >>conftest.$ac_ext <<_ACEOF

3059 /* end confdefs.h. */

3060 #ifdef __STDC__

3061 # include <limits.h>

3062 #else

3063 # include <assert.h>

3064 #endif

3065 Syntax error

3066 _ACEOF

3067 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

3068 (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

3069 ac_status=$?

3070 grep -v '^ *+' conftest.er1 >conftest.err

3071 rm -f conftest.er1

3072 cat conftest.err >&5

3073 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3074 (exit $ac_status); } >/dev/null; then

3075 if test -s conftest.err; then

3076 ac_cpp_err=$ac_c_preproc_warn_flag

3077 ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

3078 else

3079 ac_cpp_err=

3080 fi

3081 else

3082 ac_cpp_err=yes

3083 fi

3084 if test -z "$ac_cpp_err"; then

3085 :

3086 else

3087 echo "$as_me: failed program was:" >&5

3088 sed 's/^/| /' conftest.$ac_ext >&5

3089

3090 # Broken: fails on valid input.

3091 continue

3092 fi

3093 rm -f conftest.err conftest.$ac_ext

3094

3095 # OK, works on sane cases. Now check whether non-existent headers

3096 # can be detected and how.

3097 cat >conftest.$ac_ext <<_ACEOF

3098 /* confdefs.h. */

3099 _ACEOF

3100 cat confdefs.h >>conftest.$ac_ext

3101 cat >>conftest.$ac_ext <<_ACEOF

3102 /* end confdefs.h. */

3103 #include <ac_nonexistent.h>

3104 _ACEOF

3105 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

3106 (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

3107 ac_status=$?

3108 grep -v '^ *+' conftest.er1 >conftest.err

3109 rm -f conftest.er1

3110 cat conftest.err >&5

3111 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3112 (exit $ac_status); } >/dev/null; then

3113 if test -s conftest.err; then

3114 ac_cpp_err=$ac_c_preproc_warn_flag

3115 ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

3116 else

3117 ac_cpp_err=

3118 fi

3119 else

3120 ac_cpp_err=yes

3121 fi

3122 if test -z "$ac_cpp_err"; then

3123 # Broken: success on invalid input.

3124 continue

3125 else

3126 echo "$as_me: failed program was:" >&5

3127 sed 's/^/| /' conftest.$ac_ext >&5

3128

3129 # Passes both tests.

3130 ac_preproc_ok=:

3131 break

3132 fi

3133 rm -f conftest.err conftest.$ac_ext

3134

3135 done

3136 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.

3137 rm -f conftest.err conftest.$ac_ext

3138 if $ac_preproc_ok; then

3139 :

3140 else

3141 { { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check

3142 See \`config.log' for more details." >&5

3143 echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check

3144 See \`config.log' for more details." >&2;}

3145 { (exit 1); exit 1; }; }

3146 fi

3147

3148 ac_ext=c

3149 ac_cpp='$CPP $CPPFLAGS'

3150 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'

3151 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'

3152 ac_compiler_gnu=$ac_cv_c_compiler_gnu

3153

3154

3155 echo "$as_me:$LINENO: checking for egrep" >&5

3156 echo $ECHO_N "checking for egrep... $ECHO_C" >&6

3157 if test "${ac_cv_prog_egrep+set}" = set; then

3158 echo $ECHO_N "(cached) $ECHO_C" >&6

3159 else

3160 if echo a | (grep -E '(a|b)') >/dev/null 2>&1

3161 then ac_cv_prog_egrep='grep -E'

3162 else ac_cv_prog_egrep='egrep'

3163 fi

3164 fi

3165 echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5

3166 echo "${ECHO_T}$ac_cv_prog_egrep" >&6

3167 EGREP=$ac_cv_prog_egrep

3168

3169

3170 echo "$as_me:$LINENO: checking for ANSI C header files" >&5

3171 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6

3172 if test "${ac_cv_header_stdc+set}" = set; then

3173 echo $ECHO_N "(cached) $ECHO_C" >&6

3174 else

3175 cat >conftest.$ac_ext <<_ACEOF

3176 /* confdefs.h. */

3177 _ACEOF

3178 cat confdefs.h >>conftest.$ac_ext

3179 cat >>conftest.$ac_ext <<_ACEOF

3180 /* end confdefs.h. */

3181 #include <stdlib.h>

3182 #include <stdarg.h>

3183 #include <string.h>

3184 #include <float.h>

3185

3186 int

3187 main ()

3188 {

3189

3190 ;

3191 return 0;

3192 }

3193 _ACEOF

3194 rm -f conftest.$ac_objext

3195 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

3196 (eval $ac_compile) 2>conftest.er1

3197 ac_status=$?

3198 grep -v '^ *+' conftest.er1 >conftest.err

3199 rm -f conftest.er1

3200 cat conftest.err >&5

3201 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3202 (exit $ac_status); } &&

3203 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

3204 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3205 (eval $ac_try) 2>&5

3206 ac_status=$?

3207 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3208 (exit $ac_status); }; } &&

3209 { ac_try='test -s conftest.$ac_objext'

3210 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3211 (eval $ac_try) 2>&5

3212 ac_status=$?

3213 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3214 (exit $ac_status); }; }; then

3215 ac_cv_header_stdc=yes

3216 else

3217 echo "$as_me: failed program was:" >&5

3218 sed 's/^/| /' conftest.$ac_ext >&5

3219

3220 ac_cv_header_stdc=no

3221 fi

3222 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

3223

3224 if test $ac_cv_header_stdc = yes; then

3225 # SunOS 4.x string.h does not declare mem*, contrary to ANSI.

3226 cat >conftest.$ac_ext <<_ACEOF

3227 /* confdefs.h. */

3228 _ACEOF

3229 cat confdefs.h >>conftest.$ac_ext

3230 cat >>conftest.$ac_ext <<_ACEOF

3231 /* end confdefs.h. */

3232 #include <string.h>

3233

3234 _ACEOF

3235 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

3236 $EGREP "memchr" >/dev/null 2>&1; then

3237 :

3238 else

3239 ac_cv_header_stdc=no

3240 fi

3241 rm -f conftest*

3242

3243 fi

3244

3245 if test $ac_cv_header_stdc = yes; then

3246 # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.

3247 cat >conftest.$ac_ext <<_ACEOF

3248 /* confdefs.h. */

3249 _ACEOF

3250 cat confdefs.h >>conftest.$ac_ext

3251 cat >>conftest.$ac_ext <<_ACEOF

3252 /* end confdefs.h. */

3253 #include <stdlib.h>

3254

3255 _ACEOF

3256 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

3257 $EGREP "free" >/dev/null 2>&1; then

3258 :

3259 else

3260 ac_cv_header_stdc=no

3261 fi

3262 rm -f conftest*

3263

3264 fi

3265

3266 if test $ac_cv_header_stdc = yes; then

3267 # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.

3268 if test "$cross_compiling" = yes; then

3269 :

3270 else

3271 cat >conftest.$ac_ext <<_ACEOF

3272 /* confdefs.h. */

3273 _ACEOF

3274 cat confdefs.h >>conftest.$ac_ext

3275 cat >>conftest.$ac_ext <<_ACEOF

3276 /* end confdefs.h. */

3277 #include <ctype.h>

3278 #if ((' ' & 0x0FF) == 0x020)

3279 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')

3280 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))

3281 #else

3282 # define ISLOWER(c) \

3283 (('a' <= (c) && (c) <= 'i') \

3284 || ('j' <= (c) && (c) <= 'r') \

3285 || ('s' <= (c) && (c) <= 'z'))

3286 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))

3287 #endif

3288

3289 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))

3290 int

3291 main ()

3292 {

3293 int i;

3294 for (i = 0; i < 256; i++)

3295 if (XOR (islower (i), ISLOWER (i))

3296 || toupper (i) != TOUPPER (i))

3297 exit(2);

3298 exit (0);

3299 }

3300 _ACEOF

3301 rm -f conftest$ac_exeext

3302 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

3303 (eval $ac_link) 2>&5

3304 ac_status=$?

3305 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3306 (exit $ac_status); } && { ac_try='./conftest$ac_exeext'

3307 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3308 (eval $ac_try) 2>&5

3309 ac_status=$?

3310 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3311 (exit $ac_status); }; }; then

3312 :

3313 else

3314 echo "$as_me: program exited with status $ac_status" >&5

3315 echo "$as_me: failed program was:" >&5

3316 sed 's/^/| /' conftest.$ac_ext >&5

3317

3318 ( exit $ac_status )

3319 ac_cv_header_stdc=no

3320 fi

3321 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

3322 fi

3323 fi

3324 fi

3325 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5

3326 echo "${ECHO_T}$ac_cv_header_stdc" >&6

3327 if test $ac_cv_header_stdc = yes; then

3328

3329 cat >>confdefs.h <<\_ACEOF

3330 #define STDC_HEADERS 1

3331 _ACEOF

3332

3333 fi

3334

3335 if test -n "$ac_tool_prefix"; then

3336 # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.

3337 set dummy ${ac_tool_prefix}ranlib; ac_word=$2

3338 echo "$as_me:$LINENO: checking for $ac_word" >&5

3339 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

3340 if test "${ac_cv_prog_RANLIB+set}" = set; then

3341 echo $ECHO_N "(cached) $ECHO_C" >&6

3342 else

3343 if test -n "$RANLIB"; then

3344 ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.

3345 else

3346 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

3347 for as_dir in $PATH

3348 do

3349 IFS=$as_save_IFS

3350 test -z "$as_dir" && as_dir=.

3351 for ac_exec_ext in '' $ac_executable_extensions; do

3352 if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

3353 ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"

3354 echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

3355 break 2

3356 fi

3357 done

3358 done

3359

3360 fi

3361 fi

3362 RANLIB=$ac_cv_prog_RANLIB

3363 if test -n "$RANLIB"; then

3364 echo "$as_me:$LINENO: result: $RANLIB" >&5

3365 echo "${ECHO_T}$RANLIB" >&6

3366 else

3367 echo "$as_me:$LINENO: result: no" >&5

3368 echo "${ECHO_T}no" >&6

3369 fi

3370

3371 fi

3372 if test -z "$ac_cv_prog_RANLIB"; then

3373 ac_ct_RANLIB=$RANLIB

3374 # Extract the first word of "ranlib", so it can be a program name with args.

3375 set dummy ranlib; ac_word=$2

3376 echo "$as_me:$LINENO: checking for $ac_word" >&5

3377 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

3378 if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then

3379 echo $ECHO_N "(cached) $ECHO_C" >&6

3380 else

3381 if test -n "$ac_ct_RANLIB"; then

3382 ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.

3383 else

3384 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

3385 for as_dir in $PATH

3386 do

3387 IFS=$as_save_IFS

3388 test -z "$as_dir" && as_dir=.

3389 for ac_exec_ext in '' $ac_executable_extensions; do

3390 if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

3391 ac_cv_prog_ac_ct_RANLIB="ranlib"

3392 echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

3393 break 2

3394 fi

3395 done

3396 done

3397

3398 test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"

3399 fi

3400 fi

3401 ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB

3402 if test -n "$ac_ct_RANLIB"; then

3403 echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5

3404 echo "${ECHO_T}$ac_ct_RANLIB" >&6

3405 else

3406 echo "$as_me:$LINENO: result: no" >&5

3407 echo "${ECHO_T}no" >&6

3408 fi

3409

3410 RANLIB=$ac_ct_RANLIB

3411 else

3412 RANLIB="$ac_cv_prog_RANLIB"

3413 fi

3414

3415

3416

3417

3418 if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then

3419 if test -n "$ac_tool_prefix"; then

3420 # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.

3421 set dummy ${ac_tool_prefix}pkg-config; ac_word=$2

3422 echo "$as_me:$LINENO: checking for $ac_word" >&5

3423 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

3424 if test "${ac_cv_path_PKG_CONFIG+set}" = set; then

3425 echo $ECHO_N "(cached) $ECHO_C" >&6

3426 else

3427 case $PKG_CONFIG in

3428 [\\/]* | ?:[\\/]*)

3429 ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.

3430 ;;

3431 *)

3432 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

3433 for as_dir in $PATH

3434 do

3435 IFS=$as_save_IFS

3436 test -z "$as_dir" && as_dir=.

3437 for ac_exec_ext in '' $ac_executable_extensions; do

3438 if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

3439 ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"

3440 echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

3441 break 2

3442 fi

3443 done

3444 done

3445

3446 ;;

3447 esac

3448 fi

3449 PKG_CONFIG=$ac_cv_path_PKG_CONFIG

3450

3451 if test -n "$PKG_CONFIG"; then

3452 echo "$as_me:$LINENO: result: $PKG_CONFIG" >&5

3453 echo "${ECHO_T}$PKG_CONFIG" >&6

3454 else

3455 echo "$as_me:$LINENO: result: no" >&5

3456 echo "${ECHO_T}no" >&6

3457 fi

3458

3459 fi

3460 if test -z "$ac_cv_path_PKG_CONFIG"; then

3461 ac_pt_PKG_CONFIG=$PKG_CONFIG

3462 # Extract the first word of "pkg-config", so it can be a program name with args.

3463 set dummy pkg-config; ac_word=$2

3464 echo "$as_me:$LINENO: checking for $ac_word" >&5

3465 echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

3466 if test "${ac_cv_path_ac_pt_PKG_CONFIG+set}" = set; then

3467 echo $ECHO_N "(cached) $ECHO_C" >&6

3468 else

3469 case $ac_pt_PKG_CONFIG in

3470 [\\/]* | ?:[\\/]*)

3471 ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.

3472 ;;

3473 *)

3474 as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

3475 for as_dir in $PATH

3476 do

3477 IFS=$as_save_IFS

3478 test -z "$as_dir" && as_dir=.

3479 for ac_exec_ext in '' $ac_executable_extensions; do

3480 if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

3481 ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"

3482 echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

3483 break 2

3484 fi

3485 done

3486 done

3487

3488 ;;

3489 esac

3490 fi

3491 ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG

3492

3493 if test -n "$ac_pt_PKG_CONFIG"; then

3494 echo "$as_me:$LINENO: result: $ac_pt_PKG_CONFIG" >&5

3495 echo "${ECHO_T}$ac_pt_PKG_CONFIG" >&6

3496 else

3497 echo "$as_me:$LINENO: result: no" >&5

3498 echo "${ECHO_T}no" >&6

3499 fi

3500

3501 PKG_CONFIG=$ac_pt_PKG_CONFIG

3502 else

3503 PKG_CONFIG="$ac_cv_path_PKG_CONFIG"

3504 fi

3505

3506 fi

3507 if test -n "$PKG_CONFIG"; then

3508 _pkg_min_version=0.9.0

3509 echo "$as_me:$LINENO: checking pkg-config is at least version $_pkg_min_version" >&5

3510 echo $ECHO_N "checking pkg-config is at least version $_pkg_min_version... $ECHO_C" >&6

3511 if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then

3512 echo "$as_me:$LINENO: result: yes" >&5

3513 echo "${ECHO_T}yes" >&6

3514 else

3515 echo "$as_me:$LINENO: result: no" >&5

3516 echo "${ECHO_T}no" >&6

3517 PKG_CONFIG=""

3518 fi

3519

3520 fi

3521

3522 pkg_failed=no

3523 echo "$as_me:$LINENO: checking for GLIB" >&5

3524 echo $ECHO_N "checking for GLIB... $ECHO_C" >&6

3525

3526 if test -n "$PKG_CONFIG"; then

3527 if test -n "$PKG_CONFIG" && \

3528 { (echo "$as_me:$LINENO: \$PKG_CONFIG --exists --print-errors \"glib-2.0\"") >&5

3529 ($PKG_CONFIG --exists --print-errors "glib-2.0") 2>&5

3530 ac_status=$?

3531 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3532 (exit $ac_status); }; then

3533 pkg_cv_GLIB_CFLAGS=`$PKG_CONFIG --cflags "glib-2.0" 2>/dev/null`

3534 else

3535 pkg_failed=yes

3536 fi

3537 else

3538 pkg_failed=untried

3539 fi

3540 if test -n "$PKG_CONFIG"; then

3541 if test -n "$PKG_CONFIG" && \

3542 { (echo "$as_me:$LINENO: \$PKG_CONFIG --exists --print-errors \"glib-2.0\"") >&5

3543 ($PKG_CONFIG --exists --print-errors "glib-2.0") 2>&5

3544 ac_status=$?

3545 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3546 (exit $ac_status); }; then

3547 pkg_cv_GLIB_LIBS=`$PKG_CONFIG --libs "glib-2.0" 2>/dev/null`

3548 else

3549 pkg_failed=yes

3550 fi

3551 else

3552 pkg_failed=untried

3553 fi

3554

3555 if test $pkg_failed = yes; then

3556 GLIB_PKG_ERRORS=`$PKG_CONFIG --errors-to-stdout --print-errors "glib-2.0"`

3557 # Put the nasty error message in config.log where it belongs

3558 echo "$GLIB_PKG_ERRORS" 1>&5

3559

3560 { { echo "$as_me:$LINENO: error: Package requirements (glib-2.0) were not met.

3561 Consider adjusting the PKG_CONFIG_PATH environment variable if you

3562 installed software in a non-standard prefix.

3563

3564 Alternatively you may set the GLIB_CFLAGS and GLIB_LIBS environment variables

3565 to avoid the need to call pkg-config. See the pkg-config man page for

3566 more details." >&5

3567 echo "$as_me: error: Package requirements (glib-2.0) were not met.

3568 Consider adjusting the PKG_CONFIG_PATH environment variable if you

3569 installed software in a non-standard prefix.

3570

3571 Alternatively you may set the GLIB_CFLAGS and GLIB_LIBS environment variables

3572 to avoid the need to call pkg-config. See the pkg-config man page for

3573 more details." >&2;}

3574 { (exit 1); exit 1; }; }

3575 elif test $pkg_failed = untried; then

3576 { { echo "$as_me:$LINENO: error: The pkg-config script could not be found or is too old. Make sure it

3577 is in your PATH or set the PKG_CONFIG environment variable to the full

3578 path to pkg-config.

3579

3580 Alternatively you may set the GLIB_CFLAGS and GLIB_LIBS environment variables

3581 to avoid the need to call pkg-config. See the pkg-config man page for

3582 more details.

3583

3584 To get pkg-config, see <http://www.freedesktop.org/software/pkgconfig>.

3585 See \`config.log' for more details." >&5

3586 echo "$as_me: error: The pkg-config script could not be found or is too old. Make sure it

3587 is in your PATH or set the PKG_CONFIG environment variable to the full

3588 path to pkg-config.

3589

3590 Alternatively you may set the GLIB_CFLAGS and GLIB_LIBS environment variables

3591 to avoid the need to call pkg-config. See the pkg-config man page for

3592 more details.

3593

3594 To get pkg-config, see <http://www.freedesktop.org/software/pkgconfig>.

3595 See \`config.log' for more details." >&2;}

3596 { (exit 1); exit 1; }; }

3597 else

3598 GLIB_CFLAGS=$pkg_cv_GLIB_CFLAGS

3599 GLIB_LIBS=$pkg_cv_GLIB_LIBS

3600 echo "$as_me:$LINENO: result: yes" >&5

3601 echo "${ECHO_T}yes" >&6

3602 :

3603 fi

3604

3605

3606

3607 # Check whether --enable-resolver or --disable-resolver was given.

3608 if test "${enable_resolver+set}" = set; then

3609 enableval="$enable_resolver"

3610 if test "$enable_resolver" != 'no'; then

3611 resolver_enabled='yes'

3612 fi

3613 else

3614 resolver_enabled='yes'

3615

3616 fi;

3617

3618 if test "$resolver_enabled" = yes; then

3619

3620 cat >>confdefs.h <<\_ACEOF

3621 #define ENABLE_RESOLVER 1

3622 _ACEOF

3623

3624 echo "$as_me:$LINENO: checking for res_search in -lc" >&5

3625 echo $ECHO_N "checking for res_search in -lc... $ECHO_C" >&6

3626 if test "${ac_cv_lib_c_res_search+set}" = set; then

3627 echo $ECHO_N "(cached) $ECHO_C" >&6

3628 else

3629 ac_check_lib_save_LIBS=$LIBS

3630 LIBS="-lc $LIBS"

3631 cat >conftest.$ac_ext <<_ACEOF

3632 /* confdefs.h. */

3633 _ACEOF

3634 cat confdefs.h >>conftest.$ac_ext

3635 cat >>conftest.$ac_ext <<_ACEOF

3636 /* end confdefs.h. */

3637

3638 /* Override any gcc2 internal prototype to avoid an error. */

3639 #ifdef __cplusplus

3640 extern "C"

3641 #endif

3642 /* We use char because int might match the return type of a gcc2

3643 builtin and then its argument prototype would still apply. */

3644 char res_search ();

3645 int

3646 main ()

3647 {

3648 res_search ();

3649 ;

3650 return 0;

3651 }

3652 _ACEOF

3653 rm -f conftest.$ac_objext conftest$ac_exeext

3654 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

3655 (eval $ac_link) 2>conftest.er1

3656 ac_status=$?

3657 grep -v '^ *+' conftest.er1 >conftest.err

3658 rm -f conftest.er1

3659 cat conftest.err >&5

3660 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3661 (exit $ac_status); } &&

3662 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

3663 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3664 (eval $ac_try) 2>&5

3665 ac_status=$?

3666 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3667 (exit $ac_status); }; } &&

3668 { ac_try='test -s conftest$ac_exeext'

3669 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3670 (eval $ac_try) 2>&5

3671 ac_status=$?

3672 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3673 (exit $ac_status); }; }; then

3674 ac_cv_lib_c_res_search=yes

3675 else

3676 echo "$as_me: failed program was:" >&5

3677 sed 's/^/| /' conftest.$ac_ext >&5

3678

3679 ac_cv_lib_c_res_search=no

3680 fi

3681 rm -f conftest.err conftest.$ac_objext \

3682 conftest$ac_exeext conftest.$ac_ext

3683 LIBS=$ac_check_lib_save_LIBS

3684 fi

3685 echo "$as_me:$LINENO: result: $ac_cv_lib_c_res_search" >&5

3686 echo "${ECHO_T}$ac_cv_lib_c_res_search" >&6

3687 if test $ac_cv_lib_c_res_search = yes; then

3688 need_resolv=no

3689 else

3690 need_resolv=yes

3691 fi

3692

3693 if test "$need_resolv" = yes; then

3694 echo "$as_me:$LINENO: checking for res_search in -lresolv" >&5

3695 echo $ECHO_N "checking for res_search in -lresolv... $ECHO_C" >&6

3696 if test "${ac_cv_lib_resolv_res_search+set}" = set; then

3697 echo $ECHO_N "(cached) $ECHO_C" >&6

3698 else

3699 ac_check_lib_save_LIBS=$LIBS

3700 LIBS="-lresolv $LIBS"

3701 cat >conftest.$ac_ext <<_ACEOF

3702 /* confdefs.h. */

3703 _ACEOF

3704 cat confdefs.h >>conftest.$ac_ext

3705 cat >>conftest.$ac_ext <<_ACEOF

3706 /* end confdefs.h. */

3707

3708 /* Override any gcc2 internal prototype to avoid an error. */

3709 #ifdef __cplusplus

3710 extern "C"

3711 #endif

3712 /* We use char because int might match the return type of a gcc2

3713 builtin and then its argument prototype would still apply. */

3714 char res_search ();

3715 int

3716 main ()

3717 {

3718 res_search ();

3719 ;

3720 return 0;

3721 }

3722 _ACEOF

3723 rm -f conftest.$ac_objext conftest$ac_exeext

3724 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

3725 (eval $ac_link) 2>conftest.er1

3726 ac_status=$?

3727 grep -v '^ *+' conftest.er1 >conftest.err

3728 rm -f conftest.er1

3729 cat conftest.err >&5

3730 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3731 (exit $ac_status); } &&

3732 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

3733 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3734 (eval $ac_try) 2>&5

3735 ac_status=$?

3736 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3737 (exit $ac_status); }; } &&

3738 { ac_try='test -s conftest$ac_exeext'

3739 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3740 (eval $ac_try) 2>&5

3741 ac_status=$?

3742 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3743 (exit $ac_status); }; }; then

3744 ac_cv_lib_resolv_res_search=yes

3745 else

3746 echo "$as_me: failed program was:" >&5

3747 sed 's/^/| /' conftest.$ac_ext >&5

3748

3749 ac_cv_lib_resolv_res_search=no

3750 fi

3751 rm -f conftest.err conftest.$ac_objext \

3752 conftest$ac_exeext conftest.$ac_ext

3753 LIBS=$ac_check_lib_save_LIBS

3754 fi

3755 echo "$as_me:$LINENO: result: $ac_cv_lib_resolv_res_search" >&5

3756 echo "${ECHO_T}$ac_cv_lib_resolv_res_search" >&6

3757 if test $ac_cv_lib_resolv_res_search = yes; then

3758 has_resolv=yes

3759 else

3760 { { echo "$as_me:$LINENO: error: \"no libresolv\"" >&5

3761 echo "$as_me: error: \"no libresolv\"" >&2;}

3762 { (exit 1); exit 1; }; }

3763 fi

3764

3765 RESOLV_LIBS='-lresolv'

3766 else

3767 RESOLV_LIBS=''

3768 fi

3769 else

3770 RESOLV_LIBS=''

3771 fi

3772

3773

3774

3775 for ac_func in getline

3776 do

3777 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

3778 echo "$as_me:$LINENO: checking for $ac_func" >&5

3779 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

3780 if eval "test \"\${$as_ac_var+set}\" = set"; then

3781 echo $ECHO_N "(cached) $ECHO_C" >&6

3782 else

3783 cat >conftest.$ac_ext <<_ACEOF

3784 /* confdefs.h. */

3785 _ACEOF

3786 cat confdefs.h >>conftest.$ac_ext

3787 cat >>conftest.$ac_ext <<_ACEOF

3788 /* end confdefs.h. */

3789 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

3790 For example, HP-UX 11i <limits.h> declares gettimeofday. */

3791 #define $ac_func innocuous_$ac_func

3792

3793 /* System header to define __stub macros and hopefully few prototypes,

3794 which can conflict with char $ac_func (); below.

3795 Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

3796 <limits.h> exists even on freestanding compilers. */

3797

3798 #ifdef __STDC__

3799 # include <limits.h>

3800 #else

3801 # include <assert.h>

3802 #endif

3803

3804 #undef $ac_func

3805

3806 /* Override any gcc2 internal prototype to avoid an error. */

3807 #ifdef __cplusplus

3808 extern "C"

3809 {

3810 #endif

3811 /* We use char because int might match the return type of a gcc2

3812 builtin and then its argument prototype would still apply. */

3813 char $ac_func ();

3814 /* The GNU C library defines this for functions which it implements

3815 to always fail with ENOSYS. Some functions are actually named

3816 something starting with __ and the normal name is an alias. */

3817 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)

3818 choke me

3819 #else

3820 char (*f) () = $ac_func;

3821 #endif

3822 #ifdef __cplusplus

3823 }

3824 #endif

3825

3826 int

3827 main ()

3828 {

3829 return f != $ac_func;

3830 ;

3831 return 0;

3832 }

3833 _ACEOF

3834 rm -f conftest.$ac_objext conftest$ac_exeext

3835 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

3836 (eval $ac_link) 2>conftest.er1

3837 ac_status=$?

3838 grep -v '^ *+' conftest.er1 >conftest.err

3839 rm -f conftest.er1

3840 cat conftest.err >&5

3841 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3842 (exit $ac_status); } &&

3843 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

3844 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3845 (eval $ac_try) 2>&5

3846 ac_status=$?

3847 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3848 (exit $ac_status); }; } &&

3849 { ac_try='test -s conftest$ac_exeext'

3850 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3851 (eval $ac_try) 2>&5

3852 ac_status=$?

3853 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3854 (exit $ac_status); }; }; then

3855 eval "$as_ac_var=yes"

3856 else

3857 echo "$as_me: failed program was:" >&5

3858 sed 's/^/| /' conftest.$ac_ext >&5

3859

3860 eval "$as_ac_var=no"

3861 fi

3862 rm -f conftest.err conftest.$ac_objext \

3863 conftest$ac_exeext conftest.$ac_ext

3864 fi

3865 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

3866 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

3867 if test `eval echo '${'$as_ac_var'}'` = yes; then

3868 cat >>confdefs.h <<_ACEOF

3869 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

3870 _ACEOF

3871

3872 fi

3873 done

3874

3875

3876

3877 for ac_func in fdatasync

3878 do

3879 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

3880 echo "$as_me:$LINENO: checking for $ac_func" >&5

3881 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

3882 if eval "test \"\${$as_ac_var+set}\" = set"; then

3883 echo $ECHO_N "(cached) $ECHO_C" >&6

3884 else

3885 cat >conftest.$ac_ext <<_ACEOF

3886 /* confdefs.h. */

3887 _ACEOF

3888 cat confdefs.h >>conftest.$ac_ext

3889 cat >>conftest.$ac_ext <<_ACEOF

3890 /* end confdefs.h. */

3891 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

3892 For example, HP-UX 11i <limits.h> declares gettimeofday. */

3893 #define $ac_func innocuous_$ac_func

3894

3895 /* System header to define __stub macros and hopefully few prototypes,

3896 which can conflict with char $ac_func (); below.

3897 Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

3898 <limits.h> exists even on freestanding compilers. */

3899

3900 #ifdef __STDC__

3901 # include <limits.h>

3902 #else

3903 # include <assert.h>

3904 #endif

3905

3906 #undef $ac_func

3907

3908 /* Override any gcc2 internal prototype to avoid an error. */

3909 #ifdef __cplusplus

3910 extern "C"

3911 {

3912 #endif

3913 /* We use char because int might match the return type of a gcc2

3914 builtin and then its argument prototype would still apply. */

3915 char $ac_func ();

3916 /* The GNU C library defines this for functions which it implements

3917 to always fail with ENOSYS. Some functions are actually named

3918 something starting with __ and the normal name is an alias. */

3919 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)

3920 choke me

3921 #else

3922 char (*f) () = $ac_func;

3923 #endif

3924 #ifdef __cplusplus

3925 }

3926 #endif

3927

3928 int

3929 main ()

3930 {

3931 return f != $ac_func;

3932 ;

3933 return 0;

3934 }

3935 _ACEOF

3936 rm -f conftest.$ac_objext conftest$ac_exeext

3937 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

3938 (eval $ac_link) 2>conftest.er1

3939 ac_status=$?

3940 grep -v '^ *+' conftest.er1 >conftest.err

3941 rm -f conftest.er1

3942 cat conftest.err >&5

3943 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3944 (exit $ac_status); } &&

3945 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

3946 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3947 (eval $ac_try) 2>&5

3948 ac_status=$?

3949 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3950 (exit $ac_status); }; } &&

3951 { ac_try='test -s conftest$ac_exeext'

3952 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

3953 (eval $ac_try) 2>&5

3954 ac_status=$?

3955 echo "$as_me:$LINENO: \$? = $ac_status" >&5

3956 (exit $ac_status); }; }; then

3957 eval "$as_ac_var=yes"

3958 else

3959 echo "$as_me: failed program was:" >&5

3960 sed 's/^/| /' conftest.$ac_ext >&5

3961

3962 eval "$as_ac_var=no"

3963 fi

3964 rm -f conftest.err conftest.$ac_objext \

3965 conftest$ac_exeext conftest.$ac_ext

3966 fi

3967 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

3968 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

3969 if test `eval echo '${'$as_ac_var'}'` = yes; then

3970 cat >>confdefs.h <<_ACEOF

3971 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

3972 _ACEOF

3973

3974 fi

3975 done

3976

3977

3978 echo "$as_me:$LINENO: checking for ANSI C header files" >&5

3979 echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6

3980 if test "${ac_cv_header_stdc+set}" = set; then

3981 echo $ECHO_N "(cached) $ECHO_C" >&6

3982 else

3983 cat >conftest.$ac_ext <<_ACEOF

3984 /* confdefs.h. */

3985 _ACEOF

3986 cat confdefs.h >>conftest.$ac_ext

3987 cat >>conftest.$ac_ext <<_ACEOF

3988 /* end confdefs.h. */

3989 #include <stdlib.h>

3990 #include <stdarg.h>

3991 #include <string.h>

3992 #include <float.h>

3993

3994 int

3995 main ()

3996 {

3997

3998 ;

3999 return 0;

4000 }

4001 _ACEOF

4002 rm -f conftest.$ac_objext

4003 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

4004 (eval $ac_compile) 2>conftest.er1

4005 ac_status=$?

4006 grep -v '^ *+' conftest.er1 >conftest.err

4007 rm -f conftest.er1

4008 cat conftest.err >&5

4009 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4010 (exit $ac_status); } &&

4011 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

4012 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4013 (eval $ac_try) 2>&5

4014 ac_status=$?

4015 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4016 (exit $ac_status); }; } &&

4017 { ac_try='test -s conftest.$ac_objext'

4018 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4019 (eval $ac_try) 2>&5

4020 ac_status=$?

4021 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4022 (exit $ac_status); }; }; then

4023 ac_cv_header_stdc=yes

4024 else

4025 echo "$as_me: failed program was:" >&5

4026 sed 's/^/| /' conftest.$ac_ext >&5

4027

4028 ac_cv_header_stdc=no

4029 fi

4030 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

4031

4032 if test $ac_cv_header_stdc = yes; then

4033 # SunOS 4.x string.h does not declare mem*, contrary to ANSI.

4034 cat >conftest.$ac_ext <<_ACEOF

4035 /* confdefs.h. */

4036 _ACEOF

4037 cat confdefs.h >>conftest.$ac_ext

4038 cat >>conftest.$ac_ext <<_ACEOF

4039 /* end confdefs.h. */

4040 #include <string.h>

4041

4042 _ACEOF

4043 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

4044 $EGREP "memchr" >/dev/null 2>&1; then

4045 :

4046 else

4047 ac_cv_header_stdc=no

4048 fi

4049 rm -f conftest*

4050

4051 fi

4052

4053 if test $ac_cv_header_stdc = yes; then

4054 # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.

4055 cat >conftest.$ac_ext <<_ACEOF

4056 /* confdefs.h. */

4057 _ACEOF

4058 cat confdefs.h >>conftest.$ac_ext

4059 cat >>conftest.$ac_ext <<_ACEOF

4060 /* end confdefs.h. */

4061 #include <stdlib.h>

4062

4063 _ACEOF

4064 if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

4065 $EGREP "free" >/dev/null 2>&1; then

4066 :

4067 else

4068 ac_cv_header_stdc=no

4069 fi

4070 rm -f conftest*

4071

4072 fi

4073

4074 if test $ac_cv_header_stdc = yes; then

4075 # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.

4076 if test "$cross_compiling" = yes; then

4077 :

4078 else

4079 cat >conftest.$ac_ext <<_ACEOF

4080 /* confdefs.h. */

4081 _ACEOF

4082 cat confdefs.h >>conftest.$ac_ext

4083 cat >>conftest.$ac_ext <<_ACEOF

4084 /* end confdefs.h. */

4085 #include <ctype.h>

4086 #if ((' ' & 0x0FF) == 0x020)

4087 # define ISLOWER(c) ('a' <= (c) && (c) <= 'z')

4088 # define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))

4089 #else

4090 # define ISLOWER(c) \

4091 (('a' <= (c) && (c) <= 'i') \

4092 || ('j' <= (c) && (c) <= 'r') \

4093 || ('s' <= (c) && (c) <= 'z'))

4094 # define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))

4095 #endif

4096

4097 #define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))

4098 int

4099 main ()

4100 {

4101 int i;

4102 for (i = 0; i < 256; i++)

4103 if (XOR (islower (i), ISLOWER (i))

4104 || toupper (i) != TOUPPER (i))

4105 exit(2);

4106 exit (0);

4107 }

4108 _ACEOF

4109 rm -f conftest$ac_exeext

4110 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

4111 (eval $ac_link) 2>&5

4112 ac_status=$?

4113 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4114 (exit $ac_status); } && { ac_try='./conftest$ac_exeext'

4115 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4116 (eval $ac_try) 2>&5

4117 ac_status=$?

4118 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4119 (exit $ac_status); }; }; then

4120 :

4121 else

4122 echo "$as_me: program exited with status $ac_status" >&5

4123 echo "$as_me: failed program was:" >&5

4124 sed 's/^/| /' conftest.$ac_ext >&5

4125

4126 ( exit $ac_status )

4127 ac_cv_header_stdc=no

4128 fi

4129 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

4130 fi

4131 fi

4132 fi

4133 echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5

4134 echo "${ECHO_T}$ac_cv_header_stdc" >&6

4135 if test $ac_cv_header_stdc = yes; then

4136

4137 cat >>confdefs.h <<\_ACEOF

4138 #define STDC_HEADERS 1

4139 _ACEOF

4140

4141 fi

4142

4143 # On IRIX 5.3, sys/types and inttypes.h are conflicting.

4144

4145

4146

4147

4148

4149

4150

4151

4152

4153 for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \

4154 inttypes.h stdint.h unistd.h

4155 do

4156 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

4157 echo "$as_me:$LINENO: checking for $ac_header" >&5

4158 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

4159 if eval "test \"\${$as_ac_Header+set}\" = set"; then

4160 echo $ECHO_N "(cached) $ECHO_C" >&6

4161 else

4162 cat >conftest.$ac_ext <<_ACEOF

4163 /* confdefs.h. */

4164 _ACEOF

4165 cat confdefs.h >>conftest.$ac_ext

4166 cat >>conftest.$ac_ext <<_ACEOF

4167 /* end confdefs.h. */

4168 $ac_includes_default

4169

4170 #include <$ac_header>

4171 _ACEOF

4172 rm -f conftest.$ac_objext

4173 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

4174 (eval $ac_compile) 2>conftest.er1

4175 ac_status=$?

4176 grep -v '^ *+' conftest.er1 >conftest.err

4177 rm -f conftest.er1

4178 cat conftest.err >&5

4179 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4180 (exit $ac_status); } &&

4181 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

4182 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4183 (eval $ac_try) 2>&5

4184 ac_status=$?

4185 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4186 (exit $ac_status); }; } &&

4187 { ac_try='test -s conftest.$ac_objext'

4188 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4189 (eval $ac_try) 2>&5

4190 ac_status=$?

4191 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4192 (exit $ac_status); }; }; then

4193 eval "$as_ac_Header=yes"

4194 else

4195 echo "$as_me: failed program was:" >&5

4196 sed 's/^/| /' conftest.$ac_ext >&5

4197

4198 eval "$as_ac_Header=no"

4199 fi

4200 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

4201 fi

4202 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

4203 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

4204 if test `eval echo '${'$as_ac_Header'}'` = yes; then

4205 cat >>confdefs.h <<_ACEOF

4206 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

4207 _ACEOF

4208

4209 fi

4210

4211 done

4212

4213

4214

4215

4216

4217

4218 for ac_header in fcntl.h sys/time.h syslog.h unistd.h

4219 do

4220 as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

4221 if eval "test \"\${$as_ac_Header+set}\" = set"; then

4222 echo "$as_me:$LINENO: checking for $ac_header" >&5

4223 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

4224 if eval "test \"\${$as_ac_Header+set}\" = set"; then

4225 echo $ECHO_N "(cached) $ECHO_C" >&6

4226 fi

4227 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

4228 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

4229 else

4230 # Is the header compilable?

4231 echo "$as_me:$LINENO: checking $ac_header usability" >&5

4232 echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

4233 cat >conftest.$ac_ext <<_ACEOF

4234 /* confdefs.h. */

4235 _ACEOF

4236 cat confdefs.h >>conftest.$ac_ext

4237 cat >>conftest.$ac_ext <<_ACEOF

4238 /* end confdefs.h. */

4239 $ac_includes_default

4240 #include <$ac_header>

4241 _ACEOF

4242 rm -f conftest.$ac_objext

4243 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

4244 (eval $ac_compile) 2>conftest.er1

4245 ac_status=$?

4246 grep -v '^ *+' conftest.er1 >conftest.err

4247 rm -f conftest.er1

4248 cat conftest.err >&5

4249 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4250 (exit $ac_status); } &&

4251 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

4252 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4253 (eval $ac_try) 2>&5

4254 ac_status=$?

4255 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4256 (exit $ac_status); }; } &&

4257 { ac_try='test -s conftest.$ac_objext'

4258 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4259 (eval $ac_try) 2>&5

4260 ac_status=$?

4261 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4262 (exit $ac_status); }; }; then

4263 ac_header_compiler=yes

4264 else

4265 echo "$as_me: failed program was:" >&5

4266 sed 's/^/| /' conftest.$ac_ext >&5

4267

4268 ac_header_compiler=no

4269 fi

4270 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

4271 echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

4272 echo "${ECHO_T}$ac_header_compiler" >&6

4273

4274 # Is the header present?

4275 echo "$as_me:$LINENO: checking $ac_header presence" >&5

4276 echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

4277 cat >conftest.$ac_ext <<_ACEOF

4278 /* confdefs.h. */

4279 _ACEOF

4280 cat confdefs.h >>conftest.$ac_ext

4281 cat >>conftest.$ac_ext <<_ACEOF

4282 /* end confdefs.h. */

4283 #include <$ac_header>

4284 _ACEOF

4285 if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

4286 (eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

4287 ac_status=$?

4288 grep -v '^ *+' conftest.er1 >conftest.err

4289 rm -f conftest.er1

4290 cat conftest.err >&5

4291 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4292 (exit $ac_status); } >/dev/null; then

4293 if test -s conftest.err; then

4294 ac_cpp_err=$ac_c_preproc_warn_flag

4295 ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

4296 else

4297 ac_cpp_err=

4298 fi

4299 else

4300 ac_cpp_err=yes

4301 fi

4302 if test -z "$ac_cpp_err"; then

4303 ac_header_preproc=yes

4304 else

4305 echo "$as_me: failed program was:" >&5

4306 sed 's/^/| /' conftest.$ac_ext >&5

4307

4308 ac_header_preproc=no

4309 fi

4310 rm -f conftest.err conftest.$ac_ext

4311 echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

4312 echo "${ECHO_T}$ac_header_preproc" >&6

4313

4314 # So? What about this header?

4315 case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in

4316 yes:no: )

4317 { echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

4318 echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

4319 { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5

4320 echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}

4321 ac_header_preproc=yes

4322 ;;

4323 no:yes:* )

4324 { echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

4325 echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

4326 { echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5

4327 echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}

4328 { echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5

4329 echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}

4330 { echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5

4331 echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;}

4332 { echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

4333 echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

4334 { echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5

4335 echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}

4336 (

4337 cat <<\_ASBOX

4338 ## ----------------------------- ##

4339 ## Report this to oku@debian.org ##

4340 ## ----------------------------- ##

4341 _ASBOX

4342 ) |

4343 sed "s/^/$as_me: WARNING: /" >&2

4344 ;;

4345 esac

4346 echo "$as_me:$LINENO: checking for $ac_header" >&5

4347 echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

4348 if eval "test \"\${$as_ac_Header+set}\" = set"; then

4349 echo $ECHO_N "(cached) $ECHO_C" >&6

4350 else

4351 eval "$as_ac_Header=\$ac_header_preproc"

4352 fi

4353 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

4354 echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

4355

4356 fi

4357 if test `eval echo '${'$as_ac_Header'}'` = yes; then

4358 cat >>confdefs.h <<_ACEOF

4359 #define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

4360 _ACEOF

4361

4362 fi

4363

4364 done

4365

4366

4367 echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5

4368 echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6

4369 if test "${ac_cv_c_const+set}" = set; then

4370 echo $ECHO_N "(cached) $ECHO_C" >&6

4371 else

4372 cat >conftest.$ac_ext <<_ACEOF

4373 /* confdefs.h. */

4374 _ACEOF

4375 cat confdefs.h >>conftest.$ac_ext

4376 cat >>conftest.$ac_ext <<_ACEOF

4377 /* end confdefs.h. */

4378

4379 int

4380 main ()

4381 {

4382 /* FIXME: Include the comments suggested by Paul. */

4383 #ifndef __cplusplus

4384 /* Ultrix mips cc rejects this. */

4385 typedef int charset[2];

4386 const charset x;

4387 /* SunOS 4.1.1 cc rejects this. */

4388 char const *const *ccp;

4389 char **p;

4390 /* NEC SVR4.0.2 mips cc rejects this. */

4391 struct point {int x, y;};

4392 static struct point const zero = {0,0};

4393 /* AIX XL C 1.02.0.0 rejects this.

4394 It does not let you subtract one const X* pointer from another in

4395 an arm of an if-expression whose if-part is not a constant

4396 expression */

4397 const char *g = "string";

4398 ccp = &g + (g ? g-g : 0);

4399 /* HPUX 7.0 cc rejects these. */

4400 ++ccp;

4401 p = (char**) ccp;

4402 ccp = (char const *const *) p;

4403 { /* SCO 3.2v4 cc rejects this. */

4404 char *t;

4405 char const *s = 0 ? (char *) 0 : (char const *) 0;

4406

4407 *t++ = 0;

4408 }

4409 { /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */

4410 int x[] = {25, 17};

4411 const int *foo = &x[0];

4412 ++foo;

4413 }

4414 { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */

4415 typedef const int *iptr;

4416 iptr p = 0;

4417 ++p;

4418 }

4419 { /* AIX XL C 1.02.0.0 rejects this saying

4420 "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */

4421 struct s { int j; const int *ap[3]; };

4422 struct s *b; b->j = 5;

4423 }

4424 { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */

4425 const int foo = 10;

4426 }

4427 #endif

4428

4429 ;

4430 return 0;

4431 }

4432 _ACEOF

4433 rm -f conftest.$ac_objext

4434 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

4435 (eval $ac_compile) 2>conftest.er1

4436 ac_status=$?

4437 grep -v '^ *+' conftest.er1 >conftest.err

4438 rm -f conftest.er1

4439 cat conftest.err >&5

4440 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4441 (exit $ac_status); } &&

4442 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

4443 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4444 (eval $ac_try) 2>&5

4445 ac_status=$?

4446 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4447 (exit $ac_status); }; } &&

4448 { ac_try='test -s conftest.$ac_objext'

4449 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4450 (eval $ac_try) 2>&5

4451 ac_status=$?

4452 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4453 (exit $ac_status); }; }; then

4454 ac_cv_c_const=yes

4455 else

4456 echo "$as_me: failed program was:" >&5

4457 sed 's/^/| /' conftest.$ac_ext >&5

4458

4459 ac_cv_c_const=no

4460 fi

4461 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

4462 fi

4463 echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5

4464 echo "${ECHO_T}$ac_cv_c_const" >&6

4465 if test $ac_cv_c_const = no; then

4466

4467 cat >>confdefs.h <<\_ACEOF

4468 #define const

4469 _ACEOF

4470

4471 fi

4472

4473 echo "$as_me:$LINENO: checking for pid_t" >&5

4474 echo $ECHO_N "checking for pid_t... $ECHO_C" >&6

4475 if test "${ac_cv_type_pid_t+set}" = set; then

4476 echo $ECHO_N "(cached) $ECHO_C" >&6

4477 else

4478 cat >conftest.$ac_ext <<_ACEOF

4479 /* confdefs.h. */

4480 _ACEOF

4481 cat confdefs.h >>conftest.$ac_ext

4482 cat >>conftest.$ac_ext <<_ACEOF

4483 /* end confdefs.h. */

4484 $ac_includes_default

4485 int

4486 main ()

4487 {

4488 if ((pid_t *) 0)

4489 return 0;

4490 if (sizeof (pid_t))

4491 return 0;

4492 ;

4493 return 0;

4494 }

4495 _ACEOF

4496 rm -f conftest.$ac_objext

4497 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

4498 (eval $ac_compile) 2>conftest.er1

4499 ac_status=$?

4500 grep -v '^ *+' conftest.er1 >conftest.err

4501 rm -f conftest.er1

4502 cat conftest.err >&5

4503 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4504 (exit $ac_status); } &&

4505 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

4506 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4507 (eval $ac_try) 2>&5

4508 ac_status=$?

4509 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4510 (exit $ac_status); }; } &&

4511 { ac_try='test -s conftest.$ac_objext'

4512 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4513 (eval $ac_try) 2>&5

4514 ac_status=$?

4515 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4516 (exit $ac_status); }; }; then

4517 ac_cv_type_pid_t=yes

4518 else

4519 echo "$as_me: failed program was:" >&5

4520 sed 's/^/| /' conftest.$ac_ext >&5

4521

4522 ac_cv_type_pid_t=no

4523 fi

4524 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

4525 fi

4526 echo "$as_me:$LINENO: result: $ac_cv_type_pid_t" >&5

4527 echo "${ECHO_T}$ac_cv_type_pid_t" >&6

4528 if test $ac_cv_type_pid_t = yes; then

4529 :

4530 else

4531

4532 cat >>confdefs.h <<_ACEOF

4533 #define pid_t int

4534 _ACEOF

4535

4536 fi

4537

4538 echo "$as_me:$LINENO: checking for size_t" >&5

4539 echo $ECHO_N "checking for size_t... $ECHO_C" >&6

4540 if test "${ac_cv_type_size_t+set}" = set; then

4541 echo $ECHO_N "(cached) $ECHO_C" >&6

4542 else

4543 cat >conftest.$ac_ext <<_ACEOF

4544 /* confdefs.h. */

4545 _ACEOF

4546 cat confdefs.h >>conftest.$ac_ext

4547 cat >>conftest.$ac_ext <<_ACEOF

4548 /* end confdefs.h. */

4549 $ac_includes_default

4550 int

4551 main ()

4552 {

4553 if ((size_t *) 0)

4554 return 0;

4555 if (sizeof (size_t))

4556 return 0;

4557 ;

4558 return 0;

4559 }

4560 _ACEOF

4561 rm -f conftest.$ac_objext

4562 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

4563 (eval $ac_compile) 2>conftest.er1

4564 ac_status=$?

4565 grep -v '^ *+' conftest.er1 >conftest.err

4566 rm -f conftest.er1

4567 cat conftest.err >&5

4568 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4569 (exit $ac_status); } &&

4570 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

4571 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4572 (eval $ac_try) 2>&5

4573 ac_status=$?

4574 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4575 (exit $ac_status); }; } &&

4576 { ac_try='test -s conftest.$ac_objext'

4577 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4578 (eval $ac_try) 2>&5

4579 ac_status=$?

4580 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4581 (exit $ac_status); }; }; then

4582 ac_cv_type_size_t=yes

4583 else

4584 echo "$as_me: failed program was:" >&5

4585 sed 's/^/| /' conftest.$ac_ext >&5

4586

4587 ac_cv_type_size_t=no

4588 fi

4589 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

4590 fi

4591 echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5

4592 echo "${ECHO_T}$ac_cv_type_size_t" >&6

4593 if test $ac_cv_type_size_t = yes; then

4594 :

4595 else

4596

4597 cat >>confdefs.h <<_ACEOF

4598 #define size_t unsigned

4599 _ACEOF

4600

4601 fi

4602

4603 echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5

4604 echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6

4605 if test "${ac_cv_header_time+set}" = set; then

4606 echo $ECHO_N "(cached) $ECHO_C" >&6

4607 else

4608 cat >conftest.$ac_ext <<_ACEOF

4609 /* confdefs.h. */

4610 _ACEOF

4611 cat confdefs.h >>conftest.$ac_ext

4612 cat >>conftest.$ac_ext <<_ACEOF

4613 /* end confdefs.h. */

4614 #include <sys/types.h>

4615 #include <sys/time.h>

4616 #include <time.h>

4617

4618 int

4619 main ()

4620 {

4621 if ((struct tm *) 0)

4622 return 0;

4623 ;

4624 return 0;

4625 }

4626 _ACEOF

4627 rm -f conftest.$ac_objext

4628 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

4629 (eval $ac_compile) 2>conftest.er1

4630 ac_status=$?

4631 grep -v '^ *+' conftest.er1 >conftest.err

4632 rm -f conftest.er1

4633 cat conftest.err >&5

4634 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4635 (exit $ac_status); } &&

4636 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

4637 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4638 (eval $ac_try) 2>&5

4639 ac_status=$?

4640 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4641 (exit $ac_status); }; } &&

4642 { ac_try='test -s conftest.$ac_objext'

4643 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4644 (eval $ac_try) 2>&5

4645 ac_status=$?

4646 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4647 (exit $ac_status); }; }; then

4648 ac_cv_header_time=yes

4649 else

4650 echo "$as_me: failed program was:" >&5

4651 sed 's/^/| /' conftest.$ac_ext >&5

4652

4653 ac_cv_header_time=no

4654 fi

4655 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

4656 fi

4657 echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5

4658 echo "${ECHO_T}$ac_cv_header_time" >&6

4659 if test $ac_cv_header_time = yes; then

4660

4661 cat >>confdefs.h <<\_ACEOF

4662 #define TIME_WITH_SYS_TIME 1

4663 _ACEOF

4664

4665 fi

4666

4667 echo "$as_me:$LINENO: checking whether struct tm is in sys/time.h or time.h" >&5

4668 echo $ECHO_N "checking whether struct tm is in sys/time.h or time.h... $ECHO_C" >&6

4669 if test "${ac_cv_struct_tm+set}" = set; then

4670 echo $ECHO_N "(cached) $ECHO_C" >&6

4671 else

4672 cat >conftest.$ac_ext <<_ACEOF

4673 /* confdefs.h. */

4674 _ACEOF

4675 cat confdefs.h >>conftest.$ac_ext

4676 cat >>conftest.$ac_ext <<_ACEOF

4677 /* end confdefs.h. */

4678 #include <sys/types.h>

4679 #include <time.h>

4680

4681 int

4682 main ()

4683 {

4684 struct tm *tp; tp->tm_sec;

4685 ;

4686 return 0;

4687 }

4688 _ACEOF

4689 rm -f conftest.$ac_objext

4690 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

4691 (eval $ac_compile) 2>conftest.er1

4692 ac_status=$?

4693 grep -v '^ *+' conftest.er1 >conftest.err

4694 rm -f conftest.er1

4695 cat conftest.err >&5

4696 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4697 (exit $ac_status); } &&

4698 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

4699 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4700 (eval $ac_try) 2>&5

4701 ac_status=$?

4702 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4703 (exit $ac_status); }; } &&

4704 { ac_try='test -s conftest.$ac_objext'

4705 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4706 (eval $ac_try) 2>&5

4707 ac_status=$?

4708 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4709 (exit $ac_status); }; }; then

4710 ac_cv_struct_tm=time.h

4711 else

4712 echo "$as_me: failed program was:" >&5

4713 sed 's/^/| /' conftest.$ac_ext >&5

4714

4715 ac_cv_struct_tm=sys/time.h

4716 fi

4717 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

4718 fi

4719 echo "$as_me:$LINENO: result: $ac_cv_struct_tm" >&5

4720 echo "${ECHO_T}$ac_cv_struct_tm" >&6

4721 if test $ac_cv_struct_tm = sys/time.h; then

4722

4723 cat >>confdefs.h <<\_ACEOF

4724 #define TM_IN_SYS_TIME 1

4725 _ACEOF

4726

4727 fi

4728

4729

4730 echo "$as_me:$LINENO: checking for working POSIX fnmatch" >&5

4731 echo $ECHO_N "checking for working POSIX fnmatch... $ECHO_C" >&6

4732 if test "${ac_cv_func_fnmatch_works+set}" = set; then

4733 echo $ECHO_N "(cached) $ECHO_C" >&6

4734 else

4735 # Some versions of Solaris, SCO, and the GNU C Library

4736 # have a broken or incompatible fnmatch.

4737 # So we run a test program. If we are cross-compiling, take no chance.

4738 # Thanks to John Oleynick, Franc,ois Pinard, and Paul Eggert for this test.

4739 if test "$cross_compiling" = yes; then

4740 ac_cv_func_fnmatch_works=cross

4741 else

4742 cat >conftest.$ac_ext <<_ACEOF

4743 /* confdefs.h. */

4744 _ACEOF

4745 cat confdefs.h >>conftest.$ac_ext

4746 cat >>conftest.$ac_ext <<_ACEOF

4747 /* end confdefs.h. */

4748 #include <fnmatch.h>

4749 # define y(a, b, c) (fnmatch (a, b, c) == 0)

4750 # define n(a, b, c) (fnmatch (a, b, c) == FNM_NOMATCH)

4751

4752 int

4753 main ()

4754 {

4755 exit

4756 (!(y ("a*", "abc", 0)

4757 && n ("d*/*1", "d/s/1", FNM_PATHNAME)

4758 && y ("a\\\\bc", "abc", 0)

4759 && n ("a\\\\bc", "abc", FNM_NOESCAPE)

4760 && y ("*x", ".x", 0)

4761 && n ("*x", ".x", FNM_PERIOD)

4762 && 1));

4763 ;

4764 return 0;

4765 }

4766 _ACEOF

4767 rm -f conftest$ac_exeext

4768 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

4769 (eval $ac_link) 2>&5

4770 ac_status=$?

4771 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4772 (exit $ac_status); } && { ac_try='./conftest$ac_exeext'

4773 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4774 (eval $ac_try) 2>&5

4775 ac_status=$?

4776 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4777 (exit $ac_status); }; }; then

4778 ac_cv_func_fnmatch_works=yes

4779 else

4780 echo "$as_me: program exited with status $ac_status" >&5

4781 echo "$as_me: failed program was:" >&5

4782 sed 's/^/| /' conftest.$ac_ext >&5

4783

4784 ( exit $ac_status )

4785 ac_cv_func_fnmatch_works=no

4786 fi

4787 rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

4788 fi

4789 fi

4790 echo "$as_me:$LINENO: result: $ac_cv_func_fnmatch_works" >&5

4791 echo "${ECHO_T}$ac_cv_func_fnmatch_works" >&6

4792 if test $ac_cv_func_fnmatch_works = yes; then

4793

4794 cat >>confdefs.h <<\_ACEOF

4795 #define HAVE_FNMATCH 1

4796 _ACEOF

4797

4798 fi

4799

4800

4801

4802 echo "$as_me:$LINENO: checking return type of signal handlers" >&5

4803 echo $ECHO_N "checking return type of signal handlers... $ECHO_C" >&6

4804 if test "${ac_cv_type_signal+set}" = set; then

4805 echo $ECHO_N "(cached) $ECHO_C" >&6

4806 else

4807 cat >conftest.$ac_ext <<_ACEOF

4808 /* confdefs.h. */

4809 _ACEOF

4810 cat confdefs.h >>conftest.$ac_ext

4811 cat >>conftest.$ac_ext <<_ACEOF

4812 /* end confdefs.h. */

4813 #include <sys/types.h>

4814 #include <signal.h>

4815 #ifdef signal

4816 # undef signal

4817 #endif

4818 #ifdef __cplusplus

4819 extern "C" void (*signal (int, void (*)(int)))(int);

4820 #else

4821 void (*signal ()) ();

4822 #endif

4823

4824 int

4825 main ()

4826 {

4827 int i;

4828 ;

4829 return 0;

4830 }

4831 _ACEOF

4832 rm -f conftest.$ac_objext

4833 if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

4834 (eval $ac_compile) 2>conftest.er1

4835 ac_status=$?

4836 grep -v '^ *+' conftest.er1 >conftest.err

4837 rm -f conftest.er1

4838 cat conftest.err >&5

4839 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4840 (exit $ac_status); } &&

4841 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

4842 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4843 (eval $ac_try) 2>&5

4844 ac_status=$?

4845 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4846 (exit $ac_status); }; } &&

4847 { ac_try='test -s conftest.$ac_objext'

4848 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4849 (eval $ac_try) 2>&5

4850 ac_status=$?

4851 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4852 (exit $ac_status); }; }; then

4853 ac_cv_type_signal=void

4854 else

4855 echo "$as_me: failed program was:" >&5

4856 sed 's/^/| /' conftest.$ac_ext >&5

4857

4858 ac_cv_type_signal=int

4859 fi

4860 rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

4861 fi

4862 echo "$as_me:$LINENO: result: $ac_cv_type_signal" >&5

4863 echo "${ECHO_T}$ac_cv_type_signal" >&6

4864

4865 cat >>confdefs.h <<_ACEOF

4866 #define RETSIGTYPE $ac_cv_type_signal

4867 _ACEOF

4868

4869

4870

4871 for ac_func in strftime

4872 do

4873 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

4874 echo "$as_me:$LINENO: checking for $ac_func" >&5

4875 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

4876 if eval "test \"\${$as_ac_var+set}\" = set"; then

4877 echo $ECHO_N "(cached) $ECHO_C" >&6

4878 else

4879 cat >conftest.$ac_ext <<_ACEOF

4880 /* confdefs.h. */

4881 _ACEOF

4882 cat confdefs.h >>conftest.$ac_ext

4883 cat >>conftest.$ac_ext <<_ACEOF

4884 /* end confdefs.h. */

4885 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

4886 For example, HP-UX 11i <limits.h> declares gettimeofday. */

4887 #define $ac_func innocuous_$ac_func

4888

4889 /* System header to define __stub macros and hopefully few prototypes,

4890 which can conflict with char $ac_func (); below.

4891 Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

4892 <limits.h> exists even on freestanding compilers. */

4893

4894 #ifdef __STDC__

4895 # include <limits.h>

4896 #else

4897 # include <assert.h>

4898 #endif

4899

4900 #undef $ac_func

4901

4902 /* Override any gcc2 internal prototype to avoid an error. */

4903 #ifdef __cplusplus

4904 extern "C"

4905 {

4906 #endif

4907 /* We use char because int might match the return type of a gcc2

4908 builtin and then its argument prototype would still apply. */

4909 char $ac_func ();

4910 /* The GNU C library defines this for functions which it implements

4911 to always fail with ENOSYS. Some functions are actually named

4912 something starting with __ and the normal name is an alias. */

4913 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)

4914 choke me

4915 #else

4916 char (*f) () = $ac_func;

4917 #endif

4918 #ifdef __cplusplus

4919 }

4920 #endif

4921

4922 int

4923 main ()

4924 {

4925 return f != $ac_func;

4926 ;

4927 return 0;

4928 }

4929 _ACEOF

4930 rm -f conftest.$ac_objext conftest$ac_exeext

4931 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

4932 (eval $ac_link) 2>conftest.er1

4933 ac_status=$?

4934 grep -v '^ *+' conftest.er1 >conftest.err

4935 rm -f conftest.er1

4936 cat conftest.err >&5

4937 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4938 (exit $ac_status); } &&

4939 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

4940 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4941 (eval $ac_try) 2>&5

4942 ac_status=$?

4943 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4944 (exit $ac_status); }; } &&

4945 { ac_try='test -s conftest$ac_exeext'

4946 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4947 (eval $ac_try) 2>&5

4948 ac_status=$?

4949 echo "$as_me:$LINENO: \$? = $ac_status" >&5

4950 (exit $ac_status); }; }; then

4951 eval "$as_ac_var=yes"

4952 else

4953 echo "$as_me: failed program was:" >&5

4954 sed 's/^/| /' conftest.$ac_ext >&5

4955

4956 eval "$as_ac_var=no"

4957 fi

4958 rm -f conftest.err conftest.$ac_objext \

4959 conftest$ac_exeext conftest.$ac_ext

4960 fi

4961 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

4962 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

4963 if test `eval echo '${'$as_ac_var'}'` = yes; then

4964 cat >>confdefs.h <<_ACEOF

4965 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

4966 _ACEOF

4967

4968 else

4969 # strftime is in -lintl on SCO UNIX.

4970 echo "$as_me:$LINENO: checking for strftime in -lintl" >&5

4971 echo $ECHO_N "checking for strftime in -lintl... $ECHO_C" >&6

4972 if test "${ac_cv_lib_intl_strftime+set}" = set; then

4973 echo $ECHO_N "(cached) $ECHO_C" >&6

4974 else

4975 ac_check_lib_save_LIBS=$LIBS

4976 LIBS="-lintl $LIBS"

4977 cat >conftest.$ac_ext <<_ACEOF

4978 /* confdefs.h. */

4979 _ACEOF

4980 cat confdefs.h >>conftest.$ac_ext

4981 cat >>conftest.$ac_ext <<_ACEOF

4982 /* end confdefs.h. */

4983

4984 /* Override any gcc2 internal prototype to avoid an error. */

4985 #ifdef __cplusplus

4986 extern "C"

4987 #endif

4988 /* We use char because int might match the return type of a gcc2

4989 builtin and then its argument prototype would still apply. */

4990 char strftime ();

4991 int

4992 main ()

4993 {

4994 strftime ();

4995 ;

4996 return 0;

4997 }

4998 _ACEOF

4999 rm -f conftest.$ac_objext conftest$ac_exeext

5000 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

5001 (eval $ac_link) 2>conftest.er1

5002 ac_status=$?

5003 grep -v '^ *+' conftest.er1 >conftest.err

5004 rm -f conftest.er1

5005 cat conftest.err >&5

5006 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5007 (exit $ac_status); } &&

5008 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

5009 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5010 (eval $ac_try) 2>&5

5011 ac_status=$?

5012 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5013 (exit $ac_status); }; } &&

5014 { ac_try='test -s conftest$ac_exeext'

5015 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5016 (eval $ac_try) 2>&5

5017 ac_status=$?

5018 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5019 (exit $ac_status); }; }; then

5020 ac_cv_lib_intl_strftime=yes

5021 else

5022 echo "$as_me: failed program was:" >&5

5023 sed 's/^/| /' conftest.$ac_ext >&5

5024

5025 ac_cv_lib_intl_strftime=no

5026 fi

5027 rm -f conftest.err conftest.$ac_objext \

5028 conftest$ac_exeext conftest.$ac_ext

5029 LIBS=$ac_check_lib_save_LIBS

5030 fi

5031 echo "$as_me:$LINENO: result: $ac_cv_lib_intl_strftime" >&5

5032 echo "${ECHO_T}$ac_cv_lib_intl_strftime" >&6

5033 if test $ac_cv_lib_intl_strftime = yes; then

5034 cat >>confdefs.h <<\_ACEOF

5035 #define HAVE_STRFTIME 1

5036 _ACEOF

5037

5038 LIBS="-lintl $LIBS"

5039 fi

5040

5041 fi

5042 done

5043

5044

5045 for ac_func in vprintf

5046 do

5047 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

5048 echo "$as_me:$LINENO: checking for $ac_func" >&5

5049 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

5050 if eval "test \"\${$as_ac_var+set}\" = set"; then

5051 echo $ECHO_N "(cached) $ECHO_C" >&6

5052 else

5053 cat >conftest.$ac_ext <<_ACEOF

5054 /* confdefs.h. */

5055 _ACEOF

5056 cat confdefs.h >>conftest.$ac_ext

5057 cat >>conftest.$ac_ext <<_ACEOF

5058 /* end confdefs.h. */

5059 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

5060 For example, HP-UX 11i <limits.h> declares gettimeofday. */

5061 #define $ac_func innocuous_$ac_func

5062

5063 /* System header to define __stub macros and hopefully few prototypes,

5064 which can conflict with char $ac_func (); below.

5065 Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

5066 <limits.h> exists even on freestanding compilers. */

5067

5068 #ifdef __STDC__

5069 # include <limits.h>

5070 #else

5071 # include <assert.h>

5072 #endif

5073

5074 #undef $ac_func

5075

5076 /* Override any gcc2 internal prototype to avoid an error. */

5077 #ifdef __cplusplus

5078 extern "C"

5079 {

5080 #endif

5081 /* We use char because int might match the return type of a gcc2

5082 builtin and then its argument prototype would still apply. */

5083 char $ac_func ();

5084 /* The GNU C library defines this for functions which it implements

5085 to always fail with ENOSYS. Some functions are actually named

5086 something starting with __ and the normal name is an alias. */

5087 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)

5088 choke me

5089 #else

5090 char (*f) () = $ac_func;

5091 #endif

5092 #ifdef __cplusplus

5093 }

5094 #endif

5095

5096 int

5097 main ()

5098 {

5099 return f != $ac_func;

5100 ;

5101 return 0;

5102 }

5103 _ACEOF

5104 rm -f conftest.$ac_objext conftest$ac_exeext

5105 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

5106 (eval $ac_link) 2>conftest.er1

5107 ac_status=$?

5108 grep -v '^ *+' conftest.er1 >conftest.err

5109 rm -f conftest.er1

5110 cat conftest.err >&5

5111 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5112 (exit $ac_status); } &&

5113 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

5114 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5115 (eval $ac_try) 2>&5

5116 ac_status=$?

5117 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5118 (exit $ac_status); }; } &&

5119 { ac_try='test -s conftest$ac_exeext'

5120 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5121 (eval $ac_try) 2>&5

5122 ac_status=$?

5123 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5124 (exit $ac_status); }; }; then

5125 eval "$as_ac_var=yes"

5126 else

5127 echo "$as_me: failed program was:" >&5

5128 sed 's/^/| /' conftest.$ac_ext >&5

5129

5130 eval "$as_ac_var=no"

5131 fi

5132 rm -f conftest.err conftest.$ac_objext \

5133 conftest$ac_exeext conftest.$ac_ext

5134 fi

5135 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

5136 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

5137 if test `eval echo '${'$as_ac_var'}'` = yes; then

5138 cat >>confdefs.h <<_ACEOF

5139 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

5140 _ACEOF

5141

5142 echo "$as_me:$LINENO: checking for _doprnt" >&5

5143 echo $ECHO_N "checking for _doprnt... $ECHO_C" >&6

5144 if test "${ac_cv_func__doprnt+set}" = set; then

5145 echo $ECHO_N "(cached) $ECHO_C" >&6

5146 else

5147 cat >conftest.$ac_ext <<_ACEOF

5148 /* confdefs.h. */

5149 _ACEOF

5150 cat confdefs.h >>conftest.$ac_ext

5151 cat >>conftest.$ac_ext <<_ACEOF

5152 /* end confdefs.h. */

5153 /* Define _doprnt to an innocuous variant, in case <limits.h> declares _doprnt.

5154 For example, HP-UX 11i <limits.h> declares gettimeofday. */

5155 #define _doprnt innocuous__doprnt

5156

5157 /* System header to define __stub macros and hopefully few prototypes,

5158 which can conflict with char _doprnt (); below.

5159 Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

5160 <limits.h> exists even on freestanding compilers. */

5161

5162 #ifdef __STDC__

5163 # include <limits.h>

5164 #else

5165 # include <assert.h>

5166 #endif

5167

5168 #undef _doprnt

5169

5170 /* Override any gcc2 internal prototype to avoid an error. */

5171 #ifdef __cplusplus

5172 extern "C"

5173 {

5174 #endif

5175 /* We use char because int might match the return type of a gcc2

5176 builtin and then its argument prototype would still apply. */

5177 char _doprnt ();

5178 /* The GNU C library defines this for functions which it implements

5179 to always fail with ENOSYS. Some functions are actually named

5180 something starting with __ and the normal name is an alias. */

5181 #if defined (__stub__doprnt) || defined (__stub____doprnt)

5182 choke me

5183 #else

5184 char (*f) () = _doprnt;

5185 #endif

5186 #ifdef __cplusplus

5187 }

5188 #endif

5189

5190 int

5191 main ()

5192 {

5193 return f != _doprnt;

5194 ;

5195 return 0;

5196 }

5197 _ACEOF

5198 rm -f conftest.$ac_objext conftest$ac_exeext

5199 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

5200 (eval $ac_link) 2>conftest.er1

5201 ac_status=$?

5202 grep -v '^ *+' conftest.er1 >conftest.err

5203 rm -f conftest.er1

5204 cat conftest.err >&5

5205 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5206 (exit $ac_status); } &&

5207 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

5208 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5209 (eval $ac_try) 2>&5

5210 ac_status=$?

5211 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5212 (exit $ac_status); }; } &&

5213 { ac_try='test -s conftest$ac_exeext'

5214 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5215 (eval $ac_try) 2>&5

5216 ac_status=$?

5217 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5218 (exit $ac_status); }; }; then

5219 ac_cv_func__doprnt=yes

5220 else

5221 echo "$as_me: failed program was:" >&5

5222 sed 's/^/| /' conftest.$ac_ext >&5

5223

5224 ac_cv_func__doprnt=no

5225 fi

5226 rm -f conftest.err conftest.$ac_objext \

5227 conftest$ac_exeext conftest.$ac_ext

5228 fi

5229 echo "$as_me:$LINENO: result: $ac_cv_func__doprnt" >&5

5230 echo "${ECHO_T}$ac_cv_func__doprnt" >&6

5231 if test $ac_cv_func__doprnt = yes; then

5232

5233 cat >>confdefs.h <<\_ACEOF

5234 #define HAVE_DOPRNT 1

5235 _ACEOF

5236

5237 fi

5238

5239 fi

5240 done

5241

5242

5243

5244

5245

5246

5247 for ac_func in select socket strerror strstr

5248 do

5249 as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

5250 echo "$as_me:$LINENO: checking for $ac_func" >&5

5251 echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

5252 if eval "test \"\${$as_ac_var+set}\" = set"; then

5253 echo $ECHO_N "(cached) $ECHO_C" >&6

5254 else

5255 cat >conftest.$ac_ext <<_ACEOF

5256 /* confdefs.h. */

5257 _ACEOF

5258 cat confdefs.h >>conftest.$ac_ext

5259 cat >>conftest.$ac_ext <<_ACEOF

5260 /* end confdefs.h. */

5261 /* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

5262 For example, HP-UX 11i <limits.h> declares gettimeofday. */

5263 #define $ac_func innocuous_$ac_func

5264

5265 /* System header to define __stub macros and hopefully few prototypes,

5266 which can conflict with char $ac_func (); below.

5267 Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

5268 <limits.h> exists even on freestanding compilers. */

5269

5270 #ifdef __STDC__

5271 # include <limits.h>

5272 #else

5273 # include <assert.h>

5274 #endif

5275

5276 #undef $ac_func

5277

5278 /* Override any gcc2 internal prototype to avoid an error. */

5279 #ifdef __cplusplus

5280 extern "C"

5281 {

5282 #endif

5283 /* We use char because int might match the return type of a gcc2

5284 builtin and then its argument prototype would still apply. */

5285 char $ac_func ();

5286 /* The GNU C library defines this for functions which it implements

5287 to always fail with ENOSYS. Some functions are actually named

5288 something starting with __ and the normal name is an alias. */

5289 #if defined (__stub_$ac_func) || defined (__stub___$ac_func)

5290 choke me

5291 #else

5292 char (*f) () = $ac_func;

5293 #endif

5294 #ifdef __cplusplus

5295 }

5296 #endif

5297

5298 int

5299 main ()

5300 {

5301 return f != $ac_func;

5302 ;

5303 return 0;

5304 }

5305 _ACEOF

5306 rm -f conftest.$ac_objext conftest$ac_exeext

5307 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

5308 (eval $ac_link) 2>conftest.er1

5309 ac_status=$?

5310 grep -v '^ *+' conftest.er1 >conftest.err

5311 rm -f conftest.er1

5312 cat conftest.err >&5

5313 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5314 (exit $ac_status); } &&

5315 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

5316 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5317 (eval $ac_try) 2>&5

5318 ac_status=$?

5319 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5320 (exit $ac_status); }; } &&

5321 { ac_try='test -s conftest$ac_exeext'

5322 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5323 (eval $ac_try) 2>&5

5324 ac_status=$?

5325 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5326 (exit $ac_status); }; }; then

5327 eval "$as_ac_var=yes"

5328 else

5329 echo "$as_me: failed program was:" >&5

5330 sed 's/^/| /' conftest.$ac_ext >&5

5331

5332 eval "$as_ac_var=no"

5333 fi

5334 rm -f conftest.err conftest.$ac_objext \

5335 conftest$ac_exeext conftest.$ac_ext

5336 fi

5337 echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

5338 echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

5339 if test `eval echo '${'$as_ac_var'}'` = yes; then

5340 cat >>confdefs.h <<_ACEOF

5341 #define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

5342 _ACEOF

5343

5344 fi

5345 done

5346

5347

5348

5349 # Check whether --with-user or --without-user was given.

5350 if test "${with_user+set}" = set; then

5351 withval="$with_user"

5352

5353 fi;

5354 if test "x$with_user" = 'x'; then

5355 with_user='mail'

5356 fi

5357

5358

5359 # Check whether --with-group or --without-group was given.

5360 if test "${with_group+set}" = set; then

5361 withval="$with_group"

5362

5363 fi;

5364 if test "x$with_group" = 'x'; then

5365 with_group='trusted'

5366 fi

5367

5368 # Check whether --enable-debug or --disable-debug was given.

5369 if test "${enable_debug+set}" = set; then

5370 enableval="$enable_debug"

5371 if test "x$enable_debug" != 'xno'; then

5372 debug_enabled='yes'

5373 fi

5374 else

5375 debug_enabled='yes'

5376

5377 fi;

5378 if test "x$debug_enabled" = xyes; then

5379

5380 cat >>confdefs.h <<\_ACEOF

5381 #define ENABLE_DEBUG 1

5382 _ACEOF

5383

5384 fi

5385

5386

5387 cat >>confdefs.h <<_ACEOF

5388 #define DEF_MAIL_USER "${with_user}"

5389 _ACEOF

5390

5391

5392

5393 cat >>confdefs.h <<_ACEOF

5394 #define DEF_MAIL_GROUP "${with_group}"

5395 _ACEOF

5396

5397

5398

5399

5400 # Check whether --with-glib_static or --without-glib_static was given.

5401 if test "${with_glib_static+set}" = set; then

5402 withval="$with_glib_static"

5403

5404 fi;

5405 if test "x$with_glib_static" != 'x'; then

5406 GLIB_LIBS=$with_glib_static

5407

5408 fi

5409

5410 MD5_LIBS=''

5411 BASE64_LIBS=''

5412

5413 # Check whether --enable-smtp_server or --disable-smtp_server was given.

5414 if test "${enable_smtp_server+set}" = set; then

5415 enableval="$enable_smtp_server"

5416 if test "x$enable_smtp_server" != 'xno'; then

5417 smtp_server_enabled='yes'

5418 fi

5419 else

5420 smtp_server_enabled='yes'

5421

5422 fi;

5423 if test "x$smtp_server_enabled" = xyes; then

5424

5425 cat >>confdefs.h <<\_ACEOF

5426 #define ENABLE_SMTP_SERVER 1

5427 _ACEOF

5428

5429 fi

5430

5431 # Check whether --enable-pop3 or --disable-pop3 was given.

5432 if test "${enable_pop3+set}" = set; then

5433 enableval="$enable_pop3"

5434 if test "x$enable_pop3" != 'xno'; then

5435 pop3_enabled='yes'

5436 fi

5437 else

5438 pop3_enabled='yes'

5439

5440 fi;

5441 if test "x$pop3_enabled" = xyes; then

5442

5443 cat >>confdefs.h <<\_ACEOF

5444 #define ENABLE_POP3 1

5445 _ACEOF

5446

5447 # MD5_LIBS='md5/libmd5c.a'

5448 need_md5='yes'

5449 fi

5450

5451 # Check whether --enable-auth or --disable-auth was given.

5452 if test "${enable_auth+set}" = set; then

5453 enableval="$enable_auth"

5454 if test "x$enable_auth" != 'xno'; then

5455 auth_enabled='yes'

5456 fi

5457 fi;

5458 if test "x$auth_enabled" = xyes; then

5459

5460 cat >>confdefs.h <<\_ACEOF

5461 #define ENABLE_AUTH 1

5462 _ACEOF

5463

5464 BASE64_LIBS='base64/libbase64.a'

5465 # MD5_LIBS='md5/libmd5c.a'

5466 need_md5='yes'

5467 fi

5468

5469

5470 # Check whether --enable-maildir or --disable-maildir was given.

5471 if test "${enable_maildir+set}" = set; then

5472 enableval="$enable_maildir"

5473 if test "x$enable_maildir" != 'xno'; then

5474 maildir_enabled='yes'

5475 fi

5476 fi;

5477 if test "x$maildir_enabled" = xyes; then

5478

5479 cat >>confdefs.h <<\_ACEOF

5480 #define ENABLE_MAILDIR 1

5481 _ACEOF

5482

5483 fi

5484

5485

5486 # Check whether --with-libcrypto or --without-libcrypto was given.

5487 if test "${with_libcrypto+set}" = set; then

5488 withval="$with_libcrypto"

5489

5490 fi;

5491 if test "x$with_libcrypto" != 'xyes'; then

5492 with_libcrypto='no'

5493 fi

5494

5495 if test "x$need_md5" = 'xyes'; then

5496 if test "x$with_libcrypto" = "xyes"; then

5497 echo "$as_me:$LINENO: checking for MD5 in -lcrypto" >&5

5498 echo $ECHO_N "checking for MD5 in -lcrypto... $ECHO_C" >&6

5499 if test "${ac_cv_lib_crypto_MD5+set}" = set; then

5500 echo $ECHO_N "(cached) $ECHO_C" >&6

5501 else

5502 ac_check_lib_save_LIBS=$LIBS

5503 LIBS="-lcrypto $LIBS"

5504 cat >conftest.$ac_ext <<_ACEOF

5505 /* confdefs.h. */

5506 _ACEOF

5507 cat confdefs.h >>conftest.$ac_ext

5508 cat >>conftest.$ac_ext <<_ACEOF

5509 /* end confdefs.h. */

5510

5511 /* Override any gcc2 internal prototype to avoid an error. */

5512 #ifdef __cplusplus

5513 extern "C"

5514 #endif

5515 /* We use char because int might match the return type of a gcc2

5516 builtin and then its argument prototype would still apply. */

5517 char MD5 ();

5518 int

5519 main ()

5520 {

5521 MD5 ();

5522 ;

5523 return 0;

5524 }

5525 _ACEOF

5526 rm -f conftest.$ac_objext conftest$ac_exeext

5527 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

5528 (eval $ac_link) 2>conftest.er1

5529 ac_status=$?

5530 grep -v '^ *+' conftest.er1 >conftest.err

5531 rm -f conftest.er1

5532 cat conftest.err >&5

5533 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5534 (exit $ac_status); } &&

5535 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

5536 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5537 (eval $ac_try) 2>&5

5538 ac_status=$?

5539 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5540 (exit $ac_status); }; } &&

5541 { ac_try='test -s conftest$ac_exeext'

5542 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5543 (eval $ac_try) 2>&5

5544 ac_status=$?

5545 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5546 (exit $ac_status); }; }; then

5547 ac_cv_lib_crypto_MD5=yes

5548 else

5549 echo "$as_me: failed program was:" >&5

5550 sed 's/^/| /' conftest.$ac_ext >&5

5551

5552 ac_cv_lib_crypto_MD5=no

5553 fi

5554 rm -f conftest.err conftest.$ac_objext \

5555 conftest$ac_exeext conftest.$ac_ext

5556 LIBS=$ac_check_lib_save_LIBS

5557 fi

5558 echo "$as_me:$LINENO: result: $ac_cv_lib_crypto_MD5" >&5

5559 echo "${ECHO_T}$ac_cv_lib_crypto_MD5" >&6

5560 if test $ac_cv_lib_crypto_MD5 = yes; then

5561 has_crypto='yes'

5562 else

5563 { { echo "$as_me:$LINENO: error: 'no libcrypto'" >&5

5564 echo "$as_me: error: 'no libcrypto'" >&2;}

5565 { (exit 1); exit 1; }; }

5566 fi

5567

5568 if test "x$has_crypto" = 'xyes'; then

5569

5570 cat >>confdefs.h <<\_ACEOF

5571 #define USE_LIB_CRYPTO 1

5572 _ACEOF

5573

5574 MD5_LIBS='-lcrypto'

5575 fi

5576 else

5577 MD5_LIBS='md5/libmd5c.a'

5578 fi

5579 fi

5580

5581

5582 IDENT_LIBS=''

5583 # Check whether --enable-ident or --disable-ident was given.

5584 if test "${enable_ident+set}" = set; then

5585 enableval="$enable_ident"

5586 if test "x$enable_ident" != 'xno'; then

5587 ident_enabled='yes'

5588 fi

5589 fi;

5590

5591 if test "x$ident_enabled" = xyes; then

5592

5593 cat >>confdefs.h <<\_ACEOF

5594 #define ENABLE_IDENT 1

5595 _ACEOF

5596

5597 echo "$as_me:$LINENO: checking for ident_id in -lident" >&5

5598 echo $ECHO_N "checking for ident_id in -lident... $ECHO_C" >&6

5599 if test "${ac_cv_lib_ident_ident_id+set}" = set; then

5600 echo $ECHO_N "(cached) $ECHO_C" >&6

5601 else

5602 ac_check_lib_save_LIBS=$LIBS

5603 LIBS="-lident $LIBS"

5604 cat >conftest.$ac_ext <<_ACEOF

5605 /* confdefs.h. */

5606 _ACEOF

5607 cat confdefs.h >>conftest.$ac_ext

5608 cat >>conftest.$ac_ext <<_ACEOF

5609 /* end confdefs.h. */

5610

5611 /* Override any gcc2 internal prototype to avoid an error. */

5612 #ifdef __cplusplus

5613 extern "C"

5614 #endif

5615 /* We use char because int might match the return type of a gcc2

5616 builtin and then its argument prototype would still apply. */

5617 char ident_id ();

5618 int

5619 main ()

5620 {

5621 ident_id ();

5622 ;

5623 return 0;

5624 }

5625 _ACEOF

5626 rm -f conftest.$ac_objext conftest$ac_exeext

5627 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

5628 (eval $ac_link) 2>conftest.er1

5629 ac_status=$?

5630 grep -v '^ *+' conftest.er1 >conftest.err

5631 rm -f conftest.er1

5632 cat conftest.err >&5

5633 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5634 (exit $ac_status); } &&

5635 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

5636 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5637 (eval $ac_try) 2>&5

5638 ac_status=$?

5639 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5640 (exit $ac_status); }; } &&

5641 { ac_try='test -s conftest$ac_exeext'

5642 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5643 (eval $ac_try) 2>&5

5644 ac_status=$?

5645 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5646 (exit $ac_status); }; }; then

5647 ac_cv_lib_ident_ident_id=yes

5648 else

5649 echo "$as_me: failed program was:" >&5

5650 sed 's/^/| /' conftest.$ac_ext >&5

5651

5652 ac_cv_lib_ident_ident_id=no

5653 fi

5654 rm -f conftest.err conftest.$ac_objext \

5655 conftest$ac_exeext conftest.$ac_ext

5656 LIBS=$ac_check_lib_save_LIBS

5657 fi

5658 echo "$as_me:$LINENO: result: $ac_cv_lib_ident_ident_id" >&5

5659 echo "${ECHO_T}$ac_cv_lib_ident_ident_id" >&6

5660 if test $ac_cv_lib_ident_ident_id = yes; then

5661 IDENT_LIBS='-lident'

5662 else

5663 IDENT_LIBS='libident/libident.a'

5664 fi

5665

5666 fi

5667

5668

5669 # Check whether --enable-mserver or --disable-mserver was given.

5670 if test "${enable_mserver+set}" = set; then

5671 enableval="$enable_mserver"

5672 if test "x$enable_mserver" != 'xno'; then

5673 mserver_enabled='yes'

5674 fi

5675 fi;

5676 if test "x$mserver_enabled" = xyes; then

5677

5678 cat >>confdefs.h <<\_ACEOF

5679 #define ENABLE_MSERVER 1

5680 _ACEOF

5681

5682 fi

5683

5684

5685 # Check whether --with-liblockfile or --without-liblockfile was given.

5686 if test "${with_liblockfile+set}" = set; then

5687 withval="$with_liblockfile"

5688

5689 fi;

5690 if test "x$with_liblockfile" != 'x'; then

5691 with_liblockfile='yes'

5692 fi

5693 if test "x$with_liblockfile" = xyes; then

5694 echo "$as_me:$LINENO: checking for maillock in -llockfile" >&5

5695 echo $ECHO_N "checking for maillock in -llockfile... $ECHO_C" >&6

5696 if test "${ac_cv_lib_lockfile_maillock+set}" = set; then

5697 echo $ECHO_N "(cached) $ECHO_C" >&6

5698 else

5699 ac_check_lib_save_LIBS=$LIBS

5700 LIBS="-llockfile $LIBS"

5701 cat >conftest.$ac_ext <<_ACEOF

5702 /* confdefs.h. */

5703 _ACEOF

5704 cat confdefs.h >>conftest.$ac_ext

5705 cat >>conftest.$ac_ext <<_ACEOF

5706 /* end confdefs.h. */

5707

5708 /* Override any gcc2 internal prototype to avoid an error. */

5709 #ifdef __cplusplus

5710 extern "C"

5711 #endif

5712 /* We use char because int might match the return type of a gcc2

5713 builtin and then its argument prototype would still apply. */

5714 char maillock ();

5715 int

5716 main ()

5717 {

5718 maillock ();

5719 ;

5720 return 0;

5721 }

5722 _ACEOF

5723 rm -f conftest.$ac_objext conftest$ac_exeext

5724 if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

5725 (eval $ac_link) 2>conftest.er1

5726 ac_status=$?

5727 grep -v '^ *+' conftest.er1 >conftest.err

5728 rm -f conftest.er1

5729 cat conftest.err >&5

5730 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5731 (exit $ac_status); } &&

5732 { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'

5733 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5734 (eval $ac_try) 2>&5

5735 ac_status=$?

5736 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5737 (exit $ac_status); }; } &&

5738 { ac_try='test -s conftest$ac_exeext'

5739 { (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5740 (eval $ac_try) 2>&5

5741 ac_status=$?

5742 echo "$as_me:$LINENO: \$? = $ac_status" >&5

5743 (exit $ac_status); }; }; then

5744 ac_cv_lib_lockfile_maillock=yes

5745 else

5746 echo "$as_me: failed program was:" >&5

5747 sed 's/^/| /' conftest.$ac_ext >&5

5748

5749 ac_cv_lib_lockfile_maillock=no

5750 fi

5751 rm -f conftest.err conftest.$ac_objext \

5752 conftest$ac_exeext conftest.$ac_ext

5753 LIBS=$ac_check_lib_save_LIBS

5754 fi

5755 echo "$as_me:$LINENO: result: $ac_cv_lib_lockfile_maillock" >&5

5756 echo "${ECHO_T}$ac_cv_lib_lockfile_maillock" >&6

5757 if test $ac_cv_lib_lockfile_maillock = yes; then

5758 has_lockfile=yes

5759 else

5760 { { echo "$as_me:$LINENO: error: \"no liblockfile\"" >&5

5761 echo "$as_me: error: \"no liblockfile\"" >&2;}

5762 { (exit 1); exit 1; }; }

5763 fi

5764

5765 LOCKFILE_LIBS='-llockfile'

5766

5767 cat >>confdefs.h <<\_ACEOF

5768 #define USE_LIBLOCKFILE 1

5769 _ACEOF

5770

5771 else

5772 LOCKFILE_LIBS=''

5773 fi

5774

5775

5776

5777

5778 # Check whether --with-logdir or --without-logdir was given.

5779 if test "${with_logdir+set}" = set; then

5780 withval="$with_logdir"

5781

5782 else

5783 with_logdir='/var/log/masqmail/'

5784

5785 fi;

5786

5787

5788

5789 # Check whether --with-spooldir or --without-spooldir was given.

5790 if test "${with_spooldir+set}" = set; then

5791 withval="$with_spooldir"

5792

5793 else

5794 with_spooldir='/var/spool/masqmail/'

5795

5796 fi;

5797

5798

5799

5800 # Check whether --with-confdir or --without-confdir was given.

5801 if test "${with_confdir+set}" = set; then

5802 withval="$with_confdir"

5803

5804 else

5805 with_confdir='/etc/masqmail'

5806

5807 fi;

5808

5809 cat >>confdefs.h <<_ACEOF

5810 #define CONF_DIR "${with_confdir}"

5811 _ACEOF

5812

5813

5814

5815 test "x$prefix" = xNONE && prefix="$ac_default_prefix"

5816

5817 cat >>confdefs.h <<_ACEOF

5818 #define DATA_DIR "`eval echo \""$datadir"\"`/masqmail"

5819 _ACEOF

5820

5821

5822 if test "x${exec_prefix}" != 'xNONE'; then

5823

5824 cat >>confdefs.h <<_ACEOF

5825 #define SBINDIR "${exec_prefix}/sbin"

5826 _ACEOF

5827

5828 else

5829 if test "x${prefix}" != 'xNONE'; then

5830 cat >>confdefs.h <<_ACEOF

5831 #define SBINDIR "${prefix}/sbin"

5832 _ACEOF

5833

5834 else

5835 cat >>confdefs.h <<_ACEOF

5836 #define SBINDIR "/usr/sbin"

5837 _ACEOF

5838

5839 fi

5840 fi

5841

5842 ac_config_files="$ac_config_files Makefile debian/Makefile docs/Makefile docs/man/Makefile docs/xml/Makefile tests/Makefile src/Makefile src/base64/Makefile src/md5/Makefile src/libident/Makefile suse/masqmail.spec redhat/masqmail.spec"

5843 cat >confcache <<\_ACEOF

5844 # This file is a shell script that caches the results of configure

5845 # tests run on this system so they can be shared between configure

5846 # scripts and configure runs, see configure's option --config-cache.

5847 # It is not useful on other systems. If it contains results you don't

5848 # want to keep, you may remove or edit it.

5849 #

5850 # config.status only pays attention to the cache file if you give it

5851 # the --recheck option to rerun configure.

5852 #

5853 # `ac_cv_env_foo' variables (set or unset) will be overridden when

5854 # loading this file, other *unset* `ac_cv_foo' will be assigned the