~ubuntu-branches/ubuntu/oneiric/nis/oneiric-proposed

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 install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM mkdir_p AWK SET_MAKE am__leading_dot AMTAR am__tar am__untar YPBINDIR YPMAPDIR SBINDIR 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 RANLIB ac_ct_RANLIB libc_cv_fpie PIE_CFLAGS PIE_LDFLAGS EGREP BASH MAKE ALIASES USE_FQDN CHECKROOT LIBDBM LIBCRYPT LIBSLP USE_SLP RESOLV 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

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

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

372

373

ac_prev=bindir ;;

374

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

392

393

ac_prev=datadir ;;

394

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 \

421

422

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

423

ac_prev=exec_prefix ;;

424

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

425

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

452

453

ac_prev=infodir ;;

454

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

472

ac_prev=localstatedir ;;

473

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

474

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

475

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 \

492

493

no_recursion=yes ;;

494

495

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

496

497

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

498

ac_prev=oldincludedir ;;

499

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

500

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 \

541

542

silent=yes ;;

543

544

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 \

552

553

| --sha | --sh)

554

ac_prev=sharedstatedir ;;

555

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

556

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

557

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

566

567

ac_prev=srcdir ;;

568

569

srcdir=$ac_optarg ;;

570

571

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

572

573

ac_prev=sysconfdir ;;

574

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

575

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

583

584

verbose=yes ;;

585

586

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

624

ac_prev=x_libraries ;;

625

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

626

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

660

661

# Be sure to have absolute paths.

662

for ac_var in exec_prefix prefix

663

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

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

700

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

728

else

729

ac_srcdir_defaulted=no

730

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

739

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

777

778

# Report the --help message.

779

780

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

781

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

782

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

783

cat <<_ACEOF

784

\`configure' configures ypserv 2.18 to adapt to many kinds of systems.

785

786

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

787

788

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

789

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

790

791

Defaults for the options are specified in brackets.

792

793

Configuration:

794

-h, --help display this help and exit

795

--help=short display options specific to this package

796

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

797

-V, --version display version information and exit

798

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

799

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

800

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

801

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

802

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

803

804

_ACEOF

805

806

cat <<_ACEOF

807

Installation directories:

808

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

809

[$ac_default_prefix]

810

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

811

[PREFIX]

812

813

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

814

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

815

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

816

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

817

818

For better control, use the options below.

819

820

Fine tuning of the installation directories:

821

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

822

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

823

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

824

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

825

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

826

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

827

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

828

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

829

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

830

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

831

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

832

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

833

_ACEOF

834

835

cat <<\_ACEOF

836

837

Program names:

838

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

839

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

840

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

841

_ACEOF

842

843

844

if test -n "$ac_init_help"; then

845

case $ac_init_help in

846

short | recursive ) echo "Configuration of ypserv 2.18:";;

847

esac

848

cat <<\_ACEOF

849

850

Optional Features:

851

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

852

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

853

--enable-ypmapdir=path Location of NIS maps default=/var/yp

854

--disable-dependency-tracking speeds up one-time build

855

--enable-dependency-tracking do not reject slow dependency extractors

856

--disable-fqdn Always use FQDN default=yes

857

--disable-checkroot Disable check for root password default=yes

858

859

Optional Packages:

860

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

861

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

862

--with-dmalloc use dmalloc, as in

863

http://www.dmalloc.com/dmalloc.tar.gz

864

--with-efence use ElectricFence

865

866

Some influential environment variables:

867

CC C compiler command

868

CFLAGS C compiler flags

869

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

870

nonstandard directory <lib dir>

871

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

872

headers in a nonstandard directory <include dir>

873

CPP C preprocessor

874

875

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

876

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

877

878

Report bugs to <kukuk@linux-nis.org>.

879

_ACEOF

880

881

882

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

883

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

884

ac_popdir=`pwd`

885

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

886

test -d $ac_dir || continue

887

ac_builddir=.

888

889

if test "$ac_dir" != .; then

890

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

891

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

892

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

893

else

894

ac_dir_suffix= ac_top_builddir=

895

896

897

case $srcdir in

898

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

899

ac_srcdir=.

900

if test -z "$ac_top_builddir"; then

901

ac_top_srcdir=.

902

else

903

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

904

fi ;;

905

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

906

ac_srcdir=$srcdir$ac_dir_suffix;

907

ac_top_srcdir=$srcdir ;;

908

*) # Relative path.

909

ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix

910

ac_top_srcdir=$ac_top_builddir$srcdir ;;

911

esac

912

913

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

914

# the directories may not exist.

915

case `pwd` in

916

.) ac_abs_builddir="$ac_dir";;

917

918

case "$ac_dir" in

919

.) ac_abs_builddir=`pwd`;;

920

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

921

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

922

esac;;

923

esac

924

case $ac_abs_builddir in

925

.) ac_abs_top_builddir=${ac_top_builddir}.;;

926

927

case ${ac_top_builddir}. in

928

.) ac_abs_top_builddir=$ac_abs_builddir;;

929

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

930

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

931

esac;;

932

esac

933

case $ac_abs_builddir in

934

.) ac_abs_srcdir=$ac_srcdir;;

935

936

case $ac_srcdir in

937

.) ac_abs_srcdir=$ac_abs_builddir;;

938

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

939

*) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;

940

esac;;

941

esac

942

case $ac_abs_builddir in

943

.) ac_abs_top_srcdir=$ac_top_srcdir;;

944

945

case $ac_top_srcdir in

946

.) ac_abs_top_srcdir=$ac_abs_builddir;;

947

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

948

*) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;

949

esac;;

950

esac

951

952

cd $ac_dir

953

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

954

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

955

echo

956

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

957

elif test -f $ac_srcdir/configure; then

958

echo

959

$SHELL $ac_srcdir/configure --help=recursive

960

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

961

test -f $ac_srcdir/configure.in; then

962

echo

963

$ac_configure --help

964

else

965

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

966

967

cd $ac_popdir

968

done

969

970

971

test -n "$ac_init_help" && exit 0

972

if $ac_init_version; then

973

cat <<\_ACEOF

974

ypserv configure 2.18

975

generated by GNU Autoconf 2.59

976

977

978

This configure script is free software; the Free Software Foundation

979

gives unlimited permission to copy, distribute and modify it.

980

_ACEOF

981

exit 0

982

983

exec 5>config.log

984

cat >&5 <<_ACEOF

985

This file contains any messages produced by compilers while

986

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

987

988

It was created by ypserv $as_me 2.18, which was

989

generated by GNU Autoconf 2.59. Invocation command line was

990

991

$ $0 $@

992

993

_ACEOF

994

{

995

cat <<_ASUNAME

996

## --------- ##

997

## Platform. ##

998

## --------- ##

999

1000

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

1001

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

1002

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

1003

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

1004

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

1005

1006

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

1007

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

1008

1009

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

1010

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

1011

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

1012

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

1013

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

1014

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

1015

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

1016

1017

_ASUNAME

1018

1019

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1020

for as_dir in $PATH

1021

1022

IFS=$as_save_IFS

1023

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

1024

echo "PATH: $as_dir"

1025

done

1026

1027

} >&5

1028

1029

cat >&5 <<_ACEOF

1030

1031

1032

## ----------- ##

1033

## Core tests. ##

1034

## ----------- ##

1035

1036

_ACEOF

1037

1038

1039

# Keep a trace of the command line.

1040

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

1041

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

1042

# Also quote any args containing shell meta-characters.

1043

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

1044

ac_configure_args=

1045

ac_configure_args0=

1046

ac_configure_args1=

1047

ac_sep=

1048

ac_must_keep_next=false

1049

for ac_pass in 1 2

1050

1051

for ac_arg

1052

1053

case $ac_arg in

1054

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

1055

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

1056

1057

continue ;;

1058

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

1059

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

1060

esac

1061

case $ac_pass in

1062

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

1063

1064

ac_configure_args1="$ac_configure_args1 '$ac_arg'"

1065

if test $ac_must_keep_next = true; then

1066

ac_must_keep_next=false # Got value, back to normal.

1067

else

1068

case $ac_arg in

1069

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

1070

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

1071

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

1072

1073

case "$ac_configure_args0 " in

1074

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

1075

esac

1076

;;

1077

-* ) ac_must_keep_next=true ;;

1078

esac

1079

1080

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

1081

# Get rid of the leading space.

1082

ac_sep=" "

1083

;;

1084

esac

1085

done

1086

done

1087

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

1088

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

1089

1090

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

1091

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

1092

# would cause problems or look ugly.

1093

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

1094

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

1095

trap 'exit_status=$?

1096

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

1097

{

1098

echo

1099

1100

cat <<\_ASBOX

1101

## ---------------- ##

1102

## Cache variables. ##

1103

## ---------------- ##

1104

_ASBOX

1105

echo

1106

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

1107

{

1108

(set) 2>&1 |

1109

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

1110

*ac_space=\ *)

1111

sed -n \

1112

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

1113

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

1114

;;

1115

1116

sed -n \

1117

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

1118

;;

1119

esac;

1120

}

1121

echo

1122

1123

cat <<\_ASBOX

1124

## ----------------- ##

1125

## Output variables. ##

1126

## ----------------- ##

1127

_ASBOX

1128

echo

1129

for ac_var in $ac_subst_vars

1130

1131

eval ac_val=$`echo $ac_var`

1132

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

1133

done | sort

1134

echo

1135

1136

if test -n "$ac_subst_files"; then

1137

cat <<\_ASBOX

1138

## ------------- ##

1139

## Output files. ##

1140

## ------------- ##

1141

_ASBOX

1142

echo

1143

for ac_var in $ac_subst_files

1144

1145

eval ac_val=$`echo $ac_var`

1146

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

1147

done | sort

1148

echo

1149

1150

1151

if test -s confdefs.h; then

1152

cat <<\_ASBOX

1153

## ----------- ##

1154

## confdefs.h. ##

1155

## ----------- ##

1156

_ASBOX

1157

echo

1158

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

1159

echo

1160

1161

test "$ac_signal" != 0 &&

1162

echo "$as_me: caught signal $ac_signal"

1163

echo "$as_me: exit $exit_status"

1164

} >&5

1165

rm -f core *.core &&

1166

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

1167

exit $exit_status

1168

' 0

1169

for ac_signal in 1 2 13 15; do

1170

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

1171

done

1172

ac_signal=0

1173

1174

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

1175

rm -rf conftest* confdefs.h

1176

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

1177

echo >confdefs.h

1178

1179

# Predefined preprocessor variables.

1180

1181

cat >>confdefs.h <<_ACEOF

1182

#define PACKAGE_NAME "$PACKAGE_NAME"

1183

_ACEOF

1184

1185

1186

cat >>confdefs.h <<_ACEOF

1187

#define PACKAGE_TARNAME "$PACKAGE_TARNAME"

1188

_ACEOF

1189

1190

1191

cat >>confdefs.h <<_ACEOF

1192

#define PACKAGE_VERSION "$PACKAGE_VERSION"

1193

_ACEOF

1194

1195

1196

cat >>confdefs.h <<_ACEOF

1197

#define PACKAGE_STRING "$PACKAGE_STRING"

1198

_ACEOF

1199

1200

1201

cat >>confdefs.h <<_ACEOF

1202

#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"

1203

_ACEOF

1204

1205

1206

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

1207

# Prefer explicitly selected file to automatically selected ones.

1208

if test -z "$CONFIG_SITE"; then

1209

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

1210

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

1211

else

1212

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

1213

1214

1215

for ac_site_file in $CONFIG_SITE; do

1216

if test -r "$ac_site_file"; then

1217

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

1218

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

1219

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

1220

. "$ac_site_file"

1221

1222

done

1223

1224

if test -r "$cache_file"; then

1225

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

1226

# files actually), so we avoid doing that.

1227

if test -f "$cache_file"; then

1228

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

1229

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

1230

case $cache_file in

1231

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

1232

*) . ./$cache_file;;

1233

esac

1234

1235

else

1236

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

1237

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

1238

>$cache_file

1239

1240

1241

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

1242

# value.

1243

ac_cache_corrupted=false

1244

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

1245

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

1246

eval ac_old_set=\$ac_cv_env_${ac_var}_set

1247

eval ac_new_set=\$ac_env_${ac_var}_set

1248

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

1249

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

1250

case $ac_old_set,$ac_new_set in

1251

set,)

1252

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

1253

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

1254

ac_cache_corrupted=: ;;

1255

,set)

1256

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

1257

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

1258

ac_cache_corrupted=: ;;

1259

,);;

1260

1261

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

1262

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

1263

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

1264

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

1265

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

1266

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

1267

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

1268

ac_cache_corrupted=:

1269

fi;;

1270

esac

1271

# Pass precious variables to config.status.

1272

if test "$ac_new_set" = set; then

1273

case $ac_new_val in

1274

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

1275

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

1276

*) ac_arg=$ac_var=$ac_new_val ;;

1277

esac

1278

case " $ac_configure_args " in

1279

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

1280

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

1281

esac

1282

1283

done

1284

if $ac_cache_corrupted; then

1285

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

1286

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

1287

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

1288

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

1289

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

1290

1291

1292

ac_ext=c

1293

ac_cpp='$CPP $CPPFLAGS'

1294

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

1295

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

1296

ac_compiler_gnu=$ac_cv_c_compiler_gnu

1297

1298

1299

1300

1301

1302

1303

1304

1305

1306

1307

1308

1309

1310

1311

1312

1313

1314

1315

1316

1317

1318

1319

1320

1321

1322

1323

1324

am__api_version="1.9"

1325

ac_aux_dir=

1326

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

1327

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

1328

ac_aux_dir=$ac_dir

1329

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

1330

break

1331

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

1332

ac_aux_dir=$ac_dir

1333

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

1334

break

1335

elif test -f $ac_dir/shtool; then

1336

ac_aux_dir=$ac_dir

1337

ac_install_sh="$ac_aux_dir/shtool install -c"

1338

break

1339

1340

done

1341

if test -z "$ac_aux_dir"; then

1342

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

1343

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

1344

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

1345

1346

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

1347

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

1348

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

1349

1350

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

1351

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

1352

# incompatible versions:

1353

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

1354

# SunOS /usr/etc/install

1355

# IRIX /sbin/install

1356

# AIX /bin/install

1357

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

1358

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

1359

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

1360

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

1361

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

1362

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

1363

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

1364

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

1365

if test -z "$INSTALL"; then

1366

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

1367

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

1368

else

1369

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1370

for as_dir in $PATH

1371

1372

IFS=$as_save_IFS

1373

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

1374

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

1375

case $as_dir/ in

1376

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

1377

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

1378

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

1379

/usr/ucb/* ) ;;

1380

1381

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

1382

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

1383

# by default.

1384

for ac_prog in ginstall scoinst install; do

1385

for ac_exec_ext in '' $ac_executable_extensions; do

1386

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

1387

if test $ac_prog = install &&

1388

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

1389

# AIX install. It has an incompatible calling convention.

1390

1391

elif test $ac_prog = install &&

1392

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

1393

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

1394

1395

else

1396

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

1397

break 3

1398

1399

1400

done

1401

done

1402

;;

1403

esac

1404

done

1405

1406

1407

1408

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

1409

INSTALL=$ac_cv_path_install

1410

else

1411

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

1412

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

1413

# break other packages using the cache if that directory is

1414

# removed, or if the path is relative.

1415

INSTALL=$ac_install_sh

1416

1417

1418

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

1419

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

1420

1421

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

1422

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

1423

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

1424

1425

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

1426

1427

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

1428

1429

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

1430

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

1431

# Just in case

1432

sleep 1

1433

echo timestamp > conftest.file

1434

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

1435

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

1436

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

1437

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

1438

# directory).

1439

if (

1440

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

1441

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

1442

# -L didn't work.

1443

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

1444

1445

rm -f conftest.file

1446

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

1447

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

1448

1449

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

1450

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

1451

# broken ls alias from the environment. This has actually

1452

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

1453

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

1454

alias in your environment" >&5

1455

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

1456

alias in your environment" >&2;}

1457

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

1458

1459

1460

test "$2" = conftest.file

1461

)

1462

then

1463

# Ok.

1464

1465

else

1466

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

1467

Check your system clock" >&5

1468

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

1469

Check your system clock" >&2;}

1470

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

1471

1472

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

1473

echo "${ECHO_T}yes" >&6

1474

test "$program_prefix" != NONE &&

1475

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

1476

# Use a double $ so make ignores it.

1477

test "$program_suffix" != NONE &&

1478

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

1479

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

1480

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

1481

cat <<\_ACEOF >conftest.sed

1482

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

1483

_ACEOF

1484

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

1485

rm conftest.sed

1486

1487

# expand $ac_aux_dir to an absolute path

1488

am_aux_dir=`cd $ac_aux_dir && pwd`

1489

1490

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

1491

# Use eval to expand $SHELL

1492

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

1493

am_missing_run="$MISSING --run "

1494

else

1495

am_missing_run=

1496

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

1497

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

1498

1499

1500

if mkdir -p --version . >/dev/null 2>&1 && test ! -d ./--version; then

1501

# We used to keeping the `.' as first argument, in order to

1502

# allow $(mkdir_p) to be used without argument. As in

1503

# $(mkdir_p) $(somedir)

1504

# where $(somedir) is conditionally defined. However this is wrong

1505

# for two reasons:

1506

# 1. if the package is installed by a user who cannot write `.'

1507

# make install will fail,

1508

# 2. the above comment should most certainly read

1509

# $(mkdir_p) $(DESTDIR)$(somedir)

1510

# so it does not work when $(somedir) is undefined and

1511

# $(DESTDIR) is not.

1512

# To support the latter case, we have to write

1513

# test -z "$(somedir)" || $(mkdir_p) $(DESTDIR)$(somedir),

1514

# so the `.' trick is pointless.

1515

mkdir_p='mkdir -p --'

1516

else

1517

# On NextStep and OpenStep, the `mkdir' command does not

1518

# recognize any option. It will interpret all options as

1519

# directories to create, and then abort because `.' already

1520

# exists.

1521

for d in ./-p ./--version;

1522

1523

test -d $d && rmdir $d

1524

done

1525

# $(mkinstalldirs) is defined by Automake if mkinstalldirs exists.

1526

if test -f "$ac_aux_dir/mkinstalldirs"; then

1527

mkdir_p='$(mkinstalldirs)'

1528

else

1529

mkdir_p='$(install_sh) -d'

1530

1531

1532

1533

for ac_prog in gawk mawk nawk awk

1534

1535

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

1536

set dummy $ac_prog; ac_word=$2

1537

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

1538

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

1539

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

1540

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

1541

else

1542

if test -n "$AWK"; then

1543

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

1544

else

1545

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1546

for as_dir in $PATH

1547

1548

IFS=$as_save_IFS

1549

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

1550

for ac_exec_ext in '' $ac_executable_extensions; do

1551

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

1552

ac_cv_prog_AWK="$ac_prog"

1553

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

1554

break 2

1555

1556

done

1557

done

1558

1559

1560

1561

AWK=$ac_cv_prog_AWK

1562

if test -n "$AWK"; then

1563

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

1564

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

1565

else

1566

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

1567

echo "${ECHO_T}no" >&6

1568

1569

1570

test -n "$AWK" && break

1571

done

1572

1573

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

1574

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

1575

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

1576

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

1577

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

1578

else

1579

cat >conftest.make <<\_ACEOF

1580

all:

1581

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

1582

_ACEOF

1583

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

1584

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

1585

if test -n "$ac_maketemp"; then

1586

eval ac_cv_prog_make_${ac_make}_set=yes

1587

else

1588

eval ac_cv_prog_make_${ac_make}_set=no

1589

1590

rm -f conftest.make

1591

1592

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

1593

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

1594

echo "${ECHO_T}yes" >&6

1595

SET_MAKE=

1596

else

1597

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

1598

echo "${ECHO_T}no" >&6

1599

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

1600

1601

1602

rm -rf .tst 2>/dev/null

1603

mkdir .tst 2>/dev/null

1604

if test -d .tst; then

1605

am__leading_dot=.

1606

else

1607

am__leading_dot=_

1608

1609

rmdir .tst 2>/dev/null

1610

1611

# test to see if srcdir already configured

1612

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

1613

test -f $srcdir/config.status; then

1614

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

1615

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

1616

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

1617

1618

1619

# test whether we have cygpath

1620

if test -z "$CYGPATH_W"; then

1621

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

1622

CYGPATH_W='cygpath -w'

1623

else

1624

CYGPATH_W=echo

1625

1626

1627

1628

1629

# Define the identity of the package.

1630

PACKAGE='ypserv'

1631

VERSION='2.18'

1632

1633

1634

cat >>confdefs.h <<_ACEOF

1635

#define PACKAGE "$PACKAGE"

1636

_ACEOF

1637

1638

1639

cat >>confdefs.h <<_ACEOF

1640

#define VERSION "$VERSION"

1641

_ACEOF

1642

1643

# Some tools Automake needs.

1644

1645

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

1646

1647

1648

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

1649

1650

1651

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

1652

1653

1654

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

1655

1656

1657

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

1658

1659

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

1660

1661

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

1662

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

1663

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

1664

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

1665

if test "$cross_compiling" != no; then

1666

if test -n "$ac_tool_prefix"; then

1667

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

1668

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

1669

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

1670

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

1671

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

1672

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

1673

else

1674

if test -n "$STRIP"; then

1675

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

1676

else

1677

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1678

for as_dir in $PATH

1679

1680

IFS=$as_save_IFS

1681

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

1682

for ac_exec_ext in '' $ac_executable_extensions; do

1683

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

1684

ac_cv_prog_STRIP="${ac_tool_prefix}strip"

1685

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

1686

break 2

1687

1688

done

1689

done

1690

1691

1692

1693

STRIP=$ac_cv_prog_STRIP

1694

if test -n "$STRIP"; then

1695

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

1696

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

1697

else

1698

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

1699

echo "${ECHO_T}no" >&6

1700

1701

1702

1703

if test -z "$ac_cv_prog_STRIP"; then

1704

ac_ct_STRIP=$STRIP

1705

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

1706

set dummy strip; ac_word=$2

1707

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

1708

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

1709

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

1710

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

1711

else

1712

if test -n "$ac_ct_STRIP"; then

1713

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

1714

else

1715

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1716

for as_dir in $PATH

1717

1718

IFS=$as_save_IFS

1719

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

1720

for ac_exec_ext in '' $ac_executable_extensions; do

1721

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

1722

ac_cv_prog_ac_ct_STRIP="strip"

1723

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

1724

break 2

1725

1726

done

1727

done

1728

1729

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

1730

1731

1732

ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP

1733

if test -n "$ac_ct_STRIP"; then

1734

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

1735

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

1736

else

1737

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

1738

echo "${ECHO_T}no" >&6

1739

1740

1741

STRIP=$ac_ct_STRIP

1742

else

1743

STRIP="$ac_cv_prog_STRIP"

1744

1745

1746

1747

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

1748

1749

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

1750

# some platforms.

1751

# Always define AMTAR for backward compatibility.

1752

1753

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

1754

1755

am__tar='${AMTAR} chof - "$$tardir"'; am__untar='${AMTAR} xf -'

1756

1757

1758

1759

1760

1761

1762

ac_config_headers="$ac_config_headers config.h"

1763

1764

1765

1766

1767

1768

1769

test "${prefix}" = "NONE" && prefix="/usr"

1770

if test ${prefix} = '/usr'

1771

then

1772

if test ${sysconfdir} = '${prefix}/etc'

1773

then

1774

sysconfdir="/etc"

1775

1776

if test ${mandir} = '${prefix}/man'

1777

then

1778

mandir='${prefix}/share/man'

1779

1780

1781

if test ${libexecdir} = '${exec_prefix}/libexec'

1782

then

1783

libexecdir='${exec_prefix}/lib/yp'

1784

if test "${exec_prefix}" = "NONE"

1785

then

1786

YPBINDIR=/usr/lib/yp

1787

else

1788

YPBINDIR=${exec_prefix}/lib/yp

1789

1790

else

1791

YPBINDIR=${libexecdir}

1792

1793

1794

1795

# Check whether --enable-ypmapdir or --disable-ypmapdir was given.

1796

if test "${enable_ypmapdir+set}" = set; then

1797

enableval="$enable_ypmapdir"

1798

YPMAPDIR=$enableval

1799

else

1800

YPMAPDIR=/var/yp

1801

fi;

1802

1803

1804

1805

if test ${sbindir} = '${exec_prefix}/sbin'

1806

then

1807

if test "${exec_prefix}" = "NONE"

1808

then

1809

SBINDIR=/usr/sbin

1810

else

1811

SBINDIR=${exec_prefix}/sbin

1812

1813

else

1814

SBINDIR=${sbindir}

1815

1816

1817

1818

ac_ext=c

1819

ac_cpp='$CPP $CPPFLAGS'

1820

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

1821

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

1822

ac_compiler_gnu=$ac_cv_c_compiler_gnu

1823

if test -n "$ac_tool_prefix"; then

1824

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

1825

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

1826

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

1827

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

1828

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

1829

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

1830

else

1831

if test -n "$CC"; then

1832

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

1833

else

1834

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1835

for as_dir in $PATH

1836

1837

IFS=$as_save_IFS

1838

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

1839

for ac_exec_ext in '' $ac_executable_extensions; do

1840

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

1841

ac_cv_prog_CC="${ac_tool_prefix}gcc"

1842

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

1843

break 2

1844

1845

done

1846

done

1847

1848

1849

1850

CC=$ac_cv_prog_CC

1851

if test -n "$CC"; then

1852

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

1853

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

1854

else

1855

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

1856

echo "${ECHO_T}no" >&6

1857

1858

1859

1860

if test -z "$ac_cv_prog_CC"; then

1861

ac_ct_CC=$CC

1862

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

1863

set dummy gcc; ac_word=$2

1864

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

1865

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

1866

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

1867

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

1868

else

1869

if test -n "$ac_ct_CC"; then

1870

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

1871

else

1872

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1873

for as_dir in $PATH

1874

1875

IFS=$as_save_IFS

1876

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

1877

for ac_exec_ext in '' $ac_executable_extensions; do

1878

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

1879

ac_cv_prog_ac_ct_CC="gcc"

1880

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

1881

break 2

1882

1883

done

1884

done

1885

1886

1887

1888

ac_ct_CC=$ac_cv_prog_ac_ct_CC

1889

if test -n "$ac_ct_CC"; then

1890

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

1891

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

1892

else

1893

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

1894

echo "${ECHO_T}no" >&6

1895

1896

1897

CC=$ac_ct_CC

1898

else

1899

CC="$ac_cv_prog_CC"

1900

1901

1902

if test -z "$CC"; then

1903

if test -n "$ac_tool_prefix"; then

1904

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

1905

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

1906

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

1907

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

1908

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

1909

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

1910

else

1911

if test -n "$CC"; then

1912

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

1913

else

1914

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1915

for as_dir in $PATH

1916

1917

IFS=$as_save_IFS

1918

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

1919

for ac_exec_ext in '' $ac_executable_extensions; do

1920

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

1921

ac_cv_prog_CC="${ac_tool_prefix}cc"

1922

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

1923

break 2

1924

1925

done

1926

done

1927

1928

1929

1930

CC=$ac_cv_prog_CC

1931

if test -n "$CC"; then

1932

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

1933

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

1934

else

1935

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

1936

echo "${ECHO_T}no" >&6

1937

1938

1939

1940

if test -z "$ac_cv_prog_CC"; then

1941

ac_ct_CC=$CC

1942

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

1943

set dummy cc; ac_word=$2

1944

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

1945

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

1946

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

1947

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

1948

else

1949

if test -n "$ac_ct_CC"; then

1950

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

1951

else

1952

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1953

for as_dir in $PATH

1954

1955

IFS=$as_save_IFS

1956

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

1957

for ac_exec_ext in '' $ac_executable_extensions; do

1958

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

1959

ac_cv_prog_ac_ct_CC="cc"

1960

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

1961

break 2

1962

1963

done

1964

done

1965

1966

1967

1968

ac_ct_CC=$ac_cv_prog_ac_ct_CC

1969

if test -n "$ac_ct_CC"; then

1970

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

1971

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

1972

else

1973

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

1974

echo "${ECHO_T}no" >&6

1975

1976

1977

CC=$ac_ct_CC

1978

else

1979

CC="$ac_cv_prog_CC"

1980

1981

1982

1983

if test -z "$CC"; then

1984

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

1985

set dummy cc; ac_word=$2

1986

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

1987

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

1988

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

1989

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

1990

else

1991

if test -n "$CC"; then

1992

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

1993

else

1994

ac_prog_rejected=no

1995

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

1996

for as_dir in $PATH

1997

1998

IFS=$as_save_IFS

1999

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

2000

for ac_exec_ext in '' $ac_executable_extensions; do

2001

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

2002

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

2003

ac_prog_rejected=yes

2004

continue

2005

2006

ac_cv_prog_CC="cc"

2007

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

2008

break 2

2009

2010

done

2011

done

2012

2013

if test $ac_prog_rejected = yes; then

2014

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

2015

set dummy $ac_cv_prog_CC

2016

shift

2017

if test $# != 0; then

2018

# We chose a different compiler from the bogus one.

2019

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

2020

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

2021

shift

2022

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

2023

2024

2025

2026

2027

CC=$ac_cv_prog_CC

2028

if test -n "$CC"; then

2029

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

2030

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

2031

else

2032

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

2033

echo "${ECHO_T}no" >&6

2034

2035

2036

2037

if test -z "$CC"; then

2038

if test -n "$ac_tool_prefix"; then

2039

for ac_prog in cl

2040

2041

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

2042

set dummy $ac_tool_prefix$ac_prog; ac_word=$2

2043

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

2044

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

2045

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

2046

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

2047

else

2048

if test -n "$CC"; then

2049

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

2050

else

2051

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

2052

for as_dir in $PATH

2053

2054

IFS=$as_save_IFS

2055

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

2056

for ac_exec_ext in '' $ac_executable_extensions; do

2057

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

2058

ac_cv_prog_CC="$ac_tool_prefix$ac_prog"

2059

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

2060

break 2

2061

2062

done

2063

done

2064

2065

2066

2067

CC=$ac_cv_prog_CC

2068

if test -n "$CC"; then

2069

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

2070

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

2071

else

2072

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

2073

echo "${ECHO_T}no" >&6

2074

2075

2076

test -n "$CC" && break

2077

done

2078

2079

if test -z "$CC"; then

2080

ac_ct_CC=$CC

2081

for ac_prog in cl

2082

2083

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

2084

set dummy $ac_prog; ac_word=$2

2085

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

2086

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

2087

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

2088

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

2089

else

2090

if test -n "$ac_ct_CC"; then

2091

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

2092

else

2093

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

2094

for as_dir in $PATH

2095

2096

IFS=$as_save_IFS

2097

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

2098

for ac_exec_ext in '' $ac_executable_extensions; do

2099

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

2100

ac_cv_prog_ac_ct_CC="$ac_prog"

2101

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

2102

break 2

2103

2104

done

2105

done

2106

2107

2108

2109

ac_ct_CC=$ac_cv_prog_ac_ct_CC

2110

if test -n "$ac_ct_CC"; then

2111

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

2112

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

2113

else

2114

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

2115

echo "${ECHO_T}no" >&6

2116

2117

2118

test -n "$ac_ct_CC" && break

2119

done

2120

2121

CC=$ac_ct_CC

2122

2123

2124

2125

2126

2127

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

2128

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

2129

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

2130

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

2131

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

2132

2133

# Provide some information about the compiler.

2134

echo "$as_me:$LINENO:" \

2135

"checking for C compiler version" >&5

2136

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

2137

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

2138

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

2139

ac_status=$?

2140

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

2141

(exit $ac_status); }

2142

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

2143

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

2144

ac_status=$?

2145

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

2146

(exit $ac_status); }

2147

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

2148

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

2149

ac_status=$?

2150

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

2151

(exit $ac_status); }

2152

2153

cat >conftest.$ac_ext <<_ACEOF

2154

/* confdefs.h. */

2155

_ACEOF

2156

cat confdefs.h >>conftest.$ac_ext

2157

cat >>conftest.$ac_ext <<_ACEOF

2158

/* end confdefs.h. */

2159

2160

int

2161

main ()

2162

{

2163

2164

;

2165

return 0;

2166

}

2167

_ACEOF

2168

ac_clean_files_save=$ac_clean_files

2169

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

2170

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

2171

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

2172

# of exeext.

2173

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

2174

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

2175

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

2176

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

2177

(eval $ac_link_default) 2>&5

2178

ac_status=$?

2179

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

2180

(exit $ac_status); }; then

2181

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

2182

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

2183

# resort.

2184

2185

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

2186

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

2187

ac_cv_exeext=

2188

# b.out is created by i960 compilers.

2189

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

2190

2191

test -f "$ac_file" || continue

2192

case $ac_file in

2193

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

2194

;;

2195

conftest.$ac_ext )

2196

# This is the source file.

2197

;;

2198

[ab].out )

2199

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

2200

# certainly right.

2201

break;;

2202

*.* )

2203

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

2204

# FIXME: I believe we export ac_cv_exeext for Libtool,

2205

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

2206

# maintain Libtool? --akim.

2207

export ac_cv_exeext

2208

break;;

2209

* )

2210

break;;

2211

esac

2212

done

2213

else

2214

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

2215

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

2216

2217

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

2218

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

2219

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

2220

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

2221

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

2222

2223

2224

ac_exeext=$ac_cv_exeext

2225

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

2226

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

2227

2228

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

2229

# the compiler is broken, or we cross compile.

2230

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

2231

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

2232

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

2233

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

2234

if test "$cross_compiling" != yes; then

2235

if { ac_try='./$ac_file'

2236

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

2237

(eval $ac_try) 2>&5

2238

ac_status=$?

2239

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

2240

(exit $ac_status); }; }; then

2241

cross_compiling=no

2242

else

2243

if test "$cross_compiling" = maybe; then

2244

cross_compiling=yes

2245

else

2246

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

2247

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

2248

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

2249

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

2250

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

2251

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

2252

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

2253

2254

2255

2256

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

2257

echo "${ECHO_T}yes" >&6

2258

2259

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

2260

ac_clean_files=$ac_clean_files_save

2261

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

2262

# the compiler is broken, or we cross compile.

2263

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

2264

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

2265

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

2266

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

2267

2268

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

2269

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

2270

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

2271

(eval $ac_link) 2>&5

2272

ac_status=$?

2273

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

2274

(exit $ac_status); }; then

2275

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

2276

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

2277

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

2278

# `rm'.

2279

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

2280

test -f "$ac_file" || continue

2281

case $ac_file in

2282

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

2283

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

2284

export ac_cv_exeext

2285

break;;

2286

* ) break;;

2287

esac

2288

done

2289

else

2290

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

2291

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

2292

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

2293

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

2294

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

2295

2296

2297

rm -f conftest$ac_cv_exeext

2298

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

2299

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

2300

2301

rm -f conftest.$ac_ext

2302

EXEEXT=$ac_cv_exeext

2303

ac_exeext=$EXEEXT

2304

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

2305

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

2306

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

2307

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

2308

else

2309

cat >conftest.$ac_ext <<_ACEOF

2310

/* confdefs.h. */

2311

_ACEOF

2312

cat confdefs.h >>conftest.$ac_ext

2313

cat >>conftest.$ac_ext <<_ACEOF

2314

/* end confdefs.h. */

2315

2316

int

2317

main ()

2318

{

2319

2320

;

2321

return 0;

2322

}

2323

_ACEOF

2324

rm -f conftest.o conftest.obj

2325

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

2326

(eval $ac_compile) 2>&5

2327

ac_status=$?

2328

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

2329

(exit $ac_status); }; then

2330

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

2331

case $ac_file in

2332

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

2333

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

2334

break;;

2335

esac

2336

done

2337

else

2338

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

2339

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

2340

2341

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

2342

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

2343

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

2344

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

2345

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

2346

2347

2348

rm -f conftest.$ac_cv_objext conftest.$ac_ext

2349

2350

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

2351

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

2352

OBJEXT=$ac_cv_objext

2353

ac_objext=$OBJEXT

2354

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

2355

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

2356

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

2357

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

2358

else

2359

cat >conftest.$ac_ext <<_ACEOF

2360

/* confdefs.h. */

2361

_ACEOF

2362

cat confdefs.h >>conftest.$ac_ext

2363

cat >>conftest.$ac_ext <<_ACEOF

2364

/* end confdefs.h. */

2365

2366

int

2367

main ()

2368

{

2369

#ifndef __GNUC__

2370

choke me

2371

#endif

2372

2373

;

2374

return 0;

2375

}

2376

_ACEOF

2377

rm -f conftest.$ac_objext

2378

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

2379

(eval $ac_compile) 2>conftest.er1

2380

ac_status=$?

2381

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

2382

rm -f conftest.er1

2383

cat conftest.err >&5

2384

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

2385

(exit $ac_status); } &&

2386

{ ac_try='test -z "$ac_c_werror_flag"

2387

|| test ! -s conftest.err'

2388

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

2389

(eval $ac_try) 2>&5

2390

ac_status=$?

2391

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

2392

(exit $ac_status); }; } &&

2393

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

2394

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

2395

(eval $ac_try) 2>&5

2396

ac_status=$?

2397

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

2398

(exit $ac_status); }; }; then

2399

ac_compiler_gnu=yes

2400

else

2401

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

2402

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

2403

2404

ac_compiler_gnu=no

2405

2406

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

2407

ac_cv_c_compiler_gnu=$ac_compiler_gnu

2408

2409

2410

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

2411

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

2412

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

2413

ac_test_CFLAGS=${CFLAGS+set}

2414

ac_save_CFLAGS=$CFLAGS

2415

CFLAGS="-g"

2416

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

2417

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

2418

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

2419

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

2420

else

2421

cat >conftest.$ac_ext <<_ACEOF

2422

/* confdefs.h. */

2423

_ACEOF

2424

cat confdefs.h >>conftest.$ac_ext

2425

cat >>conftest.$ac_ext <<_ACEOF

2426

/* end confdefs.h. */

2427

2428

int

2429

main ()

2430

{

2431

2432

;

2433

return 0;

2434

}

2435

_ACEOF

2436

rm -f conftest.$ac_objext

2437

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

2438

(eval $ac_compile) 2>conftest.er1

2439

ac_status=$?

2440

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

2441

rm -f conftest.er1

2442

cat conftest.err >&5

2443

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

2444

(exit $ac_status); } &&

2445

{ ac_try='test -z "$ac_c_werror_flag"

2446

|| test ! -s conftest.err'

2447

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

2448

(eval $ac_try) 2>&5

2449

ac_status=$?

2450

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

2451

(exit $ac_status); }; } &&

2452

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

2453

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

2454

(eval $ac_try) 2>&5

2455

ac_status=$?

2456

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

2457

(exit $ac_status); }; }; then

2458

ac_cv_prog_cc_g=yes

2459

else

2460

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

2461

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

2462

2463

ac_cv_prog_cc_g=no

2464

2465

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

2466

2467

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

2468

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

2469

if test "$ac_test_CFLAGS" = set; then

2470

CFLAGS=$ac_save_CFLAGS

2471

elif test $ac_cv_prog_cc_g = yes; then

2472

if test "$GCC" = yes; then

2473

CFLAGS="-g -O2"

2474

else

2475

CFLAGS="-g"

2476

2477

else

2478

if test "$GCC" = yes; then

2479

CFLAGS="-O2"

2480

else

2481

CFLAGS=

2482

2483

2484

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

2485

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

2486

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

2487

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

2488

else

2489

ac_cv_prog_cc_stdc=no

2490

ac_save_CC=$CC

2491

cat >conftest.$ac_ext <<_ACEOF

2492

/* confdefs.h. */

2493

_ACEOF

2494

cat confdefs.h >>conftest.$ac_ext

2495

cat >>conftest.$ac_ext <<_ACEOF

2496

/* end confdefs.h. */

2497

#include <stdarg.h>

2498

#include <stdio.h>

2499

#include <sys/types.h>

2500

#include <sys/stat.h>

2501

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

2502

struct buf { int x; };

2503

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

2504

static char *e (p, i)

2505

char **p;

2506

int i;

2507

{

2508

return p[i];

2509

}

2510

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

2511

{

2512

char *s;

2513

va_list v;

2514

va_start (v,p);

2515

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

2516

va_end (v);

2517

return s;

2518

}

2519

2520

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

2521

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

2522

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

2523

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

2524

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

2525

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

2526

that's true only with -std1. */

2527

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

2528

2529

int test (int i, double x);

2530

struct s1 {int (*f) (int a);};

2531

struct s2 {int (*f) (double a);};

2532

int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);

2533

int argc;

2534

char **argv;

2535

int

2536

main ()

2537

{

2538

return f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1];

2539

;

2540

return 0;

2541

}

2542

_ACEOF

2543

# Don't try gcc -ansi; that turns off useful extensions and

2544

# breaks some systems' header files.

2545

# AIX -qlanglvl=ansi

2546

# Ultrix and OSF/1 -std1

2547

# HP-UX 10.20 and later -Ae

2548

# HP-UX older versions -Aa -D_HPUX_SOURCE

2549

# SVR4 -Xc -D__EXTENSIONS__

2550

for ac_arg in "" -qlanglvl=ansi -std1 -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"

2551

2552

CC="$ac_save_CC $ac_arg"

2553

rm -f conftest.$ac_objext

2554

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

2555

(eval $ac_compile) 2>conftest.er1

2556

ac_status=$?

2557

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

2558

rm -f conftest.er1

2559

cat conftest.err >&5

2560

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

2561

(exit $ac_status); } &&

2562

{ ac_try='test -z "$ac_c_werror_flag"

2563

|| test ! -s conftest.err'

2564

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

2565

(eval $ac_try) 2>&5

2566

ac_status=$?

2567

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

2568

(exit $ac_status); }; } &&

2569

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

2570

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

2571

(eval $ac_try) 2>&5

2572

ac_status=$?

2573

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

2574

(exit $ac_status); }; }; then

2575

ac_cv_prog_cc_stdc=$ac_arg

2576

break

2577

else

2578

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

2579

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

2580

2581

2582

rm -f conftest.err conftest.$ac_objext

2583

done

2584

rm -f conftest.$ac_ext conftest.$ac_objext

2585

CC=$ac_save_CC

2586

2587

2588

2589

case "x$ac_cv_prog_cc_stdc" in

2590

x|xno)

2591

echo "$as_me:$LINENO: result: none needed" >&5

2592

echo "${ECHO_T}none needed" >&6 ;;

2593

2594

echo "$as_me:$LINENO: result: $ac_cv_prog_cc_stdc" >&5

2595

echo "${ECHO_T}$ac_cv_prog_cc_stdc" >&6

2596

CC="$CC $ac_cv_prog_cc_stdc" ;;

2597

esac

2598

2599

# Some people use a C++ compiler to compile C. Since we use `exit',

2600

# in C++ we need to declare it. In case someone uses the same compiler

2601

# for both compiling C and C++ we need to have the C++ compiler decide

2602

# the declaration of exit, since it's the most demanding environment.

2603

cat >conftest.$ac_ext <<_ACEOF

2604

#ifndef __cplusplus

2605

choke me

2606

#endif

2607

_ACEOF

2608

rm -f conftest.$ac_objext

2609

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

2610

(eval $ac_compile) 2>conftest.er1

2611

ac_status=$?

2612

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

2613

rm -f conftest.er1

2614

cat conftest.err >&5

2615

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

2616

(exit $ac_status); } &&

2617

{ ac_try='test -z "$ac_c_werror_flag"

2618

|| test ! -s conftest.err'

2619

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

2620

(eval $ac_try) 2>&5

2621

ac_status=$?

2622

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

2623

(exit $ac_status); }; } &&

2624

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

2625

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

2626

(eval $ac_try) 2>&5

2627

ac_status=$?

2628

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

2629

(exit $ac_status); }; }; then

2630

for ac_declaration in \

2631

'' \

2632

'extern "C" void std::exit (int) throw (); using std::exit;' \

2633

'extern "C" void std::exit (int); using std::exit;' \

2634

'extern "C" void exit (int) throw ();' \

2635

'extern "C" void exit (int);' \

2636

'void exit (int);'

2637

2638

cat >conftest.$ac_ext <<_ACEOF

2639

/* confdefs.h. */

2640

_ACEOF

2641

cat confdefs.h >>conftest.$ac_ext

2642

cat >>conftest.$ac_ext <<_ACEOF

2643

/* end confdefs.h. */

2644

$ac_declaration

2645

#include <stdlib.h>

2646

int

2647

main ()

2648

{

2649

exit (42);

2650

;

2651

return 0;

2652

}

2653

_ACEOF

2654

rm -f conftest.$ac_objext

2655

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

2656

(eval $ac_compile) 2>conftest.er1

2657

ac_status=$?

2658

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

2659

rm -f conftest.er1

2660

cat conftest.err >&5

2661

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

2662

(exit $ac_status); } &&

2663

{ ac_try='test -z "$ac_c_werror_flag"

2664

|| test ! -s conftest.err'

2665

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

2666

(eval $ac_try) 2>&5

2667

ac_status=$?

2668

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

2669

(exit $ac_status); }; } &&

2670

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

2671

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

2672

(eval $ac_try) 2>&5

2673

ac_status=$?

2674

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

2675

(exit $ac_status); }; }; then

2676

2677

else

2678

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

2679

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

2680

2681

continue

2682

2683

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

2684

cat >conftest.$ac_ext <<_ACEOF

2685

/* confdefs.h. */

2686

_ACEOF

2687

cat confdefs.h >>conftest.$ac_ext

2688

cat >>conftest.$ac_ext <<_ACEOF

2689

/* end confdefs.h. */

2690

$ac_declaration

2691

int

2692

main ()

2693

{

2694

exit (42);

2695

;

2696

return 0;

2697

}

2698

_ACEOF

2699

rm -f conftest.$ac_objext

2700

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

2701

(eval $ac_compile) 2>conftest.er1

2702

ac_status=$?

2703

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

2704

rm -f conftest.er1

2705

cat conftest.err >&5

2706

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

2707

(exit $ac_status); } &&

2708

{ ac_try='test -z "$ac_c_werror_flag"

2709

|| test ! -s conftest.err'

2710

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

2711

(eval $ac_try) 2>&5

2712

ac_status=$?

2713

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

2714

(exit $ac_status); }; } &&

2715

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

2716

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

2717

(eval $ac_try) 2>&5

2718

ac_status=$?

2719

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

2720

(exit $ac_status); }; }; then

2721

break

2722

else

2723

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

2724

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

2725

2726

2727

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

2728

done

2729

rm -f conftest*

2730

if test -n "$ac_declaration"; then

2731

echo '#ifdef __cplusplus' >>confdefs.h

2732

echo $ac_declaration >>confdefs.h

2733

echo '#endif' >>confdefs.h

2734

2735

2736

else

2737

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

2738

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

2739

2740

2741

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

2742

ac_ext=c

2743

ac_cpp='$CPP $CPPFLAGS'

2744

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

2745

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

2746

ac_compiler_gnu=$ac_cv_c_compiler_gnu

2747

DEPDIR="${am__leading_dot}deps"

2748

2749

ac_config_commands="$ac_config_commands depfiles"

2750

2751

2752

am_make=${MAKE-make}

2753

cat > confinc << 'END'

2754

am__doit:

2755

@echo done

2756

.PHONY: am__doit

2757

END

2758

# If we don't find an include directive, just comment out the code.

2759

echo "$as_me:$LINENO: checking for style of include used by $am_make" >&5

2760

echo $ECHO_N "checking for style of include used by $am_make... $ECHO_C" >&6

2761

am__include="#"

2762

am__quote=

2763

_am_result=none

2764

# First try GNU make style include.

2765

echo "include confinc" > confmf

2766

# We grep out `Entering directory' and `Leaving directory'

2767

# messages which can occur if `w' ends up in MAKEFLAGS.

2768

# In particular we don't look at `^make:' because GNU make might

2769

# be invoked under some other name (usually "gmake"), in which

2770

# case it prints its new name instead of `make'.

2771

if test "`$am_make -s -f confmf 2> /dev/null | grep -v 'ing directory'`" = "done"; then

2772

am__include=include

2773

am__quote=

2774

_am_result=GNU

2775

2776

# Now try BSD make style include.

2777

if test "$am__include" = "#"; then

2778

echo '.include "confinc"' > confmf

2779

if test "`$am_make -s -f confmf 2> /dev/null`" = "done"; then

2780

am__include=.include

2781

am__quote="\""

2782

_am_result=BSD

2783

2784

2785

2786

2787

echo "$as_me:$LINENO: result: $_am_result" >&5

2788

echo "${ECHO_T}$_am_result" >&6

2789

rm -f confinc confmf

2790

2791

# Check whether --enable-dependency-tracking or --disable-dependency-tracking was given.

2792

if test "${enable_dependency_tracking+set}" = set; then

2793

enableval="$enable_dependency_tracking"

2794

2795

fi;

2796

if test "x$enable_dependency_tracking" != xno; then

2797

am_depcomp="$ac_aux_dir/depcomp"

2798

AMDEPBACKSLASH='\'

2799

2800

2801

2802

if test "x$enable_dependency_tracking" != xno; then

2803

AMDEP_TRUE=

2804

AMDEP_FALSE='#'

2805

else

2806

AMDEP_TRUE='#'

2807

AMDEP_FALSE=

2808

2809

2810

2811

2812

2813

depcc="$CC" am_compiler_list=

2814

2815

echo "$as_me:$LINENO: checking dependency style of $depcc" >&5

2816

echo $ECHO_N "checking dependency style of $depcc... $ECHO_C" >&6

2817

if test "${am_cv_CC_dependencies_compiler_type+set}" = set; then

2818

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

2819

else

2820

if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then

2821

# We make a subdir and do the tests there. Otherwise we can end up

2822

# making bogus files that we don't know about and never remove. For

2823

# instance it was reported that on HP-UX the gcc test will end up

2824

# making a dummy file named `D' -- because `-MD' means `put the output

2825

# in D'.

2826

mkdir conftest.dir

2827

# Copy depcomp to subdir because otherwise we won't find it if we're

2828

# using a relative directory.

2829

cp "$am_depcomp" conftest.dir

2830

cd conftest.dir

2831

# We will build objects and dependencies in a subdirectory because

2832

# it helps to detect inapplicable dependency modes. For instance

2833

# both Tru64's cc and ICC support -MD to output dependencies as a

2834

# side effect of compilation, but ICC will put the dependencies in

2835

# the current directory while Tru64 will put them in the object

2836

# directory.

2837

mkdir sub

2838

2839

am_cv_CC_dependencies_compiler_type=none

2840

if test "$am_compiler_list" = ""; then

2841

am_compiler_list=`sed -n 's/^#*$[a-zA-Z0-9]*$)$/\1/p' < ./depcomp`

2842

2843

for depmode in $am_compiler_list; do

2844

# Setup a source with many dependencies, because some compilers

2845

# like to wrap large dependency lists on column 80 (with \), and

2846

# we should not choose a depcomp mode which is confused by this.

2847

2848

# We need to recreate these files for each test, as the compiler may

2849

# overwrite some of them when testing with obscure command lines.

2850

# This happens at least with the AIX C compiler.

2851

: > sub/conftest.c

2852

for i in 1 2 3 4 5 6; do

2853

echo '#include "conftst'$i'.h"' >> sub/conftest.c

2854

# Using `: > sub/conftst$i.h' creates only sub/conftst1.h with

2855

# Solaris 8's {/usr,}/bin/sh.

2856

touch sub/conftst$i.h

2857

done

2858

echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf

2859

2860

case $depmode in

2861

nosideeffect)

2862

# after this tag, mechanisms are not by side-effect, so they'll

2863

# only be used when explicitly requested

2864

if test "x$enable_dependency_tracking" = xyes; then

2865

continue

2866

else

2867

break

2868

2869

;;

2870

none) break ;;

2871

esac

2872

# We check with `-c' and `-o' for the sake of the "dashmstdout"

2873

# mode. It turns out that the SunPro C++ compiler does not properly

2874

# handle `-M -o', and we need to detect this.

2875

if depmode=$depmode \

2876

source=sub/conftest.c object=sub/conftest.${OBJEXT-o} \

2877

depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \

2878

$SHELL ./depcomp $depcc -c -o sub/conftest.${OBJEXT-o} sub/conftest.c \

2879

>/dev/null 2>conftest.err &&

2880

grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&

2881

grep sub/conftest.${OBJEXT-o} sub/conftest.Po > /dev/null 2>&1 &&

2882

${MAKE-make} -s -f confmf > /dev/null 2>&1; then

2883

# icc doesn't choke on unknown options, it will just issue warnings

2884

# or remarks (even with -Werror). So we grep stderr for any message

2885

# that says an option was ignored or not supported.

2886

# When given -MP, icc 7.0 and 7.1 complain thusly:

2887

# icc: Command line warning: ignoring option '-M'; no argument required

2888

# The diagnosis changed in icc 8.0:

2889

# icc: Command line remark: option '-MP' not supported

2890

if (grep 'ignoring option' conftest.err ||

2891

grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else

2892

am_cv_CC_dependencies_compiler_type=$depmode

2893

break

2894

2895

2896

done

2897

2898

cd ..

2899

rm -rf conftest.dir

2900

else

2901

am_cv_CC_dependencies_compiler_type=none

2902

2903

2904

2905

echo "$as_me:$LINENO: result: $am_cv_CC_dependencies_compiler_type" >&5

2906

echo "${ECHO_T}$am_cv_CC_dependencies_compiler_type" >&6

2907

CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type

2908

2909

2910

2911

2912

test "x$enable_dependency_tracking" != xno \

2913

&& test "$am_cv_CC_dependencies_compiler_type" = gcc3; then

2914

am__fastdepCC_TRUE=

2915

am__fastdepCC_FALSE='#'

2916

else

2917

am__fastdepCC_TRUE='#'

2918

am__fastdepCC_FALSE=

2919

2920

2921

2922

2923

echo "$as_me:$LINENO: checking for library containing strerror" >&5

2924

echo $ECHO_N "checking for library containing strerror... $ECHO_C" >&6

2925

if test "${ac_cv_search_strerror+set}" = set; then

2926

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

2927

else

2928

ac_func_search_save_LIBS=$LIBS

2929

ac_cv_search_strerror=no

2930

cat >conftest.$ac_ext <<_ACEOF

2931

/* confdefs.h. */

2932

_ACEOF

2933

cat confdefs.h >>conftest.$ac_ext

2934

cat >>conftest.$ac_ext <<_ACEOF

2935

/* end confdefs.h. */

2936

2937

/* Override any gcc2 internal prototype to avoid an error. */

2938

#ifdef __cplusplus

2939

extern "C"

2940

#endif

2941

/* We use char because int might match the return type of a gcc2

2942

builtin and then its argument prototype would still apply. */

2943

char strerror ();

2944

int

2945

main ()

2946

{

2947

strerror ();

2948

;

2949

return 0;

2950

}

2951

_ACEOF

2952

rm -f conftest.$ac_objext conftest$ac_exeext

2953

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

2954

(eval $ac_link) 2>conftest.er1

2955

ac_status=$?

2956

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

2957

rm -f conftest.er1

2958

cat conftest.err >&5

2959

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

2960

(exit $ac_status); } &&

2961

{ ac_try='test -z "$ac_c_werror_flag"

2962

|| test ! -s conftest.err'

2963

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

2964

(eval $ac_try) 2>&5

2965

ac_status=$?

2966

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

2967

(exit $ac_status); }; } &&

2968

{ ac_try='test -s conftest$ac_exeext'

2969

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

2970

(eval $ac_try) 2>&5

2971

ac_status=$?

2972

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

2973

(exit $ac_status); }; }; then

2974

ac_cv_search_strerror="none required"

2975

else

2976

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

2977

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

2978

2979

2980

rm -f conftest.err conftest.$ac_objext \

2981

conftest$ac_exeext conftest.$ac_ext

2982

if test "$ac_cv_search_strerror" = no; then

2983

for ac_lib in cposix; do

2984

LIBS="-l$ac_lib $ac_func_search_save_LIBS"

2985

cat >conftest.$ac_ext <<_ACEOF

2986

/* confdefs.h. */

2987

_ACEOF

2988

cat confdefs.h >>conftest.$ac_ext

2989

cat >>conftest.$ac_ext <<_ACEOF

2990

/* end confdefs.h. */

2991

2992

/* Override any gcc2 internal prototype to avoid an error. */

2993

#ifdef __cplusplus

2994

extern "C"

2995

#endif

2996

/* We use char because int might match the return type of a gcc2

2997

builtin and then its argument prototype would still apply. */

2998

char strerror ();

2999

int

3000

main ()

3001

{

3002

strerror ();

3003

;

3004

return 0;

3005

}

3006

_ACEOF

3007

rm -f conftest.$ac_objext conftest$ac_exeext

3008

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

3009

(eval $ac_link) 2>conftest.er1

3010

ac_status=$?

3011

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

3012

rm -f conftest.er1

3013

cat conftest.err >&5

3014

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

3015

(exit $ac_status); } &&

3016

{ ac_try='test -z "$ac_c_werror_flag"

3017

|| test ! -s conftest.err'

3018

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

3019

(eval $ac_try) 2>&5

3020

ac_status=$?

3021

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

3022

(exit $ac_status); }; } &&

3023

{ ac_try='test -s conftest$ac_exeext'

3024

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

3025

(eval $ac_try) 2>&5

3026

ac_status=$?

3027

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

3028

(exit $ac_status); }; }; then

3029

ac_cv_search_strerror="-l$ac_lib"

3030

break

3031

else

3032

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

3033

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

3034

3035

3036

rm -f conftest.err conftest.$ac_objext \

3037

conftest$ac_exeext conftest.$ac_ext

3038

done

3039

3040

LIBS=$ac_func_search_save_LIBS

3041

3042

echo "$as_me:$LINENO: result: $ac_cv_search_strerror" >&5

3043

echo "${ECHO_T}$ac_cv_search_strerror" >&6

3044

if test "$ac_cv_search_strerror" != no; then

3045

test "$ac_cv_search_strerror" = "none required" || LIBS="$ac_cv_search_strerror $LIBS"

3046

3047

3048

3049

ac_ext=c

3050

ac_cpp='$CPP $CPPFLAGS'

3051

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

3052

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

3053

ac_compiler_gnu=$ac_cv_c_compiler_gnu

3054

echo "$as_me:$LINENO: checking how to run the C preprocessor" >&5

3055

echo $ECHO_N "checking how to run the C preprocessor... $ECHO_C" >&6

3056

# On Suns, sometimes $CPP names a directory.

3057

if test -n "$CPP" && test -d "$CPP"; then

3058

CPP=

3059

3060

if test -z "$CPP"; then

3061

if test "${ac_cv_prog_CPP+set}" = set; then

3062

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

3063

else

3064

# Double quotes because CPP needs to be expanded

3065

for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"

3066

3067

ac_preproc_ok=false

3068

for ac_c_preproc_warn_flag in '' yes

3069

3070

# Use a header file that comes with gcc, so configuring glibc

3071

# with a fresh cross-compiler works.

3072

# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

3073

# <limits.h> exists even on freestanding compilers.

3074

# On the NeXT, cc -E runs the code through the compiler's parser,

3075

# not just through cpp. "Syntax error" is here to catch this case.

3076

cat >conftest.$ac_ext <<_ACEOF

3077

/* confdefs.h. */

3078

_ACEOF

3079

cat confdefs.h >>conftest.$ac_ext

3080

cat >>conftest.$ac_ext <<_ACEOF

3081

/* end confdefs.h. */

3082

#ifdef __STDC__

3083

# include <limits.h>

3084

#else

3085

# include <assert.h>

3086

#endif

3087

Syntax error

3088

_ACEOF

3089

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

3090

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

3091

ac_status=$?

3092

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

3093

rm -f conftest.er1

3094

cat conftest.err >&5

3095

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

3096

(exit $ac_status); } >/dev/null; then

3097

if test -s conftest.err; then

3098

ac_cpp_err=$ac_c_preproc_warn_flag

3099

ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

3100

else

3101

ac_cpp_err=

3102

3103

else

3104

ac_cpp_err=yes

3105

3106

if test -z "$ac_cpp_err"; then

3107

3108

else

3109

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

3110

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

3111

3112

# Broken: fails on valid input.

3113

continue

3114

3115

rm -f conftest.err conftest.$ac_ext

3116

3117

# OK, works on sane cases. Now check whether non-existent headers

3118

# can be detected and how.

3119

cat >conftest.$ac_ext <<_ACEOF

3120

/* confdefs.h. */

3121

_ACEOF

3122

cat confdefs.h >>conftest.$ac_ext

3123

cat >>conftest.$ac_ext <<_ACEOF

3124

/* end confdefs.h. */

3125

#include <ac_nonexistent.h>

3126

_ACEOF

3127

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

3128

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

3129

ac_status=$?

3130

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

3131

rm -f conftest.er1

3132

cat conftest.err >&5

3133

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

3134

(exit $ac_status); } >/dev/null; then

3135

if test -s conftest.err; then

3136

ac_cpp_err=$ac_c_preproc_warn_flag

3137

ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

3138

else

3139

ac_cpp_err=

3140

3141

else

3142

ac_cpp_err=yes

3143

3144

if test -z "$ac_cpp_err"; then

3145

# Broken: success on invalid input.

3146

continue

3147

else

3148

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

3149

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

3150

3151

# Passes both tests.

3152

ac_preproc_ok=:

3153

break

3154

3155

rm -f conftest.err conftest.$ac_ext

3156

3157

done

3158

# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.

3159

rm -f conftest.err conftest.$ac_ext

3160

if $ac_preproc_ok; then

3161

break

3162

3163

3164

done

3165

ac_cv_prog_CPP=$CPP

3166

3167

3168

CPP=$ac_cv_prog_CPP

3169

else

3170

ac_cv_prog_CPP=$CPP

3171

3172

echo "$as_me:$LINENO: result: $CPP" >&5

3173

echo "${ECHO_T}$CPP" >&6

3174

ac_preproc_ok=false

3175

for ac_c_preproc_warn_flag in '' yes

3176

3177

# Use a header file that comes with gcc, so configuring glibc

3178

# with a fresh cross-compiler works.

3179

# Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

3180

# <limits.h> exists even on freestanding compilers.

3181

# On the NeXT, cc -E runs the code through the compiler's parser,

3182

# not just through cpp. "Syntax error" is here to catch this case.

3183

cat >conftest.$ac_ext <<_ACEOF

3184

/* confdefs.h. */

3185

_ACEOF

3186

cat confdefs.h >>conftest.$ac_ext

3187

cat >>conftest.$ac_ext <<_ACEOF

3188

/* end confdefs.h. */

3189

#ifdef __STDC__

3190

# include <limits.h>

3191

#else

3192

# include <assert.h>

3193

#endif

3194

Syntax error

3195

_ACEOF

3196

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

3197

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

3198

ac_status=$?

3199

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

3200

rm -f conftest.er1

3201

cat conftest.err >&5

3202

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

3203

(exit $ac_status); } >/dev/null; then

3204

if test -s conftest.err; then

3205

ac_cpp_err=$ac_c_preproc_warn_flag

3206

ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

3207

else

3208

ac_cpp_err=

3209

3210

else

3211

ac_cpp_err=yes

3212

3213

if test -z "$ac_cpp_err"; then

3214

3215

else

3216

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

3217

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

3218

3219

# Broken: fails on valid input.

3220

continue

3221

3222

rm -f conftest.err conftest.$ac_ext

3223

3224

# OK, works on sane cases. Now check whether non-existent headers

3225

# can be detected and how.

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 <ac_nonexistent.h>

3233

_ACEOF

3234

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

3235

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

3236

ac_status=$?

3237

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

3238

rm -f conftest.er1

3239

cat conftest.err >&5

3240

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

3241

(exit $ac_status); } >/dev/null; then

3242

if test -s conftest.err; then

3243

ac_cpp_err=$ac_c_preproc_warn_flag

3244

ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

3245

else

3246

ac_cpp_err=

3247

3248

else

3249

ac_cpp_err=yes

3250

3251

if test -z "$ac_cpp_err"; then

3252

# Broken: success on invalid input.

3253

continue

3254

else

3255

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

3256

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

3257

3258

# Passes both tests.

3259

ac_preproc_ok=:

3260

break

3261

3262

rm -f conftest.err conftest.$ac_ext

3263

3264

done

3265

# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.

3266

rm -f conftest.err conftest.$ac_ext

3267

if $ac_preproc_ok; then

3268

3269

else

3270

{ { echo "$as_me:$LINENO: error: C preprocessor \"$CPP\" fails sanity check

3271

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

3272

echo "$as_me: error: C preprocessor \"$CPP\" fails sanity check

3273

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

3274

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

3275

3276

3277

ac_ext=c

3278

ac_cpp='$CPP $CPPFLAGS'

3279

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

3280

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

3281

ac_compiler_gnu=$ac_cv_c_compiler_gnu

3282

3283

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

3284

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

3285

# incompatible versions:

3286

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

3287

# SunOS /usr/etc/install

3288

# IRIX /sbin/install

3289

# AIX /bin/install

3290

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

3291

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

3292

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

3293

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

3294

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

3295

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

3296

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

3297

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

3298

if test -z "$INSTALL"; then

3299

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

3300

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

3301

else

3302

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

3303

for as_dir in $PATH

3304

3305

IFS=$as_save_IFS

3306

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

3307

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

3308

case $as_dir/ in

3309

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

3310

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

3311

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

3312

/usr/ucb/* ) ;;

3313

3314

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

3315

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

3316

# by default.

3317

for ac_prog in ginstall scoinst install; do

3318

for ac_exec_ext in '' $ac_executable_extensions; do

3319

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

3320

if test $ac_prog = install &&

3321

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

3322

# AIX install. It has an incompatible calling convention.

3323

3324

elif test $ac_prog = install &&

3325

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

3326

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

3327

3328

else

3329

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

3330

break 3

3331

3332

3333

done

3334

done

3335

;;

3336

esac

3337

done

3338

3339

3340

3341

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

3342

INSTALL=$ac_cv_path_install

3343

else

3344

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

3345

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

3346

# break other packages using the cache if that directory is

3347

# removed, or if the path is relative.

3348

INSTALL=$ac_install_sh

3349

3350

3351

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

3352

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

3353

3354

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

3355

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

3356

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

3357

3358

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

3359

3360

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

3361

3362

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

3363

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

3364

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

3365

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

3366

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

3367

else

3368

cat >conftest.make <<\_ACEOF

3369

all:

3370

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

3371

_ACEOF

3372

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

3373

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

3374

if test -n "$ac_maketemp"; then

3375

eval ac_cv_prog_make_${ac_make}_set=yes

3376

else

3377

eval ac_cv_prog_make_${ac_make}_set=no

3378

3379

rm -f conftest.make

3380

3381

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

3382

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

3383

echo "${ECHO_T}yes" >&6

3384

SET_MAKE=

3385

else

3386

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

3387

echo "${ECHO_T}no" >&6

3388

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

3389

3390

3391

if test -n "$ac_tool_prefix"; then

3392

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

3393

set dummy ${ac_tool_prefix}ranlib; ac_word=$2

3394

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

3395

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

3396

if test "${ac_cv_prog_RANLIB+set}" = set; then

3397

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

3398

else

3399

if test -n "$RANLIB"; then

3400

ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.

3401

else

3402

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

3403

for as_dir in $PATH

3404

3405

IFS=$as_save_IFS

3406

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

3407

for ac_exec_ext in '' $ac_executable_extensions; do

3408

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

3409

ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"

3410

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

3411

break 2

3412

3413

done

3414

done

3415

3416

3417

3418

RANLIB=$ac_cv_prog_RANLIB

3419

if test -n "$RANLIB"; then

3420

echo "$as_me:$LINENO: result: $RANLIB" >&5

3421

echo "${ECHO_T}$RANLIB" >&6

3422

else

3423

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

3424

echo "${ECHO_T}no" >&6

3425

3426

3427

3428

if test -z "$ac_cv_prog_RANLIB"; then

3429

ac_ct_RANLIB=$RANLIB

3430

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

3431

set dummy ranlib; ac_word=$2

3432

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

3433

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

3434

if test "${ac_cv_prog_ac_ct_RANLIB+set}" = set; then

3435

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

3436

else

3437

if test -n "$ac_ct_RANLIB"; then

3438

ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.

3439

else

3440

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

3441

for as_dir in $PATH

3442

3443

IFS=$as_save_IFS

3444

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

3445

for ac_exec_ext in '' $ac_executable_extensions; do

3446

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

3447

ac_cv_prog_ac_ct_RANLIB="ranlib"

3448

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

3449

break 2

3450

3451

done

3452

done

3453

3454

test -z "$ac_cv_prog_ac_ct_RANLIB" && ac_cv_prog_ac_ct_RANLIB=":"

3455

3456

3457

ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB

3458

if test -n "$ac_ct_RANLIB"; then

3459

echo "$as_me:$LINENO: result: $ac_ct_RANLIB" >&5

3460

echo "${ECHO_T}$ac_ct_RANLIB" >&6

3461

else

3462

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

3463

echo "${ECHO_T}no" >&6

3464

3465

3466

RANLIB=$ac_ct_RANLIB

3467

else

3468

RANLIB="$ac_cv_prog_RANLIB"

3469

3470

3471

3472

if eval "test x$GCC = xyes"; then

3473

for flag in \

3474

-pedantic \

3475

-W \

3476

-Wall \

3477

-Wbad-function-cast \

3478

-Wcast-align \

3479

-Wcast-qual \

3480

-Wmissing-declarations \

3481

-Wmissing-prototypes \

3482

-Wpointer-arith \

3483

-Wreturn-type \

3484

-Wstrict-prototypes

3485

3486

case "$CFLAGS" in

3487

"$flag" | "$flag "* | *" $flag" | *" $flag "* )

3488

3489

;;

3490

3491

CFLAGS="$CFLAGS $flag"

3492

;;

3493

esac

3494

3495

done

3496

3497

3498

echo "$as_me:$LINENO: checking for -fpie" >&5

3499

echo $ECHO_N "checking for -fpie... $ECHO_C" >&6

3500

if test "${libc_cv_fpie+set}" = set; then

3501

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

3502

else

3503

cat > conftest.c <<EOF

3504

int foo;

3505

main () { return 0;}

3506

EOF

3507

if { ac_try='${CC-cc} $CFLAGS $CPPFLAGS $LDFLAGS -pie -fpie

3508

-o conftest conftest.c 1>&5'

3509

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

3510

(eval $ac_try) 2>&5

3511

ac_status=$?

3512

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

3513

(exit $ac_status); }; }

3514

then

3515

libc_cv_fpie=yes

3516

PIE_CFLAGS="-fpie"

3517

PIE_LDFLAGS="-pie"

3518

else

3519

libc_cv_fpie=no

3520

PIE_CFLAGS=""

3521

PIE_LDFLAGS=""

3522

3523

rm -f conftest*

3524

3525

echo "$as_me:$LINENO: result: $libc_cv_fpie" >&5

3526

echo "${ECHO_T}$libc_cv_fpie" >&6

3527

3528

3529

3530

3531

echo "$as_me:$LINENO: checking if malloc debugging is wanted" >&5

3532

echo $ECHO_N "checking if malloc debugging is wanted... $ECHO_C" >&6

3533

3534

# Check whether --with-dmalloc or --without-dmalloc was given.

3535

if test "${with_dmalloc+set}" = set; then

3536

withval="$with_dmalloc"

3537

if test "$withval" = yes; then

3538

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

3539

echo "${ECHO_T}yes" >&6

3540

3541

cat >>confdefs.h <<\_ACEOF

3542

#define WITH_DMALLOC 1

3543

_ACEOF

3544

3545

LIBS="$LIBS -ldmalloc"

3546

LDFLAGS="$LDFLAGS -g"

3547

else

3548

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

3549

echo "${ECHO_T}no" >&6

3550

3551

else

3552

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

3553

echo "${ECHO_T}no" >&6

3554

fi;

3555

3556

echo "$as_me:$LINENO: checking if malloc debugging with efence is wanted" >&5

3557

echo $ECHO_N "checking if malloc debugging with efence is wanted... $ECHO_C" >&6

3558

3559

# Check whether --with-efence or --without-efence was given.

3560

if test "${with_efence+set}" = set; then

3561

withval="$with_efence"

3562

if test "$withval" = yes; then

3563

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

3564

echo "${ECHO_T}yes" >&6

3565

3566

cat >>confdefs.h <<\_ACEOF

3567

#define WITH_EFENCE 1

3568

_ACEOF

3569

3570

LIBS="$LIBS -lefence"

3571

LDFLAGS="$LDFLAGS -g"

3572

CFLAGS="-g"

3573

else

3574

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

3575

echo "${ECHO_T}no" >&6

3576

3577

else

3578

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

3579

echo "${ECHO_T}no" >&6

3580

fi;

3581

3582

3583

echo "$as_me:$LINENO: checking whether byte ordering is bigendian" >&5

3584

echo $ECHO_N "checking whether byte ordering is bigendian... $ECHO_C" >&6

3585

if test "${ac_cv_c_bigendian+set}" = set; then

3586

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

3587

else

3588

# See if sys/param.h defines the BYTE_ORDER macro.

3589

cat >conftest.$ac_ext <<_ACEOF

3590

/* confdefs.h. */

3591

_ACEOF

3592

cat confdefs.h >>conftest.$ac_ext

3593

cat >>conftest.$ac_ext <<_ACEOF

3594

/* end confdefs.h. */

3595

#include <sys/types.h>

3596

#include <sys/param.h>

3597

3598

int

3599

main ()

3600

{

3601

#if !BYTE_ORDER || !BIG_ENDIAN || !LITTLE_ENDIAN

3602

bogus endian macros

3603

#endif

3604

3605

;

3606

return 0;

3607

}

3608

_ACEOF

3609

rm -f conftest.$ac_objext

3610

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

3611

(eval $ac_compile) 2>conftest.er1

3612

ac_status=$?

3613

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

3614

rm -f conftest.er1

3615

cat conftest.err >&5

3616

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

3617

(exit $ac_status); } &&

3618

{ ac_try='test -z "$ac_c_werror_flag"

3619

|| test ! -s conftest.err'

3620

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

3621

(eval $ac_try) 2>&5

3622

ac_status=$?

3623

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

3624

(exit $ac_status); }; } &&

3625

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

3626

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

3627

(eval $ac_try) 2>&5

3628

ac_status=$?

3629

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

3630

(exit $ac_status); }; }; then

3631

# It does; now see whether it defined to BIG_ENDIAN or not.

3632

cat >conftest.$ac_ext <<_ACEOF

3633

/* confdefs.h. */

3634

_ACEOF

3635

cat confdefs.h >>conftest.$ac_ext

3636

cat >>conftest.$ac_ext <<_ACEOF

3637

/* end confdefs.h. */

3638

#include <sys/types.h>

3639

#include <sys/param.h>

3640

3641

int

3642

main ()

3643

{

3644

#if BYTE_ORDER != BIG_ENDIAN

3645

not big endian

3646

#endif

3647

3648

;

3649

return 0;

3650

}

3651

_ACEOF

3652

rm -f conftest.$ac_objext

3653

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

3654

(eval $ac_compile) 2>conftest.er1

3655

ac_status=$?

3656

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

3657

rm -f conftest.er1

3658

cat conftest.err >&5

3659

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

3660

(exit $ac_status); } &&

3661

{ ac_try='test -z "$ac_c_werror_flag"

3662

|| 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_objext'

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_c_bigendian=yes

3675

else

3676

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

3677

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

3678

3679

ac_cv_c_bigendian=no

3680

3681

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

3682

else

3683

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

3684

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

3685

3686

# It does not; compile a test program.

3687

if test "$cross_compiling" = yes; then

3688

# try to guess the endianness by grepping values into an object file

3689

ac_cv_c_bigendian=unknown

3690

cat >conftest.$ac_ext <<_ACEOF

3691

/* confdefs.h. */

3692

_ACEOF

3693

cat confdefs.h >>conftest.$ac_ext

3694

cat >>conftest.$ac_ext <<_ACEOF

3695

/* end confdefs.h. */

3696

short ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };

3697

short ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };

3698

void _ascii () { char *s = (char *) ascii_mm; s = (char *) ascii_ii; }

3699

short ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };

3700

short ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };

3701

void _ebcdic () { char *s = (char *) ebcdic_mm; s = (char *) ebcdic_ii; }

3702

int

3703

main ()

3704

{

3705

_ascii (); _ebcdic ();

3706

;

3707

return 0;

3708

}

3709

_ACEOF

3710

rm -f conftest.$ac_objext

3711

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

3712

(eval $ac_compile) 2>conftest.er1

3713

ac_status=$?

3714

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

3715

rm -f conftest.er1

3716

cat conftest.err >&5

3717

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

3718

(exit $ac_status); } &&

3719

{ ac_try='test -z "$ac_c_werror_flag"

3720

|| test ! -s conftest.err'

3721

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

3722

(eval $ac_try) 2>&5

3723

ac_status=$?

3724

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

3725

(exit $ac_status); }; } &&

3726

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

3727

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

3728

(eval $ac_try) 2>&5

3729

ac_status=$?

3730

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

3731

(exit $ac_status); }; }; then

3732

if grep BIGenDianSyS conftest.$ac_objext >/dev/null ; then

3733

ac_cv_c_bigendian=yes

3734

3735

if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then

3736

if test "$ac_cv_c_bigendian" = unknown; then

3737

ac_cv_c_bigendian=no

3738

else

3739

# finding both strings is unlikely to happen, but who knows?

3740

ac_cv_c_bigendian=unknown

3741

3742

3743

else

3744

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

3745

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

3746

3747

3748

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

3749

else

3750

cat >conftest.$ac_ext <<_ACEOF

3751

/* confdefs.h. */

3752

_ACEOF

3753

cat confdefs.h >>conftest.$ac_ext

3754

cat >>conftest.$ac_ext <<_ACEOF

3755

/* end confdefs.h. */

3756

int

3757

main ()

3758

{

3759

/* Are we little or big endian? From Harbison&Steele. */

3760

union

3761

{

3762

long l;

3763

char c[sizeof (long)];

3764

} u;

3765

u.l = 1;

3766

exit (u.c[sizeof (long) - 1] == 1);

3767

}

3768

_ACEOF

3769

rm -f conftest$ac_exeext

3770

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

3771

(eval $ac_link) 2>&5

3772

ac_status=$?

3773

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

3774

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

3775

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

3776

(eval $ac_try) 2>&5

3777

ac_status=$?

3778

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

3779

(exit $ac_status); }; }; then

3780

ac_cv_c_bigendian=no

3781

else

3782

echo "$as_me: program exited with status $ac_status" >&5

3783

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

3784

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

3785

3786

( exit $ac_status )

3787

ac_cv_c_bigendian=yes

3788

3789

rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

3790

3791

3792

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

3793

3794

echo "$as_me:$LINENO: result: $ac_cv_c_bigendian" >&5

3795

echo "${ECHO_T}$ac_cv_c_bigendian" >&6

3796

case $ac_cv_c_bigendian in

3797

yes)

3798

3799

cat >>confdefs.h <<\_ACEOF

3800

#define WORDS_BIGENDIAN 1

3801

_ACEOF

3802

;;

3803

no)

3804

;;

3805

3806

{ { echo "$as_me:$LINENO: error: unknown endianness

3807

presetting ac_cv_c_bigendian=no (or yes) will help" >&5

3808

echo "$as_me: error: unknown endianness

3809

presetting ac_cv_c_bigendian=no (or yes) will help" >&2;}

3810

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

3811

esac

3812

3813

3814

echo "$as_me:$LINENO: checking for egrep" >&5

3815

echo $ECHO_N "checking for egrep... $ECHO_C" >&6

3816

if test "${ac_cv_prog_egrep+set}" = set; then

3817

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

3818

else

3819

if echo a | (grep -E '(a|b)') >/dev/null 2>&1

3820

then ac_cv_prog_egrep='grep -E'

3821

else ac_cv_prog_egrep='egrep'

3822

3823

3824

echo "$as_me:$LINENO: result: $ac_cv_prog_egrep" >&5

3825

echo "${ECHO_T}$ac_cv_prog_egrep" >&6

3826

EGREP=$ac_cv_prog_egrep

3827

3828

3829

echo "$as_me:$LINENO: checking for ANSI C header files" >&5

3830

echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6

3831

if test "${ac_cv_header_stdc+set}" = set; then

3832

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

3833

else

3834

cat >conftest.$ac_ext <<_ACEOF

3835

/* confdefs.h. */

3836

_ACEOF

3837

cat confdefs.h >>conftest.$ac_ext

3838

cat >>conftest.$ac_ext <<_ACEOF

3839

/* end confdefs.h. */

3840

#include <stdlib.h>

3841

#include <stdarg.h>

3842

#include <string.h>

3843

#include <float.h>

3844

3845

int

3846

main ()

3847

{

3848

3849

;

3850

return 0;

3851

}

3852

_ACEOF

3853

rm -f conftest.$ac_objext

3854

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

3855

(eval $ac_compile) 2>conftest.er1

3856

ac_status=$?

3857

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

3858

rm -f conftest.er1

3859

cat conftest.err >&5

3860

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

3861

(exit $ac_status); } &&

3862

{ ac_try='test -z "$ac_c_werror_flag"

3863

|| test ! -s conftest.err'

3864

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

3865

(eval $ac_try) 2>&5

3866

ac_status=$?

3867

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

3868

(exit $ac_status); }; } &&

3869

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

3870

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

3871

(eval $ac_try) 2>&5

3872

ac_status=$?

3873

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

3874

(exit $ac_status); }; }; then

3875

ac_cv_header_stdc=yes

3876

else

3877

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

3878

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

3879

3880

ac_cv_header_stdc=no

3881

3882

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

3883

3884

if test $ac_cv_header_stdc = yes; then

3885

# SunOS 4.x string.h does not declare mem*, contrary to ANSI.

3886

cat >conftest.$ac_ext <<_ACEOF

3887

/* confdefs.h. */

3888

_ACEOF

3889

cat confdefs.h >>conftest.$ac_ext

3890

cat >>conftest.$ac_ext <<_ACEOF

3891

/* end confdefs.h. */

3892

#include <string.h>

3893

3894

_ACEOF

3895

if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

3896

$EGREP "memchr" >/dev/null 2>&1; then

3897

3898

else

3899

ac_cv_header_stdc=no

3900

3901

rm -f conftest*

3902

3903

3904

3905

if test $ac_cv_header_stdc = yes; then

3906

# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.

3907

cat >conftest.$ac_ext <<_ACEOF

3908

/* confdefs.h. */

3909

_ACEOF

3910

cat confdefs.h >>conftest.$ac_ext

3911

cat >>conftest.$ac_ext <<_ACEOF

3912

/* end confdefs.h. */

3913

#include <stdlib.h>

3914

3915

_ACEOF

3916

if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

3917

$EGREP "free" >/dev/null 2>&1; then

3918

3919

else

3920

ac_cv_header_stdc=no

3921

3922

rm -f conftest*

3923

3924

3925

3926

if test $ac_cv_header_stdc = yes; then

3927

# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.

3928

if test "$cross_compiling" = yes; then

3929

3930

else

3931

cat >conftest.$ac_ext <<_ACEOF

3932

/* confdefs.h. */

3933

_ACEOF

3934

cat confdefs.h >>conftest.$ac_ext

3935

cat >>conftest.$ac_ext <<_ACEOF

3936

/* end confdefs.h. */

3937

#include <ctype.h>

3938

#if ((' ' & 0x0FF) == 0x020)

3939

# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')

3940

# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))

3941

#else

3942

# define ISLOWER(c) \

3943

(('a' <= (c) && (c) <= 'i') \

3944

|| ('j' <= (c) && (c) <= 'r') \

3945

|| ('s' <= (c) && (c) <= 'z'))

3946

# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))

3947

#endif

3948

3949

#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))

3950

int

3951

main ()

3952

{

3953

int i;

3954

for (i = 0; i < 256; i++)

3955

if (XOR (islower (i), ISLOWER (i))

3956

|| toupper (i) != TOUPPER (i))

3957

exit(2);

3958

exit (0);

3959

}

3960

_ACEOF

3961

rm -f conftest$ac_exeext

3962

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

3963

(eval $ac_link) 2>&5

3964

ac_status=$?

3965

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

3966

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

3967

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

3968

(eval $ac_try) 2>&5

3969

ac_status=$?

3970

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

3971

(exit $ac_status); }; }; then

3972

3973

else

3974

echo "$as_me: program exited with status $ac_status" >&5

3975

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

3976

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

3977

3978

( exit $ac_status )

3979

ac_cv_header_stdc=no

3980

3981

rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

3982

3983

3984

3985

echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5

3986

echo "${ECHO_T}$ac_cv_header_stdc" >&6

3987

if test $ac_cv_header_stdc = yes; then

3988

3989

cat >>confdefs.h <<\_ACEOF

3990

#define STDC_HEADERS 1

3991

_ACEOF

3992

3993

3994

3995

# On IRIX 5.3, sys/types and inttypes.h are conflicting.

3996

3997

3998

3999

4000

4001

4002

4003

4004

4005

for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \

4006

inttypes.h stdint.h unistd.h

4007

4008

as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

4009

echo "$as_me:$LINENO: checking for $ac_header" >&5

4010

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

4011

if eval "test \"\${$as_ac_Header+set}\" = set"; then

4012

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

4013

else

4014

cat >conftest.$ac_ext <<_ACEOF

4015

/* confdefs.h. */

4016

_ACEOF

4017

cat confdefs.h >>conftest.$ac_ext

4018

cat >>conftest.$ac_ext <<_ACEOF

4019

/* end confdefs.h. */

4020

$ac_includes_default

4021

4022

#include <$ac_header>

4023

_ACEOF

4024

rm -f conftest.$ac_objext

4025

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

4026

(eval $ac_compile) 2>conftest.er1

4027

ac_status=$?

4028

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

4029

rm -f conftest.er1

4030

cat conftest.err >&5

4031

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

4032

(exit $ac_status); } &&

4033

{ ac_try='test -z "$ac_c_werror_flag"

4034

|| test ! -s conftest.err'

4035

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

4036

(eval $ac_try) 2>&5

4037

ac_status=$?

4038

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

4039

(exit $ac_status); }; } &&

4040

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

4041

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

4042

(eval $ac_try) 2>&5

4043

ac_status=$?

4044

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

4045

(exit $ac_status); }; }; then

4046

eval "$as_ac_Header=yes"

4047

else

4048

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

4049

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

4050

4051

eval "$as_ac_Header=no"

4052

4053

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

4054

4055

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

4056

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

4057

if test `eval echo '${'$as_ac_Header'}'` = yes; then

4058

cat >>confdefs.h <<_ACEOF

4059

#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

4060

_ACEOF

4061

4062

4063

4064

done

4065

4066

4067

echo "$as_me:$LINENO: checking for long" >&5

4068

echo $ECHO_N "checking for long... $ECHO_C" >&6

4069

if test "${ac_cv_type_long+set}" = set; then

4070

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

4071

else

4072

cat >conftest.$ac_ext <<_ACEOF

4073

/* confdefs.h. */

4074

_ACEOF

4075

cat confdefs.h >>conftest.$ac_ext

4076

cat >>conftest.$ac_ext <<_ACEOF

4077

/* end confdefs.h. */

4078

$ac_includes_default

4079

int

4080

main ()

4081

{

4082

if ((long *) 0)

4083

return 0;

4084

if (sizeof (long))

4085

return 0;

4086

;

4087

return 0;

4088

}

4089

_ACEOF

4090

rm -f conftest.$ac_objext

4091

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

4092

(eval $ac_compile) 2>conftest.er1

4093

ac_status=$?

4094

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

4095

rm -f conftest.er1

4096

cat conftest.err >&5

4097

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

4098

(exit $ac_status); } &&

4099

{ ac_try='test -z "$ac_c_werror_flag"

4100

|| test ! -s conftest.err'

4101

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

4102

(eval $ac_try) 2>&5

4103

ac_status=$?

4104

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

4105

(exit $ac_status); }; } &&

4106

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

4107

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

4108

(eval $ac_try) 2>&5

4109

ac_status=$?

4110

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

4111

(exit $ac_status); }; }; then

4112

ac_cv_type_long=yes

4113

else

4114

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

4115

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

4116

4117

ac_cv_type_long=no

4118

4119

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

4120

4121

echo "$as_me:$LINENO: result: $ac_cv_type_long" >&5

4122

echo "${ECHO_T}$ac_cv_type_long" >&6

4123

4124

echo "$as_me:$LINENO: checking size of long" >&5

4125

echo $ECHO_N "checking size of long... $ECHO_C" >&6

4126

if test "${ac_cv_sizeof_long+set}" = set; then

4127

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

4128

else

4129

if test "$ac_cv_type_long" = yes; then

4130

# The cast to unsigned long works around a bug in the HP C Compiler

4131

# version HP92453-01 B.11.11.23709.GP, which incorrectly rejects

4132

# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.

4133

# This bug is HP SR number 8606223364.

4134

if test "$cross_compiling" = yes; then

4135

# Depending upon the size, compute the lo and hi bounds.

4136

cat >conftest.$ac_ext <<_ACEOF

4137

/* confdefs.h. */

4138

_ACEOF

4139

cat confdefs.h >>conftest.$ac_ext

4140

cat >>conftest.$ac_ext <<_ACEOF

4141

/* end confdefs.h. */

4142

$ac_includes_default

4143

int

4144

main ()

4145

{

4146

static int test_array [1 - 2 * !(((long) (sizeof (long))) >= 0)];

4147

test_array [0] = 0

4148

4149

;

4150

return 0;

4151

}

4152

_ACEOF

4153

rm -f conftest.$ac_objext

4154

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

4155

(eval $ac_compile) 2>conftest.er1

4156

ac_status=$?

4157

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

4158

rm -f conftest.er1

4159

cat conftest.err >&5

4160

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

4161

(exit $ac_status); } &&

4162

{ ac_try='test -z "$ac_c_werror_flag"

4163

|| test ! -s conftest.err'

4164

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

4165

(eval $ac_try) 2>&5

4166

ac_status=$?

4167

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

4168

(exit $ac_status); }; } &&

4169

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

4170

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

4171

(eval $ac_try) 2>&5

4172

ac_status=$?

4173

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

4174

(exit $ac_status); }; }; then

4175

ac_lo=0 ac_mid=0

4176

while :; do

4177

cat >conftest.$ac_ext <<_ACEOF

4178

/* confdefs.h. */

4179

_ACEOF

4180

cat confdefs.h >>conftest.$ac_ext

4181

cat >>conftest.$ac_ext <<_ACEOF

4182

/* end confdefs.h. */

4183

$ac_includes_default

4184

int

4185

main ()

4186

{

4187

static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];

4188

test_array [0] = 0

4189

4190

;

4191

return 0;

4192

}

4193

_ACEOF

4194

rm -f conftest.$ac_objext

4195

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

4196

(eval $ac_compile) 2>conftest.er1

4197

ac_status=$?

4198

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

4199

rm -f conftest.er1

4200

cat conftest.err >&5

4201

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

4202

(exit $ac_status); } &&

4203

{ ac_try='test -z "$ac_c_werror_flag"

4204

|| test ! -s conftest.err'

4205

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

4206

(eval $ac_try) 2>&5

4207

ac_status=$?

4208

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4209

(exit $ac_status); }; } &&

4210

{ ac_try='test -s conftest.$ac_objext'

4211

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4212

(eval $ac_try) 2>&5

4213

ac_status=$?

4214

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4215

(exit $ac_status); }; }; then

4216

ac_hi=$ac_mid; break

4217

else

4218

echo "$as_me: failed program was:" >&5

4219

sed 's/^/| /' conftest.$ac_ext >&5

4220

4221

ac_lo=`expr $ac_mid + 1`

4222

if test $ac_lo -le $ac_mid; then

4223

ac_lo= ac_hi=

4224

break

4225

4226

ac_mid=`expr 2 '*' $ac_mid + 1`

4227

4228

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

4229

done

4230

else

4231

echo "$as_me: failed program was:" >&5

4232

sed 's/^/| /' conftest.$ac_ext >&5

4233

4234

cat >conftest.$ac_ext <<_ACEOF

4235

/* confdefs.h. */

4236

_ACEOF

4237

cat confdefs.h >>conftest.$ac_ext

4238

cat >>conftest.$ac_ext <<_ACEOF

4239

/* end confdefs.h. */

4240

$ac_includes_default

4241

int

4242

main ()

4243

{

4244

static int test_array [1 - 2 * !(((long) (sizeof (long))) < 0)];

4245

test_array [0] = 0

4246

4247

;

4248

return 0;

4249

}

4250

_ACEOF

4251

rm -f conftest.$ac_objext

4252

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

4253

(eval $ac_compile) 2>conftest.er1

4254

ac_status=$?

4255

grep -v '^ *+' conftest.er1 >conftest.err

4256

rm -f conftest.er1

4257

cat conftest.err >&5

4258

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4259

(exit $ac_status); } &&

4260

{ ac_try='test -z "$ac_c_werror_flag"

4261

|| test ! -s conftest.err'

4262

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4263

(eval $ac_try) 2>&5

4264

ac_status=$?

4265

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4266

(exit $ac_status); }; } &&

4267

{ ac_try='test -s conftest.$ac_objext'

4268

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4269

(eval $ac_try) 2>&5

4270

ac_status=$?

4271

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4272

(exit $ac_status); }; }; then

4273

ac_hi=-1 ac_mid=-1

4274

while :; do

4275

cat >conftest.$ac_ext <<_ACEOF

4276

/* confdefs.h. */

4277

_ACEOF

4278

cat confdefs.h >>conftest.$ac_ext

4279

cat >>conftest.$ac_ext <<_ACEOF

4280

/* end confdefs.h. */

4281

$ac_includes_default

4282

int

4283

main ()

4284

{

4285

static int test_array [1 - 2 * !(((long) (sizeof (long))) >= $ac_mid)];

4286

test_array [0] = 0

4287

4288

;

4289

return 0;

4290

}

4291

_ACEOF

4292

rm -f conftest.$ac_objext

4293

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

4294

(eval $ac_compile) 2>conftest.er1

4295

ac_status=$?

4296

grep -v '^ *+' conftest.er1 >conftest.err

4297

rm -f conftest.er1

4298

cat conftest.err >&5

4299

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4300

(exit $ac_status); } &&

4301

{ ac_try='test -z "$ac_c_werror_flag"

4302

|| test ! -s conftest.err'

4303

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4304

(eval $ac_try) 2>&5

4305

ac_status=$?

4306

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4307

(exit $ac_status); }; } &&

4308

{ ac_try='test -s conftest.$ac_objext'

4309

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4310

(eval $ac_try) 2>&5

4311

ac_status=$?

4312

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4313

(exit $ac_status); }; }; then

4314

ac_lo=$ac_mid; break

4315

else

4316

echo "$as_me: failed program was:" >&5

4317

sed 's/^/| /' conftest.$ac_ext >&5

4318

4319

ac_hi=`expr '(' $ac_mid ')' - 1`

4320

if test $ac_mid -le $ac_hi; then

4321

ac_lo= ac_hi=

4322

break

4323

4324

ac_mid=`expr 2 '*' $ac_mid`

4325

4326

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

4327

done

4328

else

4329

echo "$as_me: failed program was:" >&5

4330

sed 's/^/| /' conftest.$ac_ext >&5

4331

4332

ac_lo= ac_hi=

4333

4334

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

4335

4336

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

4337

# Binary search between lo and hi bounds.

4338

while test "x$ac_lo" != "x$ac_hi"; do

4339

ac_mid=`expr '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo`

4340

cat >conftest.$ac_ext <<_ACEOF

4341

/* confdefs.h. */

4342

_ACEOF

4343

cat confdefs.h >>conftest.$ac_ext

4344

cat >>conftest.$ac_ext <<_ACEOF

4345

/* end confdefs.h. */

4346

$ac_includes_default

4347

int

4348

main ()

4349

{

4350

static int test_array [1 - 2 * !(((long) (sizeof (long))) <= $ac_mid)];

4351

test_array [0] = 0

4352

4353

;

4354

return 0;

4355

}

4356

_ACEOF

4357

rm -f conftest.$ac_objext

4358

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

4359

(eval $ac_compile) 2>conftest.er1

4360

ac_status=$?

4361

grep -v '^ *+' conftest.er1 >conftest.err

4362

rm -f conftest.er1

4363

cat conftest.err >&5

4364

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4365

(exit $ac_status); } &&

4366

{ ac_try='test -z "$ac_c_werror_flag"

4367

|| test ! -s conftest.err'

4368

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4369

(eval $ac_try) 2>&5

4370

ac_status=$?

4371

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4372

(exit $ac_status); }; } &&

4373

{ ac_try='test -s conftest.$ac_objext'

4374

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4375

(eval $ac_try) 2>&5

4376

ac_status=$?

4377

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4378

(exit $ac_status); }; }; then

4379

ac_hi=$ac_mid

4380

else

4381

echo "$as_me: failed program was:" >&5

4382

sed 's/^/| /' conftest.$ac_ext >&5

4383

4384

ac_lo=`expr '(' $ac_mid ')' + 1`

4385

4386

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

4387

done

4388

case $ac_lo in

4389

?*) ac_cv_sizeof_long=$ac_lo;;

4390

'') { { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77

4391

See \`config.log' for more details." >&5

4392

echo "$as_me: error: cannot compute sizeof (long), 77

4393

See \`config.log' for more details." >&2;}

4394

{ (exit 1); exit 1; }; } ;;

4395

esac

4396

else

4397

if test "$cross_compiling" = yes; then

4398

{ { echo "$as_me:$LINENO: error: cannot run test program while cross compiling

4399

See \`config.log' for more details." >&5

4400

echo "$as_me: error: cannot run test program while cross compiling

4401

See \`config.log' for more details." >&2;}

4402

{ (exit 1); exit 1; }; }

4403

else

4404

cat >conftest.$ac_ext <<_ACEOF

4405

/* confdefs.h. */

4406

_ACEOF

4407

cat confdefs.h >>conftest.$ac_ext

4408

cat >>conftest.$ac_ext <<_ACEOF

4409

/* end confdefs.h. */

4410

$ac_includes_default

4411

long longval () { return (long) (sizeof (long)); }

4412

unsigned long ulongval () { return (long) (sizeof (long)); }

4413

#include <stdio.h>

4414

#include <stdlib.h>

4415

int

4416

main ()

4417

{

4418

4419

FILE *f = fopen ("conftest.val", "w");

4420

if (! f)

4421

exit (1);

4422

if (((long) (sizeof (long))) < 0)

4423

{

4424

long i = longval ();

4425

if (i != ((long) (sizeof (long))))

4426

exit (1);

4427

fprintf (f, "%ld\n", i);

4428

}

4429

else

4430

{

4431

unsigned long i = ulongval ();

4432

if (i != ((long) (sizeof (long))))

4433

exit (1);

4434

fprintf (f, "%lu\n", i);

4435

}

4436

exit (ferror (f) || fclose (f) != 0);

4437

4438

;

4439

return 0;

4440

}

4441

_ACEOF

4442

rm -f conftest$ac_exeext

4443

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

4444

(eval $ac_link) 2>&5

4445

ac_status=$?

4446

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4447

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

4448

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4449

(eval $ac_try) 2>&5

4450

ac_status=$?

4451

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4452

(exit $ac_status); }; }; then

4453

ac_cv_sizeof_long=`cat conftest.val`

4454

else

4455

echo "$as_me: program exited with status $ac_status" >&5

4456

echo "$as_me: failed program was:" >&5

4457

sed 's/^/| /' conftest.$ac_ext >&5

4458

4459

( exit $ac_status )

4460

{ { echo "$as_me:$LINENO: error: cannot compute sizeof (long), 77

4461

See \`config.log' for more details." >&5

4462

echo "$as_me: error: cannot compute sizeof (long), 77

4463

See \`config.log' for more details." >&2;}

4464

{ (exit 1); exit 1; }; }

4465

4466

rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

4467

4468

4469

rm -f conftest.val

4470

else

4471

ac_cv_sizeof_long=0

4472

4473

4474

echo "$as_me:$LINENO: result: $ac_cv_sizeof_long" >&5

4475

echo "${ECHO_T}$ac_cv_sizeof_long" >&6

4476

cat >>confdefs.h <<_ACEOF

4477

#define SIZEOF_LONG $ac_cv_sizeof_long

4478

_ACEOF

4479

4480

4481

4482

for ac_prog in mawk gawk nawk awk

4483

4484

# Extract the first word of "$ac_prog", so it can be a program name with args.

4485

set dummy $ac_prog; ac_word=$2

4486

echo "$as_me:$LINENO: checking for $ac_word" >&5

4487

echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

4488

if test "${ac_cv_path_AWK+set}" = set; then

4489

echo $ECHO_N "(cached) $ECHO_C" >&6

4490

else

4491

case $AWK in

4492

[\\/]* | ?:[\\/]*)

4493

ac_cv_path_AWK="$AWK" # Let the user override the test with a path.

4494

;;

4495

4496

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

4497

for as_dir in $PATH

4498

4499

IFS=$as_save_IFS

4500

test -z "$as_dir" && as_dir=.

4501

for ac_exec_ext in '' $ac_executable_extensions; do

4502

if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

4503

ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"

4504

echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

4505

break 2

4506

4507

done

4508

done

4509

4510

;;

4511

esac

4512

4513

AWK=$ac_cv_path_AWK

4514

4515

if test -n "$AWK"; then

4516

echo "$as_me:$LINENO: result: $AWK" >&5

4517

echo "${ECHO_T}$AWK" >&6

4518

else

4519

echo "$as_me:$LINENO: result: no" >&5

4520

echo "${ECHO_T}no" >&6

4521

4522

4523

test -n "$AWK" && break

4524

done

4525

test -n "$AWK" || AWK="ERROR"

4526

4527

if test $AWK = ERROR

4528

then

4529

echo " "

4530

echo "ERROR: You must have at last one of the following programs:"

4531

echo " mawk, gawk, nawk or awk !"

4532

echo " "

4533

exit

4534

4535

4536

for ac_prog in bash /sbin/sh

4537

4538

# Extract the first word of "$ac_prog", so it can be a program name with args.

4539

set dummy $ac_prog; ac_word=$2

4540

echo "$as_me:$LINENO: checking for $ac_word" >&5

4541

echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

4542

if test "${ac_cv_path_BASH+set}" = set; then

4543

echo $ECHO_N "(cached) $ECHO_C" >&6

4544

else

4545

case $BASH in

4546

[\\/]* | ?:[\\/]*)

4547

ac_cv_path_BASH="$BASH" # Let the user override the test with a path.

4548

;;

4549

4550

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

4551

for as_dir in $PATH

4552

4553

IFS=$as_save_IFS

4554

test -z "$as_dir" && as_dir=.

4555

for ac_exec_ext in '' $ac_executable_extensions; do

4556

if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

4557

ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"

4558

echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

4559

break 2

4560

4561

done

4562

done

4563

4564

;;

4565

esac

4566

4567

BASH=$ac_cv_path_BASH

4568

4569

if test -n "$BASH"; then

4570

echo "$as_me:$LINENO: result: $BASH" >&5

4571

echo "${ECHO_T}$BASH" >&6

4572

else

4573

echo "$as_me:$LINENO: result: no" >&5

4574

echo "${ECHO_T}no" >&6

4575

4576

4577

test -n "$BASH" && break

4578

done

4579

test -n "$BASH" || BASH="/bin/sh"

4580

4581

4582

for ac_prog in gmake make

4583

4584

# Extract the first word of "$ac_prog", so it can be a program name with args.

4585

set dummy $ac_prog; ac_word=$2

4586

echo "$as_me:$LINENO: checking for $ac_word" >&5

4587

echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

4588

if test "${ac_cv_path_MAKE+set}" = set; then

4589

echo $ECHO_N "(cached) $ECHO_C" >&6

4590

else

4591

case $MAKE in

4592

[\\/]* | ?:[\\/]*)

4593

ac_cv_path_MAKE="$MAKE" # Let the user override the test with a path.

4594

;;

4595

4596

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

4597

as_dummy="$PATH:/usr/ccs/bin:/usr/local/bin"

4598

for as_dir in $as_dummy

4599

4600

IFS=$as_save_IFS

4601

test -z "$as_dir" && as_dir=.

4602

for ac_exec_ext in '' $ac_executable_extensions; do

4603

if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

4604

ac_cv_path_MAKE="$as_dir/$ac_word$ac_exec_ext"

4605

echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

4606

break 2

4607

4608

done

4609

done

4610

4611

;;

4612

esac

4613

4614

MAKE=$ac_cv_path_MAKE

4615

4616

if test -n "$MAKE"; then

4617

echo "$as_me:$LINENO: result: $MAKE" >&5

4618

echo "${ECHO_T}$MAKE" >&6

4619

else

4620

echo "$as_me:$LINENO: result: no" >&5

4621

echo "${ECHO_T}no" >&6

4622

4623

4624

test -n "$MAKE" && break

4625

done

4626

test -n "$MAKE" || MAKE=""""

4627

4628

if test x$MAKE = x

4629

then

4630

echo " "

4631

echo "Warning: No make on this system?"

4632

echo " "

4633

exit

4634

4635

4636

4637

# Extract the first word of "aliases", so it can be a program name with args.

4638

set dummy aliases; ac_word=$2

4639

echo "$as_me:$LINENO: checking for $ac_word" >&5

4640

echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6

4641

if test "${ac_cv_path_ALIASES+set}" = set; then

4642

echo $ECHO_N "(cached) $ECHO_C" >&6

4643

else

4644

case $ALIASES in

4645

[\\/]* | ?:[\\/]*)

4646

ac_cv_path_ALIASES="$ALIASES" # Let the user override the test with a path.

4647

;;

4648

4649

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

4650

as_dummy="/etc/mail:/etc"

4651

for as_dir in $as_dummy

4652

4653

IFS=$as_save_IFS

4654

test -z "$as_dir" && as_dir=.

4655

for ac_exec_ext in '' $ac_executable_extensions; do

4656

if $as_executable_p "$as_dir/$ac_word$ac_exec_ext"; then

4657

ac_cv_path_ALIASES="$as_dir/$ac_word$ac_exec_ext"

4658

echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5

4659

break 2

4660

4661

done

4662

done

4663

4664

test -z "$ac_cv_path_ALIASES" && ac_cv_path_ALIASES="/etc/mail/aliases"

4665

;;

4666

esac

4667

4668

ALIASES=$ac_cv_path_ALIASES

4669

4670

if test -n "$ALIASES"; then

4671

echo "$as_me:$LINENO: result: $ALIASES" >&5

4672

echo "${ECHO_T}$ALIASES" >&6

4673

else

4674

echo "$as_me:$LINENO: result: no" >&5

4675

echo "${ECHO_T}no" >&6

4676

4677

4678

4679

4680

4681

# Check whether --enable-fqdn or --disable-fqdn was given.

4682

if test "${enable_fqdn+set}" = set; then

4683

enableval="$enable_fqdn"

4684

USE_PARAM_FQDN=$enableval

4685

else

4686

USE_PARAM_FQDN=yes

4687

fi;

4688

if test "$USE_PARAM_FQDN" = "no"; then

4689

USE_FQDN=0

4690

else

4691

USE_FQDN=1

4692

4693

4694

4695

# Check whether --enable-checkroot or --disable-checkroot was given.

4696

if test "${enable_checkroot+set}" = set; then

4697

enableval="$enable_checkroot"

4698

CHECKROOT=$enableval

4699

else

4700

CHECKROOT=yes

4701

fi;

4702

4703

4704

echo "$as_me:$LINENO: checking for gdbm_open in -lgdbm" >&5

4705

echo $ECHO_N "checking for gdbm_open in -lgdbm... $ECHO_C" >&6

4706

if test "${ac_cv_lib_gdbm_gdbm_open+set}" = set; then

4707

echo $ECHO_N "(cached) $ECHO_C" >&6

4708

else

4709

ac_check_lib_save_LIBS=$LIBS

4710

LIBS="-lgdbm $LIBS"

4711

cat >conftest.$ac_ext <<_ACEOF

4712

/* confdefs.h. */

4713

_ACEOF

4714

cat confdefs.h >>conftest.$ac_ext

4715

cat >>conftest.$ac_ext <<_ACEOF

4716

/* end confdefs.h. */

4717

4718

/* Override any gcc2 internal prototype to avoid an error. */

4719

#ifdef __cplusplus

4720

extern "C"

4721

#endif

4722

/* We use char because int might match the return type of a gcc2

4723

builtin and then its argument prototype would still apply. */

4724

char gdbm_open ();

4725

int

4726

main ()

4727

{

4728

gdbm_open ();

4729

;

4730

return 0;

4731

}

4732

_ACEOF

4733

rm -f conftest.$ac_objext conftest$ac_exeext

4734

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

4735

(eval $ac_link) 2>conftest.er1

4736

ac_status=$?

4737

grep -v '^ *+' conftest.er1 >conftest.err

4738

rm -f conftest.er1

4739

cat conftest.err >&5

4740

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4741

(exit $ac_status); } &&

4742

{ ac_try='test -z "$ac_c_werror_flag"

4743

|| test ! -s conftest.err'

4744

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4745

(eval $ac_try) 2>&5

4746

ac_status=$?

4747

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4748

(exit $ac_status); }; } &&

4749

{ ac_try='test -s conftest$ac_exeext'

4750

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4751

(eval $ac_try) 2>&5

4752

ac_status=$?

4753

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4754

(exit $ac_status); }; }; then

4755

ac_cv_lib_gdbm_gdbm_open=yes

4756

else

4757

echo "$as_me: failed program was:" >&5

4758

sed 's/^/| /' conftest.$ac_ext >&5

4759

4760

ac_cv_lib_gdbm_gdbm_open=no

4761

4762

rm -f conftest.err conftest.$ac_objext \

4763

conftest$ac_exeext conftest.$ac_ext

4764

LIBS=$ac_check_lib_save_LIBS

4765

4766

echo "$as_me:$LINENO: result: $ac_cv_lib_gdbm_gdbm_open" >&5

4767

echo "${ECHO_T}$ac_cv_lib_gdbm_gdbm_open" >&6

4768

if test $ac_cv_lib_gdbm_gdbm_open = yes; then

4769

LIBDBM="-lgdbm"

4770

else

4771

LIBDBM=""

4772

4773

4774

if test x"" != x"${LIBDBM}"

4775

then

4776

4777

cat >>confdefs.h <<\_ACEOF

4778

#define HAVE_LIBGDBM 1

4779

_ACEOF

4780

4781

libdb_parameter=yes

4782

else

4783

4784

for ac_func in dbm_open

4785

4786

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

4787

echo "$as_me:$LINENO: checking for $ac_func" >&5

4788

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

4789

if eval "test \"\${$as_ac_var+set}\" = set"; then

4790

echo $ECHO_N "(cached) $ECHO_C" >&6

4791

else

4792

cat >conftest.$ac_ext <<_ACEOF

4793

/* confdefs.h. */

4794

_ACEOF

4795

cat confdefs.h >>conftest.$ac_ext

4796

cat >>conftest.$ac_ext <<_ACEOF

4797

/* end confdefs.h. */

4798

/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

4799

For example, HP-UX 11i <limits.h> declares gettimeofday. */

4800

#define $ac_func innocuous_$ac_func

4801

4802

/* System header to define __stub macros and hopefully few prototypes,

4803

which can conflict with char $ac_func (); below.

4804

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

4805

<limits.h> exists even on freestanding compilers. */

4806

4807

#ifdef __STDC__

4808

# include <limits.h>

4809

#else

4810

# include <assert.h>

4811

#endif

4812

4813

#undef $ac_func

4814

4815

/* Override any gcc2 internal prototype to avoid an error. */

4816

#ifdef __cplusplus

4817

extern "C"

4818

{

4819

#endif

4820

/* We use char because int might match the return type of a gcc2

4821

builtin and then its argument prototype would still apply. */

4822

char $ac_func ();

4823

/* The GNU C library defines this for functions which it implements

4824

to always fail with ENOSYS. Some functions are actually named

4825

something starting with __ and the normal name is an alias. */

4826

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

4827

choke me

4828

#else

4829

char (*f) () = $ac_func;

4830

#endif

4831

#ifdef __cplusplus

4832

}

4833

#endif

4834

4835

int

4836

main ()

4837

{

4838

return f != $ac_func;

4839

;

4840

return 0;

4841

}

4842

_ACEOF

4843

rm -f conftest.$ac_objext conftest$ac_exeext

4844

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

4845

(eval $ac_link) 2>conftest.er1

4846

ac_status=$?

4847

grep -v '^ *+' conftest.er1 >conftest.err

4848

rm -f conftest.er1

4849

cat conftest.err >&5

4850

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4851

(exit $ac_status); } &&

4852

{ ac_try='test -z "$ac_c_werror_flag"

4853

|| test ! -s conftest.err'

4854

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4855

(eval $ac_try) 2>&5

4856

ac_status=$?

4857

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4858

(exit $ac_status); }; } &&

4859

{ ac_try='test -s conftest$ac_exeext'

4860

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4861

(eval $ac_try) 2>&5

4862

ac_status=$?

4863

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4864

(exit $ac_status); }; }; then

4865

eval "$as_ac_var=yes"

4866

else

4867

echo "$as_me: failed program was:" >&5

4868

sed 's/^/| /' conftest.$ac_ext >&5

4869

4870

eval "$as_ac_var=no"

4871

4872

rm -f conftest.err conftest.$ac_objext \

4873

conftest$ac_exeext conftest.$ac_ext

4874

4875

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

4876

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

4877

if test `eval echo '${'$as_ac_var'}'` = yes; then

4878

cat >>confdefs.h <<_ACEOF

4879

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

4880

_ACEOF

4881

4882

4883

done

4884

4885

if test x$ac_cv_func_dbm_open = xyes

4886

then

4887

4888

cat >>confdefs.h <<\_ACEOF

4889

#define HAVE_NDBM 1

4890

_ACEOF

4891

4892

libdb_parameter=yes

4893

4894

4895

4896

4897

if test x$libdb_parameter != xyes

4898

then

4899

echo "

4900

4901

You need the GNU GDBM or the Solaris NDBM functions for this package !"

4902

echo ""

4903

echo ""

4904

exit

4905

4906

4907

echo "$as_me:$LINENO: checking for crypt in -lxcrypt" >&5

4908

echo $ECHO_N "checking for crypt in -lxcrypt... $ECHO_C" >&6

4909

if test "${ac_cv_lib_xcrypt_crypt+set}" = set; then

4910

echo $ECHO_N "(cached) $ECHO_C" >&6

4911

else

4912

ac_check_lib_save_LIBS=$LIBS

4913

LIBS="-lxcrypt $LIBS"

4914

cat >conftest.$ac_ext <<_ACEOF

4915

/* confdefs.h. */

4916

_ACEOF

4917

cat confdefs.h >>conftest.$ac_ext

4918

cat >>conftest.$ac_ext <<_ACEOF

4919

/* end confdefs.h. */

4920

4921

/* Override any gcc2 internal prototype to avoid an error. */

4922

#ifdef __cplusplus

4923

extern "C"

4924

#endif

4925

/* We use char because int might match the return type of a gcc2

4926

builtin and then its argument prototype would still apply. */

4927

char crypt ();

4928

int

4929

main ()

4930

{

4931

crypt ();

4932

;

4933

return 0;

4934

}

4935

_ACEOF

4936

rm -f conftest.$ac_objext conftest$ac_exeext

4937

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

4938

(eval $ac_link) 2>conftest.er1

4939

ac_status=$?

4940

grep -v '^ *+' conftest.er1 >conftest.err

4941

rm -f conftest.er1

4942

cat conftest.err >&5

4943

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4944

(exit $ac_status); } &&

4945

{ ac_try='test -z "$ac_c_werror_flag"

4946

|| test ! -s conftest.err'

4947

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4948

(eval $ac_try) 2>&5

4949

ac_status=$?

4950

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4951

(exit $ac_status); }; } &&

4952

{ ac_try='test -s conftest$ac_exeext'

4953

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

4954

(eval $ac_try) 2>&5

4955

ac_status=$?

4956

echo "$as_me:$LINENO: \$? = $ac_status" >&5

4957

(exit $ac_status); }; }; then

4958

ac_cv_lib_xcrypt_crypt=yes

4959

else

4960

echo "$as_me: failed program was:" >&5

4961

sed 's/^/| /' conftest.$ac_ext >&5

4962

4963

ac_cv_lib_xcrypt_crypt=no

4964

4965

rm -f conftest.err conftest.$ac_objext \

4966

conftest$ac_exeext conftest.$ac_ext

4967

LIBS=$ac_check_lib_save_LIBS

4968

4969

echo "$as_me:$LINENO: result: $ac_cv_lib_xcrypt_crypt" >&5

4970

echo "${ECHO_T}$ac_cv_lib_xcrypt_crypt" >&6

4971

if test $ac_cv_lib_xcrypt_crypt = yes; then

4972

LIBCRYPT="-lxcrypt"

4973

else

4974

LIBCRYPT=""

4975

4976

4977

if test -z "$LIBCRYPT" ; then

4978

echo "$as_me:$LINENO: checking for crypt in -lcrypt" >&5

4979

echo $ECHO_N "checking for crypt in -lcrypt... $ECHO_C" >&6

4980

if test "${ac_cv_lib_crypt_crypt+set}" = set; then

4981

echo $ECHO_N "(cached) $ECHO_C" >&6

4982

else

4983

ac_check_lib_save_LIBS=$LIBS

4984

LIBS="-lcrypt $LIBS"

4985

cat >conftest.$ac_ext <<_ACEOF

4986

/* confdefs.h. */

4987

_ACEOF

4988

cat confdefs.h >>conftest.$ac_ext

4989

cat >>conftest.$ac_ext <<_ACEOF

4990

/* end confdefs.h. */

4991

4992

/* Override any gcc2 internal prototype to avoid an error. */

4993

#ifdef __cplusplus

4994

extern "C"

4995

#endif

4996

/* We use char because int might match the return type of a gcc2

4997

builtin and then its argument prototype would still apply. */

4998

char crypt ();

4999

int

5000

main ()

5001

{

5002

crypt ();

5003

;

5004

return 0;

5005

}

5006

_ACEOF

5007

rm -f conftest.$ac_objext conftest$ac_exeext

5008

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

5009

(eval $ac_link) 2>conftest.er1

5010

ac_status=$?

5011

grep -v '^ *+' conftest.er1 >conftest.err

5012

rm -f conftest.er1

5013

cat conftest.err >&5

5014

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5015

(exit $ac_status); } &&

5016

{ ac_try='test -z "$ac_c_werror_flag"

5017

|| test ! -s conftest.err'

5018

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5019

(eval $ac_try) 2>&5

5020

ac_status=$?

5021

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5022

(exit $ac_status); }; } &&

5023

{ ac_try='test -s conftest$ac_exeext'

5024

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5025

(eval $ac_try) 2>&5

5026

ac_status=$?

5027

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5028

(exit $ac_status); }; }; then

5029

ac_cv_lib_crypt_crypt=yes

5030

else

5031

echo "$as_me: failed program was:" >&5

5032

sed 's/^/| /' conftest.$ac_ext >&5

5033

5034

ac_cv_lib_crypt_crypt=no

5035

5036

rm -f conftest.err conftest.$ac_objext \

5037

conftest$ac_exeext conftest.$ac_ext

5038

LIBS=$ac_check_lib_save_LIBS

5039

5040

echo "$as_me:$LINENO: result: $ac_cv_lib_crypt_crypt" >&5

5041

echo "${ECHO_T}$ac_cv_lib_crypt_crypt" >&6

5042

if test $ac_cv_lib_crypt_crypt = yes; then

5043

LIBCRYPT="-lcrypt"

5044

else

5045

LIBCRYPT=""

5046

5047

5048

5049

for ac_header in crypt.h

5050

5051

as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

5052

if eval "test \"\${$as_ac_Header+set}\" = set"; then

5053

echo "$as_me:$LINENO: checking for $ac_header" >&5

5054

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

5055

if eval "test \"\${$as_ac_Header+set}\" = set"; then

5056

echo $ECHO_N "(cached) $ECHO_C" >&6

5057

5058

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

5059

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

5060

else

5061

# Is the header compilable?

5062

echo "$as_me:$LINENO: checking $ac_header usability" >&5

5063

echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

5064

cat >conftest.$ac_ext <<_ACEOF

5065

/* confdefs.h. */

5066

_ACEOF

5067

cat confdefs.h >>conftest.$ac_ext

5068

cat >>conftest.$ac_ext <<_ACEOF

5069

/* end confdefs.h. */

5070

$ac_includes_default

5071

#include <$ac_header>

5072

_ACEOF

5073

rm -f conftest.$ac_objext

5074

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

5075

(eval $ac_compile) 2>conftest.er1

5076

ac_status=$?

5077

grep -v '^ *+' conftest.er1 >conftest.err

5078

rm -f conftest.er1

5079

cat conftest.err >&5

5080

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5081

(exit $ac_status); } &&

5082

{ ac_try='test -z "$ac_c_werror_flag"

5083

|| test ! -s conftest.err'

5084

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5085

(eval $ac_try) 2>&5

5086

ac_status=$?

5087

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5088

(exit $ac_status); }; } &&

5089

{ ac_try='test -s conftest.$ac_objext'

5090

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5091

(eval $ac_try) 2>&5

5092

ac_status=$?

5093

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5094

(exit $ac_status); }; }; then

5095

ac_header_compiler=yes

5096

else

5097

echo "$as_me: failed program was:" >&5

5098

sed 's/^/| /' conftest.$ac_ext >&5

5099

5100

ac_header_compiler=no

5101

5102

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

5103

echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

5104

echo "${ECHO_T}$ac_header_compiler" >&6

5105

5106

# Is the header present?

5107

echo "$as_me:$LINENO: checking $ac_header presence" >&5

5108

echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

5109

cat >conftest.$ac_ext <<_ACEOF

5110

/* confdefs.h. */

5111

_ACEOF

5112

cat confdefs.h >>conftest.$ac_ext

5113

cat >>conftest.$ac_ext <<_ACEOF

5114

/* end confdefs.h. */

5115

#include <$ac_header>

5116

_ACEOF

5117

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

5118

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

5119

ac_status=$?

5120

grep -v '^ *+' conftest.er1 >conftest.err

5121

rm -f conftest.er1

5122

cat conftest.err >&5

5123

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5124

(exit $ac_status); } >/dev/null; then

5125

if test -s conftest.err; then

5126

ac_cpp_err=$ac_c_preproc_warn_flag

5127

ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

5128

else

5129

ac_cpp_err=

5130

5131

else

5132

ac_cpp_err=yes

5133

5134

if test -z "$ac_cpp_err"; then

5135

ac_header_preproc=yes

5136

else

5137

echo "$as_me: failed program was:" >&5

5138

sed 's/^/| /' conftest.$ac_ext >&5

5139

5140

ac_header_preproc=no

5141

5142

rm -f conftest.err conftest.$ac_ext

5143

echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

5144

echo "${ECHO_T}$ac_header_preproc" >&6

5145

5146

# So? What about this header?

5147

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in

5148

yes:no: )

5149

{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

5150

echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

5151

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5

5152

echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}

5153

ac_header_preproc=yes

5154

;;

5155

no:yes:* )

5156

{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

5157

echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

5158

{ echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5

5159

echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}

5160

{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5

5161

echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}

5162

{ echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5

5163

echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;}

5164

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

5165

echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

5166

{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5

5167

echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}

5168

(

5169

cat <<\_ASBOX

5170

## ---------------------------------- ##

5171

## Report this to kukuk@linux-nis.org ##

5172

## ---------------------------------- ##

5173

_ASBOX

5174

) |

5175

sed "s/^/$as_me: WARNING: /" >&2

5176

;;

5177

esac

5178

echo "$as_me:$LINENO: checking for $ac_header" >&5

5179

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

5180

if eval "test \"\${$as_ac_Header+set}\" = set"; then

5181

echo $ECHO_N "(cached) $ECHO_C" >&6

5182

else

5183

eval "$as_ac_Header=\$ac_header_preproc"

5184

5185

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

5186

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

5187

5188

5189

if test `eval echo '${'$as_ac_Header'}'` = yes; then

5190

cat >>confdefs.h <<_ACEOF

5191

#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

5192

_ACEOF

5193

5194

5195

5196

done

5197

5198

else

5199

5200

5201

for ac_header in xcrypt.h crypt.h

5202

5203

as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

5204

if eval "test \"\${$as_ac_Header+set}\" = set"; then

5205

echo "$as_me:$LINENO: checking for $ac_header" >&5

5206

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

5207

if eval "test \"\${$as_ac_Header+set}\" = set"; then

5208

echo $ECHO_N "(cached) $ECHO_C" >&6

5209

5210

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

5211

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

5212

else

5213

# Is the header compilable?

5214

echo "$as_me:$LINENO: checking $ac_header usability" >&5

5215

echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

5216

cat >conftest.$ac_ext <<_ACEOF

5217

/* confdefs.h. */

5218

_ACEOF

5219

cat confdefs.h >>conftest.$ac_ext

5220

cat >>conftest.$ac_ext <<_ACEOF

5221

/* end confdefs.h. */

5222

$ac_includes_default

5223

#include <$ac_header>

5224

_ACEOF

5225

rm -f conftest.$ac_objext

5226

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

5227

(eval $ac_compile) 2>conftest.er1

5228

ac_status=$?

5229

grep -v '^ *+' conftest.er1 >conftest.err

5230

rm -f conftest.er1

5231

cat conftest.err >&5

5232

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5233

(exit $ac_status); } &&

5234

{ ac_try='test -z "$ac_c_werror_flag"

5235

|| test ! -s conftest.err'

5236

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5237

(eval $ac_try) 2>&5

5238

ac_status=$?

5239

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5240

(exit $ac_status); }; } &&

5241

{ ac_try='test -s conftest.$ac_objext'

5242

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5243

(eval $ac_try) 2>&5

5244

ac_status=$?

5245

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5246

(exit $ac_status); }; }; then

5247

ac_header_compiler=yes

5248

else

5249

echo "$as_me: failed program was:" >&5

5250

sed 's/^/| /' conftest.$ac_ext >&5

5251

5252

ac_header_compiler=no

5253

5254

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

5255

echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

5256

echo "${ECHO_T}$ac_header_compiler" >&6

5257

5258

# Is the header present?

5259

echo "$as_me:$LINENO: checking $ac_header presence" >&5

5260

echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

5261

cat >conftest.$ac_ext <<_ACEOF

5262

/* confdefs.h. */

5263

_ACEOF

5264

cat confdefs.h >>conftest.$ac_ext

5265

cat >>conftest.$ac_ext <<_ACEOF

5266

/* end confdefs.h. */

5267

#include <$ac_header>

5268

_ACEOF

5269

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

5270

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

5271

ac_status=$?

5272

grep -v '^ *+' conftest.er1 >conftest.err

5273

rm -f conftest.er1

5274

cat conftest.err >&5

5275

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5276

(exit $ac_status); } >/dev/null; then

5277

if test -s conftest.err; then

5278

ac_cpp_err=$ac_c_preproc_warn_flag

5279

ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

5280

else

5281

ac_cpp_err=

5282

5283

else

5284

ac_cpp_err=yes

5285

5286

if test -z "$ac_cpp_err"; then

5287

ac_header_preproc=yes

5288

else

5289

echo "$as_me: failed program was:" >&5

5290

sed 's/^/| /' conftest.$ac_ext >&5

5291

5292

ac_header_preproc=no

5293

5294

rm -f conftest.err conftest.$ac_ext

5295

echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

5296

echo "${ECHO_T}$ac_header_preproc" >&6

5297

5298

# So? What about this header?

5299

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in

5300

yes:no: )

5301

{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

5302

echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

5303

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5

5304

echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}

5305

ac_header_preproc=yes

5306

;;

5307

no:yes:* )

5308

{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

5309

echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

5310

{ echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5

5311

echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}

5312

{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5

5313

echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}

5314

{ echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5

5315

echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;}

5316

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

5317

echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

5318

{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5

5319

echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}

5320

(

5321

cat <<\_ASBOX

5322

## ---------------------------------- ##

5323

## Report this to kukuk@linux-nis.org ##

5324

## ---------------------------------- ##

5325

_ASBOX

5326

) |

5327

sed "s/^/$as_me: WARNING: /" >&2

5328

;;

5329

esac

5330

echo "$as_me:$LINENO: checking for $ac_header" >&5

5331

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

5332

if eval "test \"\${$as_ac_Header+set}\" = set"; then

5333

echo $ECHO_N "(cached) $ECHO_C" >&6

5334

else

5335

eval "$as_ac_Header=\$ac_header_preproc"

5336

5337

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

5338

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

5339

5340

5341

if test `eval echo '${'$as_ac_Header'}'` = yes; then

5342

cat >>confdefs.h <<_ACEOF

5343

#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

5344

_ACEOF

5345

5346

5347

5348

done

5349

5350

5351

5352

5353

USE_SLP=0

5354

echo "$as_me:$LINENO: checking for SLPReg in -lslp" >&5

5355

echo $ECHO_N "checking for SLPReg in -lslp... $ECHO_C" >&6

5356

if test "${ac_cv_lib_slp_SLPReg+set}" = set; then

5357

echo $ECHO_N "(cached) $ECHO_C" >&6

5358

else

5359

ac_check_lib_save_LIBS=$LIBS

5360

LIBS="-lslp $LIBS"

5361

cat >conftest.$ac_ext <<_ACEOF

5362

/* confdefs.h. */

5363

_ACEOF

5364

cat confdefs.h >>conftest.$ac_ext

5365

cat >>conftest.$ac_ext <<_ACEOF

5366

/* end confdefs.h. */

5367

5368

/* Override any gcc2 internal prototype to avoid an error. */

5369

#ifdef __cplusplus

5370

extern "C"

5371

#endif

5372

/* We use char because int might match the return type of a gcc2

5373

builtin and then its argument prototype would still apply. */

5374

char SLPReg ();

5375

int

5376

main ()

5377

{

5378

SLPReg ();

5379

;

5380

return 0;

5381

}

5382

_ACEOF

5383

rm -f conftest.$ac_objext conftest$ac_exeext

5384

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

5385

(eval $ac_link) 2>conftest.er1

5386

ac_status=$?

5387

grep -v '^ *+' conftest.er1 >conftest.err

5388

rm -f conftest.er1

5389

cat conftest.err >&5

5390

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5391

(exit $ac_status); } &&

5392

{ ac_try='test -z "$ac_c_werror_flag"

5393

|| test ! -s conftest.err'

5394

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5395

(eval $ac_try) 2>&5

5396

ac_status=$?

5397

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5398

(exit $ac_status); }; } &&

5399

{ ac_try='test -s conftest$ac_exeext'

5400

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5401

(eval $ac_try) 2>&5

5402

ac_status=$?

5403

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5404

(exit $ac_status); }; }; then

5405

ac_cv_lib_slp_SLPReg=yes

5406

else

5407

echo "$as_me: failed program was:" >&5

5408

sed 's/^/| /' conftest.$ac_ext >&5

5409

5410

ac_cv_lib_slp_SLPReg=no

5411

5412

rm -f conftest.err conftest.$ac_objext \

5413

conftest$ac_exeext conftest.$ac_ext

5414

LIBS=$ac_check_lib_save_LIBS

5415

5416

echo "$as_me:$LINENO: result: $ac_cv_lib_slp_SLPReg" >&5

5417

echo "${ECHO_T}$ac_cv_lib_slp_SLPReg" >&6

5418

if test $ac_cv_lib_slp_SLPReg = yes; then

5419

LIBSLP="-lslp"

5420

else

5421

LIBSLP=""

5422

5423

5424

5425

if test -n "$LIBSLP" ; then

5426

5427

for ac_header in slp.h

5428

5429

as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

5430

if eval "test \"\${$as_ac_Header+set}\" = set"; then

5431

echo "$as_me:$LINENO: checking for $ac_header" >&5

5432

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

5433

if eval "test \"\${$as_ac_Header+set}\" = set"; then

5434

echo $ECHO_N "(cached) $ECHO_C" >&6

5435

5436

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

5437

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

5438

else

5439

# Is the header compilable?

5440

echo "$as_me:$LINENO: checking $ac_header usability" >&5

5441

echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

5442

cat >conftest.$ac_ext <<_ACEOF

5443

/* confdefs.h. */

5444

_ACEOF

5445

cat confdefs.h >>conftest.$ac_ext

5446

cat >>conftest.$ac_ext <<_ACEOF

5447

/* end confdefs.h. */

5448

$ac_includes_default

5449

#include <$ac_header>

5450

_ACEOF

5451

rm -f conftest.$ac_objext

5452

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

5453

(eval $ac_compile) 2>conftest.er1

5454

ac_status=$?

5455

grep -v '^ *+' conftest.er1 >conftest.err

5456

rm -f conftest.er1

5457

cat conftest.err >&5

5458

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5459

(exit $ac_status); } &&

5460

{ ac_try='test -z "$ac_c_werror_flag"

5461

|| test ! -s conftest.err'

5462

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5463

(eval $ac_try) 2>&5

5464

ac_status=$?

5465

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5466

(exit $ac_status); }; } &&

5467

{ ac_try='test -s conftest.$ac_objext'

5468

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5469

(eval $ac_try) 2>&5

5470

ac_status=$?

5471

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5472

(exit $ac_status); }; }; then

5473

ac_header_compiler=yes

5474

else

5475

echo "$as_me: failed program was:" >&5

5476

sed 's/^/| /' conftest.$ac_ext >&5

5477

5478

ac_header_compiler=no

5479

5480

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

5481

echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

5482

echo "${ECHO_T}$ac_header_compiler" >&6

5483

5484

# Is the header present?

5485

echo "$as_me:$LINENO: checking $ac_header presence" >&5

5486

echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

5487

cat >conftest.$ac_ext <<_ACEOF

5488

/* confdefs.h. */

5489

_ACEOF

5490

cat confdefs.h >>conftest.$ac_ext

5491

cat >>conftest.$ac_ext <<_ACEOF

5492

/* end confdefs.h. */

5493

#include <$ac_header>

5494

_ACEOF

5495

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

5496

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

5497

ac_status=$?

5498

grep -v '^ *+' conftest.er1 >conftest.err

5499

rm -f conftest.er1

5500

cat conftest.err >&5

5501

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5502

(exit $ac_status); } >/dev/null; then

5503

if test -s conftest.err; then

5504

ac_cpp_err=$ac_c_preproc_warn_flag

5505

ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

5506

else

5507

ac_cpp_err=

5508

5509

else

5510

ac_cpp_err=yes

5511

5512

if test -z "$ac_cpp_err"; then

5513

ac_header_preproc=yes

5514

else

5515

echo "$as_me: failed program was:" >&5

5516

sed 's/^/| /' conftest.$ac_ext >&5

5517

5518

ac_header_preproc=no

5519

5520

rm -f conftest.err conftest.$ac_ext

5521

echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

5522

echo "${ECHO_T}$ac_header_preproc" >&6

5523

5524

# So? What about this header?

5525

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in

5526

yes:no: )

5527

{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

5528

echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

5529

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5

5530

echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}

5531

ac_header_preproc=yes

5532

;;

5533

no:yes:* )

5534

{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

5535

echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

5536

{ echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5

5537

echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}

5538

{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5

5539

echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}

5540

{ echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5

5541

echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;}

5542

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

5543

echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

5544

{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5

5545

echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}

5546

(

5547

cat <<\_ASBOX

5548

## ---------------------------------- ##

5549

## Report this to kukuk@linux-nis.org ##

5550

## ---------------------------------- ##

5551

_ASBOX

5552

) |

5553

sed "s/^/$as_me: WARNING: /" >&2

5554

;;

5555

esac

5556

echo "$as_me:$LINENO: checking for $ac_header" >&5

5557

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

5558

if eval "test \"\${$as_ac_Header+set}\" = set"; then

5559

echo $ECHO_N "(cached) $ECHO_C" >&6

5560

else

5561

eval "$as_ac_Header=\$ac_header_preproc"

5562

5563

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

5564

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

5565

5566

5567

if test `eval echo '${'$as_ac_Header'}'` = yes; then

5568

cat >>confdefs.h <<_ACEOF

5569

#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

5570

_ACEOF

5571

5572

5573

5574

done

5575

5576

if test "$ac_cv_header_slp_h" = yes; then

5577

USE_SLP=1

5578

5579

5580

5581

5582

5583

for ac_func in getrpcport

5584

5585

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

5586

echo "$as_me:$LINENO: checking for $ac_func" >&5

5587

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

5588

if eval "test \"\${$as_ac_var+set}\" = set"; then

5589

echo $ECHO_N "(cached) $ECHO_C" >&6

5590

else

5591

cat >conftest.$ac_ext <<_ACEOF

5592

/* confdefs.h. */

5593

_ACEOF

5594

cat confdefs.h >>conftest.$ac_ext

5595

cat >>conftest.$ac_ext <<_ACEOF

5596

/* end confdefs.h. */

5597

/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

5598

For example, HP-UX 11i <limits.h> declares gettimeofday. */

5599

#define $ac_func innocuous_$ac_func

5600

5601

/* System header to define __stub macros and hopefully few prototypes,

5602

which can conflict with char $ac_func (); below.

5603

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

5604

<limits.h> exists even on freestanding compilers. */

5605

5606

#ifdef __STDC__

5607

# include <limits.h>

5608

#else

5609

# include <assert.h>

5610

#endif

5611

5612

#undef $ac_func

5613

5614

/* Override any gcc2 internal prototype to avoid an error. */

5615

#ifdef __cplusplus

5616

extern "C"

5617

{

5618

#endif

5619

/* We use char because int might match the return type of a gcc2

5620

builtin and then its argument prototype would still apply. */

5621

char $ac_func ();

5622

/* The GNU C library defines this for functions which it implements

5623

to always fail with ENOSYS. Some functions are actually named

5624

something starting with __ and the normal name is an alias. */

5625

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

5626

choke me

5627

#else

5628

char (*f) () = $ac_func;

5629

#endif

5630

#ifdef __cplusplus

5631

}

5632

#endif

5633

5634

int

5635

main ()

5636

{

5637

return f != $ac_func;

5638

;

5639

return 0;

5640

}

5641

_ACEOF

5642

rm -f conftest.$ac_objext conftest$ac_exeext

5643

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

5644

(eval $ac_link) 2>conftest.er1

5645

ac_status=$?

5646

grep -v '^ *+' conftest.er1 >conftest.err

5647

rm -f conftest.er1

5648

cat conftest.err >&5

5649

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5650

(exit $ac_status); } &&

5651

{ ac_try='test -z "$ac_c_werror_flag"

5652

|| test ! -s conftest.err'

5653

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5654

(eval $ac_try) 2>&5

5655

ac_status=$?

5656

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5657

(exit $ac_status); }; } &&

5658

{ ac_try='test -s conftest$ac_exeext'

5659

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5660

(eval $ac_try) 2>&5

5661

ac_status=$?

5662

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5663

(exit $ac_status); }; }; then

5664

eval "$as_ac_var=yes"

5665

else

5666

echo "$as_me: failed program was:" >&5

5667

sed 's/^/| /' conftest.$ac_ext >&5

5668

5669

eval "$as_ac_var=no"

5670

5671

rm -f conftest.err conftest.$ac_objext \

5672

conftest$ac_exeext conftest.$ac_ext

5673

5674

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

5675

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

5676

if test `eval echo '${'$as_ac_var'}'` = yes; then

5677

cat >>confdefs.h <<_ACEOF

5678

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

5679

_ACEOF

5680

5681

5682

done

5683

5684

if test "$ac_cv_func_getrpcport" = no; then

5685

echo "$as_me:$LINENO: checking for getrpcport in -lrpcsvc" >&5

5686

echo $ECHO_N "checking for getrpcport in -lrpcsvc... $ECHO_C" >&6

5687

if test "${ac_cv_lib_rpcsvc_getrpcport+set}" = set; then

5688

echo $ECHO_N "(cached) $ECHO_C" >&6

5689

else

5690

ac_check_lib_save_LIBS=$LIBS

5691

LIBS="-lrpcsvc $LIBS"

5692

cat >conftest.$ac_ext <<_ACEOF

5693

/* confdefs.h. */

5694

_ACEOF

5695

cat confdefs.h >>conftest.$ac_ext

5696

cat >>conftest.$ac_ext <<_ACEOF

5697

/* end confdefs.h. */

5698

5699

/* Override any gcc2 internal prototype to avoid an error. */

5700

#ifdef __cplusplus

5701

extern "C"

5702

#endif

5703

/* We use char because int might match the return type of a gcc2

5704

builtin and then its argument prototype would still apply. */

5705

char getrpcport ();

5706

int

5707

main ()

5708

{

5709

getrpcport ();

5710

;

5711

return 0;

5712

}

5713

_ACEOF

5714

rm -f conftest.$ac_objext conftest$ac_exeext

5715

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

5716

(eval $ac_link) 2>conftest.er1

5717

ac_status=$?

5718

grep -v '^ *+' conftest.er1 >conftest.err

5719

rm -f conftest.er1

5720

cat conftest.err >&5

5721

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5722

(exit $ac_status); } &&

5723

{ ac_try='test -z "$ac_c_werror_flag"

5724

|| test ! -s conftest.err'

5725

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5726

(eval $ac_try) 2>&5

5727

ac_status=$?

5728

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5729

(exit $ac_status); }; } &&

5730

{ ac_try='test -s conftest$ac_exeext'

5731

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5732

(eval $ac_try) 2>&5

5733

ac_status=$?

5734

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5735

(exit $ac_status); }; }; then

5736

ac_cv_lib_rpcsvc_getrpcport=yes

5737

else

5738

echo "$as_me: failed program was:" >&5

5739

sed 's/^/| /' conftest.$ac_ext >&5

5740

5741

ac_cv_lib_rpcsvc_getrpcport=no

5742

5743

rm -f conftest.err conftest.$ac_objext \

5744

conftest$ac_exeext conftest.$ac_ext

5745

LIBS=$ac_check_lib_save_LIBS

5746

5747

echo "$as_me:$LINENO: result: $ac_cv_lib_rpcsvc_getrpcport" >&5

5748

echo "${ECHO_T}$ac_cv_lib_rpcsvc_getrpcport" >&6

5749

if test $ac_cv_lib_rpcsvc_getrpcport = yes; then

5750

ac_cv_func_getrpcport=yes; LIBS="-lrpcsvc $LIBS"

5751

5752

5753

5754

5755

5756

echo "$as_me:$LINENO: checking for gethostbyname in -lnsl" >&5

5757

echo $ECHO_N "checking for gethostbyname in -lnsl... $ECHO_C" >&6

5758

if test "${ac_cv_lib_nsl_gethostbyname+set}" = set; then

5759

echo $ECHO_N "(cached) $ECHO_C" >&6

5760

else

5761

ac_check_lib_save_LIBS=$LIBS

5762

LIBS="-lnsl $LIBS"

5763

cat >conftest.$ac_ext <<_ACEOF

5764

/* confdefs.h. */

5765

_ACEOF

5766

cat confdefs.h >>conftest.$ac_ext

5767

cat >>conftest.$ac_ext <<_ACEOF

5768

/* end confdefs.h. */

5769

5770

/* Override any gcc2 internal prototype to avoid an error. */

5771

#ifdef __cplusplus

5772

extern "C"

5773

#endif

5774

/* We use char because int might match the return type of a gcc2

5775

builtin and then its argument prototype would still apply. */

5776

char gethostbyname ();

5777

int

5778

main ()

5779

{

5780

gethostbyname ();

5781

;

5782

return 0;

5783

}

5784

_ACEOF

5785

rm -f conftest.$ac_objext conftest$ac_exeext

5786

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

5787

(eval $ac_link) 2>conftest.er1

5788

ac_status=$?

5789

grep -v '^ *+' conftest.er1 >conftest.err

5790

rm -f conftest.er1

5791

cat conftest.err >&5

5792

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5793

(exit $ac_status); } &&

5794

{ ac_try='test -z "$ac_c_werror_flag"

5795

|| test ! -s conftest.err'

5796

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5797

(eval $ac_try) 2>&5

5798

ac_status=$?

5799

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5800

(exit $ac_status); }; } &&

5801

{ ac_try='test -s conftest$ac_exeext'

5802

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5803

(eval $ac_try) 2>&5

5804

ac_status=$?

5805

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5806

(exit $ac_status); }; }; then

5807

ac_cv_lib_nsl_gethostbyname=yes

5808

else

5809

echo "$as_me: failed program was:" >&5

5810

sed 's/^/| /' conftest.$ac_ext >&5

5811

5812

ac_cv_lib_nsl_gethostbyname=no

5813

5814

rm -f conftest.err conftest.$ac_objext \

5815

conftest$ac_exeext conftest.$ac_ext

5816

LIBS=$ac_check_lib_save_LIBS

5817

5818

echo "$as_me:$LINENO: result: $ac_cv_lib_nsl_gethostbyname" >&5

5819

echo "${ECHO_T}$ac_cv_lib_nsl_gethostbyname" >&6

5820

if test $ac_cv_lib_nsl_gethostbyname = yes; then

5821

cat >>confdefs.h <<_ACEOF

5822

#define HAVE_LIBNSL 1

5823

_ACEOF

5824

5825

LIBS="-lnsl $LIBS"

5826

5827

5828

5829

5830

echo "$as_me:$LINENO: checking for socket in -lsocket" >&5

5831

echo $ECHO_N "checking for socket in -lsocket... $ECHO_C" >&6

5832

if test "${ac_cv_lib_socket_socket+set}" = set; then

5833

echo $ECHO_N "(cached) $ECHO_C" >&6

5834

else

5835

ac_check_lib_save_LIBS=$LIBS

5836

LIBS="-lsocket $LIBS"

5837

cat >conftest.$ac_ext <<_ACEOF

5838

/* confdefs.h. */

5839

_ACEOF

5840

cat confdefs.h >>conftest.$ac_ext

5841

cat >>conftest.$ac_ext <<_ACEOF

5842

/* end confdefs.h. */

5843

5844

/* Override any gcc2 internal prototype to avoid an error. */

5845

#ifdef __cplusplus

5846

extern "C"

5847

#endif

5848

/* We use char because int might match the return type of a gcc2

5849

builtin and then its argument prototype would still apply. */

5850

char socket ();

5851

int

5852

main ()

5853

{

5854

socket ();

5855

;

5856

return 0;

5857

}

5858

_ACEOF

5859

rm -f conftest.$ac_objext conftest$ac_exeext

5860

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

5861

(eval $ac_link) 2>conftest.er1

5862

ac_status=$?

5863

grep -v '^ *+' conftest.er1 >conftest.err

5864

rm -f conftest.er1

5865

cat conftest.err >&5

5866

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5867

(exit $ac_status); } &&

5868

{ ac_try='test -z "$ac_c_werror_flag"

5869

|| test ! -s conftest.err'

5870

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5871

(eval $ac_try) 2>&5

5872

ac_status=$?

5873

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5874

(exit $ac_status); }; } &&

5875

{ ac_try='test -s conftest$ac_exeext'

5876

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5877

(eval $ac_try) 2>&5

5878

ac_status=$?

5879

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5880

(exit $ac_status); }; }; then

5881

ac_cv_lib_socket_socket=yes

5882

else

5883

echo "$as_me: failed program was:" >&5

5884

sed 's/^/| /' conftest.$ac_ext >&5

5885

5886

ac_cv_lib_socket_socket=no

5887

5888

rm -f conftest.err conftest.$ac_objext \

5889

conftest$ac_exeext conftest.$ac_ext

5890

LIBS=$ac_check_lib_save_LIBS

5891

5892

echo "$as_me:$LINENO: result: $ac_cv_lib_socket_socket" >&5

5893

echo "${ECHO_T}$ac_cv_lib_socket_socket" >&6

5894

if test $ac_cv_lib_socket_socket = yes; then

5895

cat >>confdefs.h <<_ACEOF

5896

#define HAVE_LIBSOCKET 1

5897

_ACEOF

5898

5899

LIBS="-lsocket $LIBS"

5900

5901

5902

5903

echo "$as_me:$LINENO: checking for res_gethostbyname in -lresolv" >&5

5904

echo $ECHO_N "checking for res_gethostbyname in -lresolv... $ECHO_C" >&6

5905

if test "${ac_cv_lib_resolv_res_gethostbyname+set}" = set; then

5906

echo $ECHO_N "(cached) $ECHO_C" >&6

5907

else

5908

ac_check_lib_save_LIBS=$LIBS

5909

LIBS="-lresolv $LIBS"

5910

cat >conftest.$ac_ext <<_ACEOF

5911

/* confdefs.h. */

5912

_ACEOF

5913

cat confdefs.h >>conftest.$ac_ext

5914

cat >>conftest.$ac_ext <<_ACEOF

5915

/* end confdefs.h. */

5916

5917

/* Override any gcc2 internal prototype to avoid an error. */

5918

#ifdef __cplusplus

5919

extern "C"

5920

#endif

5921

/* We use char because int might match the return type of a gcc2

5922

builtin and then its argument prototype would still apply. */

5923

char res_gethostbyname ();

5924

int

5925

main ()

5926

{

5927

res_gethostbyname ();

5928

;

5929

return 0;

5930

}

5931

_ACEOF

5932

rm -f conftest.$ac_objext conftest$ac_exeext

5933

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

5934

(eval $ac_link) 2>conftest.er1

5935

ac_status=$?

5936

grep -v '^ *+' conftest.er1 >conftest.err

5937

rm -f conftest.er1

5938

cat conftest.err >&5

5939

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5940

(exit $ac_status); } &&

5941

{ ac_try='test -z "$ac_c_werror_flag"

5942

|| test ! -s conftest.err'

5943

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5944

(eval $ac_try) 2>&5

5945

ac_status=$?

5946

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5947

(exit $ac_status); }; } &&

5948

{ ac_try='test -s conftest$ac_exeext'

5949

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

5950

(eval $ac_try) 2>&5

5951

ac_status=$?

5952

echo "$as_me:$LINENO: \$? = $ac_status" >&5

5953

(exit $ac_status); }; }; then

5954

ac_cv_lib_resolv_res_gethostbyname=yes

5955

else

5956

echo "$as_me: failed program was:" >&5

5957

sed 's/^/| /' conftest.$ac_ext >&5

5958

5959

ac_cv_lib_resolv_res_gethostbyname=no

5960

5961

rm -f conftest.err conftest.$ac_objext \

5962

conftest$ac_exeext conftest.$ac_ext

5963

LIBS=$ac_check_lib_save_LIBS

5964

5965

echo "$as_me:$LINENO: result: $ac_cv_lib_resolv_res_gethostbyname" >&5

5966

echo "${ECHO_T}$ac_cv_lib_resolv_res_gethostbyname" >&6

5967

if test $ac_cv_lib_resolv_res_gethostbyname = yes; then

5968

RESOLV="-lresolv"

5969

else

5970

RESOLV=""

5971

5972

5973

if test x$RESOLV != x

5974

then

5975

5976

cat >>confdefs.h <<\_ACEOF

5977

#define HAVE_RES_GETHOSTBYNAME 1

5978

_ACEOF

5979

5980

else

5981

echo "$as_me:$LINENO: checking for gethostbyname in -lresolv+" >&5

5982

echo $ECHO_N "checking for gethostbyname in -lresolv+... $ECHO_C" >&6

5983

if test "${ac_cv_lib_resolvp_gethostbyname+set}" = set; then

5984

echo $ECHO_N "(cached) $ECHO_C" >&6

5985

else

5986

ac_check_lib_save_LIBS=$LIBS

5987

LIBS="-lresolv+ $LIBS"

5988

cat >conftest.$ac_ext <<_ACEOF

5989

/* confdefs.h. */

5990

_ACEOF

5991

cat confdefs.h >>conftest.$ac_ext

5992

cat >>conftest.$ac_ext <<_ACEOF

5993

/* end confdefs.h. */

5994

5995

/* Override any gcc2 internal prototype to avoid an error. */

5996

#ifdef __cplusplus

5997

extern "C"

5998

#endif

5999

/* We use char because int might match the return type of a gcc2

6000

builtin and then its argument prototype would still apply. */

6001

char gethostbyname ();

6002

int

6003

main ()

6004

{

6005

gethostbyname ();

6006

;

6007

return 0;

6008

}

6009

_ACEOF

6010

rm -f conftest.$ac_objext conftest$ac_exeext

6011

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

6012

(eval $ac_link) 2>conftest.er1

6013

ac_status=$?

6014

grep -v '^ *+' conftest.er1 >conftest.err

6015

rm -f conftest.er1

6016

cat conftest.err >&5

6017

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6018

(exit $ac_status); } &&

6019

{ ac_try='test -z "$ac_c_werror_flag"

6020

|| test ! -s conftest.err'

6021

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6022

(eval $ac_try) 2>&5

6023

ac_status=$?

6024

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6025

(exit $ac_status); }; } &&

6026

{ ac_try='test -s conftest$ac_exeext'

6027

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6028

(eval $ac_try) 2>&5

6029

ac_status=$?

6030

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6031

(exit $ac_status); }; }; then

6032

ac_cv_lib_resolvp_gethostbyname=yes

6033

else

6034

echo "$as_me: failed program was:" >&5

6035

sed 's/^/| /' conftest.$ac_ext >&5

6036

6037

ac_cv_lib_resolvp_gethostbyname=no

6038

6039

rm -f conftest.err conftest.$ac_objext \

6040

conftest$ac_exeext conftest.$ac_ext

6041

LIBS=$ac_check_lib_save_LIBS

6042

6043

echo "$as_me:$LINENO: result: $ac_cv_lib_resolvp_gethostbyname" >&5

6044

echo "${ECHO_T}$ac_cv_lib_resolvp_gethostbyname" >&6

6045

if test $ac_cv_lib_resolvp_gethostbyname = yes; then

6046

RESOLV="-lresolv+"

6047

else

6048

RESOLV=""

6049

6050

6051

6052

6053

6054

6055

6056

6057

6058

6059

ac_header_dirent=no

6060

for ac_hdr in dirent.h sys/ndir.h sys/dir.h ndir.h; do

6061

as_ac_Header=`echo "ac_cv_header_dirent_$ac_hdr" | $as_tr_sh`

6062

echo "$as_me:$LINENO: checking for $ac_hdr that defines DIR" >&5

6063

echo $ECHO_N "checking for $ac_hdr that defines DIR... $ECHO_C" >&6

6064

if eval "test \"\${$as_ac_Header+set}\" = set"; then

6065

echo $ECHO_N "(cached) $ECHO_C" >&6

6066

else

6067

cat >conftest.$ac_ext <<_ACEOF

6068

/* confdefs.h. */

6069

_ACEOF

6070

cat confdefs.h >>conftest.$ac_ext

6071

cat >>conftest.$ac_ext <<_ACEOF

6072

/* end confdefs.h. */

6073

#include <sys/types.h>

6074

#include <$ac_hdr>

6075

6076

int

6077

main ()

6078

{

6079

if ((DIR *) 0)

6080

return 0;

6081

;

6082

return 0;

6083

}

6084

_ACEOF

6085

rm -f conftest.$ac_objext

6086

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

6087

(eval $ac_compile) 2>conftest.er1

6088

ac_status=$?

6089

grep -v '^ *+' conftest.er1 >conftest.err

6090

rm -f conftest.er1

6091

cat conftest.err >&5

6092

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6093

(exit $ac_status); } &&

6094

{ ac_try='test -z "$ac_c_werror_flag"

6095

|| test ! -s conftest.err'

6096

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6097

(eval $ac_try) 2>&5

6098

ac_status=$?

6099

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6100

(exit $ac_status); }; } &&

6101

{ ac_try='test -s conftest.$ac_objext'

6102

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6103

(eval $ac_try) 2>&5

6104

ac_status=$?

6105

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6106

(exit $ac_status); }; }; then

6107

eval "$as_ac_Header=yes"

6108

else

6109

echo "$as_me: failed program was:" >&5

6110

sed 's/^/| /' conftest.$ac_ext >&5

6111

6112

eval "$as_ac_Header=no"

6113

6114

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

6115

6116

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

6117

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

6118

if test `eval echo '${'$as_ac_Header'}'` = yes; then

6119

cat >>confdefs.h <<_ACEOF

6120

#define `echo "HAVE_$ac_hdr" | $as_tr_cpp` 1

6121

_ACEOF

6122

6123

ac_header_dirent=$ac_hdr; break

6124

6125

6126

done

6127

# Two versions of opendir et al. are in -ldir and -lx on SCO Xenix.

6128

if test $ac_header_dirent = dirent.h; then

6129

echo "$as_me:$LINENO: checking for library containing opendir" >&5

6130

echo $ECHO_N "checking for library containing opendir... $ECHO_C" >&6

6131

if test "${ac_cv_search_opendir+set}" = set; then

6132

echo $ECHO_N "(cached) $ECHO_C" >&6

6133

else

6134

ac_func_search_save_LIBS=$LIBS

6135

ac_cv_search_opendir=no

6136

cat >conftest.$ac_ext <<_ACEOF

6137

/* confdefs.h. */

6138

_ACEOF

6139

cat confdefs.h >>conftest.$ac_ext

6140

cat >>conftest.$ac_ext <<_ACEOF

6141

/* end confdefs.h. */

6142

6143

/* Override any gcc2 internal prototype to avoid an error. */

6144

#ifdef __cplusplus

6145

extern "C"

6146

#endif

6147

/* We use char because int might match the return type of a gcc2

6148

builtin and then its argument prototype would still apply. */

6149

char opendir ();

6150

int

6151

main ()

6152

{

6153

opendir ();

6154

;

6155

return 0;

6156

}

6157

_ACEOF

6158

rm -f conftest.$ac_objext conftest$ac_exeext

6159

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

6160

(eval $ac_link) 2>conftest.er1

6161

ac_status=$?

6162

grep -v '^ *+' conftest.er1 >conftest.err

6163

rm -f conftest.er1

6164

cat conftest.err >&5

6165

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6166

(exit $ac_status); } &&

6167

{ ac_try='test -z "$ac_c_werror_flag"

6168

|| test ! -s conftest.err'

6169

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6170

(eval $ac_try) 2>&5

6171

ac_status=$?

6172

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6173

(exit $ac_status); }; } &&

6174

{ ac_try='test -s conftest$ac_exeext'

6175

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6176

(eval $ac_try) 2>&5

6177

ac_status=$?

6178

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6179

(exit $ac_status); }; }; then

6180

ac_cv_search_opendir="none required"

6181

else

6182

echo "$as_me: failed program was:" >&5

6183

sed 's/^/| /' conftest.$ac_ext >&5

6184

6185

6186

rm -f conftest.err conftest.$ac_objext \

6187

conftest$ac_exeext conftest.$ac_ext

6188

if test "$ac_cv_search_opendir" = no; then

6189

for ac_lib in dir; do

6190

LIBS="-l$ac_lib $ac_func_search_save_LIBS"

6191

cat >conftest.$ac_ext <<_ACEOF

6192

/* confdefs.h. */

6193

_ACEOF

6194

cat confdefs.h >>conftest.$ac_ext

6195

cat >>conftest.$ac_ext <<_ACEOF

6196

/* end confdefs.h. */

6197

6198

/* Override any gcc2 internal prototype to avoid an error. */

6199

#ifdef __cplusplus

6200

extern "C"

6201

#endif

6202

/* We use char because int might match the return type of a gcc2

6203

builtin and then its argument prototype would still apply. */

6204

char opendir ();

6205

int

6206

main ()

6207

{

6208

opendir ();

6209

;

6210

return 0;

6211

}

6212

_ACEOF

6213

rm -f conftest.$ac_objext conftest$ac_exeext

6214

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

6215

(eval $ac_link) 2>conftest.er1

6216

ac_status=$?

6217

grep -v '^ *+' conftest.er1 >conftest.err

6218

rm -f conftest.er1

6219

cat conftest.err >&5

6220

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6221

(exit $ac_status); } &&

6222

{ ac_try='test -z "$ac_c_werror_flag"

6223

|| test ! -s conftest.err'

6224

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6225

(eval $ac_try) 2>&5

6226

ac_status=$?

6227

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6228

(exit $ac_status); }; } &&

6229

{ ac_try='test -s conftest$ac_exeext'

6230

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6231

(eval $ac_try) 2>&5

6232

ac_status=$?

6233

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6234

(exit $ac_status); }; }; then

6235

ac_cv_search_opendir="-l$ac_lib"

6236

break

6237

else

6238

echo "$as_me: failed program was:" >&5

6239

sed 's/^/| /' conftest.$ac_ext >&5

6240

6241

6242

rm -f conftest.err conftest.$ac_objext \

6243

conftest$ac_exeext conftest.$ac_ext

6244

done

6245

6246

LIBS=$ac_func_search_save_LIBS

6247

6248

echo "$as_me:$LINENO: result: $ac_cv_search_opendir" >&5

6249

echo "${ECHO_T}$ac_cv_search_opendir" >&6

6250

if test "$ac_cv_search_opendir" != no; then

6251

test "$ac_cv_search_opendir" = "none required" || LIBS="$ac_cv_search_opendir $LIBS"

6252

6253

6254

6255

else

6256

echo "$as_me:$LINENO: checking for library containing opendir" >&5

6257

echo $ECHO_N "checking for library containing opendir... $ECHO_C" >&6

6258

if test "${ac_cv_search_opendir+set}" = set; then

6259

echo $ECHO_N "(cached) $ECHO_C" >&6

6260

else

6261

ac_func_search_save_LIBS=$LIBS

6262

ac_cv_search_opendir=no

6263

cat >conftest.$ac_ext <<_ACEOF

6264

/* confdefs.h. */

6265

_ACEOF

6266

cat confdefs.h >>conftest.$ac_ext

6267

cat >>conftest.$ac_ext <<_ACEOF

6268

/* end confdefs.h. */

6269

6270

/* Override any gcc2 internal prototype to avoid an error. */

6271

#ifdef __cplusplus

6272

extern "C"

6273

#endif

6274

/* We use char because int might match the return type of a gcc2

6275

builtin and then its argument prototype would still apply. */

6276

char opendir ();

6277

int

6278

main ()

6279

{

6280

opendir ();

6281

;

6282

return 0;

6283

}

6284

_ACEOF

6285

rm -f conftest.$ac_objext conftest$ac_exeext

6286

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

6287

(eval $ac_link) 2>conftest.er1

6288

ac_status=$?

6289

grep -v '^ *+' conftest.er1 >conftest.err

6290

rm -f conftest.er1

6291

cat conftest.err >&5

6292

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6293

(exit $ac_status); } &&

6294

{ ac_try='test -z "$ac_c_werror_flag"

6295

|| test ! -s conftest.err'

6296

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6297

(eval $ac_try) 2>&5

6298

ac_status=$?

6299

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6300

(exit $ac_status); }; } &&

6301

{ ac_try='test -s conftest$ac_exeext'

6302

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6303

(eval $ac_try) 2>&5

6304

ac_status=$?

6305

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6306

(exit $ac_status); }; }; then

6307

ac_cv_search_opendir="none required"

6308

else

6309

echo "$as_me: failed program was:" >&5

6310

sed 's/^/| /' conftest.$ac_ext >&5

6311

6312

6313

rm -f conftest.err conftest.$ac_objext \

6314

conftest$ac_exeext conftest.$ac_ext

6315

if test "$ac_cv_search_opendir" = no; then

6316

for ac_lib in x; do

6317

LIBS="-l$ac_lib $ac_func_search_save_LIBS"

6318

cat >conftest.$ac_ext <<_ACEOF

6319

/* confdefs.h. */

6320

_ACEOF

6321

cat confdefs.h >>conftest.$ac_ext

6322

cat >>conftest.$ac_ext <<_ACEOF

6323

/* end confdefs.h. */

6324

6325

/* Override any gcc2 internal prototype to avoid an error. */

6326

#ifdef __cplusplus

6327

extern "C"

6328

#endif

6329

/* We use char because int might match the return type of a gcc2

6330

builtin and then its argument prototype would still apply. */

6331

char opendir ();

6332

int

6333

main ()

6334

{

6335

opendir ();

6336

;

6337

return 0;

6338

}

6339

_ACEOF

6340

rm -f conftest.$ac_objext conftest$ac_exeext

6341

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

6342

(eval $ac_link) 2>conftest.er1

6343

ac_status=$?

6344

grep -v '^ *+' conftest.er1 >conftest.err

6345

rm -f conftest.er1

6346

cat conftest.err >&5

6347

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6348

(exit $ac_status); } &&

6349

{ ac_try='test -z "$ac_c_werror_flag"

6350

|| test ! -s conftest.err'

6351

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6352

(eval $ac_try) 2>&5

6353

ac_status=$?

6354

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6355

(exit $ac_status); }; } &&

6356

{ ac_try='test -s conftest$ac_exeext'

6357

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6358

(eval $ac_try) 2>&5

6359

ac_status=$?

6360

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6361

(exit $ac_status); }; }; then

6362

ac_cv_search_opendir="-l$ac_lib"

6363

break

6364

else

6365

echo "$as_me: failed program was:" >&5

6366

sed 's/^/| /' conftest.$ac_ext >&5

6367

6368

6369

rm -f conftest.err conftest.$ac_objext \

6370

conftest$ac_exeext conftest.$ac_ext

6371

done

6372

6373

LIBS=$ac_func_search_save_LIBS

6374

6375

echo "$as_me:$LINENO: result: $ac_cv_search_opendir" >&5

6376

echo "${ECHO_T}$ac_cv_search_opendir" >&6

6377

if test "$ac_cv_search_opendir" != no; then

6378

test "$ac_cv_search_opendir" = "none required" || LIBS="$ac_cv_search_opendir $LIBS"

6379

6380

6381

6382

6383

6384

echo "$as_me:$LINENO: checking for ANSI C header files" >&5

6385

echo $ECHO_N "checking for ANSI C header files... $ECHO_C" >&6

6386

if test "${ac_cv_header_stdc+set}" = set; then

6387

echo $ECHO_N "(cached) $ECHO_C" >&6

6388

else

6389

cat >conftest.$ac_ext <<_ACEOF

6390

/* confdefs.h. */

6391

_ACEOF

6392

cat confdefs.h >>conftest.$ac_ext

6393

cat >>conftest.$ac_ext <<_ACEOF

6394

/* end confdefs.h. */

6395

#include <stdlib.h>

6396

#include <stdarg.h>

6397

#include <string.h>

6398

#include <float.h>

6399

6400

int

6401

main ()

6402

{

6403

6404

;

6405

return 0;

6406

}

6407

_ACEOF

6408

rm -f conftest.$ac_objext

6409

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

6410

(eval $ac_compile) 2>conftest.er1

6411

ac_status=$?

6412

grep -v '^ *+' conftest.er1 >conftest.err

6413

rm -f conftest.er1

6414

cat conftest.err >&5

6415

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6416

(exit $ac_status); } &&

6417

{ ac_try='test -z "$ac_c_werror_flag"

6418

|| test ! -s conftest.err'

6419

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6420

(eval $ac_try) 2>&5

6421

ac_status=$?

6422

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6423

(exit $ac_status); }; } &&

6424

{ ac_try='test -s conftest.$ac_objext'

6425

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6426

(eval $ac_try) 2>&5

6427

ac_status=$?

6428

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6429

(exit $ac_status); }; }; then

6430

ac_cv_header_stdc=yes

6431

else

6432

echo "$as_me: failed program was:" >&5

6433

sed 's/^/| /' conftest.$ac_ext >&5

6434

6435

ac_cv_header_stdc=no

6436

6437

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

6438

6439

if test $ac_cv_header_stdc = yes; then

6440

# SunOS 4.x string.h does not declare mem*, contrary to ANSI.

6441

cat >conftest.$ac_ext <<_ACEOF

6442

/* confdefs.h. */

6443

_ACEOF

6444

cat confdefs.h >>conftest.$ac_ext

6445

cat >>conftest.$ac_ext <<_ACEOF

6446

/* end confdefs.h. */

6447

#include <string.h>

6448

6449

_ACEOF

6450

if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

6451

$EGREP "memchr" >/dev/null 2>&1; then

6452

6453

else

6454

ac_cv_header_stdc=no

6455

6456

rm -f conftest*

6457

6458

6459

6460

if test $ac_cv_header_stdc = yes; then

6461

# ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.

6462

cat >conftest.$ac_ext <<_ACEOF

6463

/* confdefs.h. */

6464

_ACEOF

6465

cat confdefs.h >>conftest.$ac_ext

6466

cat >>conftest.$ac_ext <<_ACEOF

6467

/* end confdefs.h. */

6468

#include <stdlib.h>

6469

6470

_ACEOF

6471

if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

6472

$EGREP "free" >/dev/null 2>&1; then

6473

6474

else

6475

ac_cv_header_stdc=no

6476

6477

rm -f conftest*

6478

6479

6480

6481

if test $ac_cv_header_stdc = yes; then

6482

# /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.

6483

if test "$cross_compiling" = yes; then

6484

6485

else

6486

cat >conftest.$ac_ext <<_ACEOF

6487

/* confdefs.h. */

6488

_ACEOF

6489

cat confdefs.h >>conftest.$ac_ext

6490

cat >>conftest.$ac_ext <<_ACEOF

6491

/* end confdefs.h. */

6492

#include <ctype.h>

6493

#if ((' ' & 0x0FF) == 0x020)

6494

# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')

6495

# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))

6496

#else

6497

# define ISLOWER(c) \

6498

(('a' <= (c) && (c) <= 'i') \

6499

|| ('j' <= (c) && (c) <= 'r') \

6500

|| ('s' <= (c) && (c) <= 'z'))

6501

# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))

6502

#endif

6503

6504

#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))

6505

int

6506

main ()

6507

{

6508

int i;

6509

for (i = 0; i < 256; i++)

6510

if (XOR (islower (i), ISLOWER (i))

6511

|| toupper (i) != TOUPPER (i))

6512

exit(2);

6513

exit (0);

6514

}

6515

_ACEOF

6516

rm -f conftest$ac_exeext

6517

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

6518

(eval $ac_link) 2>&5

6519

ac_status=$?

6520

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6521

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

6522

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6523

(eval $ac_try) 2>&5

6524

ac_status=$?

6525

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6526

(exit $ac_status); }; }; then

6527

6528

else

6529

echo "$as_me: program exited with status $ac_status" >&5

6530

echo "$as_me: failed program was:" >&5

6531

sed 's/^/| /' conftest.$ac_ext >&5

6532

6533

( exit $ac_status )

6534

ac_cv_header_stdc=no

6535

6536

rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

6537

6538

6539

6540

echo "$as_me:$LINENO: result: $ac_cv_header_stdc" >&5

6541

echo "${ECHO_T}$ac_cv_header_stdc" >&6

6542

if test $ac_cv_header_stdc = yes; then

6543

6544

cat >>confdefs.h <<\_ACEOF

6545

#define STDC_HEADERS 1

6546

_ACEOF

6547

6548

6549

6550

echo "$as_me:$LINENO: checking for sys/wait.h that is POSIX.1 compatible" >&5

6551

echo $ECHO_N "checking for sys/wait.h that is POSIX.1 compatible... $ECHO_C" >&6

6552

if test "${ac_cv_header_sys_wait_h+set}" = set; then

6553

echo $ECHO_N "(cached) $ECHO_C" >&6

6554

else

6555

cat >conftest.$ac_ext <<_ACEOF

6556

/* confdefs.h. */

6557

_ACEOF

6558

cat confdefs.h >>conftest.$ac_ext

6559

cat >>conftest.$ac_ext <<_ACEOF

6560

/* end confdefs.h. */

6561

#include <sys/types.h>

6562

#include <sys/wait.h>

6563

#ifndef WEXITSTATUS

6564

# define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)

6565

#endif

6566

#ifndef WIFEXITED

6567

# define WIFEXITED(stat_val) (((stat_val) & 255) == 0)

6568

#endif

6569

6570

int

6571

main ()

6572

{

6573

int s;

6574

wait (&s);

6575

s = WIFEXITED (s) ? WEXITSTATUS (s) : 1;

6576

;

6577

return 0;

6578

}

6579

_ACEOF

6580

rm -f conftest.$ac_objext

6581

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

6582

(eval $ac_compile) 2>conftest.er1

6583

ac_status=$?

6584

grep -v '^ *+' conftest.er1 >conftest.err

6585

rm -f conftest.er1

6586

cat conftest.err >&5

6587

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6588

(exit $ac_status); } &&

6589

{ ac_try='test -z "$ac_c_werror_flag"

6590

|| test ! -s conftest.err'

6591

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6592

(eval $ac_try) 2>&5

6593

ac_status=$?

6594

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6595

(exit $ac_status); }; } &&

6596

{ ac_try='test -s conftest.$ac_objext'

6597

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6598

(eval $ac_try) 2>&5

6599

ac_status=$?

6600

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6601

(exit $ac_status); }; }; then

6602

ac_cv_header_sys_wait_h=yes

6603

else

6604

echo "$as_me: failed program was:" >&5

6605

sed 's/^/| /' conftest.$ac_ext >&5

6606

6607

ac_cv_header_sys_wait_h=no

6608

6609

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

6610

6611

echo "$as_me:$LINENO: result: $ac_cv_header_sys_wait_h" >&5

6612

echo "${ECHO_T}$ac_cv_header_sys_wait_h" >&6

6613

if test $ac_cv_header_sys_wait_h = yes; then

6614

6615

cat >>confdefs.h <<\_ACEOF

6616

#define HAVE_SYS_WAIT_H 1

6617

_ACEOF

6618

6619

6620

6621

6622

6623

6624

6625

6626

6627

for ac_header in fcntl.h paths.h sys/file.h sys/time.h syslog.h unistd.h

6628

6629

as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

6630

if eval "test \"\${$as_ac_Header+set}\" = set"; then

6631

echo "$as_me:$LINENO: checking for $ac_header" >&5

6632

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

6633

if eval "test \"\${$as_ac_Header+set}\" = set"; then

6634

echo $ECHO_N "(cached) $ECHO_C" >&6

6635

6636

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

6637

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

6638

else

6639

# Is the header compilable?

6640

echo "$as_me:$LINENO: checking $ac_header usability" >&5

6641

echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

6642

cat >conftest.$ac_ext <<_ACEOF

6643

/* confdefs.h. */

6644

_ACEOF

6645

cat confdefs.h >>conftest.$ac_ext

6646

cat >>conftest.$ac_ext <<_ACEOF

6647

/* end confdefs.h. */

6648

$ac_includes_default

6649

#include <$ac_header>

6650

_ACEOF

6651

rm -f conftest.$ac_objext

6652

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

6653

(eval $ac_compile) 2>conftest.er1

6654

ac_status=$?

6655

grep -v '^ *+' conftest.er1 >conftest.err

6656

rm -f conftest.er1

6657

cat conftest.err >&5

6658

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6659

(exit $ac_status); } &&

6660

{ ac_try='test -z "$ac_c_werror_flag"

6661

|| test ! -s conftest.err'

6662

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6663

(eval $ac_try) 2>&5

6664

ac_status=$?

6665

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6666

(exit $ac_status); }; } &&

6667

{ ac_try='test -s conftest.$ac_objext'

6668

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6669

(eval $ac_try) 2>&5

6670

ac_status=$?

6671

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6672

(exit $ac_status); }; }; then

6673

ac_header_compiler=yes

6674

else

6675

echo "$as_me: failed program was:" >&5

6676

sed 's/^/| /' conftest.$ac_ext >&5

6677

6678

ac_header_compiler=no

6679

6680

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

6681

echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

6682

echo "${ECHO_T}$ac_header_compiler" >&6

6683

6684

# Is the header present?

6685

echo "$as_me:$LINENO: checking $ac_header presence" >&5

6686

echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

6687

cat >conftest.$ac_ext <<_ACEOF

6688

/* confdefs.h. */

6689

_ACEOF

6690

cat confdefs.h >>conftest.$ac_ext

6691

cat >>conftest.$ac_ext <<_ACEOF

6692

/* end confdefs.h. */

6693

#include <$ac_header>

6694

_ACEOF

6695

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

6696

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

6697

ac_status=$?

6698

grep -v '^ *+' conftest.er1 >conftest.err

6699

rm -f conftest.er1

6700

cat conftest.err >&5

6701

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6702

(exit $ac_status); } >/dev/null; then

6703

if test -s conftest.err; then

6704

ac_cpp_err=$ac_c_preproc_warn_flag

6705

ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

6706

else

6707

ac_cpp_err=

6708

6709

else

6710

ac_cpp_err=yes

6711

6712

if test -z "$ac_cpp_err"; then

6713

ac_header_preproc=yes

6714

else

6715

echo "$as_me: failed program was:" >&5

6716

sed 's/^/| /' conftest.$ac_ext >&5

6717

6718

ac_header_preproc=no

6719

6720

rm -f conftest.err conftest.$ac_ext

6721

echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

6722

echo "${ECHO_T}$ac_header_preproc" >&6

6723

6724

# So? What about this header?

6725

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in

6726

yes:no: )

6727

{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

6728

echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

6729

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5

6730

echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}

6731

ac_header_preproc=yes

6732

;;

6733

no:yes:* )

6734

{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

6735

echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

6736

{ echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5

6737

echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}

6738

{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5

6739

echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}

6740

{ echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5

6741

echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;}

6742

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

6743

echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

6744

{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5

6745

echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}

6746

(

6747

cat <<\_ASBOX

6748

## ---------------------------------- ##

6749

## Report this to kukuk@linux-nis.org ##

6750

## ---------------------------------- ##

6751

_ASBOX

6752

) |

6753

sed "s/^/$as_me: WARNING: /" >&2

6754

;;

6755

esac

6756

echo "$as_me:$LINENO: checking for $ac_header" >&5

6757

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

6758

if eval "test \"\${$as_ac_Header+set}\" = set"; then

6759

echo $ECHO_N "(cached) $ECHO_C" >&6

6760

else

6761

eval "$as_ac_Header=\$ac_header_preproc"

6762

6763

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

6764

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

6765

6766

6767

if test `eval echo '${'$as_ac_Header'}'` = yes; then

6768

cat >>confdefs.h <<_ACEOF

6769

#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

6770

_ACEOF

6771

6772

6773

6774

done

6775

6776

6777

6778

6779

6780

for ac_header in getopt.h shadow.h rpc/clnt_soc.h rpc/svc_soc.h

6781

6782

as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

6783

if eval "test \"\${$as_ac_Header+set}\" = set"; then

6784

echo "$as_me:$LINENO: checking for $ac_header" >&5

6785

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

6786

if eval "test \"\${$as_ac_Header+set}\" = set"; then

6787

echo $ECHO_N "(cached) $ECHO_C" >&6

6788

6789

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

6790

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

6791

else

6792

# Is the header compilable?

6793

echo "$as_me:$LINENO: checking $ac_header usability" >&5

6794

echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

6795

cat >conftest.$ac_ext <<_ACEOF

6796

/* confdefs.h. */

6797

_ACEOF

6798

cat confdefs.h >>conftest.$ac_ext

6799

cat >>conftest.$ac_ext <<_ACEOF

6800

/* end confdefs.h. */

6801

$ac_includes_default

6802

#include <$ac_header>

6803

_ACEOF

6804

rm -f conftest.$ac_objext

6805

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

6806

(eval $ac_compile) 2>conftest.er1

6807

ac_status=$?

6808

grep -v '^ *+' conftest.er1 >conftest.err

6809

rm -f conftest.er1

6810

cat conftest.err >&5

6811

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6812

(exit $ac_status); } &&

6813

{ ac_try='test -z "$ac_c_werror_flag"

6814

|| test ! -s conftest.err'

6815

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6816

(eval $ac_try) 2>&5

6817

ac_status=$?

6818

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6819

(exit $ac_status); }; } &&

6820

{ ac_try='test -s conftest.$ac_objext'

6821

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6822

(eval $ac_try) 2>&5

6823

ac_status=$?

6824

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6825

(exit $ac_status); }; }; then

6826

ac_header_compiler=yes

6827

else

6828

echo "$as_me: failed program was:" >&5

6829

sed 's/^/| /' conftest.$ac_ext >&5

6830

6831

ac_header_compiler=no

6832

6833

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

6834

echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

6835

echo "${ECHO_T}$ac_header_compiler" >&6

6836

6837

# Is the header present?

6838

echo "$as_me:$LINENO: checking $ac_header presence" >&5

6839

echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

6840

cat >conftest.$ac_ext <<_ACEOF

6841

/* confdefs.h. */

6842

_ACEOF

6843

cat confdefs.h >>conftest.$ac_ext

6844

cat >>conftest.$ac_ext <<_ACEOF

6845

/* end confdefs.h. */

6846

#include <$ac_header>

6847

_ACEOF

6848

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

6849

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

6850

ac_status=$?

6851

grep -v '^ *+' conftest.er1 >conftest.err

6852

rm -f conftest.er1

6853

cat conftest.err >&5

6854

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6855

(exit $ac_status); } >/dev/null; then

6856

if test -s conftest.err; then

6857

ac_cpp_err=$ac_c_preproc_warn_flag

6858

ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

6859

else

6860

ac_cpp_err=

6861

6862

else

6863

ac_cpp_err=yes

6864

6865

if test -z "$ac_cpp_err"; then

6866

ac_header_preproc=yes

6867

else

6868

echo "$as_me: failed program was:" >&5

6869

sed 's/^/| /' conftest.$ac_ext >&5

6870

6871

ac_header_preproc=no

6872

6873

rm -f conftest.err conftest.$ac_ext

6874

echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

6875

echo "${ECHO_T}$ac_header_preproc" >&6

6876

6877

# So? What about this header?

6878

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in

6879

yes:no: )

6880

{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

6881

echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

6882

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5

6883

echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}

6884

ac_header_preproc=yes

6885

;;

6886

no:yes:* )

6887

{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

6888

echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

6889

{ echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5

6890

echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}

6891

{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5

6892

echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}

6893

{ echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5

6894

echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;}

6895

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

6896

echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

6897

{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5

6898

echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}

6899

(

6900

cat <<\_ASBOX

6901

## ---------------------------------- ##

6902

## Report this to kukuk@linux-nis.org ##

6903

## ---------------------------------- ##

6904

_ASBOX

6905

) |

6906

sed "s/^/$as_me: WARNING: /" >&2

6907

;;

6908

esac

6909

echo "$as_me:$LINENO: checking for $ac_header" >&5

6910

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

6911

if eval "test \"\${$as_ac_Header+set}\" = set"; then

6912

echo $ECHO_N "(cached) $ECHO_C" >&6

6913

else

6914

eval "$as_ac_Header=\$ac_header_preproc"

6915

6916

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

6917

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

6918

6919

6920

if test `eval echo '${'$as_ac_Header'}'` = yes; then

6921

cat >>confdefs.h <<_ACEOF

6922

#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

6923

_ACEOF

6924

6925

6926

6927

done

6928

6929

6930

6931

for ac_header in netinet/in.h alloca.h

6932

6933

as_ac_Header=`echo "ac_cv_header_$ac_header" | $as_tr_sh`

6934

if eval "test \"\${$as_ac_Header+set}\" = set"; then

6935

echo "$as_me:$LINENO: checking for $ac_header" >&5

6936

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

6937

if eval "test \"\${$as_ac_Header+set}\" = set"; then

6938

echo $ECHO_N "(cached) $ECHO_C" >&6

6939

6940

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

6941

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

6942

else

6943

# Is the header compilable?

6944

echo "$as_me:$LINENO: checking $ac_header usability" >&5

6945

echo $ECHO_N "checking $ac_header usability... $ECHO_C" >&6

6946

cat >conftest.$ac_ext <<_ACEOF

6947

/* confdefs.h. */

6948

_ACEOF

6949

cat confdefs.h >>conftest.$ac_ext

6950

cat >>conftest.$ac_ext <<_ACEOF

6951

/* end confdefs.h. */

6952

$ac_includes_default

6953

#include <$ac_header>

6954

_ACEOF

6955

rm -f conftest.$ac_objext

6956

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

6957

(eval $ac_compile) 2>conftest.er1

6958

ac_status=$?

6959

grep -v '^ *+' conftest.er1 >conftest.err

6960

rm -f conftest.er1

6961

cat conftest.err >&5

6962

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6963

(exit $ac_status); } &&

6964

{ ac_try='test -z "$ac_c_werror_flag"

6965

|| test ! -s conftest.err'

6966

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6967

(eval $ac_try) 2>&5

6968

ac_status=$?

6969

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6970

(exit $ac_status); }; } &&

6971

{ ac_try='test -s conftest.$ac_objext'

6972

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

6973

(eval $ac_try) 2>&5

6974

ac_status=$?

6975

echo "$as_me:$LINENO: \$? = $ac_status" >&5

6976

(exit $ac_status); }; }; then

6977

ac_header_compiler=yes

6978

else

6979

echo "$as_me: failed program was:" >&5

6980

sed 's/^/| /' conftest.$ac_ext >&5

6981

6982

ac_header_compiler=no

6983

6984

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

6985

echo "$as_me:$LINENO: result: $ac_header_compiler" >&5

6986

echo "${ECHO_T}$ac_header_compiler" >&6

6987

6988

# Is the header present?

6989

echo "$as_me:$LINENO: checking $ac_header presence" >&5

6990

echo $ECHO_N "checking $ac_header presence... $ECHO_C" >&6

6991

cat >conftest.$ac_ext <<_ACEOF

6992

/* confdefs.h. */

6993

_ACEOF

6994

cat confdefs.h >>conftest.$ac_ext

6995

cat >>conftest.$ac_ext <<_ACEOF

6996

/* end confdefs.h. */

6997

#include <$ac_header>

6998

_ACEOF

6999

if { (eval echo "$as_me:$LINENO: \"$ac_cpp conftest.$ac_ext\"") >&5

7000

(eval $ac_cpp conftest.$ac_ext) 2>conftest.er1

7001

ac_status=$?

7002

grep -v '^ *+' conftest.er1 >conftest.err

7003

rm -f conftest.er1

7004

cat conftest.err >&5

7005

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7006

(exit $ac_status); } >/dev/null; then

7007

if test -s conftest.err; then

7008

ac_cpp_err=$ac_c_preproc_warn_flag

7009

ac_cpp_err=$ac_cpp_err$ac_c_werror_flag

7010

else

7011

ac_cpp_err=

7012

7013

else

7014

ac_cpp_err=yes

7015

7016

if test -z "$ac_cpp_err"; then

7017

ac_header_preproc=yes

7018

else

7019

echo "$as_me: failed program was:" >&5

7020

sed 's/^/| /' conftest.$ac_ext >&5

7021

7022

ac_header_preproc=no

7023

7024

rm -f conftest.err conftest.$ac_ext

7025

echo "$as_me:$LINENO: result: $ac_header_preproc" >&5

7026

echo "${ECHO_T}$ac_header_preproc" >&6

7027

7028

# So? What about this header?

7029

case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in

7030

yes:no: )

7031

{ echo "$as_me:$LINENO: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&5

7032

echo "$as_me: WARNING: $ac_header: accepted by the compiler, rejected by the preprocessor!" >&2;}

7033

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the compiler's result" >&5

7034

echo "$as_me: WARNING: $ac_header: proceeding with the compiler's result" >&2;}

7035

ac_header_preproc=yes

7036

;;

7037

no:yes:* )

7038

{ echo "$as_me:$LINENO: WARNING: $ac_header: present but cannot be compiled" >&5

7039

echo "$as_me: WARNING: $ac_header: present but cannot be compiled" >&2;}

7040

{ echo "$as_me:$LINENO: WARNING: $ac_header: check for missing prerequisite headers?" >&5

7041

echo "$as_me: WARNING: $ac_header: check for missing prerequisite headers?" >&2;}

7042

{ echo "$as_me:$LINENO: WARNING: $ac_header: see the Autoconf documentation" >&5

7043

echo "$as_me: WARNING: $ac_header: see the Autoconf documentation" >&2;}

7044

{ echo "$as_me:$LINENO: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&5

7045

echo "$as_me: WARNING: $ac_header: section \"Present But Cannot Be Compiled\"" >&2;}

7046

{ echo "$as_me:$LINENO: WARNING: $ac_header: proceeding with the preprocessor's result" >&5

7047

echo "$as_me: WARNING: $ac_header: proceeding with the preprocessor's result" >&2;}

7048

{ echo "$as_me:$LINENO: WARNING: $ac_header: in the future, the compiler will take precedence" >&5

7049

echo "$as_me: WARNING: $ac_header: in the future, the compiler will take precedence" >&2;}

7050

(

7051

cat <<\_ASBOX

7052

## ---------------------------------- ##

7053

## Report this to kukuk@linux-nis.org ##

7054

## ---------------------------------- ##

7055

_ASBOX

7056

) |

7057

sed "s/^/$as_me: WARNING: /" >&2

7058

;;

7059

esac

7060

echo "$as_me:$LINENO: checking for $ac_header" >&5

7061

echo $ECHO_N "checking for $ac_header... $ECHO_C" >&6

7062

if eval "test \"\${$as_ac_Header+set}\" = set"; then

7063

echo $ECHO_N "(cached) $ECHO_C" >&6

7064

else

7065

eval "$as_ac_Header=\$ac_header_preproc"

7066

7067

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_Header'}'`" >&5

7068

echo "${ECHO_T}`eval echo '${'$as_ac_Header'}'`" >&6

7069

7070

7071

if test `eval echo '${'$as_ac_Header'}'` = yes; then

7072

cat >>confdefs.h <<_ACEOF

7073

#define `echo "HAVE_$ac_header" | $as_tr_cpp` 1

7074

_ACEOF

7075

7076

7077

7078

done

7079

7080

echo "$as_me:$LINENO: checking for in_addr_t" >&5

7081

echo $ECHO_N "checking for in_addr_t... $ECHO_C" >&6

7082

if test "${ac_cv_type_in_addr_t+set}" = set; then

7083

echo $ECHO_N "(cached) $ECHO_C" >&6

7084

else

7085

cat >conftest.$ac_ext <<_ACEOF

7086

/* confdefs.h. */

7087

_ACEOF

7088

cat confdefs.h >>conftest.$ac_ext

7089

cat >>conftest.$ac_ext <<_ACEOF

7090

/* end confdefs.h. */

7091

#include <netinet/in.h>

7092

7093

int

7094

main ()

7095

{

7096

if ((in_addr_t *) 0)

7097

return 0;

7098

if (sizeof (in_addr_t))

7099

return 0;

7100

;

7101

return 0;

7102

}

7103

_ACEOF

7104

rm -f conftest.$ac_objext

7105

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

7106

(eval $ac_compile) 2>conftest.er1

7107

ac_status=$?

7108

grep -v '^ *+' conftest.er1 >conftest.err

7109

rm -f conftest.er1

7110

cat conftest.err >&5

7111

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7112

(exit $ac_status); } &&

7113

{ ac_try='test -z "$ac_c_werror_flag"

7114

|| test ! -s conftest.err'

7115

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7116

(eval $ac_try) 2>&5

7117

ac_status=$?

7118

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7119

(exit $ac_status); }; } &&

7120

{ ac_try='test -s conftest.$ac_objext'

7121

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7122

(eval $ac_try) 2>&5

7123

ac_status=$?

7124

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7125

(exit $ac_status); }; }; then

7126

ac_cv_type_in_addr_t=yes

7127

else

7128

echo "$as_me: failed program was:" >&5

7129

sed 's/^/| /' conftest.$ac_ext >&5

7130

7131

ac_cv_type_in_addr_t=no

7132

7133

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

7134

7135

echo "$as_me:$LINENO: result: $ac_cv_type_in_addr_t" >&5

7136

echo "${ECHO_T}$ac_cv_type_in_addr_t" >&6

7137

if test $ac_cv_type_in_addr_t = yes; then

7138

7139

else

7140

7141

cat >>confdefs.h <<\_ACEOF

7142

#define in_addr_t int

7143

_ACEOF

7144

7145

7146

7147

7148

echo "$as_me:$LINENO: checking for an ANSI C-conforming const" >&5

7149

echo $ECHO_N "checking for an ANSI C-conforming const... $ECHO_C" >&6

7150

if test "${ac_cv_c_const+set}" = set; then

7151

echo $ECHO_N "(cached) $ECHO_C" >&6

7152

else

7153

cat >conftest.$ac_ext <<_ACEOF

7154

/* confdefs.h. */

7155

_ACEOF

7156

cat confdefs.h >>conftest.$ac_ext

7157

cat >>conftest.$ac_ext <<_ACEOF

7158

/* end confdefs.h. */

7159

7160

int

7161

main ()

7162

{

7163

/* FIXME: Include the comments suggested by Paul. */

7164

#ifndef __cplusplus

7165

/* Ultrix mips cc rejects this. */

7166

typedef int charset[2];

7167

const charset x;

7168

/* SunOS 4.1.1 cc rejects this. */

7169

char const *const *ccp;

7170

char **p;

7171

/* NEC SVR4.0.2 mips cc rejects this. */

7172

struct point {int x, y;};

7173

static struct point const zero = {0,0};

7174

/* AIX XL C 1.02.0.0 rejects this.

7175

It does not let you subtract one const X* pointer from another in

7176

an arm of an if-expression whose if-part is not a constant

7177

expression */

7178

const char *g = "string";

7179

ccp = &g + (g ? g-g : 0);

7180

/* HPUX 7.0 cc rejects these. */

7181

++ccp;

7182

p = (char**) ccp;

7183

ccp = (char const *const *) p;

7184

{ /* SCO 3.2v4 cc rejects this. */

7185

char *t;

7186

char const *s = 0 ? (char *) 0 : (char const *) 0;

7187

7188

*t++ = 0;

7189

}

7190

{ /* Someone thinks the Sun supposedly-ANSI compiler will reject this. */

7191

int x[] = {25, 17};

7192

const int *foo = &x[0];

7193

++foo;

7194

}

7195

{ /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */

7196

typedef const int *iptr;

7197

iptr p = 0;

7198

++p;

7199

}

7200

{ /* AIX XL C 1.02.0.0 rejects this saying

7201

"k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */

7202

struct s { int j; const int *ap[3]; };

7203

struct s *b; b->j = 5;

7204

}

7205

{ /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */

7206

const int foo = 10;

7207

}

7208

#endif

7209

7210

;

7211

return 0;

7212

}

7213

_ACEOF

7214

rm -f conftest.$ac_objext

7215

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

7216

(eval $ac_compile) 2>conftest.er1

7217

ac_status=$?

7218

grep -v '^ *+' conftest.er1 >conftest.err

7219

rm -f conftest.er1

7220

cat conftest.err >&5

7221

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7222

(exit $ac_status); } &&

7223

{ ac_try='test -z "$ac_c_werror_flag"

7224

|| test ! -s conftest.err'

7225

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7226

(eval $ac_try) 2>&5

7227

ac_status=$?

7228

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7229

(exit $ac_status); }; } &&

7230

{ ac_try='test -s conftest.$ac_objext'

7231

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7232

(eval $ac_try) 2>&5

7233

ac_status=$?

7234

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7235

(exit $ac_status); }; }; then

7236

ac_cv_c_const=yes

7237

else

7238

echo "$as_me: failed program was:" >&5

7239

sed 's/^/| /' conftest.$ac_ext >&5

7240

7241

ac_cv_c_const=no

7242

7243

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

7244

7245

echo "$as_me:$LINENO: result: $ac_cv_c_const" >&5

7246

echo "${ECHO_T}$ac_cv_c_const" >&6

7247

if test $ac_cv_c_const = no; then

7248

7249

cat >>confdefs.h <<\_ACEOF

7250

#define const

7251

_ACEOF

7252

7253

7254

7255

echo "$as_me:$LINENO: checking for inline" >&5

7256

echo $ECHO_N "checking for inline... $ECHO_C" >&6

7257

if test "${ac_cv_c_inline+set}" = set; then

7258

echo $ECHO_N "(cached) $ECHO_C" >&6

7259

else

7260

ac_cv_c_inline=no

7261

for ac_kw in inline __inline__ __inline; do

7262

cat >conftest.$ac_ext <<_ACEOF

7263

/* confdefs.h. */

7264

_ACEOF

7265

cat confdefs.h >>conftest.$ac_ext

7266

cat >>conftest.$ac_ext <<_ACEOF

7267

/* end confdefs.h. */

7268

#ifndef __cplusplus

7269

typedef int foo_t;

7270

static $ac_kw foo_t static_foo () {return 0; }

7271

$ac_kw foo_t foo () {return 0; }

7272

#endif

7273

7274

_ACEOF

7275

rm -f conftest.$ac_objext

7276

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

7277

(eval $ac_compile) 2>conftest.er1

7278

ac_status=$?

7279

grep -v '^ *+' conftest.er1 >conftest.err

7280

rm -f conftest.er1

7281

cat conftest.err >&5

7282

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7283

(exit $ac_status); } &&

7284

{ ac_try='test -z "$ac_c_werror_flag"

7285

|| test ! -s conftest.err'

7286

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7287

(eval $ac_try) 2>&5

7288

ac_status=$?

7289

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7290

(exit $ac_status); }; } &&

7291

{ ac_try='test -s conftest.$ac_objext'

7292

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7293

(eval $ac_try) 2>&5

7294

ac_status=$?

7295

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7296

(exit $ac_status); }; }; then

7297

ac_cv_c_inline=$ac_kw; break

7298

else

7299

echo "$as_me: failed program was:" >&5

7300

sed 's/^/| /' conftest.$ac_ext >&5

7301

7302

7303

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

7304

done

7305

7306

7307

echo "$as_me:$LINENO: result: $ac_cv_c_inline" >&5

7308

echo "${ECHO_T}$ac_cv_c_inline" >&6

7309

7310

7311

case $ac_cv_c_inline in

7312

inline | yes) ;;

7313

7314

case $ac_cv_c_inline in

7315

no) ac_val=;;

7316

*) ac_val=$ac_cv_c_inline;;

7317

esac

7318

cat >>confdefs.h <<_ACEOF

7319

#ifndef __cplusplus

7320

#define inline $ac_val

7321

#endif

7322

_ACEOF

7323

;;

7324

esac

7325

7326

7327

echo "$as_me:$LINENO: checking for __attribute__" >&5

7328

echo $ECHO_N "checking for __attribute__... $ECHO_C" >&6

7329

if test "${ac_cv___attribute__+set}" = set; then

7330

echo $ECHO_N "(cached) $ECHO_C" >&6

7331

else

7332

7333

cat >conftest.$ac_ext <<_ACEOF

7334

/* confdefs.h. */

7335

_ACEOF

7336

cat confdefs.h >>conftest.$ac_ext

7337

cat >>conftest.$ac_ext <<_ACEOF

7338

/* end confdefs.h. */

7339

7340

#include <stdlib.h>

7341

static void foo (void) __attribute__ ((unused));

7342

7343

static void

7344

foo (void)

7345

{

7346

exit(1);

7347

}

7348

7349

int

7350

main ()

7351

{

7352

7353

exit (0);

7354

7355

;

7356

return 0;

7357

}

7358

_ACEOF

7359

rm -f conftest.$ac_objext

7360

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

7361

(eval $ac_compile) 2>conftest.er1

7362

ac_status=$?

7363

grep -v '^ *+' conftest.er1 >conftest.err

7364

rm -f conftest.er1

7365

cat conftest.err >&5

7366

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7367

(exit $ac_status); } &&

7368

{ ac_try='test -z "$ac_c_werror_flag"

7369

|| test ! -s conftest.err'

7370

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7371

(eval $ac_try) 2>&5

7372

ac_status=$?

7373

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7374

(exit $ac_status); }; } &&

7375

{ ac_try='test -s conftest.$ac_objext'

7376

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7377

(eval $ac_try) 2>&5

7378

ac_status=$?

7379

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7380

(exit $ac_status); }; }; then

7381

ac_cv___attribute__=yes

7382

else

7383

echo "$as_me: failed program was:" >&5

7384

sed 's/^/| /' conftest.$ac_ext >&5

7385

7386

ac_cv___attribute__=no

7387

7388

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

7389

7390

7391

if test "$ac_cv___attribute__" = "yes"; then

7392

7393

cat >>confdefs.h <<\_ACEOF

7394

#define UNUSED __attribute__ ((unused))

7395

_ACEOF

7396

7397

else

7398

cat >>confdefs.h <<\_ACEOF

7399

#define UNUSED

7400

_ACEOF

7401

7402

7403

echo "$as_me:$LINENO: result: $ac_cv___attribute__" >&5

7404

echo "${ECHO_T}$ac_cv___attribute__" >&6

7405

7406

echo "$as_me:$LINENO: checking for socklen_t" >&5

7407

echo $ECHO_N "checking for socklen_t... $ECHO_C" >&6

7408

if test "${ac_cv_type_socklen_t+set}" = set; then

7409

echo $ECHO_N "(cached) $ECHO_C" >&6

7410

else

7411

7412

cat >conftest.$ac_ext <<_ACEOF

7413

/* confdefs.h. */

7414

_ACEOF

7415

cat confdefs.h >>conftest.$ac_ext

7416

cat >>conftest.$ac_ext <<_ACEOF

7417

/* end confdefs.h. */

7418

#include <sys/types.h>

7419

#include <sys/socket.h>

7420

int

7421

main ()

7422

{

7423

socklen_t len = 42; return 0;

7424

;

7425

return 0;

7426

}

7427

_ACEOF

7428

rm -f conftest.$ac_objext

7429

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

7430

(eval $ac_compile) 2>conftest.er1

7431

ac_status=$?

7432

grep -v '^ *+' conftest.er1 >conftest.err

7433

rm -f conftest.er1

7434

cat conftest.err >&5

7435

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7436

(exit $ac_status); } &&

7437

{ ac_try='test -z "$ac_c_werror_flag"

7438

|| test ! -s conftest.err'

7439

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7440

(eval $ac_try) 2>&5

7441

ac_status=$?

7442

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7443

(exit $ac_status); }; } &&

7444

{ ac_try='test -s conftest.$ac_objext'

7445

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7446

(eval $ac_try) 2>&5

7447

ac_status=$?

7448

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7449

(exit $ac_status); }; }; then

7450

ac_cv_type_socklen_t=yes

7451

else

7452

echo "$as_me: failed program was:" >&5

7453

sed 's/^/| /' conftest.$ac_ext >&5

7454

7455

ac_cv_type_socklen_t=no

7456

7457

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

7458

7459

7460

echo "$as_me:$LINENO: result: $ac_cv_type_socklen_t" >&5

7461

echo "${ECHO_T}$ac_cv_type_socklen_t" >&6

7462

if test $ac_cv_type_socklen_t != yes; then

7463

7464

cat >>confdefs.h <<\_ACEOF

7465

#define socklen_t int

7466

_ACEOF

7467

7468

7469

7470

echo "$as_me:$LINENO: checking for pid_t" >&5

7471

echo $ECHO_N "checking for pid_t... $ECHO_C" >&6

7472

if test "${ac_cv_type_pid_t+set}" = set; then

7473

echo $ECHO_N "(cached) $ECHO_C" >&6

7474

else

7475

cat >conftest.$ac_ext <<_ACEOF

7476

/* confdefs.h. */

7477

_ACEOF

7478

cat confdefs.h >>conftest.$ac_ext

7479

cat >>conftest.$ac_ext <<_ACEOF

7480

/* end confdefs.h. */

7481

$ac_includes_default

7482

int

7483

main ()

7484

{

7485

if ((pid_t *) 0)

7486

return 0;

7487

if (sizeof (pid_t))

7488

return 0;

7489

;

7490

return 0;

7491

}

7492

_ACEOF

7493

rm -f conftest.$ac_objext

7494

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

7495

(eval $ac_compile) 2>conftest.er1

7496

ac_status=$?

7497

grep -v '^ *+' conftest.er1 >conftest.err

7498

rm -f conftest.er1

7499

cat conftest.err >&5

7500

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7501

(exit $ac_status); } &&

7502

{ ac_try='test -z "$ac_c_werror_flag"

7503

|| test ! -s conftest.err'

7504

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7505

(eval $ac_try) 2>&5

7506

ac_status=$?

7507

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7508

(exit $ac_status); }; } &&

7509

{ ac_try='test -s conftest.$ac_objext'

7510

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7511

(eval $ac_try) 2>&5

7512

ac_status=$?

7513

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7514

(exit $ac_status); }; }; then

7515

ac_cv_type_pid_t=yes

7516

else

7517

echo "$as_me: failed program was:" >&5

7518

sed 's/^/| /' conftest.$ac_ext >&5

7519

7520

ac_cv_type_pid_t=no

7521

7522

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

7523

7524

echo "$as_me:$LINENO: result: $ac_cv_type_pid_t" >&5

7525

echo "${ECHO_T}$ac_cv_type_pid_t" >&6

7526

if test $ac_cv_type_pid_t = yes; then

7527

7528

else

7529

7530

cat >>confdefs.h <<_ACEOF

7531

#define pid_t int

7532

_ACEOF

7533

7534

7535

7536

echo "$as_me:$LINENO: checking for size_t" >&5

7537

echo $ECHO_N "checking for size_t... $ECHO_C" >&6

7538

if test "${ac_cv_type_size_t+set}" = set; then

7539

echo $ECHO_N "(cached) $ECHO_C" >&6

7540

else

7541

cat >conftest.$ac_ext <<_ACEOF

7542

/* confdefs.h. */

7543

_ACEOF

7544

cat confdefs.h >>conftest.$ac_ext

7545

cat >>conftest.$ac_ext <<_ACEOF

7546

/* end confdefs.h. */

7547

$ac_includes_default

7548

int

7549

main ()

7550

{

7551

if ((size_t *) 0)

7552

return 0;

7553

if (sizeof (size_t))

7554

return 0;

7555

;

7556

return 0;

7557

}

7558

_ACEOF

7559

rm -f conftest.$ac_objext

7560

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

7561

(eval $ac_compile) 2>conftest.er1

7562

ac_status=$?

7563

grep -v '^ *+' conftest.er1 >conftest.err

7564

rm -f conftest.er1

7565

cat conftest.err >&5

7566

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7567

(exit $ac_status); } &&

7568

{ ac_try='test -z "$ac_c_werror_flag"

7569

|| test ! -s conftest.err'

7570

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7571

(eval $ac_try) 2>&5

7572

ac_status=$?

7573

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7574

(exit $ac_status); }; } &&

7575

{ ac_try='test -s conftest.$ac_objext'

7576

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7577

(eval $ac_try) 2>&5

7578

ac_status=$?

7579

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7580

(exit $ac_status); }; }; then

7581

ac_cv_type_size_t=yes

7582

else

7583

echo "$as_me: failed program was:" >&5

7584

sed 's/^/| /' conftest.$ac_ext >&5

7585

7586

ac_cv_type_size_t=no

7587

7588

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

7589

7590

echo "$as_me:$LINENO: result: $ac_cv_type_size_t" >&5

7591

echo "${ECHO_T}$ac_cv_type_size_t" >&6

7592

if test $ac_cv_type_size_t = yes; then

7593

7594

else

7595

7596

cat >>confdefs.h <<_ACEOF

7597

#define size_t unsigned

7598

_ACEOF

7599

7600

7601

7602

echo "$as_me:$LINENO: checking whether time.h and sys/time.h may both be included" >&5

7603

echo $ECHO_N "checking whether time.h and sys/time.h may both be included... $ECHO_C" >&6

7604

if test "${ac_cv_header_time+set}" = set; then

7605

echo $ECHO_N "(cached) $ECHO_C" >&6

7606

else

7607

cat >conftest.$ac_ext <<_ACEOF

7608

/* confdefs.h. */

7609

_ACEOF

7610

cat confdefs.h >>conftest.$ac_ext

7611

cat >>conftest.$ac_ext <<_ACEOF

7612

/* end confdefs.h. */

7613

#include <sys/types.h>

7614

#include <sys/time.h>

7615

#include <time.h>

7616

7617

int

7618

main ()

7619

{

7620

if ((struct tm *) 0)

7621

return 0;

7622

;

7623

return 0;

7624

}

7625

_ACEOF

7626

rm -f conftest.$ac_objext

7627

if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5

7628

(eval $ac_compile) 2>conftest.er1

7629

ac_status=$?

7630

grep -v '^ *+' conftest.er1 >conftest.err

7631

rm -f conftest.er1

7632

cat conftest.err >&5

7633

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7634

(exit $ac_status); } &&

7635

{ ac_try='test -z "$ac_c_werror_flag"

7636

|| test ! -s conftest.err'

7637

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7638

(eval $ac_try) 2>&5

7639

ac_status=$?

7640

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7641

(exit $ac_status); }; } &&

7642

{ ac_try='test -s conftest.$ac_objext'

7643

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7644

(eval $ac_try) 2>&5

7645

ac_status=$?

7646

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7647

(exit $ac_status); }; }; then

7648

ac_cv_header_time=yes

7649

else

7650

echo "$as_me: failed program was:" >&5

7651

sed 's/^/| /' conftest.$ac_ext >&5

7652

7653

ac_cv_header_time=no

7654

7655

rm -f conftest.err conftest.$ac_objext conftest.$ac_ext

7656

7657

echo "$as_me:$LINENO: result: $ac_cv_header_time" >&5

7658

echo "${ECHO_T}$ac_cv_header_time" >&6

7659

if test $ac_cv_header_time = yes; then

7660

7661

cat >>confdefs.h <<\_ACEOF

7662

#define TIME_WITH_SYS_TIME 1

7663

_ACEOF

7664

7665

7666

7667

7668

echo "$as_me:$LINENO: checking for resultproc_t in rpc/clnt.h" >&5

7669

echo $ECHO_N "checking for resultproc_t in rpc/clnt.h... $ECHO_C" >&6

7670

cat >conftest.$ac_ext <<_ACEOF

7671

/* confdefs.h. */

7672

_ACEOF

7673

cat confdefs.h >>conftest.$ac_ext

7674

cat >>conftest.$ac_ext <<_ACEOF

7675

/* end confdefs.h. */

7676

#include <rpc/clnt.h>

7677

7678

_ACEOF

7679

if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

7680

$EGREP "resultproc_t" >/dev/null 2>&1; then

7681

7682

7683

cat >>confdefs.h <<\_ACEOF

7684

#define HAVE_RESULTPROC_T 1

7685

_ACEOF

7686

echo "$as_me:$LINENO: result: yes" >&5

7687

echo "${ECHO_T}yes" >&6

7688

else

7689

7690

echo "$as_me:$LINENO: result: no" >&5

7691

echo "${ECHO_T}no" >&6

7692

7693

rm -f conftest*

7694

7695

echo "$as_me:$LINENO: checking for resultproc_t in rpc/pmap_clnt.h" >&5

7696

echo $ECHO_N "checking for resultproc_t in rpc/pmap_clnt.h... $ECHO_C" >&6

7697

cat >conftest.$ac_ext <<_ACEOF

7698

/* confdefs.h. */

7699

_ACEOF

7700

cat confdefs.h >>conftest.$ac_ext

7701

cat >>conftest.$ac_ext <<_ACEOF

7702

/* end confdefs.h. */

7703

#include <rpc/pmap_clnt.h>

7704

7705

_ACEOF

7706

if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |

7707

$EGREP "resultproc_t" >/dev/null 2>&1; then

7708

7709

cat >>confdefs.h <<\_ACEOF

7710

#define HAVE_RESULTPROC_T 1

7711

_ACEOF

7712

echo "$as_me:$LINENO: result: yes" >&5

7713

echo "${ECHO_T}yes" >&6

7714

else

7715

7716

echo "$as_me:$LINENO: result: no" >&5

7717

echo "${ECHO_T}no" >&6

7718

7719

rm -f conftest*

7720

7721

7722

echo "$as_me:$LINENO: checking for working memcmp" >&5

7723

echo $ECHO_N "checking for working memcmp... $ECHO_C" >&6

7724

if test "${ac_cv_func_memcmp_working+set}" = set; then

7725

echo $ECHO_N "(cached) $ECHO_C" >&6

7726

else

7727

if test "$cross_compiling" = yes; then

7728

ac_cv_func_memcmp_working=no

7729

else

7730

cat >conftest.$ac_ext <<_ACEOF

7731

/* confdefs.h. */

7732

_ACEOF

7733

cat confdefs.h >>conftest.$ac_ext

7734

cat >>conftest.$ac_ext <<_ACEOF

7735

/* end confdefs.h. */

7736

$ac_includes_default

7737

int

7738

main ()

7739

{

7740

7741

/* Some versions of memcmp are not 8-bit clean. */

7742

char c0 = 0x40, c1 = 0x80, c2 = 0x81;

7743

if (memcmp(&c0, &c2, 1) >= 0 || memcmp(&c1, &c2, 1) >= 0)

7744

exit (1);

7745

7746

/* The Next x86 OpenStep bug shows up only when comparing 16 bytes

7747

or more and with at least one buffer not starting on a 4-byte boundary.

7748

William Lewis provided this test program. */

7749

{

7750

char foo[21];

7751

char bar[21];

7752

int i;

7753

for (i = 0; i < 4; i++)

7754

{

7755

char *a = foo + i;

7756

char *b = bar + i;

7757

strcpy (a, "--------01111111");

7758

strcpy (b, "--------10000000");

7759

if (memcmp (a, b, 16) >= 0)

7760

exit (1);

7761

}

7762

exit (0);

7763

}

7764

7765

;

7766

return 0;

7767

}

7768

_ACEOF

7769

rm -f conftest$ac_exeext

7770

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

7771

(eval $ac_link) 2>&5

7772

ac_status=$?

7773

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7774

(exit $ac_status); } && { ac_try='./conftest$ac_exeext'

7775

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7776

(eval $ac_try) 2>&5

7777

ac_status=$?

7778

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7779

(exit $ac_status); }; }; then

7780

ac_cv_func_memcmp_working=yes

7781

else

7782

echo "$as_me: program exited with status $ac_status" >&5

7783

echo "$as_me: failed program was:" >&5

7784

sed 's/^/| /' conftest.$ac_ext >&5

7785

7786

( exit $ac_status )

7787

ac_cv_func_memcmp_working=no

7788

7789

rm -f core *.core gmon.out bb.out conftest$ac_exeext conftest.$ac_objext conftest.$ac_ext

7790

7791

7792

echo "$as_me:$LINENO: result: $ac_cv_func_memcmp_working" >&5

7793

echo "${ECHO_T}$ac_cv_func_memcmp_working" >&6

7794

test $ac_cv_func_memcmp_working = no && case $LIBOBJS in

7795

"memcmp.$ac_objext" | \

7796

*" memcmp.$ac_objext" | \

7797

"memcmp.$ac_objext "* | \

7798

*" memcmp.$ac_objext "* ) ;;

7799

*) LIBOBJS="$LIBOBJS memcmp.$ac_objext" ;;

7800

esac

7801

7802

7803

7804

for ac_func in vprintf

7805

7806

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

7807

echo "$as_me:$LINENO: checking for $ac_func" >&5

7808

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

7809

if eval "test \"\${$as_ac_var+set}\" = set"; then

7810

echo $ECHO_N "(cached) $ECHO_C" >&6

7811

else

7812

cat >conftest.$ac_ext <<_ACEOF

7813

/* confdefs.h. */

7814

_ACEOF

7815

cat confdefs.h >>conftest.$ac_ext

7816

cat >>conftest.$ac_ext <<_ACEOF

7817

/* end confdefs.h. */

7818

/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

7819

For example, HP-UX 11i <limits.h> declares gettimeofday. */

7820

#define $ac_func innocuous_$ac_func

7821

7822

/* System header to define __stub macros and hopefully few prototypes,

7823

which can conflict with char $ac_func (); below.

7824

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

7825

<limits.h> exists even on freestanding compilers. */

7826

7827

#ifdef __STDC__

7828

# include <limits.h>

7829

#else

7830

# include <assert.h>

7831

#endif

7832

7833

#undef $ac_func

7834

7835

/* Override any gcc2 internal prototype to avoid an error. */

7836

#ifdef __cplusplus

7837

extern "C"

7838

{

7839

#endif

7840

/* We use char because int might match the return type of a gcc2

7841

builtin and then its argument prototype would still apply. */

7842

char $ac_func ();

7843

/* The GNU C library defines this for functions which it implements

7844

to always fail with ENOSYS. Some functions are actually named

7845

something starting with __ and the normal name is an alias. */

7846

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

7847

choke me

7848

#else

7849

char (*f) () = $ac_func;

7850

#endif

7851

#ifdef __cplusplus

7852

}

7853

#endif

7854

7855

int

7856

main ()

7857

{

7858

return f != $ac_func;

7859

;

7860

return 0;

7861

}

7862

_ACEOF

7863

rm -f conftest.$ac_objext conftest$ac_exeext

7864

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

7865

(eval $ac_link) 2>conftest.er1

7866

ac_status=$?

7867

grep -v '^ *+' conftest.er1 >conftest.err

7868

rm -f conftest.er1

7869

cat conftest.err >&5

7870

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7871

(exit $ac_status); } &&

7872

{ ac_try='test -z "$ac_c_werror_flag"

7873

|| test ! -s conftest.err'

7874

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7875

(eval $ac_try) 2>&5

7876

ac_status=$?

7877

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7878

(exit $ac_status); }; } &&

7879

{ ac_try='test -s conftest$ac_exeext'

7880

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7881

(eval $ac_try) 2>&5

7882

ac_status=$?

7883

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7884

(exit $ac_status); }; }; then

7885

eval "$as_ac_var=yes"

7886

else

7887

echo "$as_me: failed program was:" >&5

7888

sed 's/^/| /' conftest.$ac_ext >&5

7889

7890

eval "$as_ac_var=no"

7891

7892

rm -f conftest.err conftest.$ac_objext \

7893

conftest$ac_exeext conftest.$ac_ext

7894

7895

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

7896

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

7897

if test `eval echo '${'$as_ac_var'}'` = yes; then

7898

cat >>confdefs.h <<_ACEOF

7899

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

7900

_ACEOF

7901

7902

echo "$as_me:$LINENO: checking for _doprnt" >&5

7903

echo $ECHO_N "checking for _doprnt... $ECHO_C" >&6

7904

if test "${ac_cv_func__doprnt+set}" = set; then

7905

echo $ECHO_N "(cached) $ECHO_C" >&6

7906

else

7907

cat >conftest.$ac_ext <<_ACEOF

7908

/* confdefs.h. */

7909

_ACEOF

7910

cat confdefs.h >>conftest.$ac_ext

7911

cat >>conftest.$ac_ext <<_ACEOF

7912

/* end confdefs.h. */

7913

/* Define _doprnt to an innocuous variant, in case <limits.h> declares _doprnt.

7914

For example, HP-UX 11i <limits.h> declares gettimeofday. */

7915

#define _doprnt innocuous__doprnt

7916

7917

/* System header to define __stub macros and hopefully few prototypes,

7918

which can conflict with char _doprnt (); below.

7919

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

7920

<limits.h> exists even on freestanding compilers. */

7921

7922

#ifdef __STDC__

7923

# include <limits.h>

7924

#else

7925

# include <assert.h>

7926

#endif

7927

7928

#undef _doprnt

7929

7930

/* Override any gcc2 internal prototype to avoid an error. */

7931

#ifdef __cplusplus

7932

extern "C"

7933

{

7934

#endif

7935

/* We use char because int might match the return type of a gcc2

7936

builtin and then its argument prototype would still apply. */

7937

char _doprnt ();

7938

/* The GNU C library defines this for functions which it implements

7939

to always fail with ENOSYS. Some functions are actually named

7940

something starting with __ and the normal name is an alias. */

7941

#if defined (__stub__doprnt) || defined (__stub____doprnt)

7942

choke me

7943

#else

7944

char (*f) () = _doprnt;

7945

#endif

7946

#ifdef __cplusplus

7947

}

7948

#endif

7949

7950

int

7951

main ()

7952

{

7953

return f != _doprnt;

7954

;

7955

return 0;

7956

}

7957

_ACEOF

7958

rm -f conftest.$ac_objext conftest$ac_exeext

7959

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

7960

(eval $ac_link) 2>conftest.er1

7961

ac_status=$?

7962

grep -v '^ *+' conftest.er1 >conftest.err

7963

rm -f conftest.er1

7964

cat conftest.err >&5

7965

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7966

(exit $ac_status); } &&

7967

{ ac_try='test -z "$ac_c_werror_flag"

7968

|| test ! -s conftest.err'

7969

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7970

(eval $ac_try) 2>&5

7971

ac_status=$?

7972

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7973

(exit $ac_status); }; } &&

7974

{ ac_try='test -s conftest$ac_exeext'

7975

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

7976

(eval $ac_try) 2>&5

7977

ac_status=$?

7978

echo "$as_me:$LINENO: \$? = $ac_status" >&5

7979

(exit $ac_status); }; }; then

7980

ac_cv_func__doprnt=yes

7981

else

7982

echo "$as_me: failed program was:" >&5

7983

sed 's/^/| /' conftest.$ac_ext >&5

7984

7985

ac_cv_func__doprnt=no

7986

7987

rm -f conftest.err conftest.$ac_objext \

7988

conftest$ac_exeext conftest.$ac_ext

7989

7990

echo "$as_me:$LINENO: result: $ac_cv_func__doprnt" >&5

7991

echo "${ECHO_T}$ac_cv_func__doprnt" >&6

7992

if test $ac_cv_func__doprnt = yes; then

7993

7994

cat >>confdefs.h <<\_ACEOF

7995

#define HAVE_DOPRNT 1

7996

_ACEOF

7997

7998

7999

8000

8001

done

8002

8003

8004

8005

8006

for ac_func in setenv putenv

8007

8008

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

8009

echo "$as_me:$LINENO: checking for $ac_func" >&5

8010

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

8011

if eval "test \"\${$as_ac_var+set}\" = set"; then

8012

echo $ECHO_N "(cached) $ECHO_C" >&6

8013

else

8014

cat >conftest.$ac_ext <<_ACEOF

8015

/* confdefs.h. */

8016

_ACEOF

8017

cat confdefs.h >>conftest.$ac_ext

8018

cat >>conftest.$ac_ext <<_ACEOF

8019

/* end confdefs.h. */

8020

/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

8021

For example, HP-UX 11i <limits.h> declares gettimeofday. */

8022

#define $ac_func innocuous_$ac_func

8023

8024

/* System header to define __stub macros and hopefully few prototypes,

8025

which can conflict with char $ac_func (); below.

8026

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

8027

<limits.h> exists even on freestanding compilers. */

8028

8029

#ifdef __STDC__

8030

# include <limits.h>

8031

#else

8032

# include <assert.h>

8033

#endif

8034

8035

#undef $ac_func

8036

8037

/* Override any gcc2 internal prototype to avoid an error. */

8038

#ifdef __cplusplus

8039

extern "C"

8040

{

8041

#endif

8042

/* We use char because int might match the return type of a gcc2

8043

builtin and then its argument prototype would still apply. */

8044

char $ac_func ();

8045

/* The GNU C library defines this for functions which it implements

8046

to always fail with ENOSYS. Some functions are actually named

8047

something starting with __ and the normal name is an alias. */

8048

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

8049

choke me

8050

#else

8051

char (*f) () = $ac_func;

8052

#endif

8053

#ifdef __cplusplus

8054

}

8055

#endif

8056

8057

int

8058

main ()

8059

{

8060

return f != $ac_func;

8061

;

8062

return 0;

8063

}

8064

_ACEOF

8065

rm -f conftest.$ac_objext conftest$ac_exeext

8066

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

8067

(eval $ac_link) 2>conftest.er1

8068

ac_status=$?

8069

grep -v '^ *+' conftest.er1 >conftest.err

8070

rm -f conftest.er1

8071

cat conftest.err >&5

8072

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8073

(exit $ac_status); } &&

8074

{ ac_try='test -z "$ac_c_werror_flag"

8075

|| test ! -s conftest.err'

8076

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8077

(eval $ac_try) 2>&5

8078

ac_status=$?

8079

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8080

(exit $ac_status); }; } &&

8081

{ ac_try='test -s conftest$ac_exeext'

8082

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8083

(eval $ac_try) 2>&5

8084

ac_status=$?

8085

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8086

(exit $ac_status); }; }; then

8087

eval "$as_ac_var=yes"

8088

else

8089

echo "$as_me: failed program was:" >&5

8090

sed 's/^/| /' conftest.$ac_ext >&5

8091

8092

eval "$as_ac_var=no"

8093

8094

rm -f conftest.err conftest.$ac_objext \

8095

conftest$ac_exeext conftest.$ac_ext

8096

8097

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

8098

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

8099

if test `eval echo '${'$as_ac_var'}'` = yes; then

8100

cat >>confdefs.h <<_ACEOF

8101

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

8102

_ACEOF

8103

8104

8105

done

8106

8107

8108

8109

8110

8111

for ac_func in fgetpwent putpwent fgetgrent getspnam

8112

8113

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

8114

echo "$as_me:$LINENO: checking for $ac_func" >&5

8115

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

8116

if eval "test \"\${$as_ac_var+set}\" = set"; then

8117

echo $ECHO_N "(cached) $ECHO_C" >&6

8118

else

8119

cat >conftest.$ac_ext <<_ACEOF

8120

/* confdefs.h. */

8121

_ACEOF

8122

cat confdefs.h >>conftest.$ac_ext

8123

cat >>conftest.$ac_ext <<_ACEOF

8124

/* end confdefs.h. */

8125

/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

8126

For example, HP-UX 11i <limits.h> declares gettimeofday. */

8127

#define $ac_func innocuous_$ac_func

8128

8129

/* System header to define __stub macros and hopefully few prototypes,

8130

which can conflict with char $ac_func (); below.

8131

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

8132

<limits.h> exists even on freestanding compilers. */

8133

8134

#ifdef __STDC__

8135

# include <limits.h>

8136

#else

8137

# include <assert.h>

8138

#endif

8139

8140

#undef $ac_func

8141

8142

/* Override any gcc2 internal prototype to avoid an error. */

8143

#ifdef __cplusplus

8144

extern "C"

8145

{

8146

#endif

8147

/* We use char because int might match the return type of a gcc2

8148

builtin and then its argument prototype would still apply. */

8149

char $ac_func ();

8150

/* The GNU C library defines this for functions which it implements

8151

to always fail with ENOSYS. Some functions are actually named

8152

something starting with __ and the normal name is an alias. */

8153

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

8154

choke me

8155

#else

8156

char (*f) () = $ac_func;

8157

#endif

8158

#ifdef __cplusplus

8159

}

8160

#endif

8161

8162

int

8163

main ()

8164

{

8165

return f != $ac_func;

8166

;

8167

return 0;

8168

}

8169

_ACEOF

8170

rm -f conftest.$ac_objext conftest$ac_exeext

8171

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

8172

(eval $ac_link) 2>conftest.er1

8173

ac_status=$?

8174

grep -v '^ *+' conftest.er1 >conftest.err

8175

rm -f conftest.er1

8176

cat conftest.err >&5

8177

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8178

(exit $ac_status); } &&

8179

{ ac_try='test -z "$ac_c_werror_flag"

8180

|| test ! -s conftest.err'

8181

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8182

(eval $ac_try) 2>&5

8183

ac_status=$?

8184

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8185

(exit $ac_status); }; } &&

8186

{ ac_try='test -s conftest$ac_exeext'

8187

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8188

(eval $ac_try) 2>&5

8189

ac_status=$?

8190

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8191

(exit $ac_status); }; }; then

8192

eval "$as_ac_var=yes"

8193

else

8194

echo "$as_me: failed program was:" >&5

8195

sed 's/^/| /' conftest.$ac_ext >&5

8196

8197

eval "$as_ac_var=no"

8198

8199

rm -f conftest.err conftest.$ac_objext \

8200

conftest$ac_exeext conftest.$ac_ext

8201

8202

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

8203

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

8204

if test `eval echo '${'$as_ac_var'}'` = yes; then

8205

cat >>confdefs.h <<_ACEOF

8206

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

8207

_ACEOF

8208

8209

8210

done

8211

8212

8213

8214

8215

8216

for ac_func in inet_aton inet_pton vsyslog lckpwdf

8217

8218

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

8219

echo "$as_me:$LINENO: checking for $ac_func" >&5

8220

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

8221

if eval "test \"\${$as_ac_var+set}\" = set"; then

8222

echo $ECHO_N "(cached) $ECHO_C" >&6

8223

else

8224

cat >conftest.$ac_ext <<_ACEOF

8225

/* confdefs.h. */

8226

_ACEOF

8227

cat confdefs.h >>conftest.$ac_ext

8228

cat >>conftest.$ac_ext <<_ACEOF

8229

/* end confdefs.h. */

8230

/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

8231

For example, HP-UX 11i <limits.h> declares gettimeofday. */

8232

#define $ac_func innocuous_$ac_func

8233

8234

/* System header to define __stub macros and hopefully few prototypes,

8235

which can conflict with char $ac_func (); below.

8236

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

8237

<limits.h> exists even on freestanding compilers. */

8238

8239

#ifdef __STDC__

8240

# include <limits.h>

8241

#else

8242

# include <assert.h>

8243

#endif

8244

8245

#undef $ac_func

8246

8247

/* Override any gcc2 internal prototype to avoid an error. */

8248

#ifdef __cplusplus

8249

extern "C"

8250

{

8251

#endif

8252

/* We use char because int might match the return type of a gcc2

8253

builtin and then its argument prototype would still apply. */

8254

char $ac_func ();

8255

/* The GNU C library defines this for functions which it implements

8256

to always fail with ENOSYS. Some functions are actually named

8257

something starting with __ and the normal name is an alias. */

8258

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

8259

choke me

8260

#else

8261

char (*f) () = $ac_func;

8262

#endif

8263

#ifdef __cplusplus

8264

}

8265

#endif

8266

8267

int

8268

main ()

8269

{

8270

return f != $ac_func;

8271

;

8272

return 0;

8273

}

8274

_ACEOF

8275

rm -f conftest.$ac_objext conftest$ac_exeext

8276

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

8277

(eval $ac_link) 2>conftest.er1

8278

ac_status=$?

8279

grep -v '^ *+' conftest.er1 >conftest.err

8280

rm -f conftest.er1

8281

cat conftest.err >&5

8282

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8283

(exit $ac_status); } &&

8284

{ ac_try='test -z "$ac_c_werror_flag"

8285

|| test ! -s conftest.err'

8286

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8287

(eval $ac_try) 2>&5

8288

ac_status=$?

8289

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8290

(exit $ac_status); }; } &&

8291

{ ac_try='test -s conftest$ac_exeext'

8292

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8293

(eval $ac_try) 2>&5

8294

ac_status=$?

8295

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8296

(exit $ac_status); }; }; then

8297

eval "$as_ac_var=yes"

8298

else

8299

echo "$as_me: failed program was:" >&5

8300

sed 's/^/| /' conftest.$ac_ext >&5

8301

8302

eval "$as_ac_var=no"

8303

8304

rm -f conftest.err conftest.$ac_objext \

8305

conftest$ac_exeext conftest.$ac_ext

8306

8307

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

8308

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

8309

if test `eval echo '${'$as_ac_var'}'` = yes; then

8310

cat >>confdefs.h <<_ACEOF

8311

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

8312

_ACEOF

8313

8314

8315

done

8316

8317

8318

8319

8320

8321

8322

8323

for ac_func in strdup strndup strerror strstr strsep stpcpy

8324

8325

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

8326

echo "$as_me:$LINENO: checking for $ac_func" >&5

8327

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

8328

if eval "test \"\${$as_ac_var+set}\" = set"; then

8329

echo $ECHO_N "(cached) $ECHO_C" >&6

8330

else

8331

cat >conftest.$ac_ext <<_ACEOF

8332

/* confdefs.h. */

8333

_ACEOF

8334

cat confdefs.h >>conftest.$ac_ext

8335

cat >>conftest.$ac_ext <<_ACEOF

8336

/* end confdefs.h. */

8337

/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

8338

For example, HP-UX 11i <limits.h> declares gettimeofday. */

8339

#define $ac_func innocuous_$ac_func

8340

8341

/* System header to define __stub macros and hopefully few prototypes,

8342

which can conflict with char $ac_func (); below.

8343

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

8344

<limits.h> exists even on freestanding compilers. */

8345

8346

#ifdef __STDC__

8347

# include <limits.h>

8348

#else

8349

# include <assert.h>

8350

#endif

8351

8352

#undef $ac_func

8353

8354

/* Override any gcc2 internal prototype to avoid an error. */

8355

#ifdef __cplusplus

8356

extern "C"

8357

{

8358

#endif

8359

/* We use char because int might match the return type of a gcc2

8360

builtin and then its argument prototype would still apply. */

8361

char $ac_func ();

8362

/* The GNU C library defines this for functions which it implements

8363

to always fail with ENOSYS. Some functions are actually named

8364

something starting with __ and the normal name is an alias. */

8365

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

8366

choke me

8367

#else

8368

char (*f) () = $ac_func;

8369

#endif

8370

#ifdef __cplusplus

8371

}

8372

#endif

8373

8374

int

8375

main ()

8376

{

8377

return f != $ac_func;

8378

;

8379

return 0;

8380

}

8381

_ACEOF

8382

rm -f conftest.$ac_objext conftest$ac_exeext

8383

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

8384

(eval $ac_link) 2>conftest.er1

8385

ac_status=$?

8386

grep -v '^ *+' conftest.er1 >conftest.err

8387

rm -f conftest.er1

8388

cat conftest.err >&5

8389

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8390

(exit $ac_status); } &&

8391

{ ac_try='test -z "$ac_c_werror_flag"

8392

|| test ! -s conftest.err'

8393

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8394

(eval $ac_try) 2>&5

8395

ac_status=$?

8396

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8397

(exit $ac_status); }; } &&

8398

{ ac_try='test -s conftest$ac_exeext'

8399

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8400

(eval $ac_try) 2>&5

8401

ac_status=$?

8402

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8403

(exit $ac_status); }; }; then

8404

eval "$as_ac_var=yes"

8405

else

8406

echo "$as_me: failed program was:" >&5

8407

sed 's/^/| /' conftest.$ac_ext >&5

8408

8409

eval "$as_ac_var=no"

8410

8411

rm -f conftest.err conftest.$ac_objext \

8412

conftest$ac_exeext conftest.$ac_ext

8413

8414

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

8415

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

8416

if test `eval echo '${'$as_ac_var'}'` = yes; then

8417

cat >>confdefs.h <<_ACEOF

8418

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

8419

_ACEOF

8420

8421

8422

done

8423

8424

8425

8426

for ac_func in snprintf asprintf

8427

8428

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

8429

echo "$as_me:$LINENO: checking for $ac_func" >&5

8430

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

8431

if eval "test \"\${$as_ac_var+set}\" = set"; then

8432

echo $ECHO_N "(cached) $ECHO_C" >&6

8433

else

8434

cat >conftest.$ac_ext <<_ACEOF

8435

/* confdefs.h. */

8436

_ACEOF

8437

cat confdefs.h >>conftest.$ac_ext

8438

cat >>conftest.$ac_ext <<_ACEOF

8439

/* end confdefs.h. */

8440

/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

8441

For example, HP-UX 11i <limits.h> declares gettimeofday. */

8442

#define $ac_func innocuous_$ac_func

8443

8444

/* System header to define __stub macros and hopefully few prototypes,

8445

which can conflict with char $ac_func (); below.

8446

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

8447

<limits.h> exists even on freestanding compilers. */

8448

8449

#ifdef __STDC__

8450

# include <limits.h>

8451

#else

8452

# include <assert.h>

8453

#endif

8454

8455

#undef $ac_func

8456

8457

/* Override any gcc2 internal prototype to avoid an error. */

8458

#ifdef __cplusplus

8459

extern "C"

8460

{

8461

#endif

8462

/* We use char because int might match the return type of a gcc2

8463

builtin and then its argument prototype would still apply. */

8464

char $ac_func ();

8465

/* The GNU C library defines this for functions which it implements

8466

to always fail with ENOSYS. Some functions are actually named

8467

something starting with __ and the normal name is an alias. */

8468

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

8469

choke me

8470

#else

8471

char (*f) () = $ac_func;

8472

#endif

8473

#ifdef __cplusplus

8474

}

8475

#endif

8476

8477

int

8478

main ()

8479

{

8480

return f != $ac_func;

8481

;

8482

return 0;

8483

}

8484

_ACEOF

8485

rm -f conftest.$ac_objext conftest$ac_exeext

8486

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

8487

(eval $ac_link) 2>conftest.er1

8488

ac_status=$?

8489

grep -v '^ *+' conftest.er1 >conftest.err

8490

rm -f conftest.er1

8491

cat conftest.err >&5

8492

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8493

(exit $ac_status); } &&

8494

{ ac_try='test -z "$ac_c_werror_flag"

8495

|| test ! -s conftest.err'

8496

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8497

(eval $ac_try) 2>&5

8498

ac_status=$?

8499

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8500

(exit $ac_status); }; } &&

8501

{ ac_try='test -s conftest$ac_exeext'

8502

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8503

(eval $ac_try) 2>&5

8504

ac_status=$?

8505

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8506

(exit $ac_status); }; }; then

8507

eval "$as_ac_var=yes"

8508

else

8509

echo "$as_me: failed program was:" >&5

8510

sed 's/^/| /' conftest.$ac_ext >&5

8511

8512

eval "$as_ac_var=no"

8513

8514

rm -f conftest.err conftest.$ac_objext \

8515

conftest$ac_exeext conftest.$ac_ext

8516

8517

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

8518

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

8519

if test `eval echo '${'$as_ac_var'}'` = yes; then

8520

cat >>confdefs.h <<_ACEOF

8521

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

8522

_ACEOF

8523

8524

8525

done

8526

8527

8528

8529

8530

8531

8532

8533

for ac_func in gethostname gettimeofday select socket uname getopt_long

8534

8535

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

8536

echo "$as_me:$LINENO: checking for $ac_func" >&5

8537

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

8538

if eval "test \"\${$as_ac_var+set}\" = set"; then

8539

echo $ECHO_N "(cached) $ECHO_C" >&6

8540

else

8541

cat >conftest.$ac_ext <<_ACEOF

8542

/* confdefs.h. */

8543

_ACEOF

8544

cat confdefs.h >>conftest.$ac_ext

8545

cat >>conftest.$ac_ext <<_ACEOF

8546

/* end confdefs.h. */

8547

/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

8548

For example, HP-UX 11i <limits.h> declares gettimeofday. */

8549

#define $ac_func innocuous_$ac_func

8550

8551

/* System header to define __stub macros and hopefully few prototypes,

8552

which can conflict with char $ac_func (); below.

8553

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

8554

<limits.h> exists even on freestanding compilers. */

8555

8556

#ifdef __STDC__

8557

# include <limits.h>

8558

#else

8559

# include <assert.h>

8560

#endif

8561

8562

#undef $ac_func

8563

8564

/* Override any gcc2 internal prototype to avoid an error. */

8565

#ifdef __cplusplus

8566

extern "C"

8567

{

8568

#endif

8569

/* We use char because int might match the return type of a gcc2

8570

builtin and then its argument prototype would still apply. */

8571

char $ac_func ();

8572

/* The GNU C library defines this for functions which it implements

8573

to always fail with ENOSYS. Some functions are actually named

8574

something starting with __ and the normal name is an alias. */

8575

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

8576

choke me

8577

#else

8578

char (*f) () = $ac_func;

8579

#endif

8580

#ifdef __cplusplus

8581

}

8582

#endif

8583

8584

int

8585

main ()

8586

{

8587

return f != $ac_func;

8588

;

8589

return 0;

8590

}

8591

_ACEOF

8592

rm -f conftest.$ac_objext conftest$ac_exeext

8593

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

8594

(eval $ac_link) 2>conftest.er1

8595

ac_status=$?

8596

grep -v '^ *+' conftest.er1 >conftest.err

8597

rm -f conftest.er1

8598

cat conftest.err >&5

8599

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8600

(exit $ac_status); } &&

8601

{ ac_try='test -z "$ac_c_werror_flag"

8602

|| test ! -s conftest.err'

8603

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8604

(eval $ac_try) 2>&5

8605

ac_status=$?

8606

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8607

(exit $ac_status); }; } &&

8608

{ ac_try='test -s conftest$ac_exeext'

8609

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8610

(eval $ac_try) 2>&5

8611

ac_status=$?

8612

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8613

(exit $ac_status); }; }; then

8614

eval "$as_ac_var=yes"

8615

else

8616

echo "$as_me: failed program was:" >&5

8617

sed 's/^/| /' conftest.$ac_ext >&5

8618

8619

eval "$as_ac_var=no"

8620

8621

rm -f conftest.err conftest.$ac_objext \

8622

conftest$ac_exeext conftest.$ac_ext

8623

8624

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

8625

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

8626

if test `eval echo '${'$as_ac_var'}'` = yes; then

8627

cat >>confdefs.h <<_ACEOF

8628

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

8629

_ACEOF

8630

8631

8632

done

8633

8634

8635

8636

for ac_func in _rpc_dtablesize getdtablesize

8637

8638

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

8639

echo "$as_me:$LINENO: checking for $ac_func" >&5

8640

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

8641

if eval "test \"\${$as_ac_var+set}\" = set"; then

8642

echo $ECHO_N "(cached) $ECHO_C" >&6

8643

else

8644

cat >conftest.$ac_ext <<_ACEOF

8645

/* confdefs.h. */

8646

_ACEOF

8647

cat confdefs.h >>conftest.$ac_ext

8648

cat >>conftest.$ac_ext <<_ACEOF

8649

/* end confdefs.h. */

8650

/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

8651

For example, HP-UX 11i <limits.h> declares gettimeofday. */

8652

#define $ac_func innocuous_$ac_func

8653

8654

/* System header to define __stub macros and hopefully few prototypes,

8655

which can conflict with char $ac_func (); below.

8656

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

8657

<limits.h> exists even on freestanding compilers. */

8658

8659

#ifdef __STDC__

8660

# include <limits.h>

8661

#else

8662

# include <assert.h>

8663

#endif

8664

8665

#undef $ac_func

8666

8667

/* Override any gcc2 internal prototype to avoid an error. */

8668

#ifdef __cplusplus

8669

extern "C"

8670

{

8671

#endif

8672

/* We use char because int might match the return type of a gcc2

8673

builtin and then its argument prototype would still apply. */

8674

char $ac_func ();

8675

/* The GNU C library defines this for functions which it implements

8676

to always fail with ENOSYS. Some functions are actually named

8677

something starting with __ and the normal name is an alias. */

8678

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

8679

choke me

8680

#else

8681

char (*f) () = $ac_func;

8682

#endif

8683

#ifdef __cplusplus

8684

}

8685

#endif

8686

8687

int

8688

main ()

8689

{

8690

return f != $ac_func;

8691

;

8692

return 0;

8693

}

8694

_ACEOF

8695

rm -f conftest.$ac_objext conftest$ac_exeext

8696

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

8697

(eval $ac_link) 2>conftest.er1

8698

ac_status=$?

8699

grep -v '^ *+' conftest.er1 >conftest.err

8700

rm -f conftest.er1

8701

cat conftest.err >&5

8702

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8703

(exit $ac_status); } &&

8704

{ ac_try='test -z "$ac_c_werror_flag"

8705

|| test ! -s conftest.err'

8706

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8707

(eval $ac_try) 2>&5

8708

ac_status=$?

8709

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8710

(exit $ac_status); }; } &&

8711

{ ac_try='test -s conftest$ac_exeext'

8712

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8713

(eval $ac_try) 2>&5

8714

ac_status=$?

8715

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8716

(exit $ac_status); }; }; then

8717

eval "$as_ac_var=yes"

8718

else

8719

echo "$as_me: failed program was:" >&5

8720

sed 's/^/| /' conftest.$ac_ext >&5

8721

8722

eval "$as_ac_var=no"

8723

8724

rm -f conftest.err conftest.$ac_objext \

8725

conftest$ac_exeext conftest.$ac_ext

8726

8727

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

8728

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

8729

if test `eval echo '${'$as_ac_var'}'` = yes; then

8730

cat >>confdefs.h <<_ACEOF

8731

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

8732

_ACEOF

8733

8734

8735

done

8736

8737

8738

8739

8740

8741

for ac_func in svc_getcaller svc_getrpccaller getline getdelim

8742

8743

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

8744

echo "$as_me:$LINENO: checking for $ac_func" >&5

8745

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

8746

if eval "test \"\${$as_ac_var+set}\" = set"; then

8747

echo $ECHO_N "(cached) $ECHO_C" >&6

8748

else

8749

cat >conftest.$ac_ext <<_ACEOF

8750

/* confdefs.h. */

8751

_ACEOF

8752

cat confdefs.h >>conftest.$ac_ext

8753

cat >>conftest.$ac_ext <<_ACEOF

8754

/* end confdefs.h. */

8755

/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

8756

For example, HP-UX 11i <limits.h> declares gettimeofday. */

8757

#define $ac_func innocuous_$ac_func

8758

8759

/* System header to define __stub macros and hopefully few prototypes,

8760

which can conflict with char $ac_func (); below.

8761

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

8762

<limits.h> exists even on freestanding compilers. */

8763

8764

#ifdef __STDC__

8765

# include <limits.h>

8766

#else

8767

# include <assert.h>

8768

#endif

8769

8770

#undef $ac_func

8771

8772

/* Override any gcc2 internal prototype to avoid an error. */

8773

#ifdef __cplusplus

8774

extern "C"

8775

{

8776

#endif

8777

/* We use char because int might match the return type of a gcc2

8778

builtin and then its argument prototype would still apply. */

8779

char $ac_func ();

8780

/* The GNU C library defines this for functions which it implements

8781

to always fail with ENOSYS. Some functions are actually named

8782

something starting with __ and the normal name is an alias. */

8783

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

8784

choke me

8785

#else

8786

char (*f) () = $ac_func;

8787

#endif

8788

#ifdef __cplusplus

8789

}

8790

#endif

8791

8792

int

8793

main ()

8794

{

8795

return f != $ac_func;

8796

;

8797

return 0;

8798

}

8799

_ACEOF

8800

rm -f conftest.$ac_objext conftest$ac_exeext

8801

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

8802

(eval $ac_link) 2>conftest.er1

8803

ac_status=$?

8804

grep -v '^ *+' conftest.er1 >conftest.err

8805

rm -f conftest.er1

8806

cat conftest.err >&5

8807

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8808

(exit $ac_status); } &&

8809

{ ac_try='test -z "$ac_c_werror_flag"

8810

|| test ! -s conftest.err'

8811

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8812

(eval $ac_try) 2>&5

8813

ac_status=$?

8814

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8815

(exit $ac_status); }; } &&

8816

{ ac_try='test -s conftest$ac_exeext'

8817

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8818

(eval $ac_try) 2>&5

8819

ac_status=$?

8820

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8821

(exit $ac_status); }; }; then

8822

eval "$as_ac_var=yes"

8823

else

8824

echo "$as_me: failed program was:" >&5

8825

sed 's/^/| /' conftest.$ac_ext >&5

8826

8827

eval "$as_ac_var=no"

8828

8829

rm -f conftest.err conftest.$ac_objext \

8830

conftest$ac_exeext conftest.$ac_ext

8831

8832

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

8833

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

8834

if test `eval echo '${'$as_ac_var'}'` = yes; then

8835

cat >>confdefs.h <<_ACEOF

8836

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

8837

_ACEOF

8838

8839

8840

done

8841

8842

8843

8844

8845

8846

for ac_func in xdr_domainname xdr_ypxfrstat xdr_ypresp_xfr xdr_ypreq_xfr

8847

8848

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

8849

echo "$as_me:$LINENO: checking for $ac_func" >&5

8850

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

8851

if eval "test \"\${$as_ac_var+set}\" = set"; then

8852

echo $ECHO_N "(cached) $ECHO_C" >&6

8853

else

8854

cat >conftest.$ac_ext <<_ACEOF

8855

/* confdefs.h. */

8856

_ACEOF

8857

cat confdefs.h >>conftest.$ac_ext

8858

cat >>conftest.$ac_ext <<_ACEOF

8859

/* end confdefs.h. */

8860

/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

8861

For example, HP-UX 11i <limits.h> declares gettimeofday. */

8862

#define $ac_func innocuous_$ac_func

8863

8864

/* System header to define __stub macros and hopefully few prototypes,

8865

which can conflict with char $ac_func (); below.

8866

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

8867

<limits.h> exists even on freestanding compilers. */

8868

8869

#ifdef __STDC__

8870

# include <limits.h>

8871

#else

8872

# include <assert.h>

8873

#endif

8874

8875

#undef $ac_func

8876

8877

/* Override any gcc2 internal prototype to avoid an error. */

8878

#ifdef __cplusplus

8879

extern "C"

8880

{

8881

#endif

8882

/* We use char because int might match the return type of a gcc2

8883

builtin and then its argument prototype would still apply. */

8884

char $ac_func ();

8885

/* The GNU C library defines this for functions which it implements

8886

to always fail with ENOSYS. Some functions are actually named

8887

something starting with __ and the normal name is an alias. */

8888

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

8889

choke me

8890

#else

8891

char (*f) () = $ac_func;

8892

#endif

8893

#ifdef __cplusplus

8894

}

8895

#endif

8896

8897

int

8898

main ()

8899

{

8900

return f != $ac_func;

8901

;

8902

return 0;

8903

}

8904

_ACEOF

8905

rm -f conftest.$ac_objext conftest$ac_exeext

8906

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

8907

(eval $ac_link) 2>conftest.er1

8908

ac_status=$?

8909

grep -v '^ *+' conftest.er1 >conftest.err

8910

rm -f conftest.er1

8911

cat conftest.err >&5

8912

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8913

(exit $ac_status); } &&

8914

{ ac_try='test -z "$ac_c_werror_flag"

8915

|| test ! -s conftest.err'

8916

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8917

(eval $ac_try) 2>&5

8918

ac_status=$?

8919

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8920

(exit $ac_status); }; } &&

8921

{ ac_try='test -s conftest$ac_exeext'

8922

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

8923

(eval $ac_try) 2>&5

8924

ac_status=$?

8925

echo "$as_me:$LINENO: \$? = $ac_status" >&5

8926

(exit $ac_status); }; }; then

8927

eval "$as_ac_var=yes"

8928

else

8929

echo "$as_me: failed program was:" >&5

8930

sed 's/^/| /' conftest.$ac_ext >&5

8931

8932

eval "$as_ac_var=no"

8933

8934

rm -f conftest.err conftest.$ac_objext \

8935

conftest$ac_exeext conftest.$ac_ext

8936

8937

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

8938

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

8939

if test `eval echo '${'$as_ac_var'}'` = yes; then

8940

cat >>confdefs.h <<_ACEOF

8941

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

8942

_ACEOF

8943

8944

8945

done

8946

8947

8948

8949

8950

8951

for ac_func in xdr_ypmap_parms xdr_ypreq_nokey xdr_ypresp_master xdr_mapname

8952

8953

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

8954

echo "$as_me:$LINENO: checking for $ac_func" >&5

8955

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

8956

if eval "test \"\${$as_ac_var+set}\" = set"; then

8957

echo $ECHO_N "(cached) $ECHO_C" >&6

8958

else

8959

cat >conftest.$ac_ext <<_ACEOF

8960

/* confdefs.h. */

8961

_ACEOF

8962

cat confdefs.h >>conftest.$ac_ext

8963

cat >>conftest.$ac_ext <<_ACEOF

8964

/* end confdefs.h. */

8965

/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

8966

For example, HP-UX 11i <limits.h> declares gettimeofday. */

8967

#define $ac_func innocuous_$ac_func

8968

8969

/* System header to define __stub macros and hopefully few prototypes,

8970

which can conflict with char $ac_func (); below.

8971

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

8972

<limits.h> exists even on freestanding compilers. */

8973

8974

#ifdef __STDC__

8975

# include <limits.h>

8976

#else

8977

# include <assert.h>

8978

#endif

8979

8980

#undef $ac_func

8981

8982

/* Override any gcc2 internal prototype to avoid an error. */

8983

#ifdef __cplusplus

8984

extern "C"

8985

{

8986

#endif

8987

/* We use char because int might match the return type of a gcc2

8988

builtin and then its argument prototype would still apply. */

8989

char $ac_func ();

8990

/* The GNU C library defines this for functions which it implements

8991

to always fail with ENOSYS. Some functions are actually named

8992

something starting with __ and the normal name is an alias. */

8993

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

8994

choke me

8995

#else

8996

char (*f) () = $ac_func;

8997

#endif

8998

#ifdef __cplusplus

8999

}

9000

#endif

9001

9002

int

9003

main ()

9004

{

9005

return f != $ac_func;

9006

;

9007

return 0;

9008

}

9009

_ACEOF

9010

rm -f conftest.$ac_objext conftest$ac_exeext

9011

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

9012

(eval $ac_link) 2>conftest.er1

9013

ac_status=$?

9014

grep -v '^ *+' conftest.er1 >conftest.err

9015

rm -f conftest.er1

9016

cat conftest.err >&5

9017

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9018

(exit $ac_status); } &&

9019

{ ac_try='test -z "$ac_c_werror_flag"

9020

|| test ! -s conftest.err'

9021

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9022

(eval $ac_try) 2>&5

9023

ac_status=$?

9024

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9025

(exit $ac_status); }; } &&

9026

{ ac_try='test -s conftest$ac_exeext'

9027

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9028

(eval $ac_try) 2>&5

9029

ac_status=$?

9030

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9031

(exit $ac_status); }; }; then

9032

eval "$as_ac_var=yes"

9033

else

9034

echo "$as_me: failed program was:" >&5

9035

sed 's/^/| /' conftest.$ac_ext >&5

9036

9037

eval "$as_ac_var=no"

9038

9039

rm -f conftest.err conftest.$ac_objext \

9040

conftest$ac_exeext conftest.$ac_ext

9041

9042

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

9043

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

9044

if test `eval echo '${'$as_ac_var'}'` = yes; then

9045

cat >>confdefs.h <<_ACEOF

9046

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

9047

_ACEOF

9048

9049

9050

done

9051

9052

9053

9054

9055

9056

for ac_func in xdr_peername xdr_ypstat xdr_ypbind_binding xdr_yppushresp_xfr

9057

9058

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

9059

echo "$as_me:$LINENO: checking for $ac_func" >&5

9060

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

9061

if eval "test \"\${$as_ac_var+set}\" = set"; then

9062

echo $ECHO_N "(cached) $ECHO_C" >&6

9063

else

9064

cat >conftest.$ac_ext <<_ACEOF

9065

/* confdefs.h. */

9066

_ACEOF

9067

cat confdefs.h >>conftest.$ac_ext

9068

cat >>conftest.$ac_ext <<_ACEOF

9069

/* end confdefs.h. */

9070

/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

9071

For example, HP-UX 11i <limits.h> declares gettimeofday. */

9072

#define $ac_func innocuous_$ac_func

9073

9074

/* System header to define __stub macros and hopefully few prototypes,

9075

which can conflict with char $ac_func (); below.

9076

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

9077

<limits.h> exists even on freestanding compilers. */

9078

9079

#ifdef __STDC__

9080

# include <limits.h>

9081

#else

9082

# include <assert.h>

9083

#endif

9084

9085

#undef $ac_func

9086

9087

/* Override any gcc2 internal prototype to avoid an error. */

9088

#ifdef __cplusplus

9089

extern "C"

9090

{

9091

#endif

9092

/* We use char because int might match the return type of a gcc2

9093

builtin and then its argument prototype would still apply. */

9094

char $ac_func ();

9095

/* The GNU C library defines this for functions which it implements

9096

to always fail with ENOSYS. Some functions are actually named

9097

something starting with __ and the normal name is an alias. */

9098

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

9099

choke me

9100

#else

9101

char (*f) () = $ac_func;

9102

#endif

9103

#ifdef __cplusplus

9104

}

9105

#endif

9106

9107

int

9108

main ()

9109

{

9110

return f != $ac_func;

9111

;

9112

return 0;

9113

}

9114

_ACEOF

9115

rm -f conftest.$ac_objext conftest$ac_exeext

9116

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

9117

(eval $ac_link) 2>conftest.er1

9118

ac_status=$?

9119

grep -v '^ *+' conftest.er1 >conftest.err

9120

rm -f conftest.er1

9121

cat conftest.err >&5

9122

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9123

(exit $ac_status); } &&

9124

{ ac_try='test -z "$ac_c_werror_flag"

9125

|| test ! -s conftest.err'

9126

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9127

(eval $ac_try) 2>&5

9128

ac_status=$?

9129

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9130

(exit $ac_status); }; } &&

9131

{ ac_try='test -s conftest$ac_exeext'

9132

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9133

(eval $ac_try) 2>&5

9134

ac_status=$?

9135

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9136

(exit $ac_status); }; }; then

9137

eval "$as_ac_var=yes"

9138

else

9139

echo "$as_me: failed program was:" >&5

9140

sed 's/^/| /' conftest.$ac_ext >&5

9141

9142

eval "$as_ac_var=no"

9143

9144

rm -f conftest.err conftest.$ac_objext \

9145

conftest$ac_exeext conftest.$ac_ext

9146

9147

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

9148

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

9149

if test `eval echo '${'$as_ac_var'}'` = yes; then

9150

cat >>confdefs.h <<_ACEOF

9151

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

9152

_ACEOF

9153

9154

9155

done

9156

9157

9158

for ac_func in xdr_yppush_status

9159

9160

as_ac_var=`echo "ac_cv_func_$ac_func" | $as_tr_sh`

9161

echo "$as_me:$LINENO: checking for $ac_func" >&5

9162

echo $ECHO_N "checking for $ac_func... $ECHO_C" >&6

9163

if eval "test \"\${$as_ac_var+set}\" = set"; then

9164

echo $ECHO_N "(cached) $ECHO_C" >&6

9165

else

9166

cat >conftest.$ac_ext <<_ACEOF

9167

/* confdefs.h. */

9168

_ACEOF

9169

cat confdefs.h >>conftest.$ac_ext

9170

cat >>conftest.$ac_ext <<_ACEOF

9171

/* end confdefs.h. */

9172

/* Define $ac_func to an innocuous variant, in case <limits.h> declares $ac_func.

9173

For example, HP-UX 11i <limits.h> declares gettimeofday. */

9174

#define $ac_func innocuous_$ac_func

9175

9176

/* System header to define __stub macros and hopefully few prototypes,

9177

which can conflict with char $ac_func (); below.

9178

Prefer <limits.h> to <assert.h> if __STDC__ is defined, since

9179

<limits.h> exists even on freestanding compilers. */

9180

9181

#ifdef __STDC__

9182

# include <limits.h>

9183

#else

9184

# include <assert.h>

9185

#endif

9186

9187

#undef $ac_func

9188

9189

/* Override any gcc2 internal prototype to avoid an error. */

9190

#ifdef __cplusplus

9191

extern "C"

9192

{

9193

#endif

9194

/* We use char because int might match the return type of a gcc2

9195

builtin and then its argument prototype would still apply. */

9196

char $ac_func ();

9197

/* The GNU C library defines this for functions which it implements

9198

to always fail with ENOSYS. Some functions are actually named

9199

something starting with __ and the normal name is an alias. */

9200

#if defined (__stub_$ac_func) || defined (__stub___$ac_func)

9201

choke me

9202

#else

9203

char (*f) () = $ac_func;

9204

#endif

9205

#ifdef __cplusplus

9206

}

9207

#endif

9208

9209

int

9210

main ()

9211

{

9212

return f != $ac_func;

9213

;

9214

return 0;

9215

}

9216

_ACEOF

9217

rm -f conftest.$ac_objext conftest$ac_exeext

9218

if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5

9219

(eval $ac_link) 2>conftest.er1

9220

ac_status=$?

9221

grep -v '^ *+' conftest.er1 >conftest.err

9222

rm -f conftest.er1

9223

cat conftest.err >&5

9224

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9225

(exit $ac_status); } &&

9226

{ ac_try='test -z "$ac_c_werror_flag"

9227

|| test ! -s conftest.err'

9228

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9229

(eval $ac_try) 2>&5

9230

ac_status=$?

9231

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9232

(exit $ac_status); }; } &&

9233

{ ac_try='test -s conftest$ac_exeext'

9234

{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5

9235

(eval $ac_try) 2>&5

9236

ac_status=$?

9237

echo "$as_me:$LINENO: \$? = $ac_status" >&5

9238

(exit $ac_status); }; }; then

9239

eval "$as_ac_var=yes"

9240

else

9241

echo "$as_me: failed program was:" >&5

9242

sed 's/^/| /' conftest.$ac_ext >&5

9243

9244

eval "$as_ac_var=no"

9245

9246

rm -f conftest.err conftest.$ac_objext \

9247

conftest$ac_exeext conftest.$ac_ext

9248

9249

echo "$as_me:$LINENO: result: `eval echo '${'$as_ac_var'}'`" >&5

9250

echo "${ECHO_T}`eval echo '${'$as_ac_var'}'`" >&6

9251

if test `eval echo '${'$as_ac_var'}'` = yes; then

9252

cat >>confdefs.h <<_ACEOF

9253

#define `echo "HAVE_$ac_func" | $as_tr_cpp` 1

9254

_ACEOF

9255

9256

9257

done

9258

9259

9260

ac_config_files="$ac_config_files lib/Makefile etc/Makefile ypserv/Makefile ypserv/ypserv.8 ypxfr/Makefile ypxfr/ypxfr.8 yppush/Makefile yppush/yppush.8 makedbm/Makefile makedbm/makedbm.8 revnetgroup/Makefile revnetgroup/revnetgroup.8 Makefile mknetid/Makefile mknetid/mknetid.8 rpc.ypxfrd/Makefile rpc.ypxfrd/rpc.ypxfrd.8 rpc.ypxfrd/ypxfrd.8 rpc.yppasswdd/Makefile rpc.yppasswdd/yppasswdd.8 rpc.yppasswdd/rpc.yppasswdd.8 yphelper/Makefile scripts/Makefile scripts/ypxfr_1perhour scripts/ypxfr_1perday scripts/ypxfr_2perday scripts/pwupdate scripts/pwupdate.8 scripts/create_printcap scripts/match_printcap scripts/ypinit scripts/ypinit.8 scripts/ypMakefile"

9261

cat >confcache <<\_ACEOF

9262

# This file is a shell script that caches the results of configure

9263

# tests run on this system so they can be shared between configure

9264

# scripts and configure runs, see configure's option --config-cache.

9265

# It is not useful on other systems. If it contains results you don't

9266

# want to keep, you may remove or edit it.

9267

9268

# config.status only pays attention to the cache file if you give it

9269

# the --recheck option to rerun configure.

9270

9271

# `ac_cv_env_foo' variables (set or unset) will be overridden when

9272

# loading this file, other *unset* `ac_cv_foo' will be assigned the

9273

# following values.

9274

9275

_ACEOF

9276

9277

# The following way of writing the cache mishandles newlines in values,

9278

# but we know of no workaround that is simple, portable, and efficient.

9279

# So, don't put newlines in cache variables' values.

9280

# Ultrix sh set writes to stderr and can't be redirected directly,

9281

# and sets the high bit in the cache file unless we assign to the vars.

9282

{

9283

(set) 2>&1 |

9284

case `(ac_space=' '; set | grep ac_space) 2>&1` in

9285

*ac_space=\ *)

9286

# `set' does not quote correctly, so add quotes (double-quote

9287

# substitution turns \\\\ into \\, and sed turns \\ into \).

9288

sed -n \

9289

"s/'/'\\\\''/g;

9290

s/^\$[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\$=\$.*\$/\\1='\\2'/p"

9291

;;

9292

9293

# `set' quotes correctly as required by POSIX, so do not add quotes.

9294

sed -n \

9295

"s/^\$[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\$=\$.*\$/\\1=\\2/p"

9296

;;

9297

esac;

9298

} |

9299

sed '

9300

t clear

9301

: clear

9302

s/^$[^=]*$=$.*[{}].*$$/test "${\1+set}" = set || &/

9303

t end

9304

/^ac_cv_env/!s/^$[^=]*$=$.*$$/\1=${\1=\2}/

9305

: end' >>confcache

9306

if diff $cache_file confcache >/dev/null 2>&1; then :; else

9307

if test -w $cache_file; then

9308

test "x$cache_file" != "x/dev/null" && echo "updating cache $cache_file"

9309

cat confcache >$cache_file

9310

else

9311

echo "not updating unwritable cache $cache_file"

9312

9313

9314

rm -f confcache

9315

9316

test "x$prefix" = xNONE && prefix=$ac_default_prefix

9317

# Let make expand exec_prefix.

9318

test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'

9319

9320

# VPATH may cause trouble with some makes, so we remove $(srcdir),

9321

# ${srcdir} and @srcdir@ from VPATH if srcdir is ".", strip leading and

9322

# trailing colons and then remove the whole line if VPATH becomes empty

9323

# (actually we leave an empty line to preserve line numbers).

9324

if test "x$srcdir" = x.; then

9325

ac_vpsub='/^[ ]*VPATH[ ]*=/{

9326

s/:*\$(srcdir):*/:/;

9327

s/:*\${srcdir}:*/:/;

9328

s/:*@srcdir@:*/:/;

9329

s/^$[^=]*=[ ]*$:*/\1/;

9330

s/:*$//;

9331

s/^[^=]*=[ ]*$//;

9332

9333

9334

9335

DEFS=-DHAVE_CONFIG_H

9336

9337

ac_libobjs=

9338

ac_ltlibobjs=

9339

for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue

9340

# 1. Remove the extension, and $U if already installed.

9341

ac_i=`echo "$ac_i" |

9342

sed 's/\$U\././;s/\.o$//;s/\.obj$//'`

9343

# 2. Add them.

9344

ac_libobjs="$ac_libobjs $ac_i\$U.$ac_objext"

9345

ac_ltlibobjs="$ac_ltlibobjs $ac_i"'$U.lo'

9346

done

9347

LIBOBJS=$ac_libobjs

9348

9349

LTLIBOBJS=$ac_ltlibobjs

9350

9351

9352

if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then

9353

{ { echo "$as_me:$LINENO: error: conditional \"AMDEP\" was never defined.

9354

Usually this means the macro was only invoked conditionally." >&5

9355

echo "$as_me: error: conditional \"AMDEP\" was never defined.

9356

Usually this means the macro was only invoked conditionally." >&2;}

9357

{ (exit 1); exit 1; }; }

9358

9359

if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then

9360

{ { echo "$as_me:$LINENO: error: conditional \"am__fastdepCC\" was never defined.

9361

Usually this means the macro was only invoked conditionally." >&5

9362

echo "$as_me: error: conditional \"am__fastdepCC\" was never defined.

9363

Usually this means the macro was only invoked conditionally." >&2;}

9364

{ (exit 1); exit 1; }; }

9365

9366

9367

: ${CONFIG_STATUS=./config.status}

9368

ac_clean_files_save=$ac_clean_files

9369

ac_clean_files="$ac_clean_files $CONFIG_STATUS"

9370

{ echo "$as_me:$LINENO: creating $CONFIG_STATUS" >&5

9371

echo "$as_me: creating $CONFIG_STATUS" >&6;}

9372

cat >$CONFIG_STATUS <<_ACEOF

9373

#! $SHELL

9374

# Generated by $as_me.

9375

# Run this file to recreate the current configuration.

9376

# Compiler output produced by configure, useful for debugging

9377

# configure, is in config.log if it exists.

9378

9379

debug=false

9380

ac_cs_recheck=false

9381

ac_cs_silent=false

9382

SHELL=\${CONFIG_SHELL-$SHELL}

9383

_ACEOF

9384

9385

cat >>$CONFIG_STATUS <<\_ACEOF

9386

## --------------------- ##

9387

## M4sh Initialization. ##

9388

## --------------------- ##

9389

9390

# Be Bourne compatible

9391

if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then

9392

emulate sh

9393

NULLCMD=:

9394

# Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which

9395

# is contrary to our usage. Disable this feature.

9396

alias -g '${1+"$@"}'='"$@"'

9397

elif test -n "${BASH_VERSION+set}" && (set -o posix) >/dev/null 2>&1; then

9398

set -o posix

9399

9400

DUALCASE=1; export DUALCASE # for MKS sh

9401

9402

# Support unset when possible.

9403

if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then

9404

as_unset=unset

9405

else

9406

as_unset=false

9407

9408

9409

9410

# Work around bugs in pre-3.0 UWIN ksh.

9411

$as_unset ENV MAIL MAILPATH

9412

PS1='$ '

9413

PS2='> '

9414

PS4='+ '

9415

9416

# NLS nuisances.

9417

for as_var in \

9418

LANG LANGUAGE LC_ADDRESS LC_ALL LC_COLLATE LC_CTYPE LC_IDENTIFICATION \

9419

LC_MEASUREMENT LC_MESSAGES LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER \

9420

LC_TELEPHONE LC_TIME

9421

9422

if (set +x; test -z "`(eval $as_var=C; export $as_var) 2>&1`"); then

9423

eval $as_var=C; export $as_var

9424

else

9425

$as_unset $as_var

9426

9427

done

9428

9429

# Required to use basename.

9430

if expr a : '$a$' >/dev/null 2>&1; then

9431

as_expr=expr

9432

else

9433

as_expr=false

9434

9435

9436

if (basename /) >/dev/null 2>&1 && test "X`basename / 2>&1`" = "X/"; then

9437

as_basename=basename

9438

else

9439

as_basename=false

9440

9441

9442

9443

# Name of the executable.

9444

as_me=`$as_basename "$0" ||

9445

$as_expr X/"$0" : '.*/$[^/][^/]*$/*$' \| \

9446

X"$0" : 'X$//$$' \| \

9447

X"$0" : 'X$/$$' \| \

9448

. : '$.$' 2>/dev/null ||

9449

echo X/"$0" |

9450

sed '/^.*\/$[^/][^/]*$\/*$/{ s//\1/; q; }

9451

/^X\/$\/\/$$/{ s//\1/; q; }

9452

/^X\/$\/$.*/{ s//\1/; q; }

9453

s/.*/./; q'`

9454

9455

9456

# PATH needs CR, and LINENO needs CR and PATH.

9457

# Avoid depending upon Character Ranges.

9458

as_cr_letters='abcdefghijklmnopqrstuvwxyz'

9459

as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'

9460

as_cr_Letters=$as_cr_letters$as_cr_LETTERS

9461

as_cr_digits='0123456789'

9462

as_cr_alnum=$as_cr_Letters$as_cr_digits

9463

9464

# The user is always right.

9465

if test "${PATH_SEPARATOR+set}" != set; then

9466

echo "#! /bin/sh" >conf$$.sh

9467

echo "exit 0" >>conf$$.sh

9468

chmod +x conf$$.sh

9469

if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then

9470

PATH_SEPARATOR=';'

9471

else

9472

PATH_SEPARATOR=:

9473

9474

rm -f conf$$.sh

9475

9476

9477

9478

as_lineno_1=$LINENO

9479

as_lineno_2=$LINENO

9480

as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`

9481

test "x$as_lineno_1" != "x$as_lineno_2" &&

9482

test "x$as_lineno_3" = "x$as_lineno_2" || {

9483

# Find who we are. Look in the path if we contain no path at all

9484

# relative or not.

9485

case $0 in

9486

*[\\/]* ) as_myself=$0 ;;

9487

*) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

9488

for as_dir in $PATH

9489

9490

IFS=$as_save_IFS

9491

test -z "$as_dir" && as_dir=.

9492

test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break

9493

done

9494

9495

;;

9496

esac

9497

# We did not find ourselves, most probably we were run as `sh COMMAND'

9498

# in which case we are not to be found in the path.

9499

if test "x$as_myself" = x; then

9500

as_myself=$0

9501

9502

if test ! -f "$as_myself"; then

9503

{ { echo "$as_me:$LINENO: error: cannot find myself; rerun with an absolute path" >&5

9504

echo "$as_me: error: cannot find myself; rerun with an absolute path" >&2;}

9505

{ (exit 1); exit 1; }; }

9506

9507

case $CONFIG_SHELL in

9508

'')

9509

as_save_IFS=$IFS; IFS=$PATH_SEPARATOR

9510

for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH

9511

9512

IFS=$as_save_IFS

9513

test -z "$as_dir" && as_dir=.

9514

for as_base in sh bash ksh sh5; do

9515

case $as_dir in

9516

/*)

9517

if ("$as_dir/$as_base" -c '

9518

as_lineno_1=$LINENO

9519

as_lineno_2=$LINENO

9520

as_lineno_3=`(expr $as_lineno_1 + 1) 2>/dev/null`

9521

test "x$as_lineno_1" != "x$as_lineno_2" &&

9522

test "x$as_lineno_3" = "x$as_lineno_2" ') 2>/dev/null; then

9523

$as_unset BASH_ENV || test "${BASH_ENV+set}" != set || { BASH_ENV=; export BASH_ENV; }

9524

$as_unset ENV || test "${ENV+set}" != set || { ENV=; export ENV; }

9525

CONFIG_SHELL=$as_dir/$as_base

9526

export CONFIG_SHELL

9527

exec "$CONFIG_SHELL" "$0" ${1+"$@"}

9528

fi;;

9529

esac

9530

done

9531

done

9532

;;

9533

esac

9534

9535

# Create $as_me.lineno as a copy of $as_myself, but with $LINENO

9536

# uniformly replaced by the line number. The first 'sed' inserts a

9537

# line-number line before each line; the second 'sed' does the real

9538

# work. The second script uses 'N' to pair each line-number line

9539

# with the numbered line, and appends trailing '-' during

9540

# substitution so that $LINENO is not a special case at line end.

9541

# (Raja R Harinath suggested sed '=', and Paul Eggert wrote the

9542

# second 'sed' script. Blame Lee E. McMahon for sed's syntax. :-)

9543

sed '=' <$as_myself |

9544

sed '

9545

9546

s,$,-,

9547

: loop

9548

s,^$['$as_cr_digits']*$$.*$[$]LINENO$[^'$as_cr_alnum'_]$,\1\2\1\3,

9549

t loop

9550

s,-$,,

9551

s,^['$as_cr_digits']*\n,,

9552

' >$as_me.lineno &&

9553

chmod +x $as_me.lineno ||

9554

{ { echo "$as_me:$LINENO: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&5

9555

echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2;}

9556

{ (exit 1); exit 1; }; }

9557

9558

# Don't try to exec as it changes $[0], causing all sort of problems

9559

# (the dirname of $[0] is not the place where we might find the

9560

# original and so on. Autoconf is especially sensible to this).

9561

. ./$as_me.lineno

9562

# Exit status is that of the last command.

9563

exit

9564

}

9565

9566

9567

case `echo "testing\c"; echo 1,2,3`,`echo -n testing; echo 1,2,3` in

9568

*c*,-n*) ECHO_N= ECHO_C='

9569

' ECHO_T=' ' ;;

9570

*c*,* ) ECHO_N=-n ECHO_C= ECHO_T= ;;

9571

*) ECHO_N= ECHO_C='\c' ECHO_T= ;;

9572

esac

9573

9574

if expr a : '$a$' >/dev/null 2>&1; then

9575

as_expr=expr

9576

else

9577

as_expr=false

9578

9579

9580

rm -f conf$$ conf$$.exe conf$$.file

9581

echo >conf$$.file

9582

if ln -s conf$$.file conf$$ 2>/dev/null; then

9583

# We could just check for DJGPP; but this test a) works b) is more generic

9584

# and c) will remain valid once DJGPP supports symlinks (DJGPP 2.04).

9585

if test -f conf$$.exe; then

9586

# Don't use ln at all; we don't have any links

9587

as_ln_s='cp -p'

9588

else

9589

as_ln_s='ln -s'

9590

9591

elif ln conf$$.file conf$$ 2>/dev/null; then

9592

as_ln_s=ln

9593

else

9594

as_ln_s='cp -p'

9595

9596

rm -f conf$$ conf$$.exe conf$$.file

9597

9598

if mkdir -p . 2>/dev/null; then

9599

as_mkdir_p=:

9600

else

9601

test -d ./-p && rmdir ./-p

9602

as_mkdir_p=false

9603

9604

9605

as_executable_p="test -f"

9606

9607

# Sed expression to map a string onto a valid CPP name.

9608

as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"

9609

9610

# Sed expression to map a string onto a valid variable name.

9611

as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"

9612

9613

9614

# IFS

9615

# We need space, tab and new line, in precisely that order.

9616

as_nl='

9617

9618

IFS=" $as_nl"

9619

9620

# CDPATH.

9621

$as_unset CDPATH

9622

9623

exec 6>&1

9624

9625

# Open the log real soon, to keep \$[0] and so on meaningful, and to

9626

# report actual input values of CONFIG_FILES etc. instead of their

9627

# values after options handling. Logging --version etc. is OK.

9628

exec 5>>config.log

9629

{

9630

echo

9631

sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX

9632

## Running $as_me. ##

9633

_ASBOX

9634

} >&5

9635

cat >&5 <<_CSEOF

9636

9637

This file was extended by ypserv $as_me 2.18, which was

9638

generated by GNU Autoconf 2.59. Invocation command line was

9639

9640

CONFIG_FILES = $CONFIG_FILES

9641

CONFIG_HEADERS = $CONFIG_HEADERS

9642

CONFIG_LINKS = $CONFIG_LINKS

9643

CONFIG_COMMANDS = $CONFIG_COMMANDS

9644

$ $0 $@

9645

9646

_CSEOF

9647

echo "on `(hostname || uname -n) 2>/dev/null | sed 1q`" >&5

9648

echo >&5

9649

_ACEOF

9650

9651

# Files that config.status was made for.

9652

if test -n "$ac_config_files"; then

9653

echo "config_files=\"$ac_config_files\"" >>$CONFIG_STATUS

9654

9655

9656

if test -n "$ac_config_headers"; then

9657

echo "config_headers=\"$ac_config_headers\"" >>$CONFIG_STATUS

9658

9659

9660

if test -n "$ac_config_links"; then

9661

echo "config_links=\"$ac_config_links\"" >>$CONFIG_STATUS

9662

9663

9664

if test -n "$ac_config_commands"; then

9665

echo "config_commands=\"$ac_config_commands\"" >>$CONFIG_STATUS

9666

9667

9668

cat >>$CONFIG_STATUS <<\_ACEOF

9669

9670

ac_cs_usage="\

9671

\`$as_me' instantiates files from templates according to the

9672

current configuration.

9673

9674

Usage: $0 [OPTIONS] [FILE]...

9675

9676

-h, --help print this help, then exit

9677

-V, --version print version number, then exit

9678

-q, --quiet do not print progress messages

9679

-d, --debug don't remove temporary files

9680

--recheck update $as_me by reconfiguring in the same conditions

9681

--file=FILE[:TEMPLATE]

9682

instantiate the configuration file FILE

9683

--header=FILE[:TEMPLATE]

9684

instantiate the configuration header FILE

9685

9686

Configuration files:

9687

$config_files

9688

9689

Configuration headers:

9690

$config_headers

9691

9692

Configuration commands:

9693

$config_commands

9694

9695

Report bugs to <bug-autoconf@gnu.org>."

9696

_ACEOF

9697

9698

cat >>$CONFIG_STATUS <<_ACEOF

9699

ac_cs_version="\\

9700

ypserv config.status 2.18

9701

configured by $0, generated by GNU Autoconf 2.59,

9702

with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"

9703

9704

9705

This config.status script is free software; the Free Software Foundation

9706

gives unlimited permission to copy, distribute and modify it."

9707

srcdir=$srcdir

9708

INSTALL="$INSTALL"

9709

_ACEOF

9710

9711

cat >>$CONFIG_STATUS <<\_ACEOF

9712

# If no file are specified by the user, then we need to provide default

9713

# value. By we need to know if files were specified by the user.

9714

ac_need_defaults=:

9715

while test $# != 0

9716

9717

case $1 in

9718

--*=*)

9719

ac_option=`expr "x$1" : 'x$[^=]*$='`

9720

ac_optarg=`expr "x$1" : 'x[^=]*=$.*$'`

9721

ac_shift=:

9722

;;

9723

-*)

9724

ac_option=$1

9725

ac_optarg=$2

9726

ac_shift=shift

9727

;;

9728

*) # This is not an option, so the user has probably given explicit

9729

# arguments.

9730

ac_option=$1

9731

ac_need_defaults=false;;

9732

esac

9733

9734

case $ac_option in

9735

# Handling of the options.

9736

_ACEOF

9737

cat >>$CONFIG_STATUS <<\_ACEOF

9738

9739

ac_cs_recheck=: ;;

9740

--version | --vers* | -V )

9741

echo "$ac_cs_version"; exit 0 ;;

9742

--he | --h)

9743

# Conflict between --help and --header

9744

{ { echo "$as_me:$LINENO: error: ambiguous option: $1

9745

Try \`$0 --help' for more information." >&5

9746

echo "$as_me: error: ambiguous option: $1

9747

Try \`$0 --help' for more information." >&2;}

9748

{ (exit 1); exit 1; }; };;

9749

--help | --hel | -h )

9750

echo "$ac_cs_usage"; exit 0 ;;

9751

--debug | --d* | -d )

9752

debug=: ;;

9753

--file | --fil | --fi | --f )

9754

$ac_shift

9755

CONFIG_FILES="$CONFIG_FILES $ac_optarg"

9756

ac_need_defaults=false;;

9757

--header | --heade | --head | --hea )

9758

$ac_shift

9759

CONFIG_HEADERS="$CONFIG_HEADERS $ac_optarg"

9760

ac_need_defaults=false;;

9761

-q | -quiet | --quiet | --quie | --qui | --qu | --q \

9762

| -silent | --silent | --silen | --sile | --sil | --si | --s)

9763

ac_cs_silent=: ;;

9764

9765

# This is an error.

9766

-*) { { echo "$as_me:$LINENO: error: unrecognized option: $1

9767

Try \`$0 --help' for more information." >&5

9768

echo "$as_me: error: unrecognized option: $1

9769

Try \`$0 --help' for more information." >&2;}

9770

{ (exit 1); exit 1; }; } ;;

9771

9772

*) ac_config_targets="$ac_config_targets $1" ;;

9773

9774

esac

9775

shift

9776

done

9777

9778

ac_configure_extra_args=

9779

9780

if $ac_cs_silent; then

9781

exec 6>/dev/null

9782

ac_configure_extra_args="$ac_configure_extra_args --silent"

9783

9784

9785

_ACEOF

9786

cat >>$CONFIG_STATUS <<_ACEOF

9787

if \$ac_cs_recheck; then

9788

echo "running $SHELL $0 " $ac_configure_args \$ac_configure_extra_args " --no-create --no-recursion" >&6

9789

exec $SHELL $0 $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion

9790

9791

9792

_ACEOF

9793

9794

cat >>$CONFIG_STATUS <<_ACEOF

9795

9796

# INIT-COMMANDS section.

9797

9798

9799

AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"

9800

9801

_ACEOF

9802

9803

9804

9805

cat >>$CONFIG_STATUS <<\_ACEOF

9806

for ac_config_target in $ac_config_targets

9807

9808

case "$ac_config_target" in

9809

# Handling of arguments.

9810

"lib/Makefile" ) CONFIG_FILES="$CONFIG_FILES lib/Makefile" ;;

9811

"etc/Makefile" ) CONFIG_FILES="$CONFIG_FILES etc/Makefile" ;;

9812

"ypserv/Makefile" ) CONFIG_FILES="$CONFIG_FILES ypserv/Makefile" ;;

9813

"ypserv/ypserv.8" ) CONFIG_FILES="$CONFIG_FILES ypserv/ypserv.8" ;;

9814

"ypxfr/Makefile" ) CONFIG_FILES="$CONFIG_FILES ypxfr/Makefile" ;;

9815

"ypxfr/ypxfr.8" ) CONFIG_FILES="$CONFIG_FILES ypxfr/ypxfr.8" ;;

9816

"yppush/Makefile" ) CONFIG_FILES="$CONFIG_FILES yppush/Makefile" ;;

9817

"yppush/yppush.8" ) CONFIG_FILES="$CONFIG_FILES yppush/yppush.8" ;;

9818

"makedbm/Makefile" ) CONFIG_FILES="$CONFIG_FILES makedbm/Makefile" ;;

9819

"makedbm/makedbm.8" ) CONFIG_FILES="$CONFIG_FILES makedbm/makedbm.8" ;;

9820

"revnetgroup/Makefile" ) CONFIG_FILES="$CONFIG_FILES revnetgroup/Makefile" ;;

9821

"revnetgroup/revnetgroup.8" ) CONFIG_FILES="$CONFIG_FILES revnetgroup/revnetgroup.8" ;;

9822

"Makefile" ) CONFIG_FILES="$CONFIG_FILES Makefile" ;;

9823

"mknetid/Makefile" ) CONFIG_FILES="$CONFIG_FILES mknetid/Makefile" ;;

9824

"mknetid/mknetid.8" ) CONFIG_FILES="$CONFIG_FILES mknetid/mknetid.8" ;;

9825

"rpc.ypxfrd/Makefile" ) CONFIG_FILES="$CONFIG_FILES rpc.ypxfrd/Makefile" ;;

9826

"rpc.ypxfrd/rpc.ypxfrd.8" ) CONFIG_FILES="$CONFIG_FILES rpc.ypxfrd/rpc.ypxfrd.8" ;;

9827

"rpc.ypxfrd/ypxfrd.8" ) CONFIG_FILES="$CONFIG_FILES rpc.ypxfrd/ypxfrd.8" ;;

9828

"rpc.yppasswdd/Makefile" ) CONFIG_FILES="$CONFIG_FILES rpc.yppasswdd/Makefile" ;;

9829

"rpc.yppasswdd/yppasswdd.8" ) CONFIG_FILES="$CONFIG_FILES rpc.yppasswdd/yppasswdd.8" ;;

9830

"rpc.yppasswdd/rpc.yppasswdd.8" ) CONFIG_FILES="$CONFIG_FILES rpc.yppasswdd/rpc.yppasswdd.8" ;;

9831

"yphelper/Makefile" ) CONFIG_FILES="$CONFIG_FILES yphelper/Makefile" ;;

9832

"scripts/Makefile" ) CONFIG_FILES="$CONFIG_FILES scripts/Makefile" ;;

9833

"scripts/ypxfr_1perhour" ) CONFIG_FILES="$CONFIG_FILES scripts/ypxfr_1perhour" ;;

9834

"scripts/ypxfr_1perday" ) CONFIG_FILES="$CONFIG_FILES scripts/ypxfr_1perday" ;;

9835

"scripts/ypxfr_2perday" ) CONFIG_FILES="$CONFIG_FILES scripts/ypxfr_2perday" ;;

9836

"scripts/pwupdate" ) CONFIG_FILES="$CONFIG_FILES scripts/pwupdate" ;;

9837

"scripts/pwupdate.8" ) CONFIG_FILES="$CONFIG_FILES scripts/pwupdate.8" ;;

9838

"scripts/create_printcap" ) CONFIG_FILES="$CONFIG_FILES scripts/create_printcap" ;;

9839

"scripts/match_printcap" ) CONFIG_FILES="$CONFIG_FILES scripts/match_printcap" ;;

9840

"scripts/ypinit" ) CONFIG_FILES="$CONFIG_FILES scripts/ypinit" ;;

9841

"scripts/ypinit.8" ) CONFIG_FILES="$CONFIG_FILES scripts/ypinit.8" ;;

9842

"scripts/ypMakefile" ) CONFIG_FILES="$CONFIG_FILES scripts/ypMakefile" ;;

9843

"depfiles" ) CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;

9844

"config.h" ) CONFIG_HEADERS="$CONFIG_HEADERS config.h" ;;

9845

*) { { echo "$as_me:$LINENO: error: invalid argument: $ac_config_target" >&5

9846

echo "$as_me: error: invalid argument: $ac_config_target" >&2;}

9847

{ (exit 1); exit 1; }; };;

9848

esac

9849

done

9850

9851

# If the user did not use the arguments to specify the items to instantiate,

9852

# then the envvar interface is used. Set only those that are not.

9853

# We use the long form for the default assignment because of an extremely

9854

# bizarre bug on SunOS 4.1.3.

9855

if $ac_need_defaults; then

9856

test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files

9857

test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers

9858

test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands

9859

9860

9861

# Have a temporary directory for convenience. Make it in the build tree

9862

# simply because there is no reason to put it here, and in addition,

9863

# creating and moving files from /tmp can sometimes cause problems.

9864

# Create a temporary directory, and hook for its removal unless debugging.

9865

$debug ||

9866

{

9867

trap 'exit_status=$?; rm -rf $tmp && exit $exit_status' 0

9868

trap '{ (exit 1); exit 1; }' 1 2 13 15

9869

}

9870

9871

# Create a (secure) tmp directory for tmp files.

9872

9873

{

9874

tmp=`(umask 077 && mktemp -d -q "./confstatXXXXXX") 2>/dev/null` &&

9875

test -n "$tmp" && test -d "$tmp"

9876

} ||

9877

{

9878

tmp=./confstat$$-$RANDOM

9879

(umask 077 && mkdir $tmp)

9880

} ||

9881

{

9882

echo "$me: cannot create a temporary directory in ." >&2

9883

{ (exit 1); exit 1; }

9884

}

9885

9886

_ACEOF

9887

9888

cat >>$CONFIG_STATUS <<_ACEOF

9889

9890

9891

# CONFIG_FILES section.

9892

9893

9894

# No need to generate the scripts if there are no CONFIG_FILES.

9895

# This happens for instance when ./config.status config.h

9896

if test -n "\$CONFIG_FILES"; then

9897

# Protect against being on the right side of a sed subst in config.status.

9898

sed 's/,@/@@/; s/@,/@@/; s/,;t t\$/@;t t/; /@;t t\$/s/[\\\\&,]/\\\\&/g;

9899

s/@@/,@/; s/@@/@,/; s/@;t t\$/,;t t/' >\$tmp/subs.sed <<\\CEOF

9900

s,@SHELL@,$SHELL,;t t

9901

s,@PATH_SEPARATOR@,$PATH_SEPARATOR,;t t

9902

s,@PACKAGE_NAME@,$PACKAGE_NAME,;t t

9903

s,@PACKAGE_TARNAME@,$PACKAGE_TARNAME,;t t

9904

s,@PACKAGE_VERSION@,$PACKAGE_VERSION,;t t

9905

s,@PACKAGE_STRING@,$PACKAGE_STRING,;t t

9906

s,@PACKAGE_BUGREPORT@,$PACKAGE_BUGREPORT,;t t

9907

s,@exec_prefix@,$exec_prefix,;t t

9908

s,@prefix@,$prefix,;t t

9909

s,@program_transform_name@,$program_transform_name,;t t

9910

s,@bindir@,$bindir,;t t

9911

s,@sbindir@,$sbindir,;t t

9912

s,@libexecdir@,$libexecdir,;t t

9913

s,@datadir@,$datadir,;t t

9914

s,@sysconfdir@,$sysconfdir,;t t

9915

s,@sharedstatedir@,$sharedstatedir,;t t

9916

s,@localstatedir@,$localstatedir,;t t

9917

s,@libdir@,$libdir,;t t

9918

s,@includedir@,$includedir,;t t

9919

s,@oldincludedir@,$oldincludedir,;t t

9920

s,@infodir@,$infodir,;t t

9921

s,@mandir@,$mandir,;t t

9922

s,@build_alias@,$build_alias,;t t

9923

s,@host_alias@,$host_alias,;t t

9924

s,@target_alias@,$target_alias,;t t

9925

s,@DEFS@,$DEFS,;t t

9926

s,@ECHO_C@,$ECHO_C,;t t

9927

s,@ECHO_N@,$ECHO_N,;t t

9928

s,@ECHO_T@,$ECHO_T,;t t

9929

s,@LIBS@,$LIBS,;t t

9930

s,@INSTALL_PROGRAM@,$INSTALL_PROGRAM,;t t

9931

s,@INSTALL_SCRIPT@,$INSTALL_SCRIPT,;t t

9932

s,@INSTALL_DATA@,$INSTALL_DATA,;t t

9933

s,@CYGPATH_W@,$CYGPATH_W,;t t

9934

s,@PACKAGE@,$PACKAGE,;t t

9935

s,@VERSION@,$VERSION,;t t

9936

s,@ACLOCAL@,$ACLOCAL,;t t

9937

s,@AUTOCONF@,$AUTOCONF,;t t

9938

s,@AUTOMAKE@,$AUTOMAKE,;t t

9939

s,@AUTOHEADER@,$AUTOHEADER,;t t

9940

s,@MAKEINFO@,$MAKEINFO,;t t

9941

s,@install_sh@,$install_sh,;t t

9942

s,@STRIP@,$STRIP,;t t

9943

s,@ac_ct_STRIP@,$ac_ct_STRIP,;t t

9944

s,@INSTALL_STRIP_PROGRAM@,$INSTALL_STRIP_PROGRAM,;t t

9945

s,@mkdir_p@,$mkdir_p,;t t

9946

s,@AWK@,$AWK,;t t

9947

s,@SET_MAKE@,$SET_MAKE,;t t

9948

s,@am__leading_dot@,$am__leading_dot,;t t

9949

s,@AMTAR@,$AMTAR,;t t

9950

s,@am__tar@,$am__tar,;t t

9951

s,@am__untar@,$am__untar,;t t

9952

s,@YPBINDIR@,$YPBINDIR,;t t

9953

s,@YPMAPDIR@,$YPMAPDIR,;t t

9954

s,@SBINDIR@,$SBINDIR,;t t

9955

s,@CC@,$CC,;t t

9956

s,@CFLAGS@,$CFLAGS,;t t

9957

s,@LDFLAGS@,$LDFLAGS,;t t

9958

s,@CPPFLAGS@,$CPPFLAGS,;t t

9959

s,@ac_ct_CC@,$ac_ct_CC,;t t

9960

s,@EXEEXT@,$EXEEXT,;t t

9961

s,@OBJEXT@,$OBJEXT,;t t

9962

s,@DEPDIR@,$DEPDIR,;t t

9963

s,@am__include@,$am__include,;t t

9964

s,@am__quote@,$am__quote,;t t

9965

s,@AMDEP_TRUE@,$AMDEP_TRUE,;t t

9966

s,@AMDEP_FALSE@,$AMDEP_FALSE,;t t

9967

s,@AMDEPBACKSLASH@,$AMDEPBACKSLASH,;t t

9968

s,@CCDEPMODE@,$CCDEPMODE,;t t

9969

s,@am__fastdepCC_TRUE@,$am__fastdepCC_TRUE,;t t

9970

s,@am__fastdepCC_FALSE@,$am__fastdepCC_FALSE,;t t

9971

s,@CPP@,$CPP,;t t

9972

s,@RANLIB@,$RANLIB,;t t

9973

s,@ac_ct_RANLIB@,$ac_ct_RANLIB,;t t

9974

s,@libc_cv_fpie@,$libc_cv_fpie,;t t

9975

s,@PIE_CFLAGS@,$PIE_CFLAGS,;t t

9976

s,@PIE_LDFLAGS@,$PIE_LDFLAGS,;t t

9977

s,@EGREP@,$EGREP,;t t

9978

s,@BASH@,$BASH,;t t

9979

s,@MAKE@,$MAKE,;t t

9980

s,@ALIASES@,$ALIASES,;t t

9981

s,@USE_FQDN@,$USE_FQDN,;t t

9982

s,@CHECKROOT@,$CHECKROOT,;t t

9983

s,@LIBDBM@,$LIBDBM,;t t

9984

s,@LIBCRYPT@,$LIBCRYPT,;t t

9985

s,@LIBSLP@,$LIBSLP,;t t

9986

s,@USE_SLP@,$USE_SLP,;t t

9987

s,@RESOLV@,$RESOLV,;t t

9988

s,@LIBOBJS@,$LIBOBJS,;t t

9989

s,@LTLIBOBJS@,$LTLIBOBJS,;t t

9990

CEOF

9991

9992

_ACEOF

9993

9994

cat >>$CONFIG_STATUS <<\_ACEOF

9995

# Split the substitutions into bite-sized pieces for seds with

9996

# small command number limits, like on Digital OSF/1 and HP-UX.

9997

ac_max_sed_lines=48

9998

ac_sed_frag=1 # Number of current file.

9999

ac_beg=1 # First line for current file.

10000

ac_end=$ac_max_sed_lines # Line after last line for current file.

10001

ac_more_lines=:

10002

ac_sed_cmds=

10003

while $ac_more_lines; do

10004

if test $ac_beg -gt 1; then

10005

sed "1,${ac_beg}d; ${ac_end}q" $tmp/subs.sed >$tmp/subs.frag

10006

else

10007

sed "${ac_end}q" $tmp/subs.sed >$tmp/subs.frag

10008

10009

if test ! -s $tmp/subs.frag; then

10010

ac_more_lines=false

10011

else

10012

# The purpose of the label and of the branching condition is to

10013

# speed up the sed processing (if there are no `@' at all, there

10014

# is no need to browse any of the substitutions).

10015

# These are the two extra sed commands mentioned above.

10016

(echo ':t

10017

/@[a-zA-Z_][a-zA-Z_0-9]*@/!b' && cat $tmp/subs.frag) >$tmp/subs-$ac_sed_frag.sed

10018

if test -z "$ac_sed_cmds"; then

10019

ac_sed_cmds="sed -f $tmp/subs-$ac_sed_frag.sed"

10020

else

10021

ac_sed_cmds="$ac_sed_cmds | sed -f $tmp/subs-$ac_sed_frag.sed"

10022

10023

ac_sed_frag=`expr $ac_sed_frag + 1`

10024

ac_beg=$ac_end

10025

ac_end=`expr $ac_end + $ac_max_sed_lines`

10026

10027

done

10028

if test -z "$ac_sed_cmds"; then

10029

ac_sed_cmds=cat

10030

10031

fi # test -n "$CONFIG_FILES"

10032

10033

_ACEOF

10034

cat >>$CONFIG_STATUS <<\_ACEOF

10035

for ac_file in : $CONFIG_FILES; do test "x$ac_file" = x: && continue

10036

# Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".

10037

case $ac_file in

10038

- | *:- | *:-:* ) # input from stdin

10039

cat >$tmp/stdin

10040

ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`

10041

ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;

10042

*:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`

10043

ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;

10044

* ) ac_file_in=$ac_file.in ;;

10045

esac

10046

10047

# Compute @srcdir@, @top_srcdir@, and @INSTALL@ for subdirectories.

10048

ac_dir=`(dirname "$ac_file") 2>/dev/null ||

10049

$as_expr X"$ac_file" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

10050

X"$ac_file" : 'X$//$[^/]' \| \

10051

X"$ac_file" : 'X$//$$' \| \

10052

X"$ac_file" : 'X$/$' \| \

10053

. : '$.$' 2>/dev/null ||

10054

echo X"$ac_file" |

10055

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

10056

/^X$\/\/$[^/].*/{ s//\1/; q; }

10057

/^X$\/\/$$/{ s//\1/; q; }

10058

/^X$\/$.*/{ s//\1/; q; }

10059

s/.*/./; q'`

10060

{ if $as_mkdir_p; then

10061

mkdir -p "$ac_dir"

10062

else

10063

as_dir="$ac_dir"

10064

as_dirs=

10065

while test ! -d "$as_dir"; do

10066

as_dirs="$as_dir $as_dirs"

10067

as_dir=`(dirname "$as_dir") 2>/dev/null ||

10068

$as_expr X"$as_dir" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

10069

X"$as_dir" : 'X$//$[^/]' \| \

10070

X"$as_dir" : 'X$//$$' \| \

10071

X"$as_dir" : 'X$/$' \| \

10072

. : '$.$' 2>/dev/null ||

10073

echo X"$as_dir" |

10074

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

10075

/^X$\/\/$[^/].*/{ s//\1/; q; }

10076

/^X$\/\/$$/{ s//\1/; q; }

10077

/^X$\/$.*/{ s//\1/; q; }

10078

s/.*/./; q'`

10079

done

10080

test ! -n "$as_dirs" || mkdir $as_dirs

10081

fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5

10082

echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}

10083

{ (exit 1); exit 1; }; }; }

10084

10085

ac_builddir=.

10086

10087

if test "$ac_dir" != .; then

10088

ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`

10089

# A "../" for each directory in $ac_dir_suffix.

10090

ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`

10091

else

10092

ac_dir_suffix= ac_top_builddir=

10093

10094

10095

case $srcdir in

10096

.) # No --srcdir option. We are building in place.

10097

ac_srcdir=.

10098

if test -z "$ac_top_builddir"; then

10099

ac_top_srcdir=.

10100

else

10101

ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`

10102

fi ;;

10103

[\\/]* | ?:[\\/]* ) # Absolute path.

10104

ac_srcdir=$srcdir$ac_dir_suffix;

10105

ac_top_srcdir=$srcdir ;;

10106

*) # Relative path.

10107

ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix

10108

ac_top_srcdir=$ac_top_builddir$srcdir ;;

10109

esac

10110

10111

# Do not use `cd foo && pwd` to compute absolute paths, because

10112

# the directories may not exist.

10113

case `pwd` in

10114

.) ac_abs_builddir="$ac_dir";;

10115

10116

case "$ac_dir" in

10117

.) ac_abs_builddir=`pwd`;;

10118

[\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;

10119

*) ac_abs_builddir=`pwd`/"$ac_dir";;

10120

esac;;

10121

esac

10122

case $ac_abs_builddir in

10123

.) ac_abs_top_builddir=${ac_top_builddir}.;;

10124

10125

case ${ac_top_builddir}. in

10126

.) ac_abs_top_builddir=$ac_abs_builddir;;

10127

[\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;

10128

*) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;

10129

esac;;

10130

esac

10131

case $ac_abs_builddir in

10132

.) ac_abs_srcdir=$ac_srcdir;;

10133

10134

case $ac_srcdir in

10135

.) ac_abs_srcdir=$ac_abs_builddir;;

10136

[\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;

10137

*) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;

10138

esac;;

10139

esac

10140

case $ac_abs_builddir in

10141

.) ac_abs_top_srcdir=$ac_top_srcdir;;

10142

10143

case $ac_top_srcdir in

10144

.) ac_abs_top_srcdir=$ac_abs_builddir;;

10145

[\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;

10146

*) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;

10147

esac;;

10148

esac

10149

10150

10151

case $INSTALL in

10152

[\\/$]* | ?:[\\/]* ) ac_INSTALL=$INSTALL ;;

10153

*) ac_INSTALL=$ac_top_builddir$INSTALL ;;

10154

esac

10155

10156

if test x"$ac_file" != x-; then

10157

{ echo "$as_me:$LINENO: creating $ac_file" >&5

10158

echo "$as_me: creating $ac_file" >&6;}

10159

rm -f "$ac_file"

10160

10161

# Let's still pretend it is `configure' which instantiates (i.e., don't

10162

# use $as_me), people would be surprised to read:

10163

# /* config.h. Generated by config.status. */

10164

if test x"$ac_file" = x-; then

10165

configure_input=

10166

else

10167

configure_input="$ac_file. "

10168

10169

configure_input=$configure_input"Generated from `echo $ac_file_in |

10170

sed 's,.*/,,'` by configure."

10171

10172

# First look for the input files in the build tree, otherwise in the

10173

# src tree.

10174

ac_file_inputs=`IFS=:

10175

for f in $ac_file_in; do

10176

case $f in

10177

-) echo $tmp/stdin ;;

10178

[\\/$]*)

10179

# Absolute (can't be DOS-style, as IFS=:)

10180

test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5

10181

echo "$as_me: error: cannot find input file: $f" >&2;}

10182

{ (exit 1); exit 1; }; }

10183

echo "$f";;

10184

*) # Relative

10185

if test -f "$f"; then

10186

# Build tree

10187

echo "$f"

10188

elif test -f "$srcdir/$f"; then

10189

# Source tree

10190

echo "$srcdir/$f"

10191

else

10192

# /dev/null tree

10193

{ { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5

10194

echo "$as_me: error: cannot find input file: $f" >&2;}

10195

{ (exit 1); exit 1; }; }

10196

fi;;

10197

esac

10198

done` || { (exit 1); exit 1; }

10199

_ACEOF

10200

cat >>$CONFIG_STATUS <<_ACEOF

10201

sed "$ac_vpsub

10202

$extrasub

10203

_ACEOF

10204

cat >>$CONFIG_STATUS <<\_ACEOF

10205

10206

/@[a-zA-Z_][a-zA-Z_0-9]*@/!b

10207

s,@configure_input@,$configure_input,;t t

10208

s,@srcdir@,$ac_srcdir,;t t

10209

s,@abs_srcdir@,$ac_abs_srcdir,;t t

10210

s,@top_srcdir@,$ac_top_srcdir,;t t

10211

s,@abs_top_srcdir@,$ac_abs_top_srcdir,;t t

10212

s,@builddir@,$ac_builddir,;t t

10213

s,@abs_builddir@,$ac_abs_builddir,;t t

10214

s,@top_builddir@,$ac_top_builddir,;t t

10215

s,@abs_top_builddir@,$ac_abs_top_builddir,;t t

10216

s,@INSTALL@,$ac_INSTALL,;t t

10217

" $ac_file_inputs | (eval "$ac_sed_cmds") >$tmp/out

10218

rm -f $tmp/stdin

10219

if test x"$ac_file" != x-; then

10220

mv $tmp/out $ac_file

10221

else

10222

cat $tmp/out

10223

rm -f $tmp/out

10224

10225

10226

done

10227

_ACEOF

10228

cat >>$CONFIG_STATUS <<\_ACEOF

10229

10230

10231

# CONFIG_HEADER section.

10232

10233

10234

# These sed commands are passed to sed as "A NAME B NAME C VALUE D", where

10235

# NAME is the cpp macro being defined and VALUE is the value it is being given.

10236

10237

# ac_d sets the value in "#define NAME VALUE" lines.

10238

ac_dA='s,^$[ ]*$#$[ ]*define[ ][ ]*$'

10239

ac_dB='[ ].*$,\1#\2'

10240

ac_dC=' '

10241

ac_dD=',;t'

10242

# ac_u turns "#undef NAME" without trailing blanks into "#define NAME VALUE".

10243

ac_uA='s,^$[ ]*$#$[ ]*$undef$[ ][ ]*$'

10244

ac_uB='$,\1#\2define\3'

10245

ac_uC=' '

10246

ac_uD=',;t'

10247

10248

for ac_file in : $CONFIG_HEADERS; do test "x$ac_file" = x: && continue

10249

# Support "outfile[:infile[:infile...]]", defaulting infile="outfile.in".

10250

case $ac_file in

10251

- | *:- | *:-:* ) # input from stdin

10252

cat >$tmp/stdin

10253

ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`

10254

ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;

10255

*:* ) ac_file_in=`echo "$ac_file" | sed 's,[^:]*:,,'`

10256

ac_file=`echo "$ac_file" | sed 's,:.*,,'` ;;

10257

* ) ac_file_in=$ac_file.in ;;

10258

esac

10259

10260

test x"$ac_file" != x- && { echo "$as_me:$LINENO: creating $ac_file" >&5

10261

echo "$as_me: creating $ac_file" >&6;}

10262

10263

# First look for the input files in the build tree, otherwise in the

10264

# src tree.

10265

ac_file_inputs=`IFS=:

10266

for f in $ac_file_in; do

10267

case $f in

10268

-) echo $tmp/stdin ;;

10269

[\\/$]*)

10270

# Absolute (can't be DOS-style, as IFS=:)

10271

test -f "$f" || { { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5

10272

echo "$as_me: error: cannot find input file: $f" >&2;}

10273

{ (exit 1); exit 1; }; }

10274

# Do quote $f, to prevent DOS paths from being IFS'd.

10275

echo "$f";;

10276

*) # Relative

10277

if test -f "$f"; then

10278

# Build tree

10279

echo "$f"

10280

elif test -f "$srcdir/$f"; then

10281

# Source tree

10282

echo "$srcdir/$f"

10283

else

10284

# /dev/null tree

10285

{ { echo "$as_me:$LINENO: error: cannot find input file: $f" >&5

10286

echo "$as_me: error: cannot find input file: $f" >&2;}

10287

{ (exit 1); exit 1; }; }

10288

fi;;

10289

esac

10290

done` || { (exit 1); exit 1; }

10291

# Remove the trailing spaces.

10292

sed 's/[ ]*$//' $ac_file_inputs >$tmp/in

10293

10294

_ACEOF

10295

10296

# Transform confdefs.h into two sed scripts, `conftest.defines' and

10297

# `conftest.undefs', that substitutes the proper values into

10298

# config.h.in to produce config.h. The first handles `#define'

10299

# templates, and the second `#undef' templates.

10300

# And first: Protect against being on the right side of a sed subst in

10301

# config.status. Protect against being in an unquoted here document

10302

# in config.status.

10303

rm -f conftest.defines conftest.undefs

10304

# Using a here document instead of a string reduces the quoting nightmare.

10305

# Putting comments in sed scripts is not portable.

10306

10307

# `end' is used to avoid that the second main sed command (meant for

10308

# 0-ary CPP macros) applies to n-ary macro definitions.

10309

# See the Autoconf documentation for `clear'.

10310

cat >confdef2sed.sed <<\_ACEOF

10311

s/[\\&,]/\\&/g

10312

s,[\\$`],\\&,g

10313

t clear

10314

: clear

10315

s,^[ ]*#[ ]*define[ ][ ]*$[^ (][^ (]*$$([^)]*)$[ ]*$.*$$,${ac_dA}\1${ac_dB}\1\2${ac_dC}\3${ac_dD},gp

10316

t end

10317

s,^[ ]*#[ ]*define[ ][ ]*$[^ ][^ ]*$[ ]*$.*$$,${ac_dA}\1${ac_dB}\1${ac_dC}\2${ac_dD},gp

10318

: end

10319

_ACEOF

10320

# If some macros were called several times there might be several times

10321

# the same #defines, which is useless. Nevertheless, we may not want to

10322

# sort them, since we want the *last* AC-DEFINE to be honored.

10323

uniq confdefs.h | sed -n -f confdef2sed.sed >conftest.defines

10324

sed 's/ac_d/ac_u/g' conftest.defines >conftest.undefs

10325

rm -f confdef2sed.sed

10326

10327

# This sed command replaces #undef with comments. This is necessary, for

10328

# example, in the case of _POSIX_SOURCE, which is predefined and required

10329

# on some systems where configure will not decide to define it.

10330

cat >>conftest.undefs <<\_ACEOF

10331

s,^[ ]*#[ ]*undef[ ][ ]*[a-zA-Z_][a-zA-Z_0-9]*,/* & */,

10332

_ACEOF

10333

10334

# Break up conftest.defines because some shells have a limit on the size

10335

# of here documents, and old seds have small limits too (100 cmds).

10336

echo ' # Handle all the #define templates only if necessary.' >>$CONFIG_STATUS

10337

echo ' if grep "^[ ]*#[ ]*define" $tmp/in >/dev/null; then' >>$CONFIG_STATUS

10338

echo ' # If there are no defines, we may have an empty if/fi' >>$CONFIG_STATUS

10339

echo ' :' >>$CONFIG_STATUS

10340

rm -f conftest.tail

10341

while grep . conftest.defines >/dev/null

10342

10343

# Write a limited-size here document to $tmp/defines.sed.

10344

echo ' cat >$tmp/defines.sed <<CEOF' >>$CONFIG_STATUS

10345

# Speed up: don't consider the non `#define' lines.

10346

echo '/^[ ]*#[ ]*define/!b' >>$CONFIG_STATUS

10347

# Work around the forget-to-reset-the-flag bug.

10348

echo 't clr' >>$CONFIG_STATUS

10349

echo ': clr' >>$CONFIG_STATUS

10350

sed ${ac_max_here_lines}q conftest.defines >>$CONFIG_STATUS

10351

echo 'CEOF

10352

sed -f $tmp/defines.sed $tmp/in >$tmp/out

10353

rm -f $tmp/in

10354

mv $tmp/out $tmp/in

10355

' >>$CONFIG_STATUS

10356

sed 1,${ac_max_here_lines}d conftest.defines >conftest.tail

10357

rm -f conftest.defines

10358

mv conftest.tail conftest.defines

10359

done

10360

rm -f conftest.defines

10361

echo ' fi # grep' >>$CONFIG_STATUS

10362

echo >>$CONFIG_STATUS

10363

10364

# Break up conftest.undefs because some shells have a limit on the size

10365

# of here documents, and old seds have small limits too (100 cmds).

10366

echo ' # Handle all the #undef templates' >>$CONFIG_STATUS

10367

rm -f conftest.tail

10368

while grep . conftest.undefs >/dev/null

10369

10370

# Write a limited-size here document to $tmp/undefs.sed.

10371

echo ' cat >$tmp/undefs.sed <<CEOF' >>$CONFIG_STATUS

10372

# Speed up: don't consider the non `#undef'

10373

echo '/^[ ]*#[ ]*undef/!b' >>$CONFIG_STATUS

10374

# Work around the forget-to-reset-the-flag bug.

10375

echo 't clr' >>$CONFIG_STATUS

10376

echo ': clr' >>$CONFIG_STATUS

10377

sed ${ac_max_here_lines}q conftest.undefs >>$CONFIG_STATUS

10378

echo 'CEOF

10379

sed -f $tmp/undefs.sed $tmp/in >$tmp/out

10380

rm -f $tmp/in

10381

mv $tmp/out $tmp/in

10382

' >>$CONFIG_STATUS

10383

sed 1,${ac_max_here_lines}d conftest.undefs >conftest.tail

10384

rm -f conftest.undefs

10385

mv conftest.tail conftest.undefs

10386

done

10387

rm -f conftest.undefs

10388

10389

cat >>$CONFIG_STATUS <<\_ACEOF

10390

# Let's still pretend it is `configure' which instantiates (i.e., don't

10391

# use $as_me), people would be surprised to read:

10392

# /* config.h. Generated by config.status. */

10393

if test x"$ac_file" = x-; then

10394

echo "/* Generated by configure. */" >$tmp/config.h

10395

else

10396

echo "/* $ac_file. Generated by configure. */" >$tmp/config.h

10397

10398

cat $tmp/in >>$tmp/config.h

10399

rm -f $tmp/in

10400

if test x"$ac_file" != x-; then

10401

if diff $ac_file $tmp/config.h >/dev/null 2>&1; then

10402

{ echo "$as_me:$LINENO: $ac_file is unchanged" >&5

10403

echo "$as_me: $ac_file is unchanged" >&6;}

10404

else

10405

ac_dir=`(dirname "$ac_file") 2>/dev/null ||

10406

$as_expr X"$ac_file" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

10407

X"$ac_file" : 'X$//$[^/]' \| \

10408

X"$ac_file" : 'X$//$$' \| \

10409

X"$ac_file" : 'X$/$' \| \

10410

. : '$.$' 2>/dev/null ||

10411

echo X"$ac_file" |

10412

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

10413

/^X$\/\/$[^/].*/{ s//\1/; q; }

10414

/^X$\/\/$$/{ s//\1/; q; }

10415

/^X$\/$.*/{ s//\1/; q; }

10416

s/.*/./; q'`

10417

{ if $as_mkdir_p; then

10418

mkdir -p "$ac_dir"

10419

else

10420

as_dir="$ac_dir"

10421

as_dirs=

10422

while test ! -d "$as_dir"; do

10423

as_dirs="$as_dir $as_dirs"

10424

as_dir=`(dirname "$as_dir") 2>/dev/null ||

10425

$as_expr X"$as_dir" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

10426

X"$as_dir" : 'X$//$[^/]' \| \

10427

X"$as_dir" : 'X$//$$' \| \

10428

X"$as_dir" : 'X$/$' \| \

10429

. : '$.$' 2>/dev/null ||

10430

echo X"$as_dir" |

10431

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

10432

/^X$\/\/$[^/].*/{ s//\1/; q; }

10433

/^X$\/\/$$/{ s//\1/; q; }

10434

/^X$\/$.*/{ s//\1/; q; }

10435

s/.*/./; q'`

10436

done

10437

test ! -n "$as_dirs" || mkdir $as_dirs

10438

fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5

10439

echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}

10440

{ (exit 1); exit 1; }; }; }

10441

10442

rm -f $ac_file

10443

mv $tmp/config.h $ac_file

10444

10445

else

10446

cat $tmp/config.h

10447

rm -f $tmp/config.h

10448

10449

# Compute $ac_file's index in $config_headers.

10450

_am_stamp_count=1

10451

for _am_header in $config_headers :; do

10452

case $_am_header in

10453

$ac_file | $ac_file:* )

10454

break ;;

10455

* )

10456

_am_stamp_count=`expr $_am_stamp_count + 1` ;;

10457

esac

10458

done

10459

echo "timestamp for $ac_file" >`(dirname $ac_file) 2>/dev/null ||

10460

$as_expr X$ac_file : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

10461

X$ac_file : 'X$//$[^/]' \| \

10462

X$ac_file : 'X$//$$' \| \

10463

X$ac_file : 'X$/$' \| \

10464

. : '$.$' 2>/dev/null ||

10465

echo X$ac_file |

10466

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

10467

/^X$\/\/$[^/].*/{ s//\1/; q; }

10468

/^X$\/\/$$/{ s//\1/; q; }

10469

/^X$\/$.*/{ s//\1/; q; }

10470

s/.*/./; q'`/stamp-h$_am_stamp_count

10471

done

10472

_ACEOF

10473

cat >>$CONFIG_STATUS <<\_ACEOF

10474

10475

10476

# CONFIG_COMMANDS section.

10477

10478

for ac_file in : $CONFIG_COMMANDS; do test "x$ac_file" = x: && continue

10479

ac_dest=`echo "$ac_file" | sed 's,:.*,,'`

10480

ac_source=`echo "$ac_file" | sed 's,[^:]*:,,'`

10481

ac_dir=`(dirname "$ac_dest") 2>/dev/null ||

10482

$as_expr X"$ac_dest" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

10483

X"$ac_dest" : 'X$//$[^/]' \| \

10484

X"$ac_dest" : 'X$//$$' \| \

10485

X"$ac_dest" : 'X$/$' \| \

10486

. : '$.$' 2>/dev/null ||

10487

echo X"$ac_dest" |

10488

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

10489

/^X$\/\/$[^/].*/{ s//\1/; q; }

10490

/^X$\/\/$$/{ s//\1/; q; }

10491

/^X$\/$.*/{ s//\1/; q; }

10492

s/.*/./; q'`

10493

{ if $as_mkdir_p; then

10494

mkdir -p "$ac_dir"

10495

else

10496

as_dir="$ac_dir"

10497

as_dirs=

10498

while test ! -d "$as_dir"; do

10499

as_dirs="$as_dir $as_dirs"

10500

as_dir=`(dirname "$as_dir") 2>/dev/null ||

10501

$as_expr X"$as_dir" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

10502

X"$as_dir" : 'X$//$[^/]' \| \

10503

X"$as_dir" : 'X$//$$' \| \

10504

X"$as_dir" : 'X$/$' \| \

10505

. : '$.$' 2>/dev/null ||

10506

echo X"$as_dir" |

10507

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

10508

/^X$\/\/$[^/].*/{ s//\1/; q; }

10509

/^X$\/\/$$/{ s//\1/; q; }

10510

/^X$\/$.*/{ s//\1/; q; }

10511

s/.*/./; q'`

10512

done

10513

test ! -n "$as_dirs" || mkdir $as_dirs

10514

fi || { { echo "$as_me:$LINENO: error: cannot create directory \"$ac_dir\"" >&5

10515

echo "$as_me: error: cannot create directory \"$ac_dir\"" >&2;}

10516

{ (exit 1); exit 1; }; }; }

10517

10518

ac_builddir=.

10519

10520

if test "$ac_dir" != .; then

10521

ac_dir_suffix=/`echo "$ac_dir" | sed 's,^\.[\\/],,'`

10522

# A "../" for each directory in $ac_dir_suffix.

10523

ac_top_builddir=`echo "$ac_dir_suffix" | sed 's,/[^\\/]*,../,g'`

10524

else

10525

ac_dir_suffix= ac_top_builddir=

10526

10527

10528

case $srcdir in

10529

.) # No --srcdir option. We are building in place.

10530

ac_srcdir=.

10531

if test -z "$ac_top_builddir"; then

10532

ac_top_srcdir=.

10533

else

10534

ac_top_srcdir=`echo $ac_top_builddir | sed 's,/$,,'`

10535

fi ;;

10536

[\\/]* | ?:[\\/]* ) # Absolute path.

10537

ac_srcdir=$srcdir$ac_dir_suffix;

10538

ac_top_srcdir=$srcdir ;;

10539

*) # Relative path.

10540

ac_srcdir=$ac_top_builddir$srcdir$ac_dir_suffix

10541

ac_top_srcdir=$ac_top_builddir$srcdir ;;

10542

esac

10543

10544

# Do not use `cd foo && pwd` to compute absolute paths, because

10545

# the directories may not exist.

10546

case `pwd` in

10547

.) ac_abs_builddir="$ac_dir";;

10548

10549

case "$ac_dir" in

10550

.) ac_abs_builddir=`pwd`;;

10551

[\\/]* | ?:[\\/]* ) ac_abs_builddir="$ac_dir";;

10552

*) ac_abs_builddir=`pwd`/"$ac_dir";;

10553

esac;;

10554

esac

10555

case $ac_abs_builddir in

10556

.) ac_abs_top_builddir=${ac_top_builddir}.;;

10557

10558

case ${ac_top_builddir}. in

10559

.) ac_abs_top_builddir=$ac_abs_builddir;;

10560

[\\/]* | ?:[\\/]* ) ac_abs_top_builddir=${ac_top_builddir}.;;

10561

*) ac_abs_top_builddir=$ac_abs_builddir/${ac_top_builddir}.;;

10562

esac;;

10563

esac

10564

case $ac_abs_builddir in

10565

.) ac_abs_srcdir=$ac_srcdir;;

10566

10567

case $ac_srcdir in

10568

.) ac_abs_srcdir=$ac_abs_builddir;;

10569

[\\/]* | ?:[\\/]* ) ac_abs_srcdir=$ac_srcdir;;

10570

*) ac_abs_srcdir=$ac_abs_builddir/$ac_srcdir;;

10571

esac;;

10572

esac

10573

case $ac_abs_builddir in

10574

.) ac_abs_top_srcdir=$ac_top_srcdir;;

10575

10576

case $ac_top_srcdir in

10577

.) ac_abs_top_srcdir=$ac_abs_builddir;;

10578

[\\/]* | ?:[\\/]* ) ac_abs_top_srcdir=$ac_top_srcdir;;

10579

*) ac_abs_top_srcdir=$ac_abs_builddir/$ac_top_srcdir;;

10580

esac;;

10581

esac

10582

10583

10584

{ echo "$as_me:$LINENO: executing $ac_dest commands" >&5

10585

echo "$as_me: executing $ac_dest commands" >&6;}

10586

case $ac_dest in

10587

depfiles ) test x"$AMDEP_TRUE" != x"" || for mf in $CONFIG_FILES; do

10588

# Strip MF so we end up with the name of the file.

10589

mf=`echo "$mf" | sed -e 's/:.*$//'`

10590

# Check whether this is an Automake generated Makefile or not.

10591

# We used to match only the files named `Makefile.in', but

10592

# some people rename them; so instead we look at the file content.

10593

# Grep'ing the first line is not enough: some people post-process

10594

# each Makefile.in and add a new line on top of each file to say so.

10595

# So let's grep whole file.

10596

if grep '^#.*generated by automake' $mf > /dev/null 2>&1; then

10597

dirpart=`(dirname "$mf") 2>/dev/null ||

10598

$as_expr X"$mf" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

10599

X"$mf" : 'X$//$[^/]' \| \

10600

X"$mf" : 'X$//$$' \| \

10601

X"$mf" : 'X$/$' \| \

10602

. : '$.$' 2>/dev/null ||

10603

echo X"$mf" |

10604

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

10605

/^X$\/\/$[^/].*/{ s//\1/; q; }

10606

/^X$\/\/$$/{ s//\1/; q; }

10607

/^X$\/$.*/{ s//\1/; q; }

10608

s/.*/./; q'`

10609

else

10610

continue

10611

10612

# Extract the definition of DEPDIR, am__include, and am__quote

10613

# from the Makefile without running `make'.

10614

DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`

10615

test -z "$DEPDIR" && continue

10616

am__include=`sed -n 's/^am__include = //p' < "$mf"`

10617

test -z "am__include" && continue

10618

am__quote=`sed -n 's/^am__quote = //p' < "$mf"`

10619

# When using ansi2knr, U may be empty or an underscore; expand it

10620

U=`sed -n 's/^U = //p' < "$mf"`

10621

# Find all dependency output files, they are included files with

10622

# $(DEPDIR) in their names. We invoke sed twice because it is the

10623

# simplest approach to changing $(DEPDIR) to its actual value in the

10624

# expansion.

10625

for file in `sed -n "

10626

s/^$am__include $am__quote$.*(DEPDIR).*$$am__quote"'$/\1/p' <"$mf" | \

10627

sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g' -e 's/\$U/'"$U"'/g'`; do

10628

# Make sure the directory exists.

10629

test -f "$dirpart/$file" && continue

10630

fdir=`(dirname "$file") 2>/dev/null ||

10631

$as_expr X"$file" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

10632

X"$file" : 'X$//$[^/]' \| \

10633

X"$file" : 'X$//$$' \| \

10634

X"$file" : 'X$/$' \| \

10635

. : '$.$' 2>/dev/null ||

10636

echo X"$file" |

10637

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

10638

/^X$\/\/$[^/].*/{ s//\1/; q; }

10639

/^X$\/\/$$/{ s//\1/; q; }

10640

/^X$\/$.*/{ s//\1/; q; }

10641

s/.*/./; q'`

10642

{ if $as_mkdir_p; then

10643

mkdir -p $dirpart/$fdir

10644

else

10645

as_dir=$dirpart/$fdir

10646

as_dirs=

10647

while test ! -d "$as_dir"; do

10648

as_dirs="$as_dir $as_dirs"

10649

as_dir=`(dirname "$as_dir") 2>/dev/null ||

10650

$as_expr X"$as_dir" : 'X$.*[^/]$//*[^/][^/]*/*$' \| \

10651

X"$as_dir" : 'X$//$[^/]' \| \

10652

X"$as_dir" : 'X$//$$' \| \

10653

X"$as_dir" : 'X$/$' \| \

10654

. : '$.$' 2>/dev/null ||

10655

echo X"$as_dir" |

10656

sed '/^X$.*[^/]$\/\/*[^/][^/]*\/*$/{ s//\1/; q; }

10657

/^X$\/\/$[^/].*/{ s//\1/; q; }

10658

/^X$\/\/$$/{ s//\1/; q; }

10659

/^X$\/$.*/{ s//\1/; q; }

10660

s/.*/./; q'`

10661

done

10662

test ! -n "$as_dirs" || mkdir $as_dirs

10663

fi || { { echo "$as_me:$LINENO: error: cannot create directory $dirpart/$fdir" >&5

10664

echo "$as_me: error: cannot create directory $dirpart/$fdir" >&2;}

10665

{ (exit 1); exit 1; }; }; }

10666

10667

# echo "creating $dirpart/$file"

10668

echo '# dummy' > "$dirpart/$file"

10669

done

10670

done

10671

;;

10672

esac

10673

done

10674

_ACEOF

10675

10676

cat >>$CONFIG_STATUS <<\_ACEOF

10677

10678

{ (exit 0); exit 0; }

10679

_ACEOF

10680

chmod +x $CONFIG_STATUS

10681

ac_clean_files=$ac_clean_files_save

10682

10683

10684

# configure is writing to config.log, and then calls config.status.

10685

# config.status does its own redirection, appending to config.log.

10686

# Unfortunately, on DOS this fails, as config.log is still kept open

10687

# by configure, so config.status won't be able to write to it; its

10688

# output is simply discarded. So we exec the FD to /dev/null,

10689

# effectively closing config.log, so it can be properly (re)opened and

10690

# appended to by config.status. When coming back to configure, we

10691

# need to make the FD available again.

10692

if test "$no_create" != yes; then

10693

ac_cs_success=:

10694

ac_config_status_args=

10695

test "$silent" = yes &&

10696

ac_config_status_args="$ac_config_status_args --quiet"

10697

exec 5>/dev/null

10698

$SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false

10699

exec 5>>config.log

10700

# Use ||, not &&, to avoid exiting from the if with $? = 1, which

10701

# would make configure fail if this is the last instruction.

10702

$ac_cs_success || { (exit 1); exit 1; }

10703

10704

10705

10706

echo "

10707

Configuration:

10708

10709

Source code location: ${srcdir}

10710

Compiler: ${CC}

10711

Compiler flags: ${CFLAGS}

10712

Preprocessor: ${CPP}

10713

Preprocessor flags: ${CPPFLAGS}

10714

Libraries: ${LIBS} ${LIBDBM} ${LIBCRYPT}

10715

Awk: ${AWK}

10716

Shell: ${BASH}

10717

NIS map dir: ${YPMAPDIR}

10718

Install path prefix: ${prefix}"

10719

if test ${sysconfdir} != '${prefix}/etc'

10720

then

10721

echo " Install ypserv.conf in: ${sysconfdir}"

10722

else

10723

echo " Install ypserv.conf in: ${prefix}/etc"

10724

10725

echo " Allow root password: ${CHECKROOT}"

10726

echo " Use FQDN as master name: ${USE_FQDN}"

10727

echo ""

Older »